Method and system for accessing operating system resources

Abstract

An operating system includes APIs developed in part to support recent innovations in computer hardware and in part to provide enhanced services to application programs. Among their other features, these APIs provide access to operating system functionality in a manner that is comprehensive, efficient, usable, extendible and, in some cases, reusable.

Claims

We claim:

1. A computer system including a microprocessor and a software program, the software program utilizing an application program interface to request services from a windowed operating system, the requested services relating to display, manipulation or arrangement of items in a window, which items may include text associated therewith, the application program interface including a separate command to request each of the following services:

arranging the items in an icon view;

creating a drag image list for a specified item;

removing all items from the window;

removing a column of items from the window;

removing an item from the window;

beginning in-place editing of text associated with a specified item;

ensuring that an item is entirely or at least partially visible, scrolling a window control if necessary;

searching for an item with specified characteristics;

retrieving a background color of the window;

retrieving a callback mask for the window;

retrieving attributes of a window column;

retrieving a width of a column in the window;

calculating a number of items that can fit vertically in a visible area of the window;

retrieving a handle of an edit control being used to edit an item's text;

retrieving a handle of an image list used for drawing items;

retrieving some or all of an item's attributes;

retrieving a number of items in the window;

retrieving a position of an item in the window;

retrieving a bounding rectangle for all or part of an item in a current view of the window;

retrieving a state of an item;

retrieving text associated with an item;

searching for an item that has specified properties and that bears a specified relationship to a given item;

retrieving a current view origin for the window;

determining a minimum column width necessary to display all of a given string;

retrieving a text background color of a window;

retrieving a text color of a window;

retrieving an index to a topmost visible item in the window;

retrieving a bounding rectangle of all items in the window;

determining which item, if any, is at a specified position;

inserting a new column in a window;

inserting a new item in a window;

forcing a window to repaint a range of items;

scrolling contents of a window;

setting a background color of the window;

setting a callback mask for a window;

setting attributes of a window column;

changing a width of a window column;

assigning an image list to a window;

setting some or all of an item's attributes;

preparing a window for adding items;

moving an item to a specified position in the window;

changing a state of an item in the window;

changing text associated with an item;

setting a background color of text in the window;

setting a text color of a window;

sorting items using an application-defined comparison function; and

updating an item.

2. The computer system of claim 1 in which said separate commands all belong to a common class of commands.

3. In a computer-based method of running a software program on a computer, the computer operating under an operating system that provides a windowed display of graphical items, at least some of said items having text associated therewith, the method including issuing instructions from the software program requesting at least ten of the following functions from the operating system, each instruction corresponding to only one of said functions:

arranging the items in an icon view;

creating a drag image list for a specified item;

removing all items from the window;

removing a column of items from the window;

removing an item from the window;

beginning in-place editing of text associated with a specified item;

ensuring that an item is entirely or at least partially visible, scrolling a window control if necessary;

searching for an item with specified characteristics;

retrieving a background color of the window;

retrieving a callback mask for the window;

retrieving attributes of a window column;

retrieving a width of a column in the window;

calculating a number of items that can fit vertically in a visible area of the window;

retrieving a handle of an edit control being used to edit an item's text;

retrieving a handle of an image list used for drawing items;

retrieving some or all of an item's attributes;

retrieving a number of items in the window;

retrieving a position of an item in the window;

retrieving a bounding rectangle for all or part of an item in a current view of the window;

retrieving a state of an item;

retrieving text associated with an item;

searching for an item that has specified properties and that bears a specified relationship to a given item;

retrieving a current view origin for the window;

determining a minimum column width necessary to display all of a given string;

retrieving a text background color of a window;

retrieving a text color of a window;

retrieving an index to a topmost visible item in the window;

retrieving a bounding rectangle of all items in the window;

determining which item, if any, is at a specified position;

inserting a new column in a window;

inserting a new item in a window;

forcing a window to repaint a range of items;

scrolling contents of a window;

setting a background color of the window;

setting a callback mask for a window;

setting atributes of a window column;

changing a width of a window column;

assigning an image list to a window;

setting some or all of an item's attributes;

preparing a window for adding items;

moving an item to a specified position in the window;

changing a state of an item in the window;

changing text associated with an item;

setting a background color of text in the window;

setting a text color of a window;

sorting items using an application-defined comparison function; and

updating an item.

4. The method of claim 3 in which said instructions all belong to a common class of instructions.

5. A method of invoking display of a collection of graphical items in an information handling system having a central processing unit and a display device, the central processing unit being controlled by an operating system and having one or more software programs that performs output operation to the display device, said method being performed by an application program interface communicating between said software program and said operating system, including the steps:

issuing a call from the software program to the operating system requesting creation of a list view window;

receiving, by the software program, a handle to the window thereby created;

storing said handle for future reference;

sending a message to the window by use of said handle, the message having the form:

LVM_ARRANGE

wParam=code;

lParam=0;

where code is a parameter selected from a group comprising: LVA_ALIGNBOTTOM, LVA_ALIGNLEFT, LVA_ALIGNRIGHT, LVA_ALIGNTOP, LVA_DEFAULT, and LVA_SNAPTOGRID.

6. The method of claim 5 which further includes sending a plurality of further messages to said window by reference to said handle, said further messages being selected from the group comprising: LV_ITEM, LVM_DELETEALLITEMS, LVM_DELETEITEM, LVM_GETITEM, LVM_GETITEMCOUNT, LVM_GETITEMSTATE, LVM_GETITEMTEXT, LVM_INSERTITEM, LVM_SETITEM, LVM_SETITEMCOUNT, LVM_SETITEMSTATE, LVM_SETITEMTEXT, LV_DISPINFO, LVM_GETCALLBACKMASK, LVM_REDRAWITEMS, LVM_SETCALLBACKMASK, LVM_UPDATE, LVN_GETDISPINFO, LVN_SETDISPINFO, LV_COLUMN, LVM_DELETECOLUMN, LVM_GETCOLUMN, LVM_GETCOLUMNWIDTH, LVM_GETSTRINGWIDTH, LVM_INSERTCOLUMN, LVM_SETCOLUMN, LVM_SETCOLUMNWIDTH, LVN_COLUMNCLICK, LV_FINDINFO, LVM_FINDITEM, LVM_GETNEXTITEM, LVM_SORTITEMS, LV_HITTESTINFO, LVM_ENSUREVISIBLE, LVM_GETCOUNTPERPAGE, LVM_GETITEMPOSITION, LVM_GETITEMRECT, LVM_GETORIGIN, LVM_GETTOPINDEX, LVM_GETVIEWRECT, LVM_HITTEST, LVM_SCROLL, LVM_SETITEMPOSITION, LVM_GETBKCOLOR, LVM_GETTEXTBKCOLOR, LVM_GETTEXTCOLOR, LVM_SETBKCOLOR, LVM_SETTEXTBKCOLOR, LVM_SETTEXTCOLOR, LVM_KEYDOWN, LVM_CREATEDRAGIMAGE, LVM_EDITLABEL, LVM_GETEDITCONTROL, LVM_GETIMAGELIST, LVM_SETIMAGELIST, LVN_BEGINDRAG, LVN_BEGINLABELEDIT, LVN_BEGINRDRAG, LVN_DELETEALLITEMS, LVN_DELETEITEM, LVN_ENDDRAG, LVN_ENDLABELEDIT, LVN_ENDRDRAG, LVN_INSERTITEM, LVN_ITEMCHANGED, LVN_ITEMCHANGING, and LVN_KEYDOWN.

7. A computer-implemented method for interfacing a plurality of software programs to an operating system comprising computer implemented steps of:

providing a set of application program interfaces, each responsive to program calls from said software programs;

generating a call from one of said application program interfaces to the operating system in response to one of said program calls, said call requesting establishment of a window of a ListView class; and

passing one of a predefined set of "LVM_" messages from the software program to a list view control.

8. A computer system comprising:

at least one application program including a set of program calls, each of said calls being related to a specific operating system operation, said set of program calls including a call requesting establishment of a window of a ListView class;

an operating system exposing a set of application programs interfaces, each corresponding to a program call from said application program, and including a message from the application program to a list view control, the message having an "LVN_" or "LVM_" prefix.

9. A machine having a memory which contains a plurality of list view controls invoked by a software program, the invocation including the following steps:

instructing an operating system to load a common controls dynamic link library;

calling an application program interface for creating a window of a ListView class;

receiving and storing a window handle returned to the software program in response to said call; and

issuing messages to the operating system relating to manipulation of said window, said messages referring to said window handle.

10. The method of claim 9 in which the messages request the operating system to perform only actions selected from the following list with respect to arrangement and display of graphical items in the list view control window:

arranging the items in an icon view;

creating a drag image list for a specified item;

removing all items from the window;

removing a column of items from the window;

removing an item from the window;

beginning in-place editing of a text associated with a specified item;

ensuring that an item is entirely or at least partially visible, scrolling a window control if necessary;

searching for an item with specified characteristics;

retrieving a background color of the window;

retrieving a callback mask for the window,

retrieving attributes of a window column;

retrieving a width of a column in the window;

calculating a number of items that can fit vertically in a visible area of the window;

retrieving a handle of an edit control being used to edit an item's text;

retrieving a handle of an image list used for drawing items;

retrieving some or all of an item's attributes;

retrieving a number of items in the window,

retrieving a position of an item in the window;

retrieving a bounding rectangle for all or part of an item in a current view of the window;

retrieving a state of an item;

retrieving text associated with an item;

searching for an item that has specified properties and that bears a specified relationship to a given item;

retrieving a current view origin for the window;

determining a minimum column width necessary to display all of a given string;

retrieving a text background color of a window;

retrieving a text color of a window;

retrieving an index to a topmost visible item in the window;

retrieving a bounding rectangle of all items in the window;

determining which item, if any, is at a specified position;

inserting a new column in a window;

inserting a new item in a window;

forcing a window to repaint a range of items;

scrolling contents of a window;

setting a background color of the window;

setting a callback mask for a window;

setting attributes of a window column;

changing a width of a window column;

assigning an image list to a window;

setting some or all of an item's attributes;

preparing a window for adding items;

moving an item to a specified position in the window;

changing a state of an item in the window;

changing text associated with an item;

setting a background color of text in the window;

setting a text color of a window;

sorting items using an application-defined comparison function; and

updating an item.

Description

FIELD OF THE INVENTION

The present invention relates to computer software development, and more particularly relates to application program interfaces (APIs) that facilitate use of operating system resources by application programs and computer hardware.

BACKGROUND AND SUMMARY OF THE INVENTION

The field of software development has undergone substantial evolution in the 50 years since its inception. An early form of software simply abstracted and represented hardware functions in a "human readable" form known as assembly language code. Special purpose application programs could then be written in such code to command the computer to perform an organized set of operations.

Assembly language coding has several drawbacks. One is that the code required to carry out a particular function has to be specifically included in each program needing that function: dozens of software developers might write code (or at least copy code) for a single function dozens of times for dozens of programs. A second drawback to assembly language coding is that programmers must understand the computer's internal hardware resources: as hardware is changed, so must the programmers' software programs.

To address these and other difficulties, the software necessary to operate a computer was soon split into two classes: operating system software, and applications software.

Operating system software (sometimes termed simply "the operating system") is a set of computer code that performs a variety of functions, including interacting with the computer hardware; insulating the programmer from the specifics of the computer hardware; and providing general functionality ("resources") that many application programs require.

Applications software (sometimes terms "applications"), in contrast, addresses a particular problem to be solved. Examples of applications software are word processors and accounting programs. Applications software and operating systems communicate using a series of standardized instruction codes passed between the two. The operating system software interprets these standardized instruction codes, and controls the computer's hardware resources in response thereto. Oftentimes, information in the form of data or messages is passed back to the applications software. In this manner, the operating system software--once written--effects most direct control of the hardware, allowing the application software programmer to focus on the particular problem sought to be solved. (Alternatively, application software can still include assembly language code--directly controlling the computer hardware and bypassing the operating system. This may be done for speed or control, or simply to provide functionality not supported by the operating system.)

The relationship between operating system software, applications software and hardware is not always clearly defined. Over the last several decades, each has evolved rapidly. As was noted above, operating systems sometimes evolve to include functions common to several applications. Similarly, operating systems are sometimes modified to include functionality previously provided only in hardware and visa-versa. For example, data compression can be done in software (by an operating system or application) and in hardware (by a specialized chip). Essentially, the three technologies have developed together in response to user demand and advances in technology.

A specific factor driving the evolution of operating system software has been the desire to simplify and speed application software development. Application software development can be a daunting task, sometimes requiring hundreds of man-years of effort for a sophisticated program. For a popular operating system such as Microsoft.RTM. Windows.TM., applications software developers may write thousands of different applications each year to execute on the Windows operating system. The investment in application development time is large. One incentive to create such programs is to provide good support for the application software through the operating system. This requires building a coherent and usable base for applications developers to work with.

Often, development of application software can be made simpler by making the operating system more complex. That is (as noted above), if a function may be useful to several different application programs, it is better to write it once for inclusion in the operating system, than requiring dozens of software developers to write it dozens of times for inclusion in dozens of different applications. In this manner, if the operating system supports a wide range of common functionality required by a number of applications, significant savings in applications software development costs and time can be achieved.

Another factor driving the continuing evolution of operating system software is the ongoing development of faster and more sophisticated computer hardware--both in the computer's central processing unit (CPU) and in its peripheral devices (e.g. printers). New CPUs typically offer enhanced instruction sets that enable certain new operations to be performed, or enable old operations to be performed more quickly. Corresponding enhancements are usually made to the operating system to afford applications access to these new CPU capabilities.

The relationship between operating systems and hardware has also driven the development of a special class of software: device drivers. Peripheral devices usually do not communicate directly with the operating system. Instead, such devices usually communicate with device driver software, which in turn communicate with the operating system. A device driver thus serves as a software interface between operating system software and peripheral device hardware. The specific requirements of a particular hardware device are often handled by the device driver, making the details transparent to the operating system. A computer system typically employs many different device drivers, e.g. one for the display, one for the printer, one for the mouse, etc.

Often, a new peripheral device can be supported just by writing a new device driver tailored to exploit its hardware; no revision to the operating system is required as long as the operating system recognizes and can communicate with the device driver. Sometimes, however, significant gains in functionality and efficiency can be achieved by upgrading an operating system's facilities for interacting with device drivers (and thus with the peripheral hardware).

It is clear that for a useful and accomplished operating system, the interfaces between the operating system and the computer hardware and application software are as important as efficient internal operation of the operating system itself.

The present invention is directed to improvements in computer operating systems. In particular, the invention concerns certain Applications Program Interfaces (APIs). APIs are mechanisms by which applications software can request services from the operating system, including certain hardware operations and access to various operating system resources. APIs also serve as the means by which messages and information provided by the operating system are relayed back to the applications software for its use. (Device drivers sometimes make use of operating system APIs as well. For expository convenience, the present specification refers to software that makes use of APIs simply as "applications software"--it being understood that this usage encompasses device drivers as well.)

The evolution of APIs tracks that of computers generally. The first operating systems provided only limited collections of APIs, which were actually more in the nature of user (operator) interfaces (e.g. Print Screen) than application interfaces. As the functionality provided by computers via operating systems increased, so did the number of APIs available to access this increased functionality.

Generally, operating systems are developed for use with a specific CPU. Thereafter, the operating system can be used on any computer that uses that or a compatible CPU, regardless of which manufacturer produced the computer, or minor idiosyncrasies in its design.

Likewise, application programs are generally developed for use with a specific operating system. To the extent that two operating systems support the same API sets, an application program is "portable" and can be executed on either system.

Contemporary operating systems are provided with rich sets of APIs--sometimes numbering in the hundreds of operating system calls and responsive messages--greatly facilitating the task of the application software development.

When implementing an API set for a new operating system or function, the straightforward approach is to write an API for each operating system function or resource that may be required by an application program or hardware device. More commonly, however, operating system APIs are developed in the process of enhancing an existing operating system. In this context, the straightforward approach is to take the predecessor operating system's API set and make use of those APIs whenever possible in the new operating system. The prior APIs can be patched or extended, where necessary, to take advantage of--for example--new hardware capabilities.

The foregoing design philosophies may be characterized largely as rote: i.e. following old ways, with old calls, old formats, and old parameters. Technically superior operating systems distinguish themselves by inventiveness beyond the rote. Invention in the interface can manifest itself in many ways: breaking out of the comfort of the old in favor of a new or unfamiliar approach; devising new operating system functions from the feature set of old CPU hardware; making existing operating system functions available in a more meaningful or efficient manner (with the same hardware); anticipating application program and hardware component needs not yet felt and laying groundwork to facilitate their eventual support, etc.

The APIs detailed in the present application are those for the Microsoft.RTM. Windows 95.TM. (earlier known as Chicago) operating system. These APIs were developed in part to support recent innovations in computer hardware, and in part to provide enhanced services to application programs.

As those skilled in the art will recognize, the Windows 95 APIs reflect many inventive improvements over those of its predecessor operating systems--not just in terms of raw functionality provided by the improved operating system, but also in the manner the enhanced functionality of the Windows 95 operating system is made available for use by application programs and hardware components. Among their other features, these APIs provide access to the Windows 95 operating system functionality in a manner that is comprehensive, efficient, usable, extendible and, in some cases, reusable.

The foregoing and additional features of the present invention will be more readily apparent from the following detailed description, which proceeds with reference to the accompanying drawings.

DESCRIPTION OF THE DRAWINGS

FIG. 1 shows relationships between different types of computer software.

FIG. 2 is a block diagram of a computer with which the present invention can be utilized.

DETAILED DESCRIPTION

In the Microsoft Windows family of operating systems (as in many operating systems from other vendors), the "window" is a central feature. To the user, it is the visual feature through which all interaction--both with applications and with the operating system--occurs. On a software level, it is the "object" through which most control/communication between the operating system and an application occurs.

Rudimentary to windows are icons. Icons are small bit maps that can be used for a variety of purposes, one of the most familiar of which is to represent Windows application programs that are available for execution. It is not unusual for a dozen or more icons to be displayed in a window.

The Windows 95 operating system includes a variety of new APIs and functions that facilitate display of icons (and other bitmaps) in windows. While such functionality could, to some degree, be achieved in prior versions of the Windows operating system, the APIs of the present invention provide significant advantages, including efficiencies in coding of application programs and faster execution.

In Windows 95, windows are created in generally the same manner as in predecessor versions of the Windows operating system, namely by use of the CreateWindow API. One of the parameters passed during invocation of this function is the window "class." In Windows 95, a new class of window has been defined, termed "list view control" (or simply "list view"). To create a list view window, CreateWindow is invoked with a specification of "WC_LISTVIEW" as the window class. (The list view window class is registered in the application's address space when the common controls dynamic-link library (DLL) is loaded.)

By requesting creation of a window of the "list view" class, the application programmer can use a rich set of new controls in displaying, arranging, and manipulating bit maps in the window. (The bit maps can, but need not, be icons.)

After creation, or manipulation, the application programmer can request that the window be presented on the screen by use of standard Windows operating system functions, e.g. the ShowWindow API.

The foregoing will be clearer from the following detailed analysis of the Windows 95 List View Controls, which is taken from documentation provided to software developers to enable them to use these new APIs, macros, and functions.

About List View Controls

A list view control is a window that displays a collection of items, each item consisting of an icon and a label. List views provide several ways of arranging items and displaying individual items. For example, additional information about each item can be displayed in columns to the right of the icon and label.

The application programmer can create a list view control by calling the CreateWindow or CreateWindowEx function, specifying the WC_LISTVIEW window class. This window class is registered when the common controls dynamic-link library (DLL) is loaded. To ensure that this DLL is loaded, the application programmer can use the InitCommonControls function.

An application sends messages to a list view control to add, remove, arrange, and otherwise manipulate items. Each message has a macro that the application programmer can use instead of sending the message explicitly.

Like most common controls, a list view control sends notification messages to its parent window in the form of WM_NOTIFY messages.

Views and Styles

List view controls can display their contents in four different ways, called views. The current view is specified by the control's window style. Additional window styles specify the alignment of items and control-specific aspects of the list view control's functionality. Information about the four views follows.

    View      Description
    Icon view Specified by the LVS_ICON window style.
              Each item appears as a full-sized icon with a label below it.
              The user can drag the items to any location in the list view
              window.
    Small icon Specified by the LVS_SMALLICON window style.
    view      Each item appears as a small icon with the label to the right of
              it. The user can drag the items to any location.
    List view Specified by the LVS_LIST window style.
              Each item appears as a small icon with a label to the right of
              it. Items are arranged in columns and cannot be dragged to
              any arbitrary location by the user.
    Report    Specified by the LVS_REPORT window style.
    view      Each item appears on its own line with information arranged
              in columns. The leftmost column contains the small icon and
              label, and subsequent columns contain subitems as specified
              by the application. Unless the LVS_NOCOLUMNHEADER
              window style is also specified, each column has a header.

    Notification message Description
    LVN_BEGINDRAG        Signals the start of a drag-and-drop operation.
    LVN.sub.--           Signals the start of in-place label editing.
    BEGINLABELEDIT
    LVN_BEGINRDRAG       Signals the start of a drag-and-drop operation,
                         using the right mouse button.
    LVN_COLUMNCLICK      Indicates that the user clicked a column header
                         in report view.
    LVN.sub.--           Signals the deletion of all list view items.
    DELETEALLITEMS
    LVN_DELETEITEM       Signals the deletion of a specific item.
    LVN_ENDDRAG          Signals the end of a drag-and-drop operation
                         that was handled by the list view control rather
                         than its parent window.
    LVN_ENDLABELEDIT     Signals the end of label editing.
    LVN_ENDRDRAG         Signals the end of a drag-and-drop operation,
                         using the right mouse button, that was handled
                         by the list view control.
    LVN_GETDISPINFO      Requests information that the list view control
                         requires to display an item.
    LVN_INSERTITEM       Signals the insertion of a new list view item.
    LVN_ITEMCHANGED      Indicates that an item has changed.
    LVN.sub.--           Indicates that an item is in the process of
    ITEMCHANGING         changing, and enables the parent window to
                         accept or deny the change.
    LVN_KEYDOWN          Signals a keyboard event.
    LVN_SETDISPINFO      Notifies a parent window that it must update
                         the information it maintains for an item.

    Message              Processing performed
    WM_CHAR              Searches for a list view item that begins with
                         the specified character and, if found, selects
                         and sets the focus to the item.
                         Multiple characters received within a time-out
                         interval are concatenated, and the list view
                         searches for an item that begins with the
                         resulting string.
    WM_COMMAND           Processes the EN_UPDATE and
                         EN_KILLFOCUS edit control notification
                         messages, and forwards all other edit control
                         notifications to the parent window.
    WM_CREATE            Performs additional initialization. If the
                         LVS_SHAREIMAGELISTS window style is
                         not specified, the list view control creates the
                         icon and small icon image lists at this point.
    WM_DESTROY           Frees resources.
    WM_ERASEBKGND        Erases the window background using the
                         current background color for the list view
                         control. If the background color is the
                         CLR_NONE value, the list view control
                         forwards the message to the parent window.
    WM_GETDLGCODE        Returns a combination of the
                         DLGC_WANTTAB and
                         DLGC_WANTARROWS values.
    WM_GETFONT           Returns the handle of the current label font.
    WM_HSCROLL           Scrolls the list view horizontally.
    WM_KEYDOWN           Processes the SPACEBAR, ENTER, and arrow
                         keys, and sends a LVN_KEYDOWN
                         notification message to the parent window.
    WM_KILLFOCUS         Repaints the focused list item, if any, and sends
                         a NM_KILLFOCUS notification message to
                         the parent window.
    WM.sub.--            Sends the parent window an NM_DBLCLK
    LBUTTONDBLCLK        notification message.
    WM_LBUTTONDOWN       Processed in different ways depending on
                         whether a click or drag operation is being
                         initiated. To determine which operation is
                         involved, the control enters a modal message
                         loop until either the button is released or the
                         mouse is moved.
                         In the case of a click, the control may change
                         which item has the focus and which items are
                         selected, taking into account the cursor
                         position, the state of the SHIFT and CTRL
                         keys, and so on. Then the list view control
                         sends its parent window an NM_CLICK
                         notification message.
                         If dragging begins over an item, the control
                         selects and sets the focus to the item. Then it
                         sends an LVN_BEGINDRAG notification
                         message to the parent window. The parent
                         window is responsible for actually carrying out
                         the drag operation.
                         If dragging begins over the window back-
                         ground, the control enters another modal
                         message loop, enabling the user to form a
                         rectangle by dragging the mouse. Items within
                         the rectangle are selected.
    WM_NCCREATE          Allocates and initializes an internal data
                         structure, and then calls the DefWindowProc
                         function.
    WM_NCDESTROY         Frees resources allocated by the list view
                         control. Unless the LVS_SHAREIMAGE
                         LISTS style is used, this includes deleting the
                         image list and small image list.
    WM_NOTIFY            Processes header control notification messages.
    WM_PAINT             Displays any items in the update region. For
                         callback items, the control first sends an
                         LVN_GETDISPINFO notification message to
                         the owner window to request display
                         information.
    WM.sub.--            Processed the same way as the
    RBUTTONDOWN          WM_LBUTTONDOWN message, except that
                         the control sends an NM_RCLICK notification
                         message (instead of NM_CLICK) and an
                         LVN_BEGINRDRAG notification message
                         (instead of LVN_BEGINDRAG).
    WM_SETFOCUS          Repaints the focused list item, if any, and sends
                         an NM_SETFOCUS notification message to
                         the parent window.
    WM_SETFONT           Saves the specified font handle, forwards the
                         message to the header window, if any, and
                         repaints using the new font.
    WM_SETREDRAW         Turns redrawing on or off.
    WM_TIMER             Begins editing of an item label. If the user
                         clicks the label of the focused item, the list
                         view control sets a timer instead of entering
                         edit mode immediately. The timer makes it
                         possible for the control to not enter edit mode if
                         the user double-clicks the label.
    WM_VSCROLL           Scrolls the list view vertically.
    WM.sub.--            Updates the window scroll bars. If the current
    WINDOWPOS            view is icon or small icon view and the
    CHANGED              LVS_AUTOARRANGE style is specified, the
                         list view control also arranges the list items.
    WM_WININICHANGE      Processes changes to system metrics.

    // CreateListView - creates a list view control.
    // Returns the handle of the new control if successful or NULL
    //  otherwise.
    // hwndParent - handle of the control's parent window
    // pfData - file containing list view items
    HWND WINAPI CreateListView(HWND hwndParent, FILE *pfData)
    {
        HWND hwndLV;
        // Force the common controls DLL to be loaded.
        InitCommonControls();
        // Create the list view window.
        hwndLV = CreateWindow(WC_LISTVIEW, "",
            WS_CHILD .vertline. LVS_REPORT .vertline. LVS_EDITLABELS,
            0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
            hwndParent, NULL, g_hinst, NULL);
        if (hwndLV == NULL)
            return NULL;
        // Call application-defined functions to initialize the
        // image lists, add columns, and add some items.
        if (!InitListViewImageLists(hwndLV) .vertline..vertline.
                !InitListViewColumns(hwndLV) .vertline..vertline.
                !InitListViewItems(hwndLV, pfData)) {
            DestroyWindow(hwndLV);
            return FALSE;
        }
        return hwndLV;    // return the control's handle
    }

    // InitListViewImageList - creates image lists for a list view.
    // Returns TRUE if successful or FALSE otherwise.
    // hwndLV - handle of the list view control
    BOOL WINAPI InitListViewImageLists(HWND hwndLV)
    {
        HICON hiconItem;         // icon for list view items
        HIMAGELIST himlLarge;    // image list for icon view
        HIMAGELIST himlSmall;    // image list for other views
        // Create the large and small icon image lists.
        himlLarge = ImageList_Create(GetSystemMetrics(SM_CXICON),
            GetSystemMetrics(SM_CYICON), TRUE, 1, 1);
        himlSmall = ImageList_Create(GetSystemMetrics(SM.sub.--
        CXSMICON),
            GetSystemMetrics(SM_CYSMICON), TRUE, 1, 1);
        // Add an icon to each image list.
        hiconItem = LoadIcon(g_hinst, MAKEINTRESOURCE(IDI.sub.--
        ITEM));
        ImageList_AddIcon(himlLarge, hiconItem);
        ImageList_AddIcon(himlSmall, hiconItem);
        DeleteObject(hiconItem);
        // Assign the image lists to the list view control.
        ListView_SetImageList(hwndLV, himlLarge, LVSIL_NORMAL);
        ListView_SetImageList(hwndLV, himlSmall, LVSIL_SMALL);
        return TRUE;
    }

    // InitListViewColumns - adds columns to a list view control.
    // Returns TRUE if successful or FALSE otherwise.
    // hwndLV - handle of the list view control
    BOOL WINAPI InitListViewColumns(HWND hwndLV)
    {
        extern char g_achTemp[256]; // temporary buffer
        LV_COLUMN lvc;
        int iCol;
        // Initialize the LV_COLUMN structure.
        lvc.mask = LVCF_FMT .vertline. LVCF_WIDTH .vertline. LVCF_TEXT
     .vertline.
        LVCF_SUBITEM;
        lvc.fmt = LVCFMT_LEFT;
        lvc.cx = 100;
        lvc.pszText = g_achTemp;
        // Add the columns.
        for (iCol = 0; iCol < C_COLUMNS; iCol++) {
            lvc.iSubItem = iCol;
            LoadString(g_hinst, IDS_FIRSTCOLUMN + iCol,
                    g_achTemp, sizeof(g_achTemp));
            if (ListView_InsertColumn(hwndLV, iCol, &lvc) == -1)
                return FALSE;
        }
        return TRUE;
    }

    #define C_COLUMNS 6
    typedef struct myitem_taq {
        LPSTR aCols[C_COLUMNS];
    } MYITEM;

    // InitListViewItems - adds a items and subitems to a list view.
    // Returns TRUE if successful or FALSE otherwise.
    // hwndLV - handle of the list view control
    // pfData - text file containing list view items with columns
    //      separated by semicolons
    BOOL WINAPI InitListViewItems(HWND hwndLV, FILE *pfData)
    {
        extern char g_achTemp[256];         // temporary buffer
        PSTR pszStart;
        PSTR pszEnd;
        int iItem;
        int iSubItem;
        LV_ITEM lvi;
        // Initialize LV_ITEM members that are common to all items.
        lvi.mask = LVIF_TEXT .vertline. LVIF_IMAGE .vertline. LVIF_PARAM
     .vertline.
        LVIF_STATE;
        lvi.state = 0;
        lvi.stateMask = 0;
        lvi.pszText = LPSTR_TEXTCALLBACK;   // app. maintains text
        lvi.iImage = 0;                     // image list index
        // Read each line in the specified file.
        for (iItem = 0;
                fgets(g_achTemp, sizeof(g_achTemp), pfData);
                iItem++) {
            // Allocate an application-defined structure to store the
            // item label and the text of each subitem.
            MYITEM *pItem = LocalAlloc(LPTR, sizeof(MYITEM));
            // Copy the first string (the label).
            pszEnd = strchr(g_achTemp, `;`);
            *pszEnd = `.backslash.0`;
            pItem->aCols[0] = DupString(g_achTemp);
            // Copy subsequent strings (subitems).
            for (iSubItem = 1;
                    iSubItem < C_COLUMNS && pszEnd != NULL;
                    iSubItem++) {
                pszStart = pszEnd + 1;
                if ((pszEnd = strchr(pszStart, `;`)) != NULL)
                    *pszEnd = `.backslash.0`;
                pItem->aCols[iSubItem] = DupString(pszStart);
            }
            // Initialize item-specific LV_ITEM members.
            lvi.iItem = iItem;
            lvi.iSubItem = 0;
            lvi.lParam = (LPARAM) pItem; // item data
            // Add the item.
            ListView_InsertItem(hwndLV, &lvi);
            // There is no need to set the text of the subitems. They
            // default to LPSTR_TEXTCALLBACK.
        }
        return TRUE;
    }
    // DupString - allocates a copy of a string.
    // lpsz - address of the null-terminated string to copy
    LPSTR DupString(LPSTR lpsz)
    {
        int cb = lstrlen(lpsz) + 1;
        LPSTR lpszNew = LocalAlloc(LMEM_FIXED, cb);
        if (lpszNew != NULL)
            CopyMemory(lpszNew, lpsz, cb);
        return lpszNew;
    }

    case WM_NOTIFY:
        // Branch depending on the specific notification message.
        switch (((LPNMHDR) lParam)->code) {
            // Process LVN_GETDISPINFO to supply information about
            //  callback items.
            case LVN_GETDISPINFO:
                Main_OnGetDispInfo((LV_DISPINFO *) lParam);
                break;
            // Process LVN_ENDLABELEDIT to change item labels after
            //  in-place editing.
            case LVN_ENDLABELEDIT:
                return Main_OnEndLabelEdit(
                    (LV_DISPINFO *) lParam
                    );
            // Process LVN_COLUMNCLICK to sort items by column.
            case LVN_COLUMNCLICK:
                #define pnm ((NM_LISTVIEW *) lParam)
                ListView_SortItems(
                    pnm->hdr.hwndFrom,
                    ListViewCompareFunc,
                    (LPARAM) (pnm->iSubItem)
                    );
                #undef pnm
                break;
    }
    break;

    // Main_OnGetDispInfo - processes the LVN_GETDISPINFO
    //  notification message.
    // pnmv - value of lParam (points to an LV_DISPINFO structure)
    VOID WINAPI Main_OnGetDispInfo(LV_DISPINFO *pnmv)
    {
        // Provide the item or subitem's text if requested.
        if (pnmv->item.mask & LVIF_TEXT) {
            MYITEM *pItem = (MVITEM *) (pnmv->item.lParam);
            lstrcpy(pnmv->item.pszText,
                    pItem->aCols(pnmv->item.iSubItem));
        }
    }
    // Main_OnEndLabelEdit - processes the LVN_ENDLABELEDIT
    //  notification message.
    // Returns TRUE if the label is changed or FALSE otherwise.
    // pnmv - value of lParam (points to an LV_DISPINFO structure)
    BOOL Main_OnEndLabelEdit(LV_DISPINFO *pnmv)
    {
        MYITEM *pItem;
        // The item is -1 if editing is being canceled.
        if (pnmv->item.iItem == -1)
            return FALSE;
        // Copy the new text to the application-defined structure,
        // a pointer to which is saved as item data.
        pItem = (MYITEM *) (pnmv->item.lParam);
        pItem->aCols[0] = (PSTR) LocalReAlloc(
            (HLOCAL) (pItem->aCols[0]),
            lstrlen(pnmv->item.pszText) + 1,
            LMEM_MOVEABLE
            );
        lstrcpy(pItem->aCols[0], pnmv->item.pszText);
        // No need to set the item text, because it is a callback item.
        return TRUE;
    }
    // ListViewCompareFunc - sorts the list view control. It is a
    //  comparison function.
    // Returns a negative value if the first item should precede the
    //  second item, a positive value if the first item should
    //  follow the second item, and zero if the items are equivalent.
    // lParam1 and lParam2 - item data for the two items (in this
    //  case, pointers to application-defined MYITEM structures)
    // lParamSort - value specified by the LVM_SORTITEMS message
    //  (in this case, the index of the column to sort)
    int CALLBACK ListViewCompareFunc(
        LPARAM lParam1,
        LPARAM lParam2,
        LPARAM lParamSort)
    {
        MYITEM *pItem1 = (MYITEM *) lParam1;
        MYITEM *pItem2 = (MYITEM *) lParam2;
        // Compare the specified column.
        int iCmp = lstrcmpi(pItem1->aCols[lParamSort],
            pItem2->aCols[lParamSort]);
        // Return the result if nonzero. Otherwise, compare the
        // first column.
        return (iCmp != 0) ? iCmp :
            lstrcmpi(pItem1->aCols[0], pItem2->aCols[0]);
    }

    // SetView - sets a list view's window style to change the view.
    // hwndLV - handle of the list view control
    // dwView - value specifying a view style
    VOID WINAPI SetView(HWND hwndLV, DWORD dwView)
    {
        // Get the current window style.
        DWORD dwStyle = GetWindowLong(hwndLV, GWL_STYLE);
        // Only set the window style if the view bits have changed.
        if ((dwStyle & LVS_TYPEMASK) != dwView)
            SetWindowLong(hwndLV, GWL_STYLE,
                (dwStyle & .about.LVS_TYPEMASK) .vertline. dwView);
    }

    LVM_ARRANGE
    wParam = (WPARAM) (int) code;
    lParam = 0;
    // Corresponding macro
    BOOL ListView_Arrange(HWND hwnd, UINT code);

    LVA.sub.--         Aligns items along the bottom edge of the
    ALIGNBOTTOM        window.
    LVA_ALIGNLEFT      Aligns items along the left edge of the window.
    LVA_ALIGNRIGHT     Aligns items along the right edge of the window.
    LVA_ALIGNTOP       Aligns items along the top edge of the window.
    LVA_DEFAULT        Aligns items according to the list view's current
                       alignment styles (the default value).
    LVA_SNAPTOGRID     Snaps all icons to the nearest grid position.

    LVM_CREATEDRAGIMAGE
    wParam = (WPARAM) (int) iItem;
    lParam = (LPARAM) (LPPOINT) lpptUpLeft;
    // Corresponding macro
    HIMAGELIST ListView_CreateDragImage(HWND hwnd, int iItem,
        LPPOINT lpptUpLeft);

    LVM_DELETEALLITEMS
    wParam = 0;
    lParam = 0;
    // Corresponding macro
    BOOL ListView_DeleteAllItems(HWND hwnd);

    LVM_DELETECOLUMN
    wParam = (WPARAM) (int) iCol;
    lParam = 0;
    // Corresponding macro
    BOOL ListView_DeleteColumn(HWND hwnd, int iCol);

    LVM_DELETEITEM
    wParam = (WPARAM) (int) iItem;
    lParam = 0;
    // Corresponding macro
    BOOL ListView_DeleteItem(HWND hwnd, int iItem);

    LVM_EDITLABEL
    wParam = (WPARAM) (int) iItem;
    lParam = 0;
    // Corresponding macro
    HWND ListView_EditLabel(HWND hwnd, int iItem);

    LVM_ENSUREVISIBLE
    wParam = (WPARAM) (int) iItem;
    lParam = (LPARAM) (BOOL) fPartialOk;
    // Corresponding macro
    BOOL ListView_EnsureVisible(HWND hwnd, int i, BOOL fPartialOK);

    LVM_FINDITEM
    wParam = (WPARAM) (int) iStart;
    lParam = (LPARAM) (const LV_FINDINFO FAR *) plvfi;
    // Corresponding macro
    int ListView_FindItem(HWND hwnd, int iStart,
        const LV_FINDINFO FAR* plvfi);

    LVM_GETBKCOLOR
    wParam = 0;
    lParam = 0;
    // Corresponding macro
    COLORREF ListView_GetBkColor(HWND hwnd);

    LVM_GETCALLBACKMASK
    wParam = 0;
    lParam = 0;
    // Corresponding macro
    UINT ListView_GetCallbackMask(HWND hwnd);

    LVM_GETCOLUMN
    wParam = (WPARAM) (int) iCol;
    lParam = (LPARAM) (LV_COLUMN FAR *) pcol;
    // Corresponding macro
    BOOL ListView_GetColumn(HWND hwnd, int iCol,
        LV_COLUMN FAR* pcol);

    LVM_GETCOLUMNWIDTH
    wParam = (WPARAM) (int) iCol;
    lParam = 0;
    // Corresponding macro
    int ListView_GetColumnWidth(HWND hwnd, int iCol);

    LVM_GETCOUNTPERPAGE
    wParam = 0;
    lParam = 0;
    // Corresponding macro
    int ListView_GetCountPerPage(HWND hwnd);

    LVM_GETEDITCONTROL
    wParam = 0;
    lParam = 0;
    // Corresponding macro
    HWND ListView_GetEditControl(HWND hwnd, int i);

    LVM_GETIMAGELIST
    wParam = (WPARAM) (int) iImageList;
    lParam = 0;
    // Corresponding macro
    HIMAGELIST ListView_GetImageList(HWND hwnd, int iImageList);

          LVSIL_NORMAL             Image list with large icons
          LVSIL_SMALL              Image list with small icons
          LVSIL_STATE              Image list with state images

    LVM_GETITEM
    wParam = 0;
    lParam = (LPARAM) (LV_ITEM FAR*) pItem;
    // Corresponding macro
    BOOL ListView_GetItem(HWND hwnd, LV_ITEM FAR* pitem);

    LVM_GETITEMCOUNT
    wParam = 0;
    lParam = 0;

    LVM_GETITEMPOSITION
    wParam = (WPARAM) (int) i;
    lParam = (LPARAM) (POINT FAR *) ppt;
    // Corresponding macro
    BOOL ListView_GetItemPosition(HWND hwnd, int i, POINT FAR*
    ppt);

    LVM_GETITEMRECT
    wParam = (WPARAM) (int) i;
    lParam = (LPARAM) (LPRECT) prc;
    // Corresponding macro
    BOOL ListView_GetItemRect(HWND hwnd, int i, RECT FAR* prc, int
    code);

    LVIR_BOUNDS     Returns the bounding rectangle of the entire item,
                    including the icon and label.
    LVIR_ICON       Returns the bounding rectangle of the icon or small
                    icon.
    LVIR_LABEL      Returns the bounding rectangle of the item text.

    LVM_GETITEMSTATE
    wParam = (wPARAM) (int) i;
    lParam = (LPARAM) (UINT) mask;
    // Corresponding macro
    UINT WINAPI ListView_GetItemState(HWND hwnd, int i, UINT mask);

    LVM_GETITEMTEXT
    wParam = (WPARAM) (int) iItem;
    lParam = (LPARAM) (LV_ITEM FAR *) pitem;
    // Corresponding macro
    void WINAPI ListView_GetItemText(HWND hwnd, int iItem,
        int iSubItem, LPSTR pszText, int cchTextMax);

    LVM_GETNEXTITEM
    wParam = (WPARAM) (int) iStart;
    lParam = MAKELPARAM((UINT) flags, 0);
    // Corresponding macro
    int ListView_GetNextItem(HWND hwnd, int iStart, UINT flags);

    LVNI_ABOVE        Searches for an item that is above the specified item.
    LVNI_ALL          Searches for a subsequent item by index (the default
                      value).
    LVNI_BELOW        Searches for an item that is below the specified
                      item.
    LVNI_PREVIOUS     Searches for a previous item by index.
    LVNI_TOLEFT       Searches for an item to the left of the specified item.
    LVNI_TORIGHT      Searches for an item to the right of the specified
                      item.
    The state can be zero, or it can be one or more of these values:
    LVNI.sub.--       The item has the LVIS_DROPHILITED state flag
    DROPHILITED       set.
    LVNI_FOCUSED      The item has the LVIS_FOCUSED state flag set.
    LVNI_HIDDEN       The item has the LVIS_HIDDEN state flag set.
    LVNI_MARKED       The item has the LVIS_MARKED state flag set.
    LVNI_SELECTED     The item has the LVIS_SELECTED state flag set.

    LVM_GETORIGIN
    wParam = 0;
    lParam = (LPARAM) (LPPOINT) lpptOrg;
    // Corresponding macro
    BOOL ListView_GetOrigin(HWND hwnd, LPPOINT lpptOrg);

    LVM_GETSTRINGWIDTH
    wParam = 0;
    lParam = (LPARAM) (LPCSTR) psz;
    // Corresponding macro
    int ListView_GetStringWidth(HWND hwnd, LPCSTR psz);

    LVM_GETTEXTBKCOLOR
    wParam = 0;
    lParam = 0;
    // Corresponding macro
    COLORREF ListView_GetTextBkColor(HWND hwnd);

    LVM_GETTEXTCOLOR
    wParam = 0;
    lParam = 0;
    // Corresponding macro
    COLORREF ListView_GetTextColor(HWND hwnd);

    LVM_GETTOPINDEX
    wParam = 0;
    lParam = 0;
    // Corresponding macro
    int ListView_GetTopIndex(HWND hwnd);

    LVM_GETVIEWRECT
    wParam = 0;
    lParam = (LPARAM) (RECT FAR *) prc;
    // Corresponding macro
    BOOL ListView_GetViewRect(HWND hwnd, RECT FAR* prc);

    LVM_HITTEST
    wParam = 0;
    lParam = (LPARAM) (LV_HITTESTINFO FAR *) pinfo;
    // Corresponding macro
    int ListView_HitTest(HWND hwnd, LV_HITTESTINFO FAR* pinfo);

    LVM_INSERTCOLUMN
    wParam = (WPARAM) (int) iCol;
    lParam = (LPARAM) (const LV_COLUMN FAR *) pcol;
    // Corresponding macro
    int ListView_InsertColumn(HWND hwnd, int iCol,
        const LV_COLUMN FAR* pcol);

    LVM_INSERTITEM
    wParam = 0;
    lParam = (LPARAM) (const LV_ITEM FAR *) pitem;
    // Corresponding macro
    int ListView_InsertItem(HWND hwnd, const LV_ITEM FAR* pitem);

    LVH_REDRAWITEMS
    wParam = 0;
    lParam = MAKELPARAM((int) iFirst, (int), iLast);
    // Corresponding macro
    BOOL ListView_RedrawItems(HWND hwnd, int iFirst, int iLast);

    LVM_SCROLL
    wParam = 0;
    lParam = MAKELPARAM((int) dx, (int) dy);
    // Corresponding macro
    BOOL ListView_Scroll(HWND hwnd, int dx, int dy);

    LVM_SETBKCOLOR
    wParam = 0;
    lParam = (LPARAM) (COLORREF) clrBk;
    // Corresponding macro
    BOOL ListView_SetBkColor(HWND hwnd, COLORREF clrBk);

    LVM_SETCALLBACKMASK
    wParam = (WPARAM) (UINT) mask;
    lParam = 0;
    // Corresponding macro
    BOOL ListView_SetCallbackMask(HWND hwnd, UINT mask);

    LVM_SETCOLUMN
    wParam = (WPARAM) (int) iCol;
    lParam = (LPARAM) (const LV_COLUMN FAR *) pcol;
    // Corresponding macro
    BOOL ListView_SetColumn(HWND hwnd, int iCol, LV_COLUMN
    FAR* pcol);

    LVM_SETCOLUMNWIDTH
    wParam = (WPARAM) (int) iCol;
    lParam = MAKELPARAM((int) cx, 0);
    // Corresponding macro
    BOOL ListView_SetColumnWidth(HWND hwnd, int iCol, int cx);

    LVM_SETIMAGELIST
    wParam = (WPARAM) (int) iImageList;
    lParam = (LPARAM) (HIMAGELIST) himl;
    // Corresponding macro
    BOOL ListView_SetImageList(HWND hwnd, HIMAGELIST himl, int
    iImageList);

    LVM_SETITEM
    wParam = 0;
    lParam = (LPARAM) (const LV_ITEM FAR *) pitem;
    // Corresponding macro
    BOOL ListView_SetItem(HWND hwnd, const LV_ITEM FAR* pitem);

    LVM_SETITEMCOUNT
    wParam = (WPARAM) (int) cItems;
    lParam = 0;
    // Corresponding macro
    VOID ListView_SetItemCount(HWND hwnd, int cItems);

    LVM_SETITEMPOSITION
    wParam = (LPARAM) (int) i;
    lParam = MAKELPARAM(int) x, (int) y);
    // Corresponding macro
    BOOL ListView_SetItemPosition(HWND hwnd, int i, int x, int y);

    LVM_SETITEMSTATE
    wParam = (wPARAM) (int) i;
    lParam = (LPARAM) (LV_ITEM FAR *) pitem;
    // Corresponding macro
    BOOL WINAPI ListView_SetItemState(HWND hwnd, int i,
        UINT state, UINT mask);

    LVM_SETITEMTEXT
    wParam = (WPARAM) (int) i;
    lParam = (LPARAM) (LV_ITEM FAR *) pitem;
    // Corresponding macro
    VOID WINAPI ListView_SetItemText(HWND hwnd, int i,
        int iSubItem, LPCSTR pszText);

    LVM_SETTEXTBKCOLOR
    wParam = 0;
    lParam = (LPARAM) (COLORREF) clrText;
    // Corresponding macro
    BOOL ListView_SetTextBkColor(HWND hwnd, COLORREF clrText);

    LVM_SETTEXTCOLOR
    wParam = 0;
    lParam = (LPARAM) (COLORREF) clrText;
    // Corresponding macro
    BOOL ListView_SetTextColor(HWND hwnd, COLORREF clrText);

    LVM_SORTITEMS
    wParam = (WPARAM) (LPARAM) lParamSort;
    lParam = (LPARAM) (PFNLVCOMPARE) pfnCompare;
    // Corresponding macro
    BOOL ListView_SortItems(HWND hwnd, PFNLVCOMPARE
    pfnCompare,
        LPARAM lParamSort);

    int CALLBACK CompareFunc(LPARAM lParam1, LPARAM lParam2,
        LPARAM lParamSort);

    LVM_UPDATE
    wParam = (WPARAM) iItem;
    lParam = 0;
    // Corresponding macro
    BOOL ListView_Update(HWND hwnd, int iItem);

    LVN_BEGINDRAG
    pnmv = (NM_LISTVIEW FAR *) lParam;

    LVN_BEGINLABELEDIT
    pdi = (LV_DISPINFO FAR *) lParam;

    LVN_BEGINRDRAG
    pnmv = (NM_LISTVIEW FAR *) lParam;

    LVN_COLUMNCLICK
    pnmv = (NM_LISTVIEW FAR *) lParam;

    pnmv = (NM_LISTVIEW FAR *) lParam;

    LVN_DELETEITEM
    pnmv = (NM_LISTVIEW FAR *) lParam;

    LVN_ENDDRAG
    pnmv = (NM_LISTVIEW FAR *) lParam;

    LVN_ENDLABELEDIT
    pdi = (LV_DISPINFO FAR *) lParam;

    LVN_ENDRDRAG
    pnmv = (NM_LISTVIEW FAR *) lParam;

    LVN_GETDISPINFO
    pnmv = (LV_DISPINFO FAR *) lParam;

    LVN_INSERTITEM
    pnmv = (NM_LISTVIEW FAR *) lParam;

    LVN_ITEMCHANGED
    pnmv = (NM_LISTVIEW FAR *) lParam;

    LVN_ITEMCHANGING
    pnmv = (NM_LISTVIEW FAR *) lParam;

    LVN_KEYDOWN
    pnkd = (LV_KEYDOWN FAR *) lParam;

    LVN_SETDISPINFO
    pnmv = (LV_DISPINFO FAR *) lParam;

    typedef struct _LV_COLUMN {
        UINT mask;        // see below
        int fmt;          // see below
        int cx;           // width of the column, in pixels
        LPSTR pszText;    // see below
        int cchTextMax;   // see below
        int iSubItem:     // index of subitem associated with column
    } LV_COLUMN;

          LVCF_FMT               The fmt member is valid.
          LVCF_SUBITEM           The iSubItem member is valid.
          LVCF_TEXT              The pszText member is valid.
          LVCF_WIDTH             The cx member is valid.

    typedef struct tagLV_DISPINFO {
        NMHDR hdr; // required for all WM_NOTIFY messages
        LV_ITEM item; // see below
    } LV_DISPINFO;

    LVIF_IMAGE    The iImage member specifies, or is to receive, the index
                  of the item's icon in the image list.
    LVIF_STATE    The state member specifies, or is to receive, the state of
                  the item.
    LVIF_TEXT     The pszText member specifies the new item text or the
                  address of a buffer that is to receive the item text.

    typedef struct _LV_FINDING {
        UINT flags;       //see below
        LPCSTR psz;       //see below
        LPARAM lParam;    //see below
    } LV_FINDINFO;

    LVFI_NOCASE     Ignores case in string comparisons. This value is
                    ignored if the LVFI_STRING value is not specified.
    LVFI_PARAM      Searches based on the IParam member. The IParam
                    member of the matching item's LV_ITEM structure
                    must match the IParam member of this structure.
                    If this value is specified, all other values are ignored.
    LVFI_PARTIAL    Matches if the item text begins with the string pointed
                    to by the psz member. This value implies use of the
                    LVFI_STRING value, and it cannot be used with the
                    LVFI_SUBSTRING value.
    LVFI_STRING     Searches based on item text. Unless additional values
                    are specified, the item text of the matching item must
                    exactly match the string pointed to by the psz member.
    LVFI.sub.--     Matches if the string pointed to by the psz member is
    SUBSTRING       contained anywhere in the item text. This value
                    implies use of the LVFI_STRING value, and it cannot
                    be used with the LVFI_PARTIAL value.
    LVFI_WRAP       Continues the search at the beginning if no match is
                    found.

    typedef struct _LV_HITTESTINFO {
        POINT pt;     // position to hit test, in client coordinates
        UINT flags;   // see below
        int iItem;    // receives the index of the matching item
    } LV_HITTESTINFO;

    LVHT_ABOVE             The position is above the client area of the
                           control.
    LVHT_BELOW             The position is below the client area of the
                           control.
    LVHT_NOWHERE           The position is inside the list view control's
                           client window but is not over a list item.
    LVHT_ONITEMICON        The position is over a list view item's icon.
    LVHT_ONITEMLABEL       The position is over a list view item's text.
    LVHT.sub.--            The position is over the state image of a list
    ONITEMSTATEICON        view item.
    LVHT_TOLEFT            The position is to the left of the list view
                           control's client area.
    LVHT_TORIGHT           The position is to the right of the list view
                           control's client area.

    typedef struct _LV_ITEM {
        UINT        mask;         // see below
        int         iItem;        // item this structure refers to
        int         iSubItem;     // subitem this refers to, or zero
        UINT        state;        // see below
        UINT        stateMask;    // see below
        LPSTR       pszText;      // see below
        int         cchTextMax;   // see below
        int         iImage;       // see below
        LPARAM      lParam;       // 32-bit value to associate with item
    } LV_ITEM;