Analysis:

The first thing the program does when the main window is created is to create a listview control.

.IF uMsg==WM_CREATE invoke CreateWindowEx, NULL, ADDR ListViewClassName, NULL, \ LVS_REPORT+WS_CHILD+WS_VISIBLE, \ 0,0,0,0,hWnd, NULL, hInstance, NULL mov hList, eax

We call CreateWindowEx, passing itthe name of the window class "SysListView32". The default view is the report view as specified by LVS_REPORT style.

invoke InsertColumn

After the listview control is created, we insert columns into it.

LOCAL lvc:LV_COLUMN mov lvc.imask,LVCF_TEXT+LVCF_WIDTH mov lvc.pszText,OFFSET Heading1 mov lvc.lx,150 invoke SendMessage,hList, LVM_INSERTCOLUMN, 0, ADDR lvc

We specify the label and the width of the first column, for storing the names of the files, in LV_COLUMN structure thus we need to set imask with LVCF_TEXT and LVCF_WIDTH flags. We fill pszText with the address of the label and lx with the width of the column, in pixels. When all is done, we send LVM_INSERTCOLUMN message to the listview control, passing the structure to it.

or lvc.imask,LVCF_FMT mov lvc.fmt,LVCFMT_RIGHT

When we are done with the insertion of the first column, we insert another column for storing the sizes of the files. Since we need the sizes to right-align in the column, we need to specify a flag in fmt member, LVCFMT_RIGHT. We must also specify LVCF_FMT flag in imask, in addition to LVCF_TEXT and LVCF_WIDTH.

mov lvc.pszText,OFFSET Heading2 mov lvc.lx,100 invoke SendMessage,hList, LVM_INSERTCOLUMN, 1, ADDR lvc

The remaining code is simple. Put the address of the label in pszText and the width in lx. Then send LVM_INSERTCOLUMN message to the listview control, specifying the column number and the address of the structure.

When the columns are inserted, we can fill items in the listview control.

invoke FillFileInfo

FillFileInfo has the following code.

FillFileInfo PROC uses edi LOCAL finddata:WIN32_FIND_DATA LOCAL FHandle:DWORD invoke FindFirstFile,ADDR FileNamePattern,ADDR finddata

We call FindFirstFile to obtain the information of the first file that matches the search criteria. FindFirstFile has the following prototype:

FindFirstFile PROTO pFileName:DWORD, pWin32_Find_Data:DWORD

pfilename is the address of the filename to search for. This string can contain wildcards. In our example, we use *.*, which amounts to search for all the files in the current folder.
pwin32_find_data is the address of the win32_find_data structure that will be filled with information about the file (if found).

This function returns INVALID_HANDLE_VALUE in EAX if no matching file is found. Otherwise it returns a search handle that will be used in subsequent FindNextFile calls.

.IF eax!=INVALID_HANDLE_VALUE mov FHandle,eax xor edi,edi

If a file is found, we store the search handle in a variable and then zero out edi which will be used as the index into the items (row number).

.WHILE eax!=0 test finddata.dwFileAttributes,FILE_ATTRIBUTE_DIRECTORY .IF ZERO?

In this tutorial, I don't want to deal with the folders yet so I filter them out by checking dwFileAttributes for files which have FILE_ATTRIBUTE_DIRECTORY flag set. If they are found, I skip to call FindNextFile.

invoke ShowFileInfo,edi, ADDR finddata inc edi .ENDIF invoke FindNextFile,FHandle,ADDR finddata .ENDW

We insert the name and size of the file into the listview control by calling ShowFileInfo function. Then we increase the current row number in edi. Lastly we proceed to call FindNextFile to search for the next file in the current folder until FindNextFile returns 0 (meaning no more file is found).

invoke FindClose,FHandle .ENDIF ret FillFileInfo ENDP

When all files in the current folder are enumerated, we must close the search handle.

Now let's look at the ShowFileInfo function. This function accepts two parameters, the index of the item (row number) and the address of WIN32_FIND_DATA structure.

ShowFileInfo PROC uses edi row:DWORD, lpFind:DWORD LOCAL lvi:LV_ITEM LOCAL buffer[20]:BYTE mov edi,lpFind ASSUME edi:ptr WIN32_FIND_DATA

Store the address of WIN32_FIND_DATA structure in edi.

mov lvi.imask,LVIF_TEXT+LVIF_PARAM push row pop lvi.iItem mov lvi.iSubItem,0

We will supply the label of the item and the value in lParam so we put LVIF_TEXT and LVIF_PARAM flags into imask. Next we set the iItem to the row number passed to the function and since this is the main item, we must filliSubItem with 0 (column 0).

lea eax,[edi].cFileName mov lvi.pszText,eax push row pop lvi.lParam

Next we put the address of the label, in this case, the name of the file in win32_find_data structure, into psztext. Because we will implement sorting in the listview control, we must fill lParam with a value. I choose to put the row number into this member so I can retrieve the item info by its index.

invoke SendMessage,hList, LVM_INSERTITEM,0, ADDR lvi

When all necessary fields in LV_ITEM are filled, we send LVM_INSERTITEM message to the listview control to insert the item into it.

mov lvi.imask,LVIF_TEXT inc lvi.iSubItem invoke wsprintf,ADDR buffer, ADDR template,[edi].nFileSizeLow lea eax,buffer mov lvi.pszText,eax

We will set the subitem associated with the item just inserted into the second column. A subitem can only have a label. Thus we specify LVIF_TEXT in imask. Then we specify the column that the subitem should reside in isubitem. In this case, we set it to 1 by incrementing isubitem. The label we will use is the size of the file. However, we must convert it to a string first by calling wsprintf. Then we put the address of the string into psztext.

invoke SendMessage,hList,LVM_SETITEM, 0,ADDR lvi ASSUME edi:nothing ret ShowFileInfo ENDP

When all necessary fields inLV_ITEM are filled, we send LVM_SETITEM message to the listview control, passing to it the address of the LV_ITEM structure. Note that we use LVM_SETITEM, not LVM_INSERTITEM because a subitem is considered as a property of an item. Thus we *set* the property of the item, not inserting a new item.

When all items are inserted into the listview control, we set the text and background colors of the listview control.

RGB 255,255,255 invoke SendMessage,hList,LVM_SETTEXTCOLOR,0,eax RGB 0,0,0 invoke SendMessage,hList,LVM_SETBKCOLOR,0,eax RGB 0,0,0 invoke SendMessage,hList,LVM_SETTEXTBKCOLOR,0,eax

I use RGB macro to convert the red, green,blue values into EAX and use it to specify the color we need. We set the foreground and background colors of the text with LVM_SETTEXTCOLORand LVM_SETTEXTBKCOLOR messages. We set the background color of the listview control by sending LVM_SETBKCOLOR message to the listview control.

invoke GetMenu,hWnd mov hMenu,eax invoke CheckMenuRadioItem,hMenu,IDM_ICON,IDM_LIST, \ IDM_REPORT,MF_CHECKED

We will let the user chooses the views he wants via the menu. Thus we must obtain the menu handle first. To help the user track the current view, we put a radio button system in our menu. The menu item that reflects the current view will be preceded by a radio button. That's why we call checkmenuradioitem. This function will put a radio button before a menu item.

Note that we create the listview control with width and height equal to 0. It will be resized later whenever the parent window is resized. This way, we can ensure that the size of the listview control will always match that of the parent window. In our example, we want the listview control to fill the whole client area of the parent window.

.ELSEIF uMsg==WM_SIZE mov eax,lParam mov edx,eax and eax,0ffffh shr edx,16 invoke MoveWindow,hList, 0, 0, eax,edx,TRUE

When the parent window receives WM_SIZE message, the low word of lParam contains the new width of the client area and the high word the new height. Then we call movewindow to resize the listview control to cover the whole client area of the parent window.

When the user selects a view in the menu. We must change the view in the listview control accordingly. We accomplish this by setting a new style in the listview control with setwindowlong.

.ELSEIF uMsg==WM_COMMAND .IF lParam==0 invoke GetWindowLong,hList,GWL_STYLE and eax,not LVS_TYPEMASK

The first thing we do is to obtain the current styles of the listview control. Then we clear the old view style from the returned style flags. lvs_typemask is a constant that is the combined value of all 4 view style constants (lvs_icon+lvs_smallicon+lvs_list+lvs_report). Thus when we perform and operation on the current style flags with the value "not LVS_TYPEMASK", it amounts to clearing away the current view style.

In designing the menu, I cheat a little. I use the view style constants as the menu IDs.

IDM_ICON equ LVS_ICON IDM_SMALLICON equ LVS_SMALLICON IDM_LIST equ LVS_LIST IDM_REPORT equ LVS_REPORT

Thus when the parent window receives WM_COMMAND message, the desired view style is in the low word of wParam as the menu ID.

mov edx,wParam and edx,0FFFFh

We have the desired view style in the low word of wParam. All we have to do is to zero out the high word.

push edx or eax,edx

And add the desired view style to the existing styles (minus the current view style) of the listview control.

invoke SetWindowLong,hList,GWL_STYLE,eax

And set the new styles with setwindowlong.

pop edx invoke CheckMenuRadioItem,hMenu,IDM_ICON,IDM_LIST,edx,MF_CHECKED .ENDIF

We also need to put the radio button in front of the selected view menu item. Thus we call checkmenuradioitem, passing the current view style (double as menu ID) to it.

When the user clicks on the column headers in the report view, we want to sort the items in the listview control. We must respond to WM_NOTIFY message.

.ELSEIF uMsg==WM_NOTIFY push edi mov edi,lParam ASSUME edi:ptr NMHDR mov eax,[edi].hwndFrom .IF eax==hList

When we receive WM_NOTIFY message, lParam contains the pointer to an nmhdr structure. We can check if this message is from the listview control by comparing the hwndfrom member of nmhdr to the handle to the listview control. If they match, we can assume that the notification came from the listview control.

.IF [edi].code==LVN_COLUMNCLICK ASSUME edi:ptr NM_LISTVIEW

If the notification is from the listview control, we check if the code is lvn_columnclick. If it is, it means the user clicks on a column header. In the case that the code is lvn_columnclick, we can ASSUME that lParam contains the pointer to an nm_listview structure which is a superset of the nmhdr structure. We then need to know on which column header the user clicks. Examination of isubitem member reveals this info. The value in iSubItem can be treated as the column number, starting from 0.

.IF [edi].iSubItem==1 .IF SizeSortOrder==0 || SizeSortOrder==2

In the case iSubItem is 1, it means the user clicks on the second column, size. We use state variables to keep the current status of the sorting order. 0 means "no sorting yet", 1 means "sort ascending", 2 means "sort descending". If the items/subitems in the column are not sorted before, or sorted descending, we set the sorting order to ascending.

invoke SendMessage,hList,LVM_SORTITEMS,1,ADDR CompareFunc

We send LVM_SORTITEMS message to the listview control, passing 1 in wParam and the address of our comparison function in lParam. Note that the value in wParam is user-defined, you can use it in any way you like. I use it as the sorting method in this example. We will take a look at the comparison function first.

CompareFunc PROC uses edi lParam1:DWORD, lParam2:DWORD, SortType:DWORD LOCAL buffer[256]:BYTE LOCAL buffer1[256]:BYTE LOCAL lvi:LV_ITEM mov lvi.imask,LVIF_TEXT lea eax,buffer mov lvi.pszText,eax mov lvi.cchTextMax,256

In the comparison function, the listview control will pass lParams (in LV_ITEM) of the two items it needs to compare to us in lParam1 and lParam2. You'll recall that we put the index of the item in lParam. Thus we can obtain information about the items by querying the listview control using the indexes. The info we need is the labels of the items/subitems being sorted. Thus we prepare an LV_ITEM structure for such purpose, specifying LVIF_TEXT in imask and the address of the buffer in pszText and the size of the buffer in cchTextMax.

.IF SortType==1 mov lvi.iSubItem,1 invoke SendMessage,hList,LVM_GETITEMTEXT,lParam1,ADDR lvi

If the value in SortType is 1 or 2, we know that the size column is clicked. 1 means sort the items according to their sizes in ascending order. 2 means the reverse. Thus we specify isubitem as 1 ( to specify the size column) and send LVM_GETITEMTEXT message to the listview control to obtain the label (size string) of the subitem.

invoke String2Dword,ADDR buffer mov edi,eax

Covert the size string into a dword value with String2Dword which is the function I wrote. It returns the dword value in EAX. We store it in edi for comparison later.

invoke SendMessage,hList,LVM_GETITEMTEXT,lParam2,ADDR lvi invoke String2Dword,ADDR buffer sub edi,eax mov eax,edi

Do likewise with the value in lParam2. When we have the sizes of the two files, we can then compare them. The rule of the comparison function is as follows:

• If the first item should precede the other, you must return a negative value in EAX.
• If the second item should precede the first one, you must return a positive value in EAX.
• If both items are equal, you must return zero in EAX.

In this case, we want to sort the items according to their sizes in ascending order. Thus we can simply subtract the size of the first item with that of the second one and return the result in EAX.

.ELSEIF SortType==3 mov lvi.iSubItem,0 invoke SendMessage,hList,LVM_GETITEMTEXT,lParam1,ADDR lvi invoke lstrcpy,ADDR buffer1,ADDR buffer invoke SendMessage,hList,LVM_GETITEMTEXT,lParam2,ADDR lvi invoke lstrcmpi,ADDR buffer1,ADDR buffer

In case the user clicks the filename column, we must compare the names of the files. We first obtain the filenames and then compare them with lstrcmpi function. We can return the return value of lstrcmpi without any modification since it also uses the same rule of comparison, eg. negative value in EAX if the first string is less than the second string.

When the items were sorted, we need to update the lParam values of all items to reflect the new indexes by calling UpdatelParam function.

invoke UpdatelParam mov SizeSortOrder,1

This function simply enumerates all items in the listview control and updates the values in lParam with the new indexes. We need to do this else the next sort will not work as expected because our assumption is that the value in lParam is the index of the item.

.ELSEIF [edi].code==NM_DBLCLK invoke ShowCurrentFocus .ENDIF

When the user double-clicks at an item, we want to display a message box with the label of the item on it. We must check if the code in nmhdr is NM_DBLCLK. If it is, we can proceed to obtain the label and display it in a message box.

ShowCurrentFocus PROC LOCAL lvi:LV_ITEM LOCAL buffer[256]:BYTE invoke SendMessage,hList,LVM_GETNEXTITEM,-1, LVNI_FOCUSED

How do we know which item is double-clicked ? When an item is clicked or double-clicked, its state is set to "focused". Even if many items are hilited (selected), only one of them has got the focus. Our job than is to find the item that has the focus. We do this by sending LVM_GETNEXTITEM message to the listview control, specifying the desired state in lParam. -1 in wParam means search all items. The index of the item is returned in EAX.

mov lvi.iItem,eax mov lvi.iSubItem,0 mov lvi.imask,LVIF_TEXT lea eax,buffer mov lvi.pszText,eax mov lvi.cchTextMax,256 invoke SendMessage,hList,LVM_GETITEM,0,ADDR lvi

We then proceed to obtain the label by sending LVM_GETITEM message to the listview control.

invoke MessageBox,0, ADDR buffer,ADDR AppName,MB_OK

Lastly, we display the label in a message box.

If you want to know how to use icons in the listview control, you can read about it in my treeview tutorial. The steps are just about the same.

---

Tutorial 30: Win32 Debug API part 3

Overview

Tutorial 32: Multiple Document Interface (MDI)