dlls/comctl32/listview.c

   1 /*
   2  * Listview control
   3  *
   4  * Copyright 1998 Eric Kohl
   5  * Copyright 1999 Luc Tourangeau
   6  *
   7  * NOTES
   8  * Listview control implementation.
   9  *
  10  * TODO:
  11  *
  12  *   1. Multiple selections in icon or small icon display modes DO NOT
  13  *      behave like the Microsoft control.
  14  *   2. No horizontal scrolling when header is larger than the client area.
  15  *   3. Implement LVM_FINDITEM for key selections.
  16  *   4. Drawing optimizations.
  17  *
  18  * Notifications:
  19  *   LISTVIEW_Notify : most notifications from children (editbox and header)
  20  *
  21  * Data structure:
  22  *   LISTVIEW_SortItems : empty stub
  23  *   LISTVIEW_SetItemCount : empty stub
  24  *
  25  * Unicode:
  26  *   LISTVIEW_SetItem32W : no unicode support
  27  *   LISTVIEW_InsertItem32W : no unicode support
  28  *   LISTVIEW_InsertColumn32W : no unicode support
  29  *   LISTVIEW_GetColumnW : no unicode support
  30  *
  31  * Advanced functionality:
  32  *   LISTVIEW_GetNumberOfWorkAreas : not implemented
  33  *   LISTVIEW_GetNextItem : empty stub
  34  *   LISTVIEW_GetHotCursor : not implemented
  35  *   LISTVIEW_GetHotItem : not implemented
  36  *   LISTVIEW_GetHoverTime : not implemented
  37  *   LISTVIEW_GetISearchString : not implemented
  38  *   LISTVIEW_GetBkImage : not implemented
  39  *   LISTVIEW_EditLabel : REPORT (need to implement a timer)
  40  *   LISTVIEW_GetColumnOrderArray : not implemented
  41  *   LISTVIEW_Arrange : empty stub
  42  *   LISTVIEW_FindItem : empty stub
  43  *   LISTVIEW_ApproximateViewRect : incomplete
  44  *   LISTVIEW_Scroll : not implemented
  45  *   LISTVIEW_KeyDown : page up and page down  + redo small icon and icon
  46  *   LISTVIEW_RedrawItems : empty stub
  47  *   LISTVIEW_Update : not completed
  48  */
  49
  50 #include <string.h>
  51 #include "winbase.h"
  52 #include "commctrl.h"
  53 #include "listview.h"
  54 #include "debug.h"
  55
  56 DEFAULT_DEBUG_CHANNEL(listview)
  57
  58 /*
  59  * constants
  60  */
  61
  62 /* maximum size of a label */
  63 #define DISP_TEXT_SIZE 128
  64
  65 /* padding for items in list and small icon display modes */
  66 #define WIDTH_PADDING 12
  67
  68 /* padding for items in list, report and small icon display modes */
  69 #define HEIGHT_PADDING 1
  70
  71 /* offset of items in report display mode */
  72 #define REPORT_MARGINX 2
  73
  74 /* padding for icon in large icon display mode */
  75 #define ICON_TOP_PADDING 2
  76 #define ICON_BOTTOM_PADDING 2
  77
  78 /* padding for label in large icon display mode */
  79 #define LABEL_VERT_OFFSET 2
  80
  81 /* default label width for items in list and small icon display modes */
  82 #define DEFAULT_LABEL_WIDTH 40
  83
  84 /* default column width for items in list display mode */
  85 #define DEFAULT_COLUMN_WIDTH 96
  86
  87 /*
  88  * macros
  89  */
  90
  91 /* retrieve the number of items in the listview */
  92 #define GETITEMCOUNT(infoPtr) ((infoPtr)->hdpaItems->nItemCount)
  93 #define ListView_LVNotify(hwnd,lCtrlId,plvnm) \
  94     (BOOL)SendMessageA((hwnd),WM_NOTIFY,(WPARAM)(INT)lCtrlId,(LPARAM)(LPNMLISTVIEW)(plvnm))
  95 #define ListView_Notify(hwnd,lCtrlId,pnmh) \
  96     (BOOL)SendMessageA((hwnd),WM_NOTIFY,(WPARAM)(INT)lCtrlId,(LPARAM)(LPNMHDR)(pnmh))
  97
  98 /*
  99  * forward declarations
 100  */
 101
 102 static VOID LISTVIEW_AlignLeft(HWND);
 103 static VOID LISTVIEW_AlignTop(HWND);
 104 static VOID LISTVIEW_AddGroupSelection(HWND, INT);
 105 static VOID LISTVIEW_AddSelection(HWND, INT);
 106 static BOOL LISTVIEW_AddSubItem(HWND, LPLVITEMA);
 107 static INT LISTVIEW_FindInsertPosition(HDPA, INT);
 108 static VOID LISTVIEW_GetItemDispInfo(HWND, INT, LISTVIEW_ITEM *lpItem, INT *,
 109                                      UINT *, CHAR **, INT);
 110 static INT LISTVIEW_GetItemHeight(HWND, LONG);
 111 static BOOL LISTVIEW_GetItemPosition(HWND, INT, LPPOINT);
 112 static LRESULT LISTVIEW_GetItemRect(HWND, INT, LPRECT);
 113 static INT LISTVIEW_GetItemWidth(HWND, LONG);
 114 static INT LISTVIEW_GetLabelWidth(HWND, INT);
 115 static LRESULT LISTVIEW_GetOrigin(HWND, LPPOINT);
 116 static LISTVIEW_SUBITEM* LISTVIEW_GetSubItem(HDPA, INT);
 117 static VOID LISTVIEW_GetSubItemDispInfo(HWND hwnd, INT, LPARAM,
 118                                         LISTVIEW_SUBITEM *, INT, INT *,
 119                                         CHAR **, INT);
 120 static LRESULT LISTVIEW_GetViewRect(HWND, LPRECT);
 121 static BOOL LISTVIEW_InitItem(HWND, LISTVIEW_ITEM *, LPLVITEMA);
 122 static BOOL LISTVIEW_InitSubItem(HWND, LISTVIEW_SUBITEM *, LPLVITEMA);
 123 static LRESULT LISTVIEW_MouseSelection(HWND, INT, INT);
 124 static BOOL LISTVIEW_RemoveColumn(HDPA, INT);
 125 static VOID LISTVIEW_RemoveSelections(HWND, INT, INT);
 126 static BOOL LISTVIEW_RemoveSubItem(HDPA, INT);
 127 static BOOL LISTVIEW_ScrollView(HWND, INT, INT);
 128 static VOID LISTVIEW_SetGroupSelection(HWND, INT);
 129 static BOOL LISTVIEW_SetItem(HWND, LPLVITEMA);
 130 static VOID LISTVIEW_SetItemFocus(HWND, INT);
 131 static BOOL LISTVIEW_SetItemPosition(HWND, INT, INT, INT);
 132 static VOID LISTVIEW_SetScroll(HWND, LONG);
 133 static VOID LISTVIEW_SetSelection(HWND, INT);
 134 static VOID LISTVIEW_SetSize(HWND, LONG, LONG, LONG);
 135 static BOOL LISTVIEW_SetSubItem(HWND, LPLVITEMA);
 136 static VOID LISTVIEW_SetViewInfo(HWND, LONG);
 137 static LRESULT LISTVIEW_SetViewRect(HWND, LPRECT);
 138 static BOOL LISTVIEW_ToggleSelection(HWND, INT);
 139 static VOID LISTVIEW_UnsupportedStyles(LONG lStyle);
 140
 141 /***
 142  * DESCRIPTION:
 143  * Scrolls the content of the listview.
 144  *
 145  * PARAMETER(S):
 146  * [I] HWND : window handle
 147  * [I] INT : number of horizontal scroll positions
 148  *           (relative to the current scroll postioon)
 149  * [I] INT : number of vertical scroll positions
 150  *           (relative to the current scroll postioon)
 151  *
 152  * RETURN:
 153  *   SUCCESS : TRUE
 154  *   FAILURE : FALSE
 155  */
 156 static BOOL LISTVIEW_ScrollView(HWND hwnd, INT nHScroll, INT nVScroll)
 157 {
 158   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
 159   LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
 160   INT nListWidth = infoPtr->rcList.right - infoPtr->rcList.left;
 161   INT nListHeight = infoPtr->rcList.bottom - infoPtr->rcList.top;
 162   INT nHScrollPos = 0;
 163   INT nVScrollPos = 0;
 164   INT nHScrollInc = 0;
 165   INT nVScrollInc = 0;
 166   BOOL bResult = FALSE;
 167
 168   if (((lStyle & WS_HSCROLL) != 0) && (nHScroll != 0))
 169   {
 170     switch (LVS_TYPEMASK & lStyle)
 171     {
 172     case LVS_LIST:
 173       nHScrollInc = nHScroll * infoPtr->nItemWidth;
 174       break;
 175
 176     case LVS_REPORT:
 177       /* TO DO : not implemented at this point. I experiences some
 178          problems when performing child window scrolling. */
 179       break;
 180
 181     case LVS_SMALLICON:
 182     case LVS_ICON:
 183       nHScrollInc = nHScroll * max(nListWidth, nListWidth / 10);
 184       break;
 185     }
 186
 187     nHScrollPos = GetScrollPos(hwnd, SB_HORZ) + nHScroll;
 188   }
 189
 190   if (((lStyle & WS_VSCROLL) != 0) & (nVScroll != 0))
 191   {
 192     switch (LVS_TYPEMASK & lStyle)
 193     {
 194     case LVS_REPORT:
 195       nVScrollInc = nVScroll * infoPtr->nItemHeight;
 196       nVScrollPos = GetScrollPos(hwnd, SB_VERT) + nVScroll;
 197       break;
 198
 199     case LVS_SMALLICON:
 200     case LVS_ICON:
 201       nVScrollInc = nVScroll * max(nListHeight, nListHeight / 10);
 202       nVScrollPos = GetScrollPos(hwnd, SB_VERT) + nVScroll;
 203       break;
 204     }
 205   }
 206
 207   /* perform scroll operation & set new scroll position */
 208   if ((nHScrollInc != 0) || (nVScrollInc != 0))
 209   {
 210     RECT rc;
 211     HDC hdc = GetDC(hwnd);
 212     ScrollDC(hdc, -nHScrollInc, -nVScrollInc, &infoPtr->rcList, NULL,
 213              (HRGN) NULL, &rc);
 214     InvalidateRect(hwnd, &rc, TRUE);
 215     SetScrollPos(hwnd, SB_HORZ, nHScrollPos, TRUE);
 216     SetScrollPos(hwnd, SB_VERT, nVScrollPos, TRUE);
 217     ReleaseDC(hwnd, hdc);
 218     bResult = TRUE;
 219   }
 220
 221   return bResult;
 222 }
 223
 224 /***
 225  * DESCRIPTION:
 226  * Prints a message for unsupported window styles.
 227  * A kind of TODO list for window styles.
 228  *
 229  * PARAMETER(S):
 230  * [I] LONG : window style
 231  *
 232  * RETURN:
 233  * None
 234  */
 235 static VOID LISTVIEW_UnsupportedStyles(LONG lStyle)
 236 {
 237   if ((LVS_TYPEMASK & lStyle) == LVS_EDITLABELS)
 238   {
 239     FIXME( listview, "  LVS_EDITLABELS\n");
 240   }
 241
 242   if ((LVS_TYPEMASK & lStyle) == LVS_NOCOLUMNHEADER)
 243   {
 244     FIXME( listview, "  LVS_SORTDESCENDING\n");
 245   }
 246
 247   if ((LVS_TYPEMASK & lStyle) == LVS_NOLABELWRAP)
 248   {
 249     FIXME( listview, "  LVS_NOLABELWRAP\n");
 250   }
 251
 252   if ((LVS_TYPEMASK & lStyle) == LVS_NOSCROLL)
 253   {
 254     FIXME( listview, "  LVS_NOSCROLL\n");
 255   }
 256
 257   if ((LVS_TYPEMASK & lStyle) == LVS_NOSORTHEADER)
 258   {
 259     FIXME( listview, "  LVS_NOSORTHEADER\n");
 260   }
 261
 262   if ((LVS_TYPEMASK & lStyle) == LVS_OWNERDRAWFIXED)
 263   {
 264     FIXME( listview, "  LVS_OWNERDRAWFIXED\n");
 265   }
 266
 267   if ((LVS_TYPEMASK & lStyle) == LVS_SHAREIMAGELISTS)
 268   {
 269     FIXME( listview, "  LVS_SHAREIMAGELISTS\n");
 270   }
 271
 272   if ((LVS_TYPEMASK & lStyle) == LVS_SHOWSELALWAYS)
 273   {
 274     FIXME( listview, "  LVS_SHOWSELALWAYS\n");
 275   }
 276
 277   if ((LVS_TYPEMASK & lStyle) == LVS_SINGLESEL)
 278   {
 279     FIXME( listview, "  LVS_SINGLESEL\n");
 280   }
 281
 282   if ((LVS_TYPEMASK & lStyle) == LVS_SORTASCENDING)
 283   {
 284     FIXME( listview, "  LVS_SORTASCENDING\n");
 285   }
 286
 287   if ((LVS_TYPEMASK & lStyle) == LVS_SORTDESCENDING)
 288   {
 289     FIXME( listview, "  LVS_SORTDESCENDING\n");
 290   }
 291 }
 292
 293 /***
 294  * DESCRIPTION:
 295  * Aligns the items with the top edge of the window.
 296  *
 297  * PARAMETER(S):
 298  * [I] HWND : window handle
 299  *
 300  * RETURN:
 301  * None
 302  */
 303 static VOID LISTVIEW_AlignTop(HWND hwnd)
 304 {
 305   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
 306   LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
 307   INT nListWidth = infoPtr->rcList.right - infoPtr->rcList.left;
 308   POINT ptItem;
 309   RECT rcView;
 310   INT i;
 311
 312   switch (LVS_TYPEMASK & lStyle)
 313   {
 314   case LVS_SMALLICON:
 315   case LVS_ICON:
 316     ZeroMemory(&ptItem, sizeof(POINT));
 317     ZeroMemory(&rcView, sizeof(RECT));
 318     if (nListWidth > infoPtr->nItemWidth)
 319     {
 320       for (i = 0; i < GETITEMCOUNT(infoPtr); i++)
 321       {
 322         if (ptItem.x + infoPtr->nItemWidth > nListWidth)
 323         {
 324           ptItem.x = 0;
 325           ptItem.y += infoPtr->nItemHeight;
 326         }
 327
 328         LISTVIEW_SetItemPosition(hwnd, i, ptItem.x, ptItem.y);
 329         ptItem.x += infoPtr->nItemWidth;
 330         rcView.right = max(rcView.right, ptItem.x);
 331       }
 332     }
 333     else
 334     {
 335       for (i = 0; i < GETITEMCOUNT(infoPtr); i++)
 336       {
 337         LISTVIEW_SetItemPosition(hwnd, i, ptItem.x, ptItem.y);
 338         ptItem.x += infoPtr->nItemWidth;
 339       }
 340       rcView.right = ptItem.x;
 341       rcView.bottom = infoPtr->nItemHeight;
 342     }
 343
 344     rcView.bottom = ptItem.y + infoPtr->nItemHeight;
 345     LISTVIEW_SetViewRect(hwnd, &rcView);
 346   }
 347 }
 348
 349 /***
 350  * DESCRIPTION:
 351  * Aligns the items with the left edge of the window.
 352  *
 353  * PARAMETER(S):
 354  * [I] HWND : window handle
 355  *
 356  * RETURN:
 357  * None
 358  */
 359 static VOID LISTVIEW_AlignLeft(HWND hwnd)
 360 {
 361   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
 362   LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
 363   INT nListHeight = infoPtr->rcList.bottom - infoPtr->rcList.top;
 364   POINT ptItem;
 365   RECT rcView;
 366   INT i;
 367
 368   switch (LVS_TYPEMASK & lStyle)
 369   {
 370   case LVS_SMALLICON:
 371   case LVS_ICON:
 372     ZeroMemory(&ptItem, sizeof(POINT));
 373     ZeroMemory(&rcView, sizeof(RECT));
 374     if (nListHeight > infoPtr->nItemHeight)
 375     {
 376       for (i = 0; i < GETITEMCOUNT(infoPtr); i++)
 377       {
 378         if (ptItem.y + infoPtr->nItemHeight > nListHeight)
 379         {
 380           ptItem.y = 0;
 381           ptItem.x += infoPtr->nItemWidth;
 382         }
 383
 384         LISTVIEW_SetItemPosition(hwnd, i, ptItem.x, ptItem.y);
 385         ptItem.y += infoPtr->nItemHeight;
 386         rcView.bottom = max(rcView.bottom, ptItem.y);
 387       }
 388     }
 389     else
 390     {
 391       for (i = 0; i < GETITEMCOUNT(infoPtr); i++)
 392       {
 393         LISTVIEW_SetItemPosition(hwnd, i, ptItem.x, ptItem.y);
 394         ptItem.y += infoPtr->nItemHeight;
 395       }
 396       rcView.bottom = ptItem.y;
 397       rcView.right = infoPtr->nItemWidth;
 398     }
 399
 400     rcView.right = ptItem.x + infoPtr->nItemWidth;
 401     LISTVIEW_SetViewRect(hwnd, &rcView);
 402     break;
 403  }
 404 }
 405
 406 /***
 407  * DESCRIPTION:
 408  * Retrieves display information.
 409  *
 410  * PARAMETER(S):
 411  * [I] HWND : window handle
 412  * [I] INT : item index
 413  * [I] LISTVIEW_ITEM* : listview control item
 414  * [O] INT : image index
 415  * [O] UINT : state value
 416  * [O] CHAR** : string
 417  * [I] INT : size of string
 418  *
 419  * RETURN:
 420  * None
 421  */
 422 static VOID LISTVIEW_GetItemDispInfo(HWND hwnd, INT nItem,
 423                                      LISTVIEW_ITEM *lpItem, INT *pnDispImage,
 424                                      UINT *puState, CHAR **ppszDispText,
 425                                      INT nDispTextSize)
 426 {
 427   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
 428   LONG lCtrlId = GetWindowLongA(hwnd, GWL_ID);
 429   NMLVDISPINFOA dispInfo;
 430   ZeroMemory(&dispInfo, sizeof(NMLVDISPINFOA));
 431
 432   if ((pnDispImage != NULL) && (lpItem->iImage == I_IMAGECALLBACK))
 433   {
 434     dispInfo.item.mask |= LVIF_IMAGE;
 435   }
 436
 437   if ((ppszDispText != NULL) && (lpItem->pszText == LPSTR_TEXTCALLBACKA))
 438   {
 439     ZeroMemory(*ppszDispText, sizeof(CHAR)*nDispTextSize);
 440     dispInfo.item.mask |= LVIF_TEXT;
 441     dispInfo.item.pszText = *ppszDispText;
 442     dispInfo.item.cchTextMax = nDispTextSize;
 443   }
 444
 445   if ((puState != NULL) && (infoPtr->uCallbackMask != 0))
 446   {
 447     dispInfo.item.mask |= LVIF_STATE;
 448     dispInfo.item.stateMask = infoPtr->uCallbackMask;
 449   }
 450
 451   if (dispInfo.item.mask != 0)
 452   {
 453     dispInfo.hdr.hwndFrom = hwnd;
 454     dispInfo.hdr.idFrom = lCtrlId;
 455     dispInfo.hdr.code = LVN_GETDISPINFOA;
 456     dispInfo.item.iItem = nItem;
 457     dispInfo.item.iSubItem = 0;
 458     dispInfo.item.lParam = lpItem->lParam;
 459     ListView_Notify(GetParent(hwnd), lCtrlId, &dispInfo);
 460   }
 461
 462   if (pnDispImage != NULL)
 463   {
 464     if (dispInfo.item.mask & LVIF_IMAGE)
 465     {
 466       *pnDispImage = dispInfo.item.iImage;
 467     }
 468     else
 469     {
 470       *pnDispImage = lpItem->iImage;
 471     }
 472   }
 473
 474   if (ppszDispText != NULL)
 475   {
 476     if (dispInfo.item.mask & LVIF_TEXT)
 477     {
 478       if (dispInfo.item.mask & LVIF_DI_SETITEM)
 479       {
 480         Str_SetPtrA(&lpItem->pszText, dispInfo.item.pszText);
 481       }
 482       *ppszDispText = dispInfo.item.pszText;
 483     }
 484     else
 485     {
 486       *ppszDispText = lpItem->pszText;
 487     }
 488   }
 489
 490   if (puState != NULL)
 491   {
 492     if (dispInfo.item.mask & LVIF_STATE)
 493     {
 494       *puState = lpItem->state;
 495       *puState &= ~dispInfo.item.stateMask;
 496       *puState |= (dispInfo.item.state & dispInfo.item.stateMask);
 497     }
 498     else
 499     {
 500       *puState = lpItem->state;
 501     }
 502   }
 503 }
 504
 505 /***
 506  * DESCRIPTION:
 507  * Retrieves subitem display information.
 508  *
 509  * PARAMETER(S):
 510  * [I] HWND : window handle
 511  * [I] INT : item index
 512  * [I] LONG : LPARAM of item
 513  * [I] LISTVIEW_SUBITEM* : listview control subitem
 514  * [I] INT : subitem position/order
 515  * [O] INT : image index
 516  * [O] UINT : state value
 517  * [O] CHAR** : display string
 518  * [I] INT : size of string
 519  *
 520  * RETURN:
 521  * None
 522  */
 523 static VOID LISTVIEW_GetSubItemDispInfo(HWND hwnd, INT nItem, LPARAM lParam,
 524                                         LISTVIEW_SUBITEM *lpSubItem,
 525                                         INT nSubItemPos, INT *pnDispImage,
 526                                         CHAR **ppszDispText, INT nDispTextSize)
 527 {
 528   LONG lCtrlId = GetWindowLongA(hwnd, GWL_ID);
 529   NMLVDISPINFOA dispInfo;
 530   ZeroMemory(&dispInfo, sizeof(NMLVDISPINFOA));
 531
 532   if (lpSubItem == NULL)
 533   {
 534     ZeroMemory(*ppszDispText, sizeof(CHAR)*nDispTextSize);
 535     dispInfo.item.mask |= LVIF_TEXT;
 536     dispInfo.item.pszText = *ppszDispText;
 537     dispInfo.item.cchTextMax = nDispTextSize;
 538     dispInfo.hdr.hwndFrom = hwnd;
 539     dispInfo.hdr.idFrom = lCtrlId;
 540     dispInfo.hdr.code = LVN_GETDISPINFOA;
 541     dispInfo.item.iItem = nItem;
 542     dispInfo.item.iSubItem = nSubItemPos;
 543     dispInfo.item.lParam = lParam;
 544     ListView_Notify(GetParent(hwnd), lCtrlId, &dispInfo);
 545     if (dispInfo.item.mask & LVIF_DI_SETITEM)
 546     {
 547       Str_SetPtrA(&lpSubItem->pszText, dispInfo.item.pszText);
 548     }
 549     *ppszDispText = dispInfo.item.pszText;
 550   }
 551   else
 552   {
 553     if ((pnDispImage != NULL) && (lpSubItem->iImage == I_IMAGECALLBACK))
 554     {
 555       dispInfo.item.mask |= LVIF_IMAGE;
 556     }
 557
 558     if ((ppszDispText != NULL) && (lpSubItem->pszText == LPSTR_TEXTCALLBACKA))
 559     {
 560       ZeroMemory(*ppszDispText, sizeof(CHAR)*nDispTextSize);
 561       dispInfo.item.mask |= LVIF_TEXT;
 562       dispInfo.item.pszText = *ppszDispText;
 563       dispInfo.item.cchTextMax = nDispTextSize;
 564     }
 565
 566     if (dispInfo.item.mask != 0)
 567     {
 568       dispInfo.hdr.hwndFrom = hwnd;
 569       dispInfo.hdr.idFrom = lCtrlId;
 570       dispInfo.hdr.code = LVN_GETDISPINFOA;
 571       dispInfo.item.iItem = nItem;
 572       dispInfo.item.iSubItem = lpSubItem->iSubItem;
 573       dispInfo.item.lParam = lParam;
 574       ListView_Notify(GetParent(hwnd), lCtrlId, &dispInfo);
 575     }
 576
 577     if (pnDispImage != NULL)
 578     {
 579       if (dispInfo.item.mask & LVIF_IMAGE)
 580       {
 581         *pnDispImage = dispInfo.item.iImage;
 582       }
 583       else
 584       {
 585         *pnDispImage = lpSubItem->iImage;
 586       }
 587     }
 588
 589     if (ppszDispText != NULL)
 590     {
 591       if (dispInfo.item.mask & LVIF_TEXT)
 592       {
 593         if (dispInfo.item.mask & LVIF_DI_SETITEM)
 594         {
 595           Str_SetPtrA(&lpSubItem->pszText, dispInfo.item.pszText);
 596         }
 597         *ppszDispText = dispInfo.item.pszText;
 598       }
 599       else
 600       {
 601         *ppszDispText = lpSubItem->pszText;
 602       }
 603     }
 604   }
 605 }
 606
 607 /***
 608  * DESCRIPTION:
 609  * Calculates the width of an item.
 610  *
 611  * PARAMETER(S):
 612  * [I] HWND : window handle
 613  * [I] LONG : window style
 614  *
 615  * RETURN:
 616  * Returns item width.
 617  */
 618 static INT LISTVIEW_GetItemWidth(HWND hwnd, LONG lStyle)
 619 {
 620   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
 621   INT nHeaderItemCount;
 622   RECT rcHeaderItem;
 623   INT nItemWidth = 0;
 624   INT nLabelWidth;
 625   INT i;
 626
 627   TRACE(listview, "(hwnd=%x,lStyle=%lx)\n", hwnd, lStyle);
 628
 629   switch (LVS_TYPEMASK & lStyle)
 630   {
 631   case LVS_ICON:
 632     nItemWidth = infoPtr->iconSpacing.cx;
 633     break;
 634
 635   case LVS_REPORT:
 636     /* calculate width of header */
 637     nHeaderItemCount = Header_GetItemCount(infoPtr->hwndHeader);
 638     for (i = 0; i < nHeaderItemCount; i++)
 639     {
 640       if (Header_GetItemRect(infoPtr->hwndHeader, i, &rcHeaderItem) != 0)
 641       {
 642         nItemWidth += (rcHeaderItem.right - rcHeaderItem.left);
 643       }
 644     }
 645     break;
 646
 647   case LVS_SMALLICON:
 648   case LVS_LIST:
 649     for (i = 0; i < GETITEMCOUNT(infoPtr); i++)
 650     {
 651       nLabelWidth = LISTVIEW_GetLabelWidth(hwnd, i);
 652       nItemWidth = max(nItemWidth, nLabelWidth);
 653     }
 654
 655     /* default label size */
 656     if (GETITEMCOUNT(infoPtr) == 0)
 657     {
 658       nItemWidth = DEFAULT_COLUMN_WIDTH;
 659     }
 660     else
 661     {
 662       if (nItemWidth == 0)
 663       {
 664         nItemWidth = DEFAULT_LABEL_WIDTH;
 665       }
 666       else
 667       {
 668         /* add padding */
 669         nItemWidth += WIDTH_PADDING;
 670
 671         if (infoPtr->himlSmall != NULL)
 672         {
 673           nItemWidth += infoPtr->iconSize.cx;
 674         }
 675
 676         if (infoPtr->himlState != NULL)
 677         {
 678           nItemWidth += infoPtr->iconSize.cx;
 679         }
 680       }
 681     }
 682     break;
 683
 684   }
 685
 686   return nItemWidth;
 687 }
 688
 689 /***
 690  * DESCRIPTION:
 691  * Calculates the height of an item.
 692  *
 693  * PARAMETER(S):
 694  * [I] HWND : window handle
 695  * [I] LONG : window style
 696  *
 697  * RETURN:
 698  * Returns item width.
 699  */
 700 static INT LISTVIEW_GetItemHeight(HWND hwnd, LONG lStyle)
 701 {
 702   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
 703   INT nItemHeight = 0;
 704   TEXTMETRICA tm;
 705   HFONT hOldFont;
 706   HDC hdc;
 707
 708   switch (LVS_TYPEMASK & lStyle)
 709   {
 710   case LVS_ICON:
 711     nItemHeight = infoPtr->iconSpacing.cy;
 712     break;
 713
 714   case LVS_SMALLICON:
 715   case LVS_REPORT:
 716   case LVS_LIST:
 717     hdc = GetDC(hwnd);
 718     hOldFont = SelectObject(hdc, infoPtr->hFont);
 719     GetTextMetricsA(hdc, &tm);
 720     nItemHeight = max(tm.tmHeight, infoPtr->iconSize.cy) + HEIGHT_PADDING;
 721     SelectObject(hdc, hOldFont);
 722     ReleaseDC(hwnd, hdc);
 723     break;
 724   }
 725
 726   return nItemHeight;
 727 }
 728
 729 /***
 730  * DESCRIPTION:
 731  * Sets diplay information (needed for drawing operations).
 732  *
 733  * PARAMETER(S):
 734  * [I] HWND : window handle
 735  *
 736  * RETURN:
 737  * None
 738  */
 739 static VOID LISTVIEW_SetViewInfo(HWND hwnd, LONG lStyle)
 740 {
 741   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
 742   INT nListHeight = infoPtr->rcList.bottom - infoPtr->rcList.top;
 743   INT nListWidth = infoPtr->rcList.right - infoPtr->rcList.left;
 744
 745   switch (LVS_TYPEMASK & lStyle)
 746   {
 747   case LVS_REPORT:
 748     /* get number of fully visible items per column */
 749     infoPtr->nCountPerColumn = max(1, nListHeight / infoPtr->nItemHeight);
 750     break;
 751
 752   case LVS_LIST:
 753     /* get number of fully visible items per column */
 754     infoPtr->nCountPerColumn = max(1, nListHeight / infoPtr->nItemHeight);
 755
 756     /* get number of fully visible items per row */
 757     infoPtr->nCountPerRow = max(1, nListWidth / infoPtr->nItemWidth);
 758     break;
 759   }
 760 }
 761
 762 /***
 763  * DESCRIPTION:
 764  * Adds a block of selections.
 765  *
 766  * PARAMETER(S):
 767  * [I] HWND : window handle
 768  * [I] INT : item index
 769  *
 770  * RETURN:
 771  * None
 772  */
 773 static VOID LISTVIEW_AddGroupSelection(HWND hwnd, INT nItem)
 774 {
 775   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
 776   INT nFirst = min(infoPtr->nSelectionMark, nItem);
 777   INT nLast = max(infoPtr->nSelectionMark, nItem);
 778   LVITEMA lvItem;
 779   INT i;
 780
 781   lvItem.state = LVIS_SELECTED;
 782   lvItem.stateMask= LVIS_SELECTED;
 783
 784   for (i = nFirst; i <= nLast; i++)
 785   {
 786     ListView_SetItemState(hwnd, i, &lvItem);
 787   }
 788
 789   LISTVIEW_SetItemFocus(hwnd, nItem);
 790   infoPtr->nSelectionMark = nItem;
 791 }
 792
 793 /***
 794  * DESCRIPTION:
 795  * Adds a single selection.
 796  *
 797  * PARAMETER(S):
 798  * [I] HWND : window handle
 799  * [I] INT : item index
 800  *
 801  * RETURN:
 802  * None
 803  */
 804 static VOID LISTVIEW_AddSelection(HWND hwnd, INT nItem)
 805 {
 806   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
 807   LVITEMA lvItem;
 808
 809   lvItem.state = LVIS_SELECTED;
 810   lvItem.stateMask= LVIS_SELECTED;
 811
 812   ListView_SetItemState(hwnd, nItem, &lvItem);
 813
 814   LISTVIEW_SetItemFocus(hwnd, nItem);
 815   infoPtr->nSelectionMark = nItem;
 816 }
 817
 818 /***
 819  * DESCRIPTION:
 820  * Selects or unselects an item.
 821  *
 822  * PARAMETER(S):
 823  * [I] HWND : window handle
 824  * [I] INT : item index
 825  *
 826  * RETURN:
 827  *   SELECT: TRUE
 828  *   UNSELECT : FALSE
 829  */
 830 static BOOL LISTVIEW_ToggleSelection(HWND hwnd, INT nItem)
 831 {
 832   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
 833   BOOL bResult;
 834   LVITEMA lvItem;
 835
 836   lvItem.stateMask= LVIS_SELECTED;
 837
 838   if (ListView_GetItemState(hwnd, nItem, LVIS_SELECTED) & LVIS_SELECTED)
 839   {
 840     lvItem.state = 0;
 841     ListView_SetItemState(hwnd, nItem, &lvItem);
 842     bResult = FALSE;
 843   }
 844   else
 845   {
 846     lvItem.state = LVIS_SELECTED;
 847     ListView_SetItemState(hwnd, nItem, &lvItem);
 848     bResult = TRUE;
 849   }
 850
 851   LISTVIEW_SetItemFocus(hwnd, nItem);
 852   infoPtr->nSelectionMark = nItem;
 853
 854   return bResult;
 855 }
 856
 857 /***
 858  * DESCRIPTION:
 859  * Sets a single group selection.
 860  *
 861  * PARAMETER(S):
 862  * [I] HWND : window handle
 863  * [I] INT : item index
 864  *
 865  * RETURN:
 866  * None
 867  */
 868 static VOID LISTVIEW_SetGroupSelection(HWND hwnd, INT nItem)
 869 {
 870   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
 871   INT nFirst = min(infoPtr->nSelectionMark, nItem);
 872   INT nLast = max(infoPtr->nSelectionMark, nItem);
 873   LVITEMA lvItem;
 874   INT i;
 875
 876   if (nFirst > 0)
 877   {
 878     LISTVIEW_RemoveSelections(hwnd, 0, nFirst - 1);
 879   }
 880
 881   if (nLast < GETITEMCOUNT(infoPtr))
 882   {
 883     LISTVIEW_RemoveSelections(hwnd, nLast + 1, GETITEMCOUNT(infoPtr));
 884   }
 885
 886   lvItem.state = LVIS_SELECTED;
 887   lvItem.stateMask = LVIS_SELECTED;
 888
 889   for (i = nFirst; i <= nLast; i++)
 890   {
 891     ListView_SetItemState(hwnd, i, &lvItem);
 892   }
 893
 894   LISTVIEW_SetItemFocus(hwnd, nItem);
 895 }
 896
 897 /***
 898  * DESCRIPTION:
 899  * Manages the item focus.
 900  *
 901  * PARAMETER(S):
 902  * [I] HWND : window handle
 903  * [I] INT : item index
 904  *
 905  * RETURN:
 906  * None
 907  */
 908 static VOID LISTVIEW_SetItemFocus(HWND hwnd, INT nItem)
 909 {
 910   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
 911   LVITEMA lvItem;
 912
 913   lvItem.state = 0;
 914   lvItem.stateMask = LVIS_FOCUSED;
 915   ListView_SetItemState(hwnd, infoPtr->nFocusedItem, &lvItem);
 916
 917   lvItem.state =  LVIS_FOCUSED;
 918   lvItem.stateMask = LVIS_FOCUSED;
 919   ListView_SetItemState(hwnd, nItem, &lvItem);
 920
 921   infoPtr->nFocusedItem = nItem;
 922
 923   /* if multiple selection is allowed */
 924   ListView_EnsureVisible(hwnd, nItem, FALSE);
 925 }
 926
 927 /***
 928  * DESCRIPTION:
 929  * Sets a single selection.
 930  *
 931  * PARAMETER(S):
 932  * [I] HWND : window handle
 933  * [I] INT : item index
 934  *
 935  * RETURN:
 936  * None
 937  */
 938 static VOID LISTVIEW_SetSelection(HWND hwnd, INT nItem)
 939 {
 940   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
 941   LVITEMA lvItem;
 942
 943   if (nItem > 0)
 944   {
 945     LISTVIEW_RemoveSelections(hwnd, 0, nItem - 1);
 946   }
 947
 948   if (nItem < GETITEMCOUNT(infoPtr))
 949   {
 950     LISTVIEW_RemoveSelections(hwnd, nItem + 1, GETITEMCOUNT(infoPtr));
 951   }
 952
 953   lvItem.state = 0;
 954   lvItem.stateMask = LVIS_FOCUSED;
 955   ListView_SetItemState(hwnd, infoPtr->nFocusedItem, &lvItem);
 956
 957   lvItem.state =  LVIS_SELECTED | LVIS_FOCUSED;
 958   lvItem.stateMask = LVIS_SELECTED | LVIS_FOCUSED;
 959   ListView_SetItemState(hwnd, nItem, &lvItem);
 960
 961   infoPtr->nFocusedItem = nItem;
 962   infoPtr->nSelectionMark = nItem;
 963 }
 964
 965 /***
 966  * DESCRIPTION:
 967  * Set selection(s) with keyboard.
 968  *
 969  * PARAMETER(S):
 970  * [I] HWND : window handle
 971  * [I] INT : item index
 972  *
 973  * RETURN:
 974  * None
 975  */
 976 static VOID LISTVIEW_KeySelection(HWND hwnd, INT nItem)
 977 {
 978   WORD wShift = HIWORD(GetKeyState(VK_SHIFT));
 979   WORD wCtrl = HIWORD(GetKeyState(VK_CONTROL));
 980
 981   if (wShift)
 982   {
 983     LISTVIEW_SetGroupSelection(hwnd, nItem);
 984   }
 985   else if (wCtrl)
 986   {
 987     LISTVIEW_SetItemFocus(hwnd, nItem);
 988   }
 989   else
 990   {
 991     LISTVIEW_SetSelection(hwnd, nItem);
 992
 993     /* if multiple selection is allowed */
 994     ListView_EnsureVisible(hwnd, nItem, FALSE);
 995   }
 996 }
 997
 998 /***
 999  * DESCRIPTION:
1000  * Determines the selected item.
1001  *
1002  * PARAMETER(S):
1003  * [I] HWND : window handle
1004  * [I] INT : x ccordinate
1005  * [I] INT : y coordinate
1006  *
1007  * RETURN:
1008  *   SUCCESS : item index
1009  *   FAILURE : -1
1010  */
1011 static LRESULT LISTVIEW_MouseSelection(HWND hwnd, INT nPosX, INT nPosY)
1012 {
1013   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
1014   RECT rcItem;
1015   INT i;
1016
1017   for (i = 0; i < GETITEMCOUNT(infoPtr); i++)
1018   {
1019     rcItem.left = LVIR_SELECTBOUNDS;
1020     if (LISTVIEW_GetItemRect(hwnd, i, &rcItem) == TRUE)
1021     {
1022       if ((rcItem.left <= nPosX) && (nPosX <= rcItem.right) &&
1023           (rcItem.top <= nPosY) && (nPosY <= rcItem.bottom))
1024       {
1025         return i;
1026       }
1027     }
1028   }
1029
1030   return -1;
1031 }
1032
1033 /***
1034  * DESCRIPTION:
1035  * Removes all selection states.
1036  *
1037  * PARAMETER(S):
1038  * [I] HWND : window handle
1039  * [I] INT : item index
1040  *
1041  * RETURN:
1042  *   SUCCCESS : TRUE
1043  *   FAILURE : FALSE
1044  */
1045 static VOID LISTVIEW_RemoveSelections(HWND hwnd, INT nFirst, INT nLast)
1046 {
1047   LVITEMA lvItem;
1048   INT i;
1049
1050   lvItem.state = 0;
1051   lvItem.stateMask = LVIS_SELECTED;
1052
1053   for (i = nFirst; i <= nLast; i++)
1054   {
1055     ListView_SetItemState(hwnd, i, &lvItem);
1056   }
1057 }
1058
1059 /***
1060  * DESCRIPTION:
1061  * Removes a column.
1062  *
1063  * PARAMETER(S):
1064  * [IO] HDPA : dynamic pointer array handle
1065  * [I] INT : column index (subitem index)
1066  *
1067  * RETURN:
1068  *   SUCCCESS : TRUE
1069  *   FAILURE : FALSE
1070  */
1071 static BOOL LISTVIEW_RemoveColumn(HDPA hdpaItems, INT nSubItem)
1072 {
1073   BOOL bResult = TRUE;
1074   HDPA hdpaSubItems;
1075   INT i;
1076
1077   for (i = 0; i < hdpaItems->nItemCount; i++)
1078   {
1079     hdpaSubItems = (HDPA)DPA_GetPtr(hdpaItems, i);
1080     if (hdpaSubItems != NULL)
1081     {
1082       if (LISTVIEW_RemoveSubItem(hdpaSubItems, nSubItem) == FALSE)
1083       {
1084         bResult = FALSE;
1085       }
1086     }
1087   }
1088
1089   return bResult;
1090 }
1091
1092 /***
1093  * DESCRIPTION:
1094  * Removes a subitem at a given position.
1095  *
1096  * PARAMETER(S):
1097  * [IO] HDPA : dynamic pointer array handle
1098  * [I] INT : subitem index
1099  *
1100  * RETURN:
1101  *   SUCCCESS : TRUE
1102  *   FAILURE : FALSE
1103  */
1104 static BOOL LISTVIEW_RemoveSubItem(HDPA hdpaSubItems, INT nSubItem)
1105 {
1106   LISTVIEW_SUBITEM *lpSubItem;
1107   INT i;
1108
1109   for (i = 1; i < hdpaSubItems->nItemCount; i++)
1110   {
1111     lpSubItem = (LISTVIEW_SUBITEM *)DPA_GetPtr(hdpaSubItems, i);
1112     if (lpSubItem != NULL)
1113     {
1114       if (lpSubItem->iSubItem == nSubItem)
1115       {
1116         /* free string */
1117         if ((lpSubItem->pszText != NULL) &&
1118             (lpSubItem->pszText != LPSTR_TEXTCALLBACKA))
1119         {
1120           COMCTL32_Free(lpSubItem->pszText);
1121         }
1122
1123         /* free item */
1124         COMCTL32_Free(lpSubItem);
1125
1126         /* free dpa memory */
1127         if (DPA_DeletePtr(hdpaSubItems, i) == NULL)
1128         {
1129           return FALSE;
1130         }
1131       }
1132       else if (lpSubItem->iSubItem > nSubItem)
1133       {
1134         return TRUE;
1135       }
1136     }
1137   }
1138
1139   return TRUE;
1140 }
1141
1142 /***
1143  * DESCRIPTION:
1144  * Compares the item information.
1145  *
1146  * PARAMETER(S):
1147  * [I] LISTVIEW_ITEM *: destination item
1148  * [I] LPLVITEM : source item
1149  *
1150  * RETURN:
1151  *   SUCCCESS : TRUE (EQUAL)
1152  *   FAILURE : FALSE (NOT EQUAL)
1153  */
1154 static UINT LISTVIEW_GetItemChanges(LISTVIEW_ITEM *lpItem, LPLVITEMA lpLVItem)
1155 {
1156   UINT uChanged = 0;
1157
1158   if ((lpItem != NULL) && (lpLVItem != NULL))
1159   {
1160     if (lpLVItem->mask & LVIF_STATE)
1161     {
1162       if ((lpItem->state & lpLVItem->stateMask) !=
1163           (lpLVItem->state & lpLVItem->stateMask))
1164       {
1165         uChanged |= LVIF_STATE;
1166       }
1167     }
1168
1169     if (lpLVItem->mask & LVIF_IMAGE)
1170     {
1171       if (lpItem->iImage != lpLVItem->iImage)
1172       {
1173         uChanged |= LVIF_IMAGE;
1174       }
1175     }
1176
1177     if (lpLVItem->mask & LVIF_PARAM)
1178     {
1179       if (lpItem->lParam != lpLVItem->lParam)
1180       {
1181         uChanged |= LVIF_PARAM;
1182       }
1183     }
1184
1185     if (lpLVItem->mask & LVIF_INDENT)
1186     {
1187       if (lpItem->iIndent != lpLVItem->iIndent)
1188       {
1189         uChanged |= LVIF_INDENT;
1190       }
1191     }
1192
1193     if (lpLVItem->mask & LVIF_TEXT)
1194     {
1195       if (lpLVItem->pszText == LPSTR_TEXTCALLBACKA)
1196       {
1197         if (lpItem->pszText != LPSTR_TEXTCALLBACKA)
1198         {
1199           uChanged |= LVIF_TEXT;
1200         }
1201       }
1202       else
1203       {
1204         if (lpItem->pszText == LPSTR_TEXTCALLBACKA)
1205         {
1206           uChanged |= LVIF_TEXT;
1207         }
1208       }
1209     }
1210   }
1211
1212   return uChanged;
1213 }
1214
1215 /***
1216  * DESCRIPTION:
1217  * Initializes item attributes.
1218  *
1219  * PARAMETER(S):
1220  * [I] HWND : window handle
1221  * [O] LISTVIEW_ITEM *: destination item
1222  * [I] LPLVITEM : source item
1223  *
1224  * RETURN:
1225  *   SUCCCESS : TRUE
1226  *   FAILURE : FALSE
1227  */
1228 static BOOL LISTVIEW_InitItem(HWND hwnd, LISTVIEW_ITEM *lpItem,
1229                               LPLVITEMA lpLVItem)
1230 {
1231   LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
1232   BOOL bResult = FALSE;
1233
1234   if ((lpItem != NULL) && (lpLVItem != NULL))
1235   {
1236     bResult = TRUE;
1237
1238     if (lpLVItem->mask & LVIF_STATE)
1239     {
1240       lpItem->state &= ~lpLVItem->stateMask;
1241       lpItem->state |= (lpLVItem->state & lpLVItem->stateMask);
1242     }
1243
1244     if (lpLVItem->mask & LVIF_IMAGE)
1245     {
1246       lpItem->iImage = lpLVItem->iImage;
1247     }
1248
1249     if (lpLVItem->mask & LVIF_PARAM)
1250     {
1251       lpItem->lParam = lpLVItem->lParam;
1252     }
1253
1254     if (lpLVItem->mask & LVIF_INDENT)
1255     {
1256       lpItem->iIndent = lpLVItem->iIndent;
1257     }
1258
1259     if (lpLVItem->mask & LVIF_TEXT)
1260     {
1261       if (lpLVItem->pszText == LPSTR_TEXTCALLBACKA)
1262       {
1263         if ((lStyle & LVS_SORTASCENDING) || (lStyle & LVS_SORTDESCENDING))
1264         {
1265           return FALSE;
1266         }
1267
1268         if ((lpItem->pszText != NULL) &&
1269             (lpItem->pszText != LPSTR_TEXTCALLBACKA))
1270         {
1271           COMCTL32_Free(lpItem->pszText);
1272         }
1273
1274         lpItem->pszText = LPSTR_TEXTCALLBACKA;
1275       }
1276       else
1277       {
1278         if (lpItem->pszText == LPSTR_TEXTCALLBACKA)
1279         {
1280           lpItem->pszText = NULL;
1281         }
1282
1283         bResult = Str_SetPtrA(&lpItem->pszText, lpLVItem->pszText);
1284       }
1285     }
1286   }
1287
1288   return bResult;
1289 }
1290
1291 /***
1292  * DESCRIPTION:
1293  * Initializes subitem attributes.
1294  *
1295  * NOTE: the documentation specifies that the operation fails if the user
1296  * tries to set the indent of a subitem.
1297  *
1298  * PARAMETER(S):
1299  * [I] HWND : window handle
1300  * [O] LISTVIEW_SUBITEM *: destination subitem
1301  * [I] LPLVITEM : source subitem
1302  *
1303  * RETURN:
1304  *   SUCCCESS : TRUE
1305  *   FAILURE : FALSE
1306  */
1307 static BOOL LISTVIEW_InitSubItem(HWND hwnd, LISTVIEW_SUBITEM *lpSubItem,
1308                                    LPLVITEMA lpLVItem)
1309 {
1310   LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
1311   BOOL bResult = FALSE;
1312
1313   if ((lpSubItem != NULL) && (lpLVItem != NULL))
1314   {
1315     if (!(lpLVItem->mask & LVIF_INDENT))
1316     {
1317       bResult = TRUE;
1318       ZeroMemory(lpSubItem, sizeof(LISTVIEW_SUBITEM));
1319
1320       lpSubItem->iSubItem = lpLVItem->iSubItem;
1321
1322       if (lpLVItem->mask & LVIF_IMAGE)
1323       {
1324         lpSubItem->iImage = lpLVItem->iImage;
1325       }
1326
1327       if (lpLVItem->mask & LVIF_TEXT)
1328       {
1329         if (lpLVItem->pszText == LPSTR_TEXTCALLBACKA)
1330         {
1331           if ((lStyle & LVS_SORTASCENDING) || (lStyle & LVS_SORTDESCENDING))
1332           {
1333             return FALSE;
1334           }
1335
1336           if ((lpSubItem->pszText != NULL) &&
1337               (lpSubItem->pszText != LPSTR_TEXTCALLBACKA))
1338           {
1339             COMCTL32_Free(lpSubItem->pszText);
1340           }
1341
1342           lpSubItem->pszText = LPSTR_TEXTCALLBACKA;
1343         }
1344         else
1345         {
1346           if (lpSubItem->pszText == LPSTR_TEXTCALLBACKA)
1347           {
1348             lpSubItem->pszText = NULL;
1349           }
1350
1351           bResult = Str_SetPtrA(&lpSubItem->pszText, lpLVItem->pszText);
1352         }
1353       }
1354     }
1355   }
1356
1357   return bResult;
1358 }
1359
1360 /***
1361  * DESCRIPTION:
1362  * Adds a subitem at a given position (column index).
1363  *
1364  * PARAMETER(S):
1365  * [I] HWND : window handle
1366  * [I] LPLVITEM : new subitem atttributes
1367  *
1368  * RETURN:
1369  *   SUCCESS : TRUE
1370  *   FAILURE : FALSE
1371  */
1372 static BOOL LISTVIEW_AddSubItem(HWND hwnd, LPLVITEMA lpLVItem)
1373 {
1374   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
1375   LISTVIEW_SUBITEM *lpSubItem = NULL;
1376   BOOL bResult = FALSE;
1377   HDPA hdpaSubItems;
1378   INT nPosition, nItem;
1379
1380   if (lpLVItem != NULL)
1381   {
1382     hdpaSubItems = (HDPA)DPA_GetPtr(infoPtr->hdpaItems, lpLVItem->iItem);
1383     if (hdpaSubItems != NULL)
1384     {
1385       lpSubItem = (LISTVIEW_SUBITEM *)COMCTL32_Alloc(sizeof(LISTVIEW_SUBITEM));
1386       if (lpSubItem != NULL)
1387       {
1388         if (LISTVIEW_InitSubItem(hwnd, lpSubItem, lpLVItem) != FALSE)
1389         {
1390           nPosition = LISTVIEW_FindInsertPosition(hdpaSubItems,
1391                                                   lpSubItem->iSubItem);
1392           nItem = DPA_InsertPtr(hdpaSubItems, nPosition, lpSubItem);
1393           if (nItem != -1)
1394           {
1395             bResult = TRUE;
1396           }
1397         }
1398       }
1399     }
1400   }
1401
1402   /* cleanup if unsuccessful */
1403   if ((bResult == FALSE) && (lpSubItem != NULL))
1404   {
1405     COMCTL32_Free(lpSubItem);
1406   }
1407
1408   return bResult;
1409 }
1410
1411 /***
1412  * DESCRIPTION:
1413  * Finds the dpa insert position (array index).
1414  *
1415  * PARAMETER(S):
1416  * [I] HWND : window handle
1417  * [I] INT : subitem index
1418  *
1419  * RETURN:
1420  *   SUCCESS : TRUE
1421  *   FAILURE : FALSE
1422  */
1423 static INT LISTVIEW_FindInsertPosition(HDPA hdpaSubItems, INT nSubItem)
1424 {
1425   LISTVIEW_SUBITEM *lpSubItem;
1426   INT i;
1427
1428   for (i = 1; i < hdpaSubItems->nItemCount; i++)
1429   {
1430     lpSubItem = (LISTVIEW_SUBITEM *)DPA_GetPtr(hdpaSubItems, i);
1431     if (lpSubItem != NULL)
1432     {
1433       if (lpSubItem->iSubItem > nSubItem)
1434       {
1435         return i;
1436       }
1437     }
1438   }
1439
1440   return hdpaSubItems->nItemCount;
1441 }
1442
1443 /***
1444  * DESCRIPTION:
1445  * Retrieves a listview subitem at a given position (column index).
1446  *
1447  * PARAMETER(S):
1448  * [I] HWND : window handle
1449  * [I] INT : subitem index
1450  *
1451  * RETURN:
1452  *   SUCCESS : TRUE
1453  *   FAILURE : FALSE
1454  */
1455 static LISTVIEW_SUBITEM* LISTVIEW_GetSubItem(HDPA hdpaSubItems, INT nSubItem)
1456 {
1457   LISTVIEW_SUBITEM *lpSubItem;
1458   INT i;
1459
1460   for (i = 1; i < hdpaSubItems->nItemCount; i++)
1461   {
1462     lpSubItem = (LISTVIEW_SUBITEM *)DPA_GetPtr(hdpaSubItems, i);
1463     if (lpSubItem != NULL)
1464     {
1465       if (lpSubItem->iSubItem == nSubItem)
1466       {
1467         return lpSubItem;
1468       }
1469       else if (lpSubItem->iSubItem > nSubItem)
1470       {
1471         return NULL;
1472       }
1473     }
1474   }
1475
1476   return NULL;
1477 }
1478
1479 /***
1480  * DESCRIPTION:
1481  * Sets item attributes.
1482  *
1483  * PARAMETER(S):
1484  * [I] HWND : window handle
1485  * [I] LPLVITEM : new item atttributes
1486  *
1487  * RETURN:
1488  *   SUCCESS : TRUE
1489  *   FAILURE : FALSE
1490  */
1491 static BOOL LISTVIEW_SetItem(HWND hwnd, LPLVITEMA lpLVItem)
1492 {
1493   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
1494   BOOL bResult = FALSE;
1495   HDPA hdpaSubItems;
1496   LISTVIEW_ITEM *lpItem;
1497   NMLISTVIEW nmlv;
1498   UINT uChanged;
1499   LONG lCtrlId = GetWindowLongA(hwnd, GWL_ID);
1500
1501   if (lpLVItem != NULL)
1502   {
1503     if (lpLVItem->iSubItem == 0)
1504     {
1505       hdpaSubItems = (HDPA)DPA_GetPtr(infoPtr->hdpaItems, lpLVItem->iItem);
1506       if (hdpaSubItems != NULL)
1507       {
1508         lpItem = (LISTVIEW_ITEM *)DPA_GetPtr(hdpaSubItems, lpLVItem->iSubItem);
1509         if (lpItem != NULL)
1510         {
1511           ZeroMemory(&nmlv, sizeof(NMLISTVIEW));
1512           nmlv.hdr.hwndFrom = hwnd;
1513           nmlv.hdr.idFrom = lCtrlId;
1514           nmlv.hdr.code = LVN_ITEMCHANGING;
1515           nmlv.lParam = lpItem->lParam;
1516           uChanged = LISTVIEW_GetItemChanges(lpItem, lpLVItem);
1517           if (uChanged != 0)
1518           {
1519             if (uChanged & LVIF_STATE)
1520             {
1521               nmlv.uNewState = lpLVItem->state & lpLVItem->stateMask;
1522               nmlv.uOldState = lpItem->state & lpLVItem->stateMask;
1523             }
1524
1525             nmlv.uChanged = uChanged;
1526             nmlv.iItem = lpLVItem->iItem;
1527             nmlv.lParam = lpItem->lParam;
1528             /* send LVN_ITEMCHANGING notification */
1529             ListView_LVNotify(GetParent(hwnd), lCtrlId, &nmlv);
1530
1531             /* copy information */
1532             bResult = LISTVIEW_InitItem(hwnd, lpItem, lpLVItem);
1533
1534             /* send LVN_ITEMCHANGED notification */
1535             nmlv.hdr.code = LVN_ITEMCHANGED;
1536             ListView_LVNotify(GetParent(hwnd), lCtrlId, &nmlv);
1537           }
1538           else
1539           {
1540             bResult = TRUE;
1541           }
1542
1543           InvalidateRect(hwnd, NULL, FALSE);
1544         }
1545       }
1546     }
1547   }
1548
1549   return bResult;
1550 }
1551
1552 /***
1553  * DESCRIPTION:
1554  * Sets subitem attributes.
1555  *
1556  * PARAMETER(S):
1557  * [I] HWND : window handle
1558  * [I] LPLVITEM : new subitem atttributes
1559  *
1560  * RETURN:
1561  *   SUCCESS : TRUE
1562  *   FAILURE : FALSE
1563  */
1564 static BOOL LISTVIEW_SetSubItem(HWND hwnd, LPLVITEMA lpLVItem)
1565 {
1566   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
1567   BOOL bResult = FALSE;
1568   HDPA hdpaSubItems;
1569   LISTVIEW_SUBITEM *lpSubItem;
1570
1571   if (lpLVItem != NULL)
1572   {
1573     if (lpLVItem->iSubItem > 0)
1574     {
1575       hdpaSubItems = (HDPA)DPA_GetPtr(infoPtr->hdpaItems, lpLVItem->iItem);
1576       if (hdpaSubItems != NULL)
1577       {
1578         /* set subitem only if column is present */
1579         if (Header_GetItemCount(infoPtr->hwndHeader) > lpLVItem->iSubItem)
1580         {
1581           lpSubItem = LISTVIEW_GetSubItem(hdpaSubItems, lpLVItem->iSubItem);
1582           if (lpSubItem != NULL)
1583           {
1584             bResult = LISTVIEW_InitSubItem(hwnd, lpSubItem, lpLVItem);
1585           }
1586           else
1587           {
1588             bResult = LISTVIEW_AddSubItem(hwnd, lpLVItem);
1589           }
1590
1591           InvalidateRect(hwnd, NULL, FALSE);
1592         }
1593       }
1594     }
1595   }
1596
1597   return bResult;
1598 }
1599
1600 /***
1601  * DESCRIPTION:
1602  * Retrieves the index of the item at coordinate (0, 0) of the client area.
1603  *
1604  * PARAMETER(S):
1605  * [I] HWND : window handle
1606  *
1607  * RETURN:
1608  * item index
1609  */
1610 static INT LISTVIEW_GetTopIndex(HWND hwnd)
1611 {
1612   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *) GetWindowLongA(hwnd, 0);
1613   LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
1614   INT nItem = 0;
1615
1616   switch (LVS_TYPEMASK & lStyle)
1617   {
1618   case LVS_LIST:
1619     if (lStyle & WS_HSCROLL)
1620     {
1621       nItem = GetScrollPos(hwnd, SB_HORZ) * infoPtr->nCountPerColumn;
1622     }
1623     break;
1624
1625   case LVS_REPORT:
1626     if (lStyle & WS_VSCROLL)
1627     {
1628       nItem = GetScrollPos(hwnd, SB_VERT);
1629     }
1630     break;
1631   }
1632
1633   return nItem;
1634 }
1635
1636 /***
1637  * DESCRIPTION:
1638  * Evaluates if scrollbars are needed & sets the scroll range/position.
1639  *
1640  * PARAMETER(S):
1641  * [I] HWND : window handle
1642  * [I] LONG : window style
1643  *
1644  * RETURN:
1645  * None
1646  */
1647 static VOID LISTVIEW_SetScroll(HWND hwnd, LONG lStyle)
1648 {
1649   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
1650   INT nListWidth = infoPtr->rcList.right - infoPtr->rcList.left;
1651   INT nListHeight = infoPtr->rcList.bottom - infoPtr->rcList.top;
1652   INT nHScrollHeight = GetSystemMetrics(SM_CYHSCROLL);
1653   INT nVScrollWidth = GetSystemMetrics(SM_CXVSCROLL);
1654   INT nHiddenWidth;
1655   INT nHiddenHeight;
1656   INT nHiddenItemCount;
1657   INT nScrollPos;
1658   INT nMaxRange;
1659   INT nCountPerPage;
1660   INT nPixPerScrollPos;
1661   RECT rcView;
1662
1663   TRACE(listview, "(hwnd=%x,lStyle=%lx)\n", hwnd, lStyle);
1664
1665   switch (LVS_TYPEMASK & lStyle)
1666   {
1667   case LVS_LIST:
1668     nCountPerPage = infoPtr->nCountPerRow * infoPtr->nCountPerColumn;
1669     if (nCountPerPage < GETITEMCOUNT(infoPtr))
1670     {
1671       /* display horizontal scrollbar */
1672       if ((lStyle &  WS_HSCROLL) == 0)
1673       {
1674         ShowScrollBar(hwnd, SB_HORZ, TRUE);
1675       }
1676
1677       /* calculate new scrollbar range */
1678       nHiddenItemCount = GETITEMCOUNT(infoPtr) - nCountPerPage;
1679       if ((nHiddenItemCount % infoPtr->nCountPerColumn) == 0)
1680       {
1681         nMaxRange = nHiddenItemCount / infoPtr->nCountPerColumn;
1682       }
1683      else
1684       {
1685         nMaxRange = nHiddenItemCount / infoPtr->nCountPerColumn + 1;
1686       }
1687
1688       SetScrollRange(hwnd, SB_HORZ, 0, nMaxRange, FALSE);
1689       nScrollPos = ListView_GetTopIndex(hwnd) / infoPtr->nCountPerColumn;
1690       SetScrollPos(hwnd, SB_HORZ, nScrollPos, TRUE);
1691     }
1692     else
1693     {
1694       /* hide scrollbar */
1695       if ((lStyle & WS_HSCROLL) != 0)
1696       {
1697         ShowScrollBar(hwnd, SB_HORZ, FALSE);
1698       }
1699     }
1700     break;
1701
1702   case LVS_REPORT:
1703 /*
1704  * This section was commented out because I experienced some problems
1705  * with the scrolling of the header control. The idea was to add a
1706  * horizontal scrollbar when the width of the client area was smaller
1707  * than the width of the header control.
1708  */
1709
1710 /*     if (infoPtr->nItemWidth > nListWidth) */
1711 /*     { */
1712 /*       if ((lStyle &  WS_HSCROLL) == 0) */
1713 /*       { */
1714 /*         ShowScrollBar(hwnd, SB_HORZ, TRUE); */
1715 /*         LISTVIEW_SetSize(hwnd, lStyle, -1, -1); */
1716 /*         LISTVIEW_SetViewInfo(hwnd, lStyle); */
1717 /*       } */
1718
1719 /*       nListWidth = infoPtr->rcList.right - infoPtr->rcList.left; */
1720 /*       nHiddenWidth = infoPtr->nItemWidth - nListWidth; */
1721 /*       nPixPerScrollPos = max(1, nListWidth / 10); */
1722
1723 /*       if ((nHiddenWidth % nPixPerScrollPos) == 0) */
1724 /*       { */
1725 /*         nMaxRange = nHiddenWidth / nPixPerScrollPos;  */
1726 /*       } */
1727 /*       else */
1728 /*       { */
1729 /*         nMaxRange = nHiddenWidth / nPixPerScrollPos + 1;  */
1730 /*       } */
1731
1732 /*       SetScrollRange(hwnd, SB_HORZ, 0, nMaxRange, FALSE); */
1733 /*       SetScrollPos(hwnd, SB_HORZ, 0, TRUE); */
1734 /*     } */
1735 /*     else */
1736 /*     { */
1737 /*       if ((lStyle &  WS_HSCROLL) != 0) */
1738 /*       { */
1739 /*         ShowScrollBar(hwnd, SB_HORZ, FASLE); */
1740 /*         LISTVIEW_SetSize(hwnd, lStyle, -1, -1);  */
1741 /*         LISTVIEW_SetViewInfo(hwnd, lStyle);  */
1742 /*       } */
1743 /*     } */
1744
1745     if (infoPtr->nCountPerColumn < GETITEMCOUNT(infoPtr))
1746     {
1747       if ((lStyle &  WS_VSCROLL) == 0)
1748       {
1749         if (nListWidth > nVScrollWidth)
1750         {
1751           ShowScrollBar(hwnd, SB_VERT, TRUE);
1752           nListWidth -= nVScrollWidth;
1753         }
1754       }
1755
1756       /* vertical range & position */
1757       nMaxRange = GETITEMCOUNT(infoPtr) - infoPtr->nCountPerColumn;
1758       SetScrollRange(hwnd, SB_VERT, 0, nMaxRange, FALSE);
1759       SetScrollPos(hwnd, SB_VERT, ListView_GetTopIndex(hwnd), TRUE);
1760     }
1761     else
1762     {
1763       if ((lStyle &  WS_VSCROLL) != 0)
1764       {
1765         ShowScrollBar(hwnd, SB_VERT, FALSE);
1766         nListWidth += nVScrollWidth;
1767       }
1768     }
1769     break;
1770
1771   case LVS_ICON:
1772   case LVS_SMALLICON:
1773     if (LISTVIEW_GetViewRect(hwnd, &rcView) != FALSE)
1774     {
1775       if (rcView.right - rcView.left > nListWidth)
1776       {
1777         if ((lStyle & WS_HSCROLL) == 0)
1778         {
1779           if (nListHeight > nHScrollHeight)
1780           {
1781             ShowScrollBar(hwnd, SB_HORZ, TRUE);
1782             nListHeight -= nHScrollHeight;
1783           }
1784         }
1785
1786         /* calculate size of hidden items */
1787         nHiddenWidth = rcView.right - rcView.left - nListWidth;
1788         nPixPerScrollPos = max(1, nListWidth / 10);
1789
1790         /* vertical range & position */
1791         if ((nHiddenWidth % nPixPerScrollPos) == 0)
1792         {
1793           nMaxRange = nHiddenWidth / nPixPerScrollPos;
1794         }
1795         else
1796         {
1797           nMaxRange = nHiddenWidth / nPixPerScrollPos + 1;
1798         }
1799
1800         /* set range and position */
1801         SetScrollRange(hwnd, SB_HORZ, 0, nMaxRange, FALSE);
1802         SetScrollPos(hwnd, SB_HORZ, 0, TRUE);
1803       }
1804       else
1805       {
1806         if ((lStyle &  WS_HSCROLL) != 0)
1807         {
1808           ShowScrollBar(hwnd, SB_HORZ, FALSE);
1809           nListHeight += nHScrollHeight;
1810         }
1811       }
1812
1813       if (rcView.bottom - rcView.top > nListHeight)
1814       {
1815         if ((lStyle &  WS_VSCROLL) == 0)
1816         {
1817           if (nListWidth > nVScrollWidth)
1818           {
1819             ShowScrollBar(hwnd, SB_VERT, TRUE);
1820             nListWidth -= nVScrollWidth;
1821           }
1822         }
1823
1824         /* calculate size of hidden items */
1825         nHiddenHeight = rcView.bottom - rcView.top - nListHeight;
1826         nPixPerScrollPos = max(1, nListHeight / 10);
1827
1828         /* set vertical range & position */
1829         if ((nHiddenHeight % nPixPerScrollPos) == 0)
1830         {
1831           nMaxRange = nHiddenHeight / nPixPerScrollPos;
1832         }
1833         else
1834         {
1835           nMaxRange = nHiddenHeight / nPixPerScrollPos + 1;
1836         }
1837
1838         /* set range and position */
1839         SetScrollRange(hwnd, SB_VERT, 0, nMaxRange, FALSE);
1840         SetScrollPos(hwnd, SB_VERT, 0, TRUE);
1841       }
1842       else
1843       {
1844         if ((lStyle &  WS_VSCROLL) != 0)
1845         {
1846           ShowScrollBar(hwnd, SB_VERT, FALSE);
1847           nListWidth += nVScrollWidth;
1848         }
1849       }
1850     }
1851     break;
1852   }
1853 }
1854
1855 /***
1856  * DESCRIPTION:
1857  * Draws a subitem.
1858  *
1859  * PARAMETER(S):
1860  * [I] HWND : window handle
1861  * [I] HDC : device context handle
1862  * [I] INT : item index
1863  * [I] LPARAM : item lparam
1864  * [I] LISTVIEW_SUBITEM * : item
1865  * [I] INT : column index (header index)
1866  * [I] RECT * : clipping rectangle
1867  *
1868  * RETURN:
1869  * None
1870  */
1871 static VOID LISTVIEW_DrawSubItem(HWND hwnd, HDC hdc, INT nItem, LPARAM lParam,
1872                                  LISTVIEW_SUBITEM *lpSubItem, INT nColumn,
1873                                  RECT *lprc)
1874 {
1875   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
1876   CHAR szDispText[DISP_TEXT_SIZE];
1877   LPSTR pszDispText = NULL;
1878
1879   /* set item colors */
1880   SetBkColor(hdc, infoPtr->clrTextBk);
1881   SetTextColor(hdc, infoPtr->clrText);
1882
1883   pszDispText = szDispText;
1884   LISTVIEW_GetSubItemDispInfo(hwnd, nItem, lParam, lpSubItem, nColumn, NULL,
1885                               &pszDispText, DISP_TEXT_SIZE);
1886
1887   /* draw text : using arbitrary offset of 10 pixels */
1888
1889   ExtTextOutA(hdc, lprc->left, lprc->top, ETO_OPAQUE|ETO_CLIPPED,
1890               lprc, pszDispText, lstrlenA(pszDispText), NULL);
1891 }
1892
1893 /***
1894  * DESCRIPTION:
1895  * Draws an item.
1896  *
1897  * PARAMETER(S):
1898  * [I] HWND : window handle
1899  * [I] HDC : device context handle
1900  * [I] LISTVIEW_ITEM * : item
1901  * [I] INT : item index
1902  * [I] RECT * : clipping rectangle
1903  *
1904  * RETURN:
1905  * None
1906  */
1907 static VOID LISTVIEW_DrawItem(HWND hwnd, HDC hdc, LISTVIEW_ITEM *lpItem,
1908                               INT nItem, RECT rc)
1909 {
1910   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
1911   CHAR szDispText[DISP_TEXT_SIZE];
1912   LPSTR pszDispText = NULL;
1913   BOOL bSelected;
1914   INT nLabelWidth;
1915   INT nImage;
1916   UINT uState;
1917
1918   TRACE(listview, "(hwnd=%x,hdc=%x,lpItem=%p,nItem=%d,rc.left=%d,rctop=%d,rc.right=%d,rc.bottom=%d)\n", hwnd, hdc, lpItem, nItem, rc.left, rc.top, rc.right, rc.bottom);
1919
1920   pszDispText = szDispText;
1921   LISTVIEW_GetItemDispInfo(hwnd, nItem, lpItem, &nImage, &uState, &pszDispText,
1922                            DISP_TEXT_SIZE);
1923
1924  if (uState & LVIS_SELECTED)
1925   {
1926     bSelected = TRUE;
1927
1928     /* set item colors */
1929     SetBkColor(hdc, GetSysColor(COLOR_HIGHLIGHT));
1930     SetTextColor(hdc, GetSysColor(COLOR_HIGHLIGHTTEXT));
1931
1932     /* set raster mode */
1933     SetROP2(hdc, R2_XORPEN);
1934   }
1935   else
1936   {
1937     bSelected = FALSE;
1938
1939     /* set item colors */
1940     SetBkColor(hdc, infoPtr->clrTextBk);
1941     SetTextColor(hdc, infoPtr->clrText);
1942
1943     /* set raster mode */
1944     SetROP2(hdc, R2_COPYPEN);
1945   }
1946
1947   /* state icons */
1948   if (infoPtr->himlState != NULL)
1949   {
1950     /* right shift 12 bits to obtain index in image list */
1951     if (bSelected != FALSE)
1952     {
1953       ImageList_Draw(infoPtr->himlState, uState >> 12, hdc, rc.left,
1954                      rc.top, ILD_SELECTED);
1955     }
1956     else
1957     {
1958       ImageList_Draw(infoPtr->himlState, uState >> 12, hdc, rc.left,
1959                      rc.top, ILD_NORMAL);
1960     }
1961
1962     rc.left += infoPtr->iconSize.cx;
1963   }
1964
1965   /* small icons */
1966   if (infoPtr->himlSmall != NULL)
1967   {
1968     if (bSelected != FALSE)
1969     {
1970       ImageList_Draw(infoPtr->himlSmall, nImage, hdc, rc.left,
1971                      rc.top, ILD_SELECTED);
1972     }
1973     else
1974     {
1975       ImageList_Draw(infoPtr->himlSmall, nImage, hdc, rc.left,
1976                      rc.top, ILD_NORMAL);
1977     }
1978
1979     rc.left += infoPtr->iconSize.cx;
1980   }
1981
1982   nLabelWidth = ListView_GetStringWidthA(hwnd, pszDispText);
1983   if (rc.left + nLabelWidth < rc.right)
1984   {
1985     rc.right = rc.left + nLabelWidth;
1986   }
1987
1988   /* draw label */
1989   ExtTextOutA(hdc, rc.left, rc.top, ETO_OPAQUE|ETO_CLIPPED,
1990               &rc, pszDispText, lstrlenA(pszDispText), NULL);
1991
1992   if (lpItem->state & LVIS_FOCUSED)
1993   {
1994     Rectangle(hdc, rc.left, rc.top, rc.right, rc.bottom);
1995   }
1996 }
1997
1998 /***
1999  * DESCRIPTION:
2000  * Draws an item when in large icon display mode.
2001  *
2002  * PARAMETER(S):
2003  * [I] HWND : window handle
2004  * [I] HDC : device context handle
2005  * [I] LISTVIEW_ITEM * : item
2006  * [I] INT : item index
2007  * [I] RECT * : clipping rectangle
2008  *
2009  * RETURN:
2010  * None
2011  */
2012 static VOID LISTVIEW_DrawLargeItem(HWND hwnd, HDC hdc, LISTVIEW_ITEM *lpItem,
2013                                    INT nItem, RECT rc)
2014 {
2015   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
2016   CHAR szDispText[DISP_TEXT_SIZE];
2017   LPSTR pszDispText = NULL;
2018   BOOL bSelected;
2019   INT nLabelWidth;
2020   INT nImage;
2021   UINT uState;
2022   INT nDrawPosX = 0;
2023   TEXTMETRICA tm;
2024
2025   TRACE(listview, "(hwnd=%x,hdc=%x,lpItem=%p,nItem=%d,rc.left=%d,rctop=%d,rc.right=%d,rc.bottom=%d)\n", hwnd, hdc, lpItem, nItem, rc.left, rc.top, rc.right, rc.bottom);
2026
2027   pszDispText = szDispText;
2028   LISTVIEW_GetItemDispInfo(hwnd, nItem, lpItem, &nImage, &uState, &pszDispText,
2029                            DISP_TEXT_SIZE);
2030   if (uState & LVIS_SELECTED)
2031   {
2032     bSelected = TRUE;
2033
2034     /* set item colors */
2035     SetBkColor(hdc, GetSysColor(COLOR_HIGHLIGHT));
2036     SetTextColor(hdc, GetSysColor(COLOR_HIGHLIGHTTEXT));
2037
2038     /* set raster mode */
2039     SetROP2(hdc, R2_XORPEN);
2040   }
2041   else
2042   {
2043     bSelected = FALSE;
2044
2045     /* set item colors */
2046     SetBkColor(hdc, infoPtr->clrTextBk);
2047     SetTextColor(hdc, infoPtr->clrText);
2048
2049     /* set raster mode */
2050     SetROP2(hdc, R2_COPYPEN);
2051   }
2052
2053   if (infoPtr->himlNormal != NULL)
2054   {
2055     rc.top += ICON_TOP_PADDING;
2056     nDrawPosX = rc.left + (infoPtr->iconSpacing.cx - infoPtr->iconSize.cx) / 2;
2057     if (bSelected != FALSE)
2058     {
2059       ImageList_Draw(infoPtr->himlNormal, nImage, hdc, nDrawPosX, rc.top,
2060                      ILD_SELECTED);
2061     }
2062     else
2063     {
2064       ImageList_Draw(infoPtr->himlNormal, nImage, hdc, nDrawPosX, rc.top,
2065                      ILD_NORMAL);
2066     }
2067   }
2068
2069   rc.top += infoPtr->iconSize.cy + ICON_BOTTOM_PADDING;
2070   nLabelWidth = ListView_GetStringWidthA(hwnd, pszDispText);
2071   nDrawPosX = infoPtr->iconSpacing.cx - nLabelWidth;
2072   if (nDrawPosX > 1)
2073   {
2074     rc.left += nDrawPosX / 2;
2075     rc.right = rc.left + nLabelWidth;
2076   }
2077   else
2078   {
2079     rc.left += 1;
2080     rc.right = rc.left + infoPtr->iconSpacing.cx - 1;
2081   }
2082
2083   /* draw label */
2084   GetTextMetricsA(hdc, &tm);
2085   rc.bottom = rc.top + tm.tmHeight + HEIGHT_PADDING;
2086   ExtTextOutA(hdc, rc.left, rc.top, ETO_OPAQUE|ETO_CLIPPED,
2087               &rc, pszDispText, lstrlenA(pszDispText), NULL);
2088
2089   if (lpItem->state & LVIS_FOCUSED)
2090   {
2091     Rectangle(hdc, rc.left, rc.top, rc.right, rc.bottom);
2092   }
2093 }
2094
2095 /***
2096  * DESCRIPTION:
2097  * Draws listview items when in report display mode.
2098  *
2099  * PARAMETER(S):
2100  * [I] HWND : window handle
2101  * [I] HDC : device context handle
2102  *
2103  * RETURN:
2104  * None
2105  */
2106 static VOID LISTVIEW_RefreshReport(HWND hwnd, HDC hdc)
2107 {
2108   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd,0);
2109   INT nDrawPosY = infoPtr->rcList.top;
2110   LISTVIEW_ITEM *lpItem;
2111   LISTVIEW_SUBITEM *lpSubItem = NULL;
2112   BOOL bNeedSubItem = TRUE;
2113   INT nColumnCount;
2114   HDPA hdpaSubItems;
2115   RECT rcItem;
2116   INT  j, k;
2117   INT nItem;
2118   INT nLast;
2119
2120   nItem = ListView_GetTopIndex(hwnd);
2121   nLast = nItem + infoPtr->nCountPerColumn;
2122   while (nItem <= nLast)
2123   {
2124     hdpaSubItems = (HDPA)DPA_GetPtr(infoPtr->hdpaItems, nItem);
2125     if (hdpaSubItems != NULL)
2126     {
2127       lpItem = (LISTVIEW_ITEM *)DPA_GetPtr(hdpaSubItems, 0);
2128       if (lpItem != NULL)
2129       {
2130         /* the width of the header items will determine the size of the
2131            listview items */
2132         Header_GetItemRect(infoPtr->hwndHeader, 0, &rcItem);
2133         rcItem.left += REPORT_MARGINX;
2134         rcItem.right = max(rcItem.left, rcItem.right - REPORT_MARGINX);
2135         rcItem.top = nDrawPosY;
2136         rcItem.bottom = rcItem.top + infoPtr->nItemHeight;
2137         LISTVIEW_DrawItem(hwnd, hdc, lpItem, nItem, rcItem);
2138       }
2139
2140       nColumnCount = Header_GetItemCount(infoPtr->hwndHeader);
2141       for (k = 1, j = 1; j < nColumnCount; j++)
2142       {
2143         Header_GetItemRect(infoPtr->hwndHeader, j, &rcItem);
2144         rcItem.left += REPORT_MARGINX;
2145         rcItem.right = max(rcItem.left, rcItem.right - REPORT_MARGINX);
2146         rcItem.top = nDrawPosY;
2147         rcItem.bottom = rcItem.top + infoPtr->nItemHeight;
2148
2149         if (k < hdpaSubItems->nItemCount)
2150         {
2151           if (bNeedSubItem != FALSE)
2152           {
2153             lpSubItem = (LISTVIEW_SUBITEM *)DPA_GetPtr(hdpaSubItems, k);
2154             k++;
2155           }
2156
2157           if (lpSubItem != NULL)
2158           {
2159             if (lpSubItem->iSubItem == j)
2160             {
2161               LISTVIEW_DrawSubItem(hwnd, hdc, nItem, lpItem->lParam, lpSubItem,
2162                                    j, &rcItem);
2163               bNeedSubItem = TRUE;
2164             }
2165             else
2166             {
2167               LISTVIEW_DrawSubItem(hwnd, hdc, nItem, lpItem->lParam, NULL, j,
2168                                    &rcItem);
2169               bNeedSubItem = FALSE;
2170             }
2171           }
2172           else
2173           {
2174             LISTVIEW_DrawSubItem(hwnd, hdc, nItem, lpItem->lParam, NULL, j,
2175                                  &rcItem);
2176             bNeedSubItem = TRUE;
2177           }
2178         }
2179         else
2180         {
2181           LISTVIEW_DrawSubItem(hwnd, hdc, nItem, lpItem->lParam, NULL, j,
2182                                &rcItem);
2183         }
2184       }
2185     }
2186
2187     nDrawPosY += infoPtr->nItemHeight;
2188     nItem++;
2189   }
2190 }
2191
2192 /***
2193  * DESCRIPTION:
2194  * Draws listview items when in list display mode.
2195  *
2196  * PARAMETER(S):
2197  * [I] HWND : window handle
2198  * [I] HDC : device context handle
2199  *
2200  * RETURN:
2201  * None
2202  */
2203 static VOID LISTVIEW_RefreshList(HWND hwnd, HDC hdc)
2204 {
2205   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
2206   LISTVIEW_ITEM *lpItem;
2207   HDPA hdpaSubItems;
2208   RECT rc;
2209   INT i, j;
2210   INT nColumnCount;
2211   INT nItem = ListView_GetTopIndex(hwnd);
2212
2213   if (infoPtr->rcList.right > 0)
2214   {
2215     /* get number of display columns */
2216     if (infoPtr->rcList.right % infoPtr->nItemWidth == 0)
2217     {
2218       nColumnCount = infoPtr->rcList.right / infoPtr->nItemWidth;
2219     }
2220     else
2221     {
2222       nColumnCount = infoPtr->rcList.right / infoPtr->nItemWidth + 1;
2223     }
2224
2225     for (i = 0; i < nColumnCount; i++)
2226     {
2227       j = 0;
2228       while ((nItem < GETITEMCOUNT(infoPtr)) &&
2229              (j<infoPtr->nCountPerColumn))
2230       {
2231         hdpaSubItems = (HDPA)DPA_GetPtr(infoPtr->hdpaItems, nItem);
2232         if (hdpaSubItems != NULL)
2233         {
2234           lpItem = (LISTVIEW_ITEM *)DPA_GetPtr(hdpaSubItems, 0);
2235           if (lpItem != NULL)
2236           {
2237             rc.top = j * infoPtr->nItemHeight;
2238             rc.left = i * infoPtr->nItemWidth;
2239             rc.bottom = rc.top + infoPtr->nItemHeight;
2240             rc.right = rc.left + infoPtr->nItemWidth;
2241             LISTVIEW_DrawItem(hwnd, hdc,  lpItem, nItem, rc);
2242           }
2243         }
2244
2245         nItem++;
2246         j++;
2247       }
2248     }
2249   }
2250 }
2251
2252 /***
2253  * DESCRIPTION:
2254  * Draws listview items when in icon or small icon display mode.
2255  *
2256  * PARAMETER(S):
2257  * [I] HWND : window handle
2258  * [I] HDC : device context handle
2259  *
2260  * RETURN:
2261  * None
2262  */
2263 static VOID LISTVIEW_RefreshIcon(HWND hwnd, HDC hdc, BOOL bSmall)
2264 {
2265   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
2266   LISTVIEW_ITEM *lpItem;
2267   HDPA hdpaSubItems;
2268   POINT ptPosition;
2269   POINT ptOrigin;
2270   RECT rc;
2271   INT i;
2272
2273   LISTVIEW_GetOrigin(hwnd, &ptOrigin);
2274
2275   for (i = 0; i < GETITEMCOUNT(infoPtr); i++)
2276   {
2277     LISTVIEW_GetItemPosition(hwnd, i, &ptPosition);
2278     ptPosition.x += ptOrigin.x;
2279     ptPosition.y += ptOrigin.y;
2280
2281     if (ptPosition.y + infoPtr->nItemHeight > infoPtr->rcList.top)
2282     {
2283       if (ptPosition.x + infoPtr->nItemWidth > infoPtr->rcList.left)
2284       {
2285         if (ptPosition.y < infoPtr->rcList.bottom)
2286         {
2287           if (ptPosition.x < infoPtr->rcList.right)
2288           {
2289             hdpaSubItems = (HDPA)DPA_GetPtr(infoPtr->hdpaItems, i);
2290             if (hdpaSubItems != NULL)
2291             {
2292               lpItem = (LISTVIEW_ITEM *)DPA_GetPtr(hdpaSubItems, 0);
2293               if (lpItem != NULL)
2294               {
2295                 rc.top = ptPosition.y;
2296                 rc.left = ptPosition.x;
2297                 rc.bottom = rc.top + infoPtr->nItemHeight;
2298                 rc.right = rc.left + infoPtr->nItemWidth;
2299                 if (bSmall == FALSE)
2300                 {
2301                   LISTVIEW_DrawLargeItem(hwnd, hdc, lpItem, i, rc);
2302                 }
2303                 else
2304                 {
2305                   LISTVIEW_DrawItem(hwnd, hdc, lpItem, i, rc);
2306                 }
2307               }
2308             }
2309           }
2310         }
2311       }
2312     }
2313   }
2314 }
2315
2316 /***
2317  * DESCRIPTION:
2318  * Draws listview items.
2319  *
2320  * PARAMETER(S):
2321  * [I] HWND : window handle
2322  * [I] HDC : device context handle
2323  *
2324  * RETURN:
2325  * NoneX
2326  */
2327 static VOID LISTVIEW_Refresh(HWND hwnd, HDC hdc)
2328 {
2329   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
2330   LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
2331   HFONT hOldFont;
2332   HPEN hPen, hOldPen;
2333
2334   /* select font */
2335   hOldFont = SelectObject(hdc, infoPtr->hFont);
2336
2337   /* select the doted pen (for drawing the focus box) */
2338   hPen = CreatePen(PS_DOT, 1, 0);
2339   hOldPen = SelectObject(hdc, hPen);
2340
2341   /* select transparent brush (for drawing the focus box) */
2342   SelectObject(hdc, GetStockObject(NULL_BRUSH));
2343
2344   switch (LVS_TYPEMASK & lStyle)
2345   {
2346   case LVS_LIST:
2347     LISTVIEW_RefreshList(hwnd, hdc);
2348     break;
2349   case LVS_REPORT:
2350     LISTVIEW_RefreshReport(hwnd, hdc);
2351     break;
2352   case LVS_SMALLICON:
2353     LISTVIEW_RefreshIcon(hwnd, hdc, TRUE);
2354     break;
2355   case LVS_ICON:
2356     LISTVIEW_RefreshIcon(hwnd, hdc, FALSE);
2357   }
2358
2359   /* unselect objects */
2360   SelectObject(hdc, hOldFont);
2361   SelectObject(hdc, hOldPen);
2362
2363   /* delete pen */
2364   DeleteObject(hPen);
2365 }
2366
2367
2368 /***
2369  * DESCRIPTION:
2370  * Calculates the approximate width and height of a given number of items.
2371  *
2372  * PARAMETER(S):
2373  * [I] HWND : window handle
2374  * [I] INT : number of items
2375  * [I] INT : width
2376  * [I] INT : height
2377  *
2378  * RETURN:
2379  * Returns a DWORD. The width in the low word and the height in high word.
2380  */
2381 static LRESULT LISTVIEW_ApproximateViewRect(HWND hwnd, INT nItemCount,
2382                                             WORD wWidth, WORD wHeight)
2383 {
2384   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
2385   LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
2386   INT nItemCountPerColumn = 1;
2387   INT nColumnCount = 0;
2388   DWORD dwViewRect = 0;
2389
2390   if (nItemCount == -1)
2391     nItemCount = GETITEMCOUNT(infoPtr);
2392
2393   if (lStyle & LVS_LIST)
2394   {
2395     if (wHeight == 0xFFFF)
2396     {
2397       /* use current height */
2398       wHeight = infoPtr->rcList.bottom;
2399     }
2400
2401     if (wHeight < infoPtr->nItemHeight)
2402     {
2403       wHeight = infoPtr->nItemHeight;
2404     }
2405
2406     if (nItemCount > 0)
2407     {
2408       if (infoPtr->nItemHeight > 0)
2409       {
2410         nItemCountPerColumn = wHeight / infoPtr->nItemHeight;
2411         if (nItemCountPerColumn == 0)
2412           nItemCountPerColumn = 1;
2413
2414         if (nItemCount % nItemCountPerColumn != 0)
2415           nColumnCount = nItemCount / nItemCountPerColumn;
2416         else
2417           nColumnCount = nItemCount / nItemCountPerColumn + 1;
2418       }
2419     }
2420
2421     /* Microsoft padding magic */
2422     wHeight = nItemCountPerColumn * infoPtr->nItemHeight + 2;
2423     wWidth = nColumnCount * infoPtr->nItemWidth + 2;
2424
2425     dwViewRect = MAKELONG(wWidth, wHeight);
2426   }
2427   else if (lStyle & LVS_REPORT)
2428   {
2429     /* TO DO */
2430     }
2431   else if (lStyle & LVS_SMALLICON)
2432   {
2433     /* TO DO */
2434   }
2435   else if (lStyle & LVS_ICON)
2436   {
2437     /* TO DO */
2438   }
2439
2440   return dwViewRect;
2441 }
2442
2443 /***
2444  * DESCRIPTION:
2445  * Arranges listview items in icon display mode.
2446  *
2447  * PARAMETER(S):
2448  * [I] HWND : window handle
2449  * [I] INT : alignment code
2450  *
2451  * RETURN:
2452  *   SUCCESS : TRUE
2453  *   FAILURE : FALSE
2454  */
2455 static LRESULT LISTVIEW_Arrange(HWND hwnd, INT nAlignCode)
2456 {
2457   LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
2458   BOOL bResult = FALSE;
2459
2460   if (((LVS_TYPEMASK & lStyle) == LVS_ICON) ||
2461       ((LVS_TYPEMASK & lStyle) == LVS_SMALLICON))
2462   {
2463     switch (nAlignCode)
2464     {
2465     case LVA_ALIGNLEFT:
2466       /* TO DO */
2467       break;
2468     case LVA_ALIGNTOP:
2469       /* TO DO */
2470       break;
2471     case LVA_DEFAULT:
2472       /* TO DO */
2473       break;
2474     case LVA_SNAPTOGRID:
2475       /* TO DO */
2476       break;
2477     }
2478   }
2479
2480   return bResult;
2481 }
2482
2483 /* << LISTVIEW_CreateDragImage >> */
2484
2485 /***
2486  * DESCRIPTION:
2487  * Removes all listview items and subitems.
2488  *
2489  * PARAMETER(S):
2490  * [I] HWND : window handle
2491  *
2492  * RETURN:
2493  *   SUCCESS : TRUE
2494  *   FAILURE : FALSE
2495  */
2496 static LRESULT LISTVIEW_DeleteAllItems(HWND hwnd)
2497 {
2498   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
2499   LONG lCtrlId = GetWindowLongA(hwnd, GWL_ID);
2500   LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
2501   LISTVIEW_ITEM *lpItem;
2502   LISTVIEW_SUBITEM *lpSubItem;
2503   NMLISTVIEW nmlv;
2504   BOOL bSuppress;
2505   BOOL bResult = FALSE;
2506   INT i;
2507   INT j;
2508   HDPA hdpaSubItems;
2509
2510   TRACE(listview, "(hwnd=%x,)\n", hwnd);
2511
2512   if (GETITEMCOUNT(infoPtr) > 0)
2513   {
2514     /* initialize memory */
2515     ZeroMemory(&nmlv, sizeof(NMLISTVIEW));
2516
2517     /* send LVN_DELETEALLITEMS notification */
2518     nmlv.hdr.hwndFrom = hwnd;
2519     nmlv.hdr.idFrom = lCtrlId;
2520     nmlv.hdr.code = LVN_DELETEALLITEMS;
2521     nmlv.iItem = -1;
2522
2523     /* verify if subsequent LVN_DELETEITEM notifications should be
2524        suppressed */
2525     bSuppress = ListView_LVNotify(GetParent(hwnd), lCtrlId, &nmlv);
2526
2527     for (i = 0; i < GETITEMCOUNT(infoPtr); i++)
2528     {
2529       hdpaSubItems = (HDPA)DPA_GetPtr(infoPtr->hdpaItems, i);
2530       if (hdpaSubItems != NULL)
2531       {
2532         for (j = 1; j < hdpaSubItems->nItemCount; j++)
2533         {
2534           lpSubItem = (LISTVIEW_SUBITEM *)DPA_GetPtr(hdpaSubItems, j);
2535           if (lpSubItem != NULL)
2536           {
2537             /* free subitem string */
2538             if ((lpSubItem->pszText != NULL) &&
2539                 (lpSubItem->pszText != LPSTR_TEXTCALLBACKA))
2540             {
2541               COMCTL32_Free(lpSubItem->pszText);
2542             }
2543
2544             /* free subitem */
2545             COMCTL32_Free(lpSubItem);
2546           }
2547         }
2548
2549         lpItem = (LISTVIEW_ITEM *)DPA_GetPtr(hdpaSubItems, 0);
2550         if (lpItem != NULL)
2551         {
2552           if (bSuppress == FALSE)
2553           {
2554             /* send LVN_DELETEITEM notification */
2555             nmlv.hdr.code = LVN_DELETEITEM;
2556             nmlv.iItem = i;
2557             nmlv.lParam = lpItem->lParam;
2558             ListView_LVNotify(GetParent(hwnd), lCtrlId, &nmlv);
2559           }
2560
2561           /* free item string */
2562           if ((lpItem->pszText != NULL) &&
2563               (lpItem->pszText != LPSTR_TEXTCALLBACKA))
2564           {
2565             COMCTL32_Free(lpItem->pszText);
2566           }
2567
2568           /* free item */
2569           COMCTL32_Free(lpItem);
2570         }
2571
2572         DPA_Destroy(hdpaSubItems);
2573       }
2574     }
2575
2576     /* reinitialize listview memory */
2577     bResult = DPA_DeleteAllPtrs(infoPtr->hdpaItems);
2578
2579     /* align items (set position of each item) */
2580     switch (lStyle & LVS_TYPEMASK)
2581     {
2582     case LVS_ICON:
2583     case LVS_SMALLICON:
2584       if (lStyle & LVS_ALIGNLEFT)
2585       {
2586         LISTVIEW_AlignLeft(hwnd);
2587       }
2588       else
2589       {
2590         LISTVIEW_AlignTop(hwnd);
2591       }
2592       break;
2593     }
2594
2595     LISTVIEW_SetScroll(hwnd, lStyle);
2596
2597     /* invalidate client area (optimization needed) */
2598     InvalidateRect(hwnd, NULL, TRUE);
2599   }
2600
2601   return bResult;
2602 }
2603
2604 /***
2605  * DESCRIPTION:
2606  * Removes a column from the listview control.
2607  *
2608  * PARAMETER(S):
2609  * [I] HWND : window handle
2610  * [I] INT : column index
2611  *
2612  * RETURN:
2613  *   SUCCESS : TRUE
2614  *   FAILURE : FALSE
2615  */
2616 static LRESULT LISTVIEW_DeleteColumn(HWND hwnd, INT nColumn)
2617 {
2618   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
2619   LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
2620   BOOL bResult = FALSE;
2621
2622   if (Header_DeleteItem(infoPtr->hwndHeader, nColumn) != FALSE)
2623   {
2624     bResult = LISTVIEW_RemoveColumn(infoPtr->hdpaItems, nColumn);
2625
2626     /* reset scroll parameters */
2627     if ((lStyle & LVS_TYPEMASK) == LVS_REPORT)
2628     {
2629       LISTVIEW_SetViewInfo(hwnd, lStyle);
2630       LISTVIEW_SetScroll(hwnd, lStyle);
2631     }
2632
2633     /* refresh client area */
2634     InvalidateRect(hwnd, NULL, FALSE);
2635   }
2636
2637   return bResult;
2638 }
2639
2640 /***
2641  * DESCRIPTION:
2642  * Removes an item from the listview control.
2643  *
2644  * PARAMETER(S):
2645  * [I] HWND : window handle
2646  * [I] INT : item index
2647  *
2648  * RETURN:
2649  *   SUCCESS : TRUE
2650  *   FAILURE : FALSE
2651  */
2652 static LRESULT LISTVIEW_DeleteItem(HWND hwnd, INT nItem)
2653 {
2654   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
2655   LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
2656   LONG lCtrlId = GetWindowLongA(hwnd, GWL_ID);
2657   NMLISTVIEW nmlv;
2658   BOOL bResult = FALSE;
2659   HDPA hdpaSubItems;
2660   LISTVIEW_ITEM *lpItem;
2661   LISTVIEW_SUBITEM *lpSubItem;
2662   INT i;
2663
2664   TRACE(listview, "(hwnd=%x,nItem=%d)\n", hwnd, nItem);
2665
2666   if ((nItem >= 0) && (nItem < GETITEMCOUNT(infoPtr)))
2667   {
2668     /* initialize memory */
2669     ZeroMemory(&nmlv, sizeof(NMLISTVIEW));
2670
2671     hdpaSubItems = (HDPA)DPA_DeletePtr(infoPtr->hdpaItems, nItem);
2672     if (hdpaSubItems != NULL)
2673     {
2674       for (i = 1; i < hdpaSubItems->nItemCount; i++)
2675       {
2676         lpSubItem = (LISTVIEW_SUBITEM *)DPA_GetPtr(hdpaSubItems, i);
2677         if (lpSubItem != NULL)
2678         {
2679           /* free item string */
2680           if ((lpSubItem->pszText != NULL) &&
2681               (lpSubItem->pszText != LPSTR_TEXTCALLBACKA))
2682           {
2683             COMCTL32_Free(lpSubItem->pszText);
2684           }
2685
2686           /* free item */
2687           COMCTL32_Free(lpSubItem);
2688         }
2689       }
2690
2691       lpItem = (LISTVIEW_ITEM *)DPA_GetPtr(hdpaSubItems, 0);
2692       if (lpItem != NULL)
2693       {
2694         /* send LVN_DELETEITEM notification */
2695         nmlv.hdr.hwndFrom = hwnd;
2696         nmlv.hdr.idFrom = lCtrlId;
2697         nmlv.hdr.code = LVN_DELETEITEM;
2698         nmlv.iItem = nItem;
2699         nmlv.lParam = lpItem->lParam;
2700         SendMessageA(GetParent(hwnd), WM_NOTIFY, (WPARAM)lCtrlId,
2701                      (LPARAM)&nmlv);
2702
2703         /* free item string */
2704         if ((lpItem->pszText != NULL) &&
2705             (lpItem->pszText != LPSTR_TEXTCALLBACKA))
2706         {
2707           COMCTL32_Free(lpItem->pszText);
2708         }
2709
2710         /* free item */
2711         COMCTL32_Free(lpItem);
2712       }
2713
2714       bResult = DPA_Destroy(hdpaSubItems);
2715     }
2716
2717     /* align items (set position of each item) */
2718     switch(lStyle & LVS_TYPEMASK)
2719     {
2720     case LVS_ICON:
2721     case LVS_SMALLICON:
2722       if (lStyle & LVS_ALIGNLEFT)
2723       {
2724         LISTVIEW_AlignLeft(hwnd);
2725       }
2726       else
2727       {
2728         LISTVIEW_AlignTop(hwnd);
2729       }
2730       break;
2731     }
2732
2733     LISTVIEW_SetScroll(hwnd, lStyle);
2734
2735     /* refresh client area */
2736     InvalidateRect(hwnd, NULL, TRUE);
2737   }
2738
2739   return bResult;
2740 }
2741
2742 /* LISTVIEW_EditLabel */
2743
2744 /***
2745  * DESCRIPTION:
2746  * Ensures the specified item is visible, scrolling into view if necessary.
2747  *
2748  * PARAMETER(S):
2749  * [I] HWND : window handle
2750  * [I] INT : item index
2751  * [I] BOOL : partially or entirely visible
2752  *
2753  * RETURN:
2754  *   SUCCESS : TRUE
2755  *   FAILURE : FALSE
2756  */
2757 static BOOL LISTVIEW_EnsureVisible(HWND hwnd, INT nItem, BOOL bPartial)
2758 {
2759   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
2760   LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
2761   INT nListHeight = infoPtr->rcList.bottom - infoPtr->rcList.top;
2762   INT nListWidth = infoPtr->rcList.right - infoPtr->rcList.left;
2763   INT nHScrollPos = 0;
2764   INT nVScrollPos = 0;
2765   INT nScrollPosHeight = 0;
2766   INT nScrollPosWidth = 0;
2767   RECT rcItem;
2768   BOOL bResult = FALSE;
2769
2770   /* ALWAYS bPartial == FALSE, FOR NOW! */
2771
2772   rcItem.left = LVIR_BOUNDS;
2773   if (LISTVIEW_GetItemRect(hwnd, nItem, &rcItem) != FALSE)
2774   {
2775     if (rcItem.left < infoPtr->rcList.left)
2776     {
2777       /* scroll left */
2778       switch (LVS_TYPEMASK & lStyle)
2779       {
2780       case LVS_LIST:
2781         rcItem.left += infoPtr->rcList.left;
2782         nScrollPosWidth = infoPtr->nItemWidth;
2783         break;
2784
2785       case LVS_SMALLICON:
2786       case LVS_ICON:
2787         nScrollPosWidth = max(1, nListWidth / 10);
2788         rcItem.left += infoPtr->rcList.left;
2789         break;
2790       }
2791
2792       if (rcItem.left % nScrollPosWidth == 0)
2793       {
2794         nHScrollPos = rcItem.left / nScrollPosWidth;
2795       }
2796       else
2797       {
2798         nHScrollPos = rcItem.left / nScrollPosWidth - 1;
2799       }
2800     }
2801     else if (rcItem.right > infoPtr->rcList.right)
2802     {
2803       /* scroll right */
2804       switch (LVS_TYPEMASK & lStyle)
2805       {
2806       case LVS_LIST:
2807         rcItem.right -= infoPtr->rcList.right;
2808         nScrollPosWidth = infoPtr->nItemWidth;
2809         break;
2810
2811       case LVS_SMALLICON:
2812       case LVS_ICON:
2813         nScrollPosWidth = max(1, nListWidth / 10);
2814         rcItem.right -= infoPtr->rcList.right;
2815         break;
2816       }
2817
2818       if (rcItem.right % nScrollPosWidth == 0)
2819       {
2820         nHScrollPos = rcItem.right / nScrollPosWidth;
2821       }
2822       else
2823       {
2824         nHScrollPos = rcItem.right / nScrollPosWidth + 1;
2825       }
2826     }
2827
2828     if (rcItem.top < infoPtr->rcList.top)
2829     {
2830       /* scroll up */
2831       switch (LVS_TYPEMASK & lStyle)
2832       {
2833       case LVS_REPORT:
2834         rcItem.top -= infoPtr->rcList.top;
2835         nScrollPosHeight = infoPtr->nItemHeight;
2836         break;
2837
2838       case LVS_SMALLICON:
2839       case LVS_ICON:
2840         nScrollPosHeight = max(1, nListHeight / 10);
2841         rcItem.top += infoPtr->rcList.top;
2842         break;
2843       }
2844
2845       if (rcItem.top % nScrollPosHeight == 0)
2846       {
2847         nVScrollPos = rcItem.top / nScrollPosHeight;
2848       }
2849       else
2850       {
2851         nVScrollPos = rcItem.top / nScrollPosHeight - 1;
2852       }
2853     }
2854     else if (rcItem.bottom > infoPtr->rcList.bottom)
2855     {
2856       switch (LVS_TYPEMASK & lStyle)
2857       {
2858       case LVS_REPORT:
2859         rcItem.bottom -= infoPtr->rcList.bottom;
2860         nScrollPosHeight = infoPtr->nItemHeight;
2861         break;
2862
2863       case LVS_SMALLICON:
2864       case LVS_ICON:
2865         nScrollPosHeight = max(1, nListHeight / 10);
2866         rcItem.bottom -= infoPtr->rcList.bottom;
2867         break;
2868       }
2869
2870       if (rcItem.bottom % nScrollPosHeight == 0)
2871       {
2872         nVScrollPos = rcItem.bottom / nScrollPosHeight;
2873       }
2874       else
2875       {
2876         nVScrollPos = rcItem.bottom / nScrollPosHeight + 1;
2877       }
2878     }
2879
2880     bResult = LISTVIEW_ScrollView(hwnd, nHScrollPos, nVScrollPos);
2881   }
2882
2883   return bResult;
2884 }
2885
2886 /***
2887  * DESCRIPTION:
2888  * Searches for an item with specific characteristics.
2889  *
2890  * PARAMETER(S):
2891  * [I] HWND : window handle
2892  * [I] INT : base item index
2893  * [I] LPLVFINDINFO : item information to look for
2894  *
2895  * RETURN:
2896  *   SUCCESS : index of item
2897  *   FAILURE : -1
2898  */
2899 static LRESULT LISTVIEW_FindItem(HWND hwnd, INT nStart,
2900                                  LPLVFINDINFO lpFindInfo)
2901 {
2902   FIXME (listview, "empty stub!\n");
2903
2904   return -1;
2905 }
2906
2907 /***
2908  * DESCRIPTION:
2909  * Retrieves the background color of the listview control.
2910  *
2911  * PARAMETER(S):
2912  * [I] HWND : window handle
2913  *
2914  * RETURN:
2915  * COLORREF associated with the background.
2916  */
2917 static LRESULT LISTVIEW_GetBkColor(HWND hwnd)
2918 {
2919   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
2920
2921   return infoPtr->clrBk;
2922 }
2923
2924 /***
2925  * DESCRIPTION:
2926  * Retrieves the background image of the listview control.
2927  *
2928  * PARAMETER(S):
2929  * [I] HWND : window handle
2930  * [O] LPLVMKBIMAGE : background image attributes
2931  *
2932  * RETURN:
2933  *   SUCCESS : TRUE
2934  *   FAILURE : FALSE`
2935  */
2936 /* static LRESULT LISTVIEW_GetBkImage(HWND hwnd, LPLVBKIMAGE lpBkImage)   */
2937 /* {   */
2938 /*   FIXME (listview, "empty stub!\n"); */
2939 /*   return FALSE;   */
2940 /* }   */
2941
2942 /***
2943  * DESCRIPTION:
2944  * Retrieves the callback mask.
2945  *
2946  * PARAMETER(S):
2947  * [I] HWND : window handle
2948  *
2949  * RETURN:
2950  *  Value of mask
2951  */
2952 static UINT LISTVIEW_GetCallbackMask(HWND hwnd)
2953 {
2954   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
2955
2956   return infoPtr->uCallbackMask;
2957 }
2958
2959 /***
2960  * DESCRIPTION:
2961  * Retrieves column attributes.
2962  *
2963  * PARAMETER(S):
2964  * [I] HWND : window handle
2965  * [I] INT :  column index
2966  * [IO] LPLVCOLUMNA : column information
2967  *
2968  * RETURN:
2969  *   SUCCESS : TRUE
2970  *   FAILURE : FALSE
2971  */
2972 static LRESULT LISTVIEW_GetColumnA(HWND hwnd, INT nItem,
2973                                      LPLVCOLUMNA lpColumn)
2974 {
2975   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
2976   HDITEMA hdi;
2977   BOOL bResult = FALSE;
2978
2979   if (lpColumn != NULL)
2980   {
2981     /* initialize memory */
2982     ZeroMemory(&hdi, sizeof(HDITEMA));
2983
2984     if (lpColumn->mask & LVCF_FMT)
2985     {
2986       hdi.mask |= HDI_FORMAT;
2987     }
2988
2989     if (lpColumn->mask & LVCF_WIDTH)
2990     {
2991       hdi.mask |= HDI_WIDTH;
2992     }
2993
2994     if (lpColumn->mask & LVCF_TEXT)
2995     {
2996       hdi.mask |= (HDI_TEXT | HDI_FORMAT);
2997     }
2998
2999     if (lpColumn->mask & LVCF_IMAGE)
3000     {
3001       hdi.mask |= HDI_IMAGE;
3002     }
3003
3004     if (lpColumn->mask & LVCF_ORDER)
3005     {
3006       hdi.mask |= HDI_ORDER;
3007     }
3008
3009     bResult = Header_GetItemA(infoPtr->hwndHeader, nItem, &hdi);
3010     if (bResult != FALSE)
3011     {
3012       if (lpColumn->mask & LVCF_FMT)
3013       {
3014         lpColumn->fmt = 0;
3015
3016         if (hdi.fmt & HDF_LEFT)
3017         {
3018           lpColumn->fmt |= LVCFMT_LEFT;
3019         }
3020         else if (hdi.fmt & HDF_RIGHT)
3021         {
3022           lpColumn->fmt |= LVCFMT_RIGHT;
3023         }
3024         else if (hdi.fmt & HDF_CENTER)
3025         {
3026           lpColumn->fmt |= LVCFMT_CENTER;
3027         }
3028
3029         if (hdi.fmt & HDF_IMAGE)
3030         {
3031           lpColumn->fmt |= LVCFMT_COL_HAS_IMAGES;
3032         }
3033       }
3034
3035       if (lpColumn->mask & LVCF_WIDTH)
3036       {
3037         lpColumn->cx = hdi.cxy;
3038       }
3039
3040       if ((lpColumn->mask & LVCF_TEXT) && (lpColumn->pszText) && (hdi.pszText))
3041       {
3042         lstrcpynA (lpColumn->pszText, hdi.pszText, lpColumn->cchTextMax);
3043       }
3044
3045       if (lpColumn->mask & LVCF_IMAGE)
3046       {
3047         lpColumn->iImage = hdi.iImage;
3048       }
3049
3050       if (lpColumn->mask & LVCF_ORDER)
3051       {
3052         lpColumn->iOrder = hdi.iOrder;
3053       }
3054     }
3055   }
3056
3057   return bResult;
3058 }
3059
3060 /* LISTVIEW_GetColumnW */
3061 /* LISTVIEW_GetColumnOrderArray */
3062
3063 /***
3064  * DESCRIPTION:
3065  * Retrieves the column width.
3066  *
3067  * PARAMETER(S):
3068  * [I] HWND : window handle
3069  * [I] int : column index
3070  *
3071  * RETURN:
3072  *   SUCCESS : column width
3073  *   FAILURE : zero
3074  */
3075 static LRESULT LISTVIEW_GetColumnWidth(HWND hwnd, INT nColumn)
3076 {
3077   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
3078   LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
3079   HDITEMA hdi;
3080   INT nColumnWidth = 0;
3081
3082   switch (LVS_TYPEMASK & lStyle)
3083   {
3084   case LVS_LIST:
3085     nColumnWidth = infoPtr->nItemWidth;
3086     break;
3087
3088   case LVS_REPORT:
3089     /* get column width from header */
3090     ZeroMemory(&hdi, sizeof(HDITEMA));
3091     hdi.mask = HDI_WIDTH;
3092     if (Header_GetItemA(infoPtr->hwndHeader, nColumn, &hdi) != FALSE)
3093     {
3094       nColumnWidth = hdi.cxy;
3095     }
3096     break;
3097   }
3098
3099   return nColumnWidth;
3100 }
3101
3102 /***
3103  * DESCRIPTION:
3104  * In list or report display mode, retrieves the number of items that can fit
3105  * vertically in the visible area. In icon or small icon display mode,
3106  * retrieves the total number of visible items.
3107  *
3108  * PARAMETER(S):
3109  * [I] HWND : window handle
3110  *
3111  * RETURN:
3112  * Number of fully visible items.
3113  */
3114 static LRESULT LISTVIEW_GetCountPerPage(HWND hwnd)
3115 {
3116   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
3117   LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
3118   INT nItemCount = 0;
3119
3120   switch (LVS_TYPEMASK & lStyle)
3121   {
3122   case LVS_LIST:
3123     if (infoPtr->rcList.right / infoPtr->nItemWidth)
3124     {
3125       nItemCount = infoPtr->nCountPerRow * infoPtr->nCountPerColumn;
3126     }
3127     break;
3128
3129   case LVS_REPORT:
3130     nItemCount = infoPtr->nCountPerColumn;
3131     break;
3132
3133   case LVS_SMALLICON:
3134   case LVS_ICON:
3135     nItemCount = GETITEMCOUNT(infoPtr);
3136     break;
3137   }
3138
3139   return nItemCount;
3140 }
3141
3142 /* LISTVIEW_GetEditControl */
3143 /* LISTVIEW_GetExtendedListViewStyle */
3144
3145 /***
3146  * DESCRIPTION:
3147  * Retrieves the handle to the header control.
3148  *
3149  * PARAMETER(S):
3150  * [I] HWND : window handle
3151  *
3152  * RETURN:
3153  * Header handle.
3154  */
3155 static LRESULT LISTVIEW_GetHeader(HWND hwnd)
3156 {
3157   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
3158
3159   return infoPtr->hwndHeader;
3160 }
3161
3162 /* LISTVIEW_GetHotCursor */
3163 /* LISTVIEW_GetHotItem */
3164 /* LISTVIEW_GetHoverTime */
3165
3166 /***
3167  * DESCRIPTION:
3168  * Retrieves an image list handle.
3169  *
3170  * PARAMETER(S):
3171  * [I] HWND : window handle
3172  * [I] INT : image list identifier
3173  *
3174  * RETURN:
3175  *   SUCCESS : image list handle
3176  *   FAILURE : NULL
3177  */
3178 static LRESULT LISTVIEW_GetImageList(HWND hwnd, INT nImageList)
3179 {
3180   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
3181   HIMAGELIST himl = NULL;
3182
3183   switch (nImageList)
3184   {
3185   case LVSIL_NORMAL:
3186     himl = infoPtr->himlNormal;
3187     break;
3188   case LVSIL_SMALL:
3189     himl = infoPtr->himlSmall;
3190     break;
3191   case LVSIL_STATE:
3192     himl = infoPtr->himlState;
3193     break;
3194   }
3195
3196   return (LRESULT)himl;
3197 }
3198
3199 /* LISTVIEW_GetISearchString */
3200
3201 /***
3202  * DESCRIPTION:
3203  * Retrieves item attributes.
3204  *
3205  * PARAMETER(S):
3206  * [I] HWND : window handle
3207  * [IO] LPLVITEMA : item info
3208  *
3209  * RETURN:
3210  *   SUCCESS : TRUE
3211  *   FAILURE : FALSE
3212  */
3213 static LRESULT LISTVIEW_GetItemA(HWND hwnd, LPLVITEMA lpLVItem)
3214 {
3215   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
3216   LISTVIEW_ITEM *lpItem;
3217   LISTVIEW_SUBITEM *lpSubItem;
3218   HDPA hdpaSubItems;
3219   BOOL bResult = FALSE;
3220
3221   TRACE(listview, "(hwnd=%x,lpLVItem=%p)\n", hwnd, lpLVItem);
3222
3223   if (lpLVItem != NULL)
3224   {
3225     if ((lpLVItem->iItem >= 0) && (lpLVItem->iItem < GETITEMCOUNT(infoPtr)))
3226     {
3227       hdpaSubItems = (HDPA)DPA_GetPtr(infoPtr->hdpaItems, lpLVItem->iItem);
3228       if (hdpaSubItems != NULL)
3229       {
3230         if (lpLVItem->iSubItem == 0)
3231         {
3232           lpItem = (LISTVIEW_ITEM *)DPA_GetPtr(hdpaSubItems, 0);
3233           if (lpItem != NULL)
3234           {
3235             bResult = TRUE;
3236
3237             /* retrieve valid data */
3238             if (lpLVItem->mask & LVIF_STATE)
3239             {
3240               lpLVItem->state = lpItem->state & lpLVItem->stateMask;
3241             }
3242
3243             if (lpLVItem->mask & LVIF_TEXT)
3244             {
3245               if (lpItem->pszText == LPSTR_TEXTCALLBACKA)
3246               {
3247                 lpLVItem->pszText = LPSTR_TEXTCALLBACKA;
3248               }
3249               else
3250               {
3251                 bResult = Str_GetPtrA(lpItem->pszText, lpLVItem->pszText,
3252                                         lpLVItem->cchTextMax);
3253               }
3254             }
3255
3256             if (lpLVItem->mask & LVIF_IMAGE)
3257             {
3258               lpLVItem->iImage = lpItem->iImage;
3259             }
3260
3261             if (lpLVItem->mask & LVIF_PARAM)
3262             {
3263               lpLVItem->lParam = lpItem->lParam;
3264             }
3265
3266             if (lpLVItem->mask & LVIF_INDENT)
3267             {
3268               lpLVItem->iIndent = lpItem->iIndent;
3269             }
3270           }
3271         }
3272         else
3273         {
3274           lpSubItem = (LISTVIEW_SUBITEM *)DPA_GetPtr(hdpaSubItems,
3275                                                      lpLVItem->iSubItem);
3276           if (lpSubItem != NULL)
3277           {
3278             bResult = TRUE;
3279
3280             if (lpLVItem->mask & LVIF_TEXT)
3281             {
3282               if (lpSubItem->pszText == LPSTR_TEXTCALLBACKA)
3283               {
3284                 lpLVItem->pszText = LPSTR_TEXTCALLBACKA;
3285               }
3286               else
3287               {
3288                 bResult = Str_GetPtrA(lpSubItem->pszText, lpLVItem->pszText,
3289                                         lpLVItem->cchTextMax);
3290               }
3291             }
3292
3293             if (lpLVItem->mask & LVIF_IMAGE)
3294             {
3295               lpLVItem->iImage = lpSubItem->iImage;
3296             }
3297           }
3298         }
3299       }
3300     }
3301   }
3302
3303   return bResult;
3304 }
3305
3306 /* LISTVIEW_GetItemW */
3307 /* LISTVIEW_GetHotCursor */
3308 /* LISTVIEW_GetHotItem */
3309 /* LISTVIEW_GetHoverTime> */
3310
3311 /***
3312  * DESCRIPTION:
3313  * Retrieves the number of items in the listview control.
3314  *
3315  * PARAMETER(S):
3316  * [I] HWND : window handle
3317  *
3318  * RETURN:
3319  * Number of items.
3320  */
3321 static LRESULT LISTVIEW_GetItemCount(HWND hwnd)
3322 {
3323   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
3324
3325   return GETITEMCOUNT(infoPtr);
3326 }
3327
3328 /***
3329  * DESCRIPTION:
3330  * Retrieves the position (upper-left) of the listview control item.
3331  *
3332  * PARAMETER(S):
3333  * [I] HWND : window handle
3334  * [I] INT : item index
3335  * [O] LPPOINT : coordinate information
3336  *
3337  * RETURN:
3338  *   SUCCESS : TRUE
3339  *   FAILURE : FALSE
3340  */
3341 static BOOL LISTVIEW_GetItemPosition(HWND hwnd, INT nItem,
3342                                      LPPOINT lpptPosition)
3343 {
3344   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
3345   LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
3346   BOOL bResult = FALSE;
3347   HDPA hdpaSubItems;
3348   LISTVIEW_ITEM *lpItem;
3349   INT nRow;
3350
3351   TRACE(listview, "(hwnd=%x,nItem=%d,lpptPosition=%p)\n", hwnd, nItem,
3352         lpptPosition);
3353
3354   if ((nItem >= 0) && (nItem < GETITEMCOUNT(infoPtr)) &&
3355       (lpptPosition != NULL))
3356   {
3357     switch (LVS_TYPEMASK & lStyle)
3358     {
3359     case LVS_LIST:
3360       bResult = TRUE;
3361       nItem = nItem - ListView_GetTopIndex(hwnd);
3362       if (nItem < 0)
3363       {
3364         nRow = nItem % infoPtr->nCountPerColumn;
3365         if (nRow == 0)
3366         {
3367           lpptPosition->x = (nItem / infoPtr->nCountPerColumn *
3368                              infoPtr->nItemWidth);
3369           lpptPosition->y = 0;
3370         }
3371         else
3372         {
3373           lpptPosition->x = ((nItem / infoPtr->nCountPerColumn - 1) *
3374                              infoPtr->nItemWidth);
3375           lpptPosition->y = ((nRow + infoPtr->nCountPerColumn) *
3376                              infoPtr->nItemHeight);
3377         }
3378       }
3379       else
3380       {
3381         lpptPosition->x = (nItem / infoPtr->nCountPerColumn *
3382                            infoPtr->nItemWidth);
3383         lpptPosition->y = (nItem % infoPtr->nCountPerColumn *
3384                            infoPtr->nItemHeight);
3385       }
3386       break;
3387
3388     case LVS_REPORT:
3389       bResult = TRUE;
3390       lpptPosition->x = REPORT_MARGINX;
3391       lpptPosition->y = ((nItem - ListView_GetTopIndex(hwnd)) *
3392                          infoPtr->nItemHeight) + infoPtr->rcList.top;
3393       break;
3394
3395     case LVS_SMALLICON:
3396     case LVS_ICON:
3397       hdpaSubItems = (HDPA)DPA_GetPtr(infoPtr->hdpaItems, nItem);
3398       if (hdpaSubItems != NULL)
3399       {
3400         lpItem = (LISTVIEW_ITEM *)DPA_GetPtr(hdpaSubItems, 0);
3401         if (lpItem != NULL)
3402         {
3403           bResult = TRUE;
3404           lpptPosition->x = lpItem->ptPosition.x;
3405           lpptPosition->y = lpItem->ptPosition.y;
3406         }
3407       }
3408       break;
3409     }
3410   }
3411
3412   return bResult;
3413 }
3414
3415 /***
3416  * DESCRIPTION:
3417  * Retrieves the bounding rectangle for a listview control item.
3418  *
3419  * PARAMETER(S):
3420  * [I] HWND : window handle
3421  * [I] INT : item index
3422  * [IO] LPRECT : bounding rectangle coordinates
3423  *
3424  * RETURN:
3425  *   SUCCESS : TRUE
3426  *   FAILURE : FALSE
3427  */
3428 static LRESULT LISTVIEW_GetItemRect(HWND hwnd, INT nItem, LPRECT lprc)
3429 {
3430   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
3431   LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
3432   BOOL bResult = FALSE;
3433   POINT ptOrigin;
3434   POINT ptItem;
3435   HDC hdc;
3436   HFONT hOldFont;
3437   INT nMaxWidth;
3438   INT nLabelWidth;
3439   TEXTMETRICA tm;
3440
3441   TRACE(listview, "(hwnd=%x,nItem=%d,lprc=%p)\n", hwnd, nItem, lprc);
3442
3443   if ((nItem >= 0) && (nItem < GETITEMCOUNT(infoPtr)) && (lprc != NULL))
3444   {
3445     if (ListView_GetItemPosition(hwnd, nItem, &ptItem) != FALSE)
3446     {
3447       switch(lprc->left)
3448       {
3449       case LVIR_ICON:
3450         switch (LVS_TYPEMASK & lStyle)
3451         {
3452         case LVS_ICON:
3453           if (infoPtr->himlNormal != NULL)
3454           {
3455             if (LISTVIEW_GetOrigin(hwnd, &ptOrigin) != FALSE)
3456             {
3457               bResult = TRUE;
3458               lprc->left = ptItem.x + ptOrigin.x;
3459               lprc->top = ptItem.y + ptOrigin.y;
3460               lprc->right = lprc->left + infoPtr->iconSize.cx;
3461               lprc->bottom = (lprc->top + infoPtr->iconSize.cy +
3462                               ICON_BOTTOM_PADDING + ICON_TOP_PADDING);
3463             }
3464           }
3465           break;
3466
3467         case LVS_SMALLICON:
3468           if (LISTVIEW_GetOrigin(hwnd, &ptOrigin) != FALSE)
3469           {
3470             bResult = TRUE;
3471             lprc->left = ptItem.x + ptOrigin.x;
3472             lprc->top = ptItem.y + ptOrigin.y;
3473             lprc->bottom = lprc->top + infoPtr->nItemHeight;
3474
3475             if (infoPtr->himlState != NULL)
3476             {
3477               lprc->left += infoPtr->iconSize.cx;
3478             }
3479
3480             if (infoPtr->himlSmall != NULL)
3481             {
3482               lprc->right = lprc->left + infoPtr->iconSize.cx;
3483             }
3484             else
3485             {
3486               lprc->right = lprc->left;
3487             }
3488           }
3489           break;
3490
3491         case LVS_REPORT:
3492         case LVS_LIST:
3493           bResult = TRUE;
3494           lprc->left = ptItem.x;
3495           lprc->top = ptItem.y;
3496           lprc->bottom = lprc->top + infoPtr->nItemHeight;
3497
3498           if (infoPtr->himlState != NULL)
3499           {
3500             lprc->left += infoPtr->iconSize.cx;
3501           }
3502
3503           if (infoPtr->himlSmall != NULL)
3504           {
3505             lprc->right = lprc->left + infoPtr->iconSize.cx;
3506           }
3507           else
3508           {
3509             lprc->right = lprc->left;
3510           }
3511           break;
3512         }
3513         break;
3514
3515       case LVIR_LABEL:
3516         switch (LVS_TYPEMASK & lStyle)
3517         {
3518         case LVS_ICON:
3519           if (infoPtr->himlNormal != NULL)
3520           {
3521             if (LISTVIEW_GetOrigin(hwnd, &ptOrigin) != FALSE)
3522             {
3523               bResult = TRUE;
3524               lprc->left = ptItem.x + ptOrigin.x;
3525               lprc->top = (ptItem.y + ptOrigin.y + infoPtr->iconSize.cy +
3526                            ICON_BOTTOM_PADDING + ICON_TOP_PADDING);
3527               nLabelWidth = LISTVIEW_GetLabelWidth(hwnd, nItem);
3528               if (infoPtr->iconSpacing.cx - nLabelWidth > 1)
3529               {
3530                 lprc->left += (infoPtr->iconSpacing.cx - nLabelWidth) / 2;
3531                 lprc->right = lprc->left + nLabelWidth;
3532               }
3533               else
3534               {
3535                 lprc->left += 1;
3536                 lprc->right = lprc->left + infoPtr->iconSpacing.cx - 1;
3537               }
3538
3539               hdc = GetDC(hwnd);
3540               hOldFont = SelectObject(hdc, infoPtr->hFont);
3541               GetTextMetricsA(hdc, &tm);
3542               lprc->bottom = lprc->top + tm.tmHeight + HEIGHT_PADDING;
3543               SelectObject(hdc, hOldFont);
3544               ReleaseDC(hwnd, hdc);
3545             }
3546           }
3547           break;
3548
3549         case LVS_SMALLICON:
3550           if (LISTVIEW_GetOrigin(hwnd, &ptOrigin) != FALSE)
3551           {
3552             bResult = TRUE;
3553             nMaxWidth = lprc->left = ptItem.x + ptOrigin.x;
3554             lprc->top = ptItem.y + ptOrigin.y;
3555             lprc->bottom = lprc->top + infoPtr->nItemHeight;
3556
3557             if (infoPtr->himlState != NULL)
3558             {
3559               lprc->left += infoPtr->iconSize.cx;
3560             }
3561
3562             if (infoPtr->himlSmall != NULL)
3563             {
3564               lprc->left += infoPtr->iconSize.cx;
3565             }
3566
3567             nLabelWidth = LISTVIEW_GetLabelWidth(hwnd, nItem);
3568             if (lprc->left + nLabelWidth < nMaxWidth + infoPtr->nItemWidth)
3569             {
3570               lprc->right = lprc->left + nLabelWidth;
3571             }
3572             else
3573             {
3574               lprc->right = nMaxWidth + infoPtr->nItemWidth;
3575             }
3576           }
3577           break;
3578
3579         case LVS_REPORT:
3580         case LVS_LIST:
3581           bResult = TRUE;
3582           lprc->left = ptItem.x;
3583           lprc->top = ptItem.y;
3584           lprc->bottom = lprc->top + infoPtr->nItemHeight;
3585
3586           if (infoPtr->himlState != NULL)
3587           {
3588             lprc->left += infoPtr->iconSize.cx;
3589           }
3590
3591           if (infoPtr->himlSmall != NULL)
3592           {
3593             lprc->left += infoPtr->iconSize.cx;
3594           }
3595
3596           lprc->right = lprc->left + LISTVIEW_GetLabelWidth(hwnd, nItem);
3597           break;
3598         }
3599         break;
3600
3601       case LVIR_BOUNDS:
3602         switch (LVS_TYPEMASK & lStyle)
3603         {
3604         case LVS_ICON:
3605           if (infoPtr->himlNormal != NULL)
3606           {
3607             if (LISTVIEW_GetOrigin(hwnd, &ptOrigin) != FALSE)
3608             {
3609               bResult = TRUE;
3610               lprc->left = ptItem.x + ptOrigin.x;
3611               lprc->top = ptItem.y + ptOrigin.y;
3612               lprc->right = lprc->left + infoPtr->iconSpacing.cx;
3613               lprc->bottom = lprc->top + infoPtr->iconSpacing.cy;
3614             }
3615           }
3616           break;
3617
3618         case LVS_SMALLICON:
3619           if (LISTVIEW_GetOrigin(hwnd, &ptOrigin) != FALSE)
3620           {
3621             bResult = TRUE;
3622             lprc->left = ptItem.x +ptOrigin.x;
3623             lprc->right = lprc->left;
3624             lprc->top = ptItem.y + ptOrigin.y;
3625             lprc->bottom = lprc->top + infoPtr->nItemHeight;
3626
3627             if (infoPtr->himlState != NULL)
3628             {
3629               lprc->right += infoPtr->iconSize.cx;
3630             }
3631
3632             if (infoPtr->himlSmall != NULL)
3633             {
3634               lprc->right += infoPtr->iconSize.cx;
3635             }
3636
3637             lprc->right += LISTVIEW_GetLabelWidth(hwnd, nItem);
3638           }
3639           break;
3640
3641         case LVS_REPORT:
3642         case LVS_LIST:
3643           bResult = TRUE;
3644           lprc->left = ptItem.x;
3645           lprc->right = lprc->left;
3646           lprc->top = ptItem.y;
3647           lprc->bottom = lprc->top + infoPtr->nItemHeight;
3648
3649           if (infoPtr->himlState != NULL)
3650           {
3651             lprc->right += infoPtr->iconSize.cx;
3652           }
3653
3654           if (infoPtr->himlSmall != NULL)
3655           {
3656             lprc->right += infoPtr->iconSize.cx;
3657           }
3658
3659           lprc->right += LISTVIEW_GetLabelWidth(hwnd, nItem);
3660           break;
3661         }
3662         break;
3663
3664       case LVIR_SELECTBOUNDS:
3665         switch (LVS_TYPEMASK & lStyle)
3666         {
3667         case LVS_ICON:
3668           if (infoPtr->himlNormal != NULL)
3669           {
3670             if (LISTVIEW_GetOrigin(hwnd, &ptOrigin) != FALSE)
3671             {
3672               bResult = TRUE;
3673               lprc->left = ptItem.x + ptOrigin.x;
3674               lprc->top = ptItem.y + ptOrigin.y;
3675               lprc->right = lprc->left + infoPtr->iconSpacing.cx;
3676               lprc->bottom = lprc->top + infoPtr->iconSpacing.cy;
3677             }
3678           }
3679           break;
3680
3681         case LVS_SMALLICON:
3682           if (LISTVIEW_GetOrigin(hwnd, &ptOrigin) != FALSE)
3683           {
3684             bResult = TRUE;
3685             lprc->left = ptItem.x + ptOrigin.x;
3686             lprc->top = ptItem.y + ptOrigin.y;
3687             lprc->bottom = lprc->top + infoPtr->nItemHeight;
3688
3689             if (infoPtr->himlState != NULL)
3690             {
3691               lprc->left += infoPtr->iconSize.cx;
3692             }
3693
3694             lprc->right = lprc->left;
3695
3696             if (infoPtr->himlSmall != NULL)
3697             {
3698               lprc->right += infoPtr->iconSize.cx;
3699             }
3700
3701             lprc->right += LISTVIEW_GetLabelWidth(hwnd, nItem);
3702           }
3703           break;
3704
3705         case LVS_REPORT:
3706         case LVS_LIST:
3707           bResult = TRUE;
3708           lprc->left = ptItem.x;
3709           lprc->top = ptItem.y;
3710           lprc->bottom = lprc->top + infoPtr->nItemHeight;
3711
3712           if (infoPtr->himlState != NULL)
3713           {
3714             lprc->left += infoPtr->iconSize.cx;
3715           }
3716
3717           lprc->right = lprc->left;
3718
3719           if (infoPtr->himlSmall != NULL)
3720           {
3721             lprc->right += infoPtr->iconSize.cx;
3722           }
3723
3724           lprc->right += LISTVIEW_GetLabelWidth(hwnd, nItem);
3725           break;
3726         }
3727         break;
3728       }
3729     }
3730   }
3731
3732   return bResult;
3733 }
3734
3735 /***
3736  * DESCRIPTION:
3737  * Retrieves the width of a label.
3738  *
3739  * PARAMETER(S):
3740  * [I] HWND : window handle
3741  *
3742  * RETURN:
3743  *   SUCCESS : string width (in pixels)
3744  *   FAILURE : zero
3745  */
3746
3747 static INT LISTVIEW_GetLabelWidth(HWND hwnd, INT nItem)
3748 {
3749   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
3750   LISTVIEW_ITEM *lpItem;
3751   HDPA hdpaSubItems;
3752   INT nLabelWidth = 0;
3753
3754   TRACE(listview, "(hwnd=%x,nItem=%d)\n", hwnd, nItem);
3755
3756   hdpaSubItems = (HDPA)DPA_GetPtr(infoPtr->hdpaItems, nItem);
3757   if (hdpaSubItems != NULL)
3758   {
3759     lpItem = (LISTVIEW_ITEM *)DPA_GetPtr(hdpaSubItems, 0);
3760     if (lpItem != NULL)
3761     {
3762       CHAR szDispText[DISP_TEXT_SIZE];
3763       LPSTR pszDispText = NULL;
3764       pszDispText = szDispText;
3765       LISTVIEW_GetItemDispInfo(hwnd, nItem, lpItem, NULL, NULL, &pszDispText,
3766                                DISP_TEXT_SIZE);
3767       nLabelWidth = ListView_GetStringWidthA(hwnd, pszDispText);
3768     }
3769   }
3770
3771   return nLabelWidth;
3772 }
3773
3774 /***
3775  * DESCRIPTION:
3776  * Retrieves the spacing between listview control items.
3777  *
3778  * PARAMETER(S):
3779  * [I] HWND : window handle
3780  * [I] BOOL : flag for small or large icon
3781  *
3782  * RETURN:
3783  * Horizontal + vertical spacing
3784  */
3785 static LRESULT LISTVIEW_GetItemSpacing(HWND hwnd, BOOL bSmall)
3786 {
3787   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
3788   LONG lResult;
3789
3790   if (bSmall == FALSE)
3791   {
3792     lResult = MAKELONG(infoPtr->iconSpacing.cx, infoPtr->iconSpacing.cy);
3793   }
3794   else
3795   {
3796     /* TODO: need to store width of smallicon item */
3797     lResult = MAKELONG(0, infoPtr->nItemHeight);
3798   }
3799
3800   return lResult;
3801 }
3802
3803 /***
3804  * DESCRIPTION:
3805  * Retrieves the state of a listview control item.
3806  *
3807  * PARAMETER(S):
3808  * [I] HWND : window handle
3809  * [I] INT : item index
3810  * [I] UINT : state mask
3811  *
3812  * RETURN:
3813  * State specified by the mask.
3814  */
3815 static LRESULT LISTVIEW_GetItemState(HWND hwnd, INT nItem, UINT uMask)
3816 {
3817   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
3818   LVITEMA lvItem;
3819   UINT uState = 0;
3820
3821   if ((nItem >= 0) && (nItem < GETITEMCOUNT(infoPtr)))
3822   {
3823     ZeroMemory(&lvItem, sizeof(LVITEMA));
3824     lvItem.iItem = nItem;
3825     lvItem.stateMask = uMask;
3826     lvItem.mask = LVIF_STATE;
3827     if (ListView_GetItemA(hwnd, &lvItem) != FALSE)
3828     {
3829       uState = lvItem.state;
3830     }
3831   }
3832
3833   return uState;
3834 }
3835
3836 /***
3837  * DESCRIPTION:
3838  * Retrieves the text of a listview control item or subitem.
3839  *
3840  * PARAMETER(S):
3841  * [I] HWND : window handle
3842  * [I] INT : item index
3843  * [IO] LPLVITEMA : item information
3844  *
3845  * RETURN:
3846  * None
3847  */
3848 static LRESULT LISTVIEW_GetItemTextA(HWND hwnd, INT nItem, LPLVITEMA lpLVItem)
3849 {
3850   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
3851   LISTVIEW_ITEM *lpItem;
3852   LISTVIEW_SUBITEM *lpSubItem;
3853   HDPA hdpaSubItems;
3854   INT nLength = 0;
3855
3856   if (lpLVItem != NULL)
3857   {
3858     if ((nItem >= 0) && (nItem < GETITEMCOUNT(infoPtr)))
3859     {
3860       hdpaSubItems = (HDPA)DPA_GetPtr(infoPtr->hdpaItems, lpLVItem->iItem);
3861       if (hdpaSubItems != NULL)
3862       {
3863         if (lpLVItem->iSubItem == 0)
3864         {
3865           lpItem = (LISTVIEW_ITEM *)DPA_GetPtr(hdpaSubItems, 0);
3866           if (lpItem != NULL)
3867           {
3868             if (lpLVItem->mask & LVIF_TEXT)
3869             {
3870               if (lpItem->pszText == LPSTR_TEXTCALLBACKA)
3871               {
3872                 lpLVItem->pszText = LPSTR_TEXTCALLBACKA;
3873               }
3874               else
3875               {
3876                 nLength = Str_GetPtrA(lpItem->pszText, lpLVItem->pszText,
3877                                       lpLVItem->cchTextMax);
3878               }
3879             }
3880           }
3881         }
3882         else
3883         {
3884           lpSubItem = (LISTVIEW_SUBITEM *)DPA_GetPtr(hdpaSubItems,
3885                                                      lpLVItem->iSubItem);
3886           if (lpSubItem != NULL)
3887           {
3888             if (lpLVItem->mask & LVIF_TEXT)
3889             {
3890               if (lpSubItem->pszText == LPSTR_TEXTCALLBACKA)
3891               {
3892                 lpLVItem->pszText = LPSTR_TEXTCALLBACKA;
3893               }
3894               else
3895               {
3896                 nLength = Str_GetPtrA(lpSubItem->pszText, lpLVItem->pszText,
3897                                       lpLVItem->cchTextMax);
3898               }
3899             }
3900           }
3901         }
3902       }
3903     }
3904   }
3905
3906   return nLength;
3907 }
3908
3909 /***
3910  * DESCRIPTION:
3911  * Searches for an item based on properties + relationships.
3912  *
3913  * PARAMETER(S):
3914  * [I] HWND : window handle
3915  * [I] INT : item index
3916  * [I] UINT : relationship flag
3917  *
3918  * RETURN:
3919  *   SUCCESS : item index
3920  *   FAILURE : -1
3921  */
3922 static LRESULT LISTVIEW_GetNextItem(HWND hwnd, INT nItem, UINT uFlags)
3923 {
3924   FIXME (listview, "empty stub!\n");
3925
3926   return -1;
3927 }
3928
3929 /* LISTVIEW_GetNumberOfWorkAreas */
3930
3931 /***
3932  * DESCRIPTION:
3933  * Retrieves the origin coordinates when in icon or small icon display mode.
3934  *
3935  * PARAMETER(S):
3936  * [I] HWND : window handle
3937  * [O] LPPOINT : coordinate information
3938  *
3939  * RETURN:
3940  *   SUCCESS : TRUE
3941  *   FAILURE : FALSE
3942  */
3943 static LRESULT LISTVIEW_GetOrigin(HWND hwnd, LPPOINT lpptOrigin)
3944 {
3945   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
3946   LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
3947   INT nListWidth = infoPtr->rcList.right - infoPtr->rcList.left;
3948   INT nListHeight = infoPtr->rcList.bottom - infoPtr->rcList.top;
3949   BOOL bResult = FALSE;
3950
3951   TRACE(listview, "(hwnd=%x,lpptOrigin=%p)\n", hwnd, lpptOrigin);
3952
3953   switch (LVS_TYPEMASK & lStyle)
3954   {
3955   case LVS_ICON:
3956   case LVS_SMALLICON:
3957     if ((lStyle & WS_HSCROLL) != 0)
3958     {
3959       lpptOrigin->x = -GetScrollPos(hwnd, SB_HORZ) * nListWidth / 10;
3960     }
3961     else
3962     {
3963       lpptOrigin->x = 0;
3964     }
3965
3966     if ((lStyle & WS_VSCROLL) != 0)
3967     {
3968       lpptOrigin->y = -GetScrollPos(hwnd, SB_VERT) * nListHeight / 10;
3969     }
3970     else
3971     {
3972       lpptOrigin->y = 0;
3973     }
3974
3975     bResult = TRUE;
3976     break;
3977   }
3978
3979   return bResult;
3980 }
3981
3982 /***
3983  * DESCRIPTION:
3984  * Retrieves the number of items that are marked as selected.
3985  *
3986  * PARAMETER(S):
3987  * [I] HWND : window handle
3988  *
3989  * RETURN:
3990  * Number of items selected.
3991  */
3992 static LRESULT LISTVIEW_GetSelectedCount(HWND hwnd)
3993 {
3994   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
3995   INT nSelectedCount = 0;
3996   INT i;
3997
3998   for (i = 0; i < GETITEMCOUNT(infoPtr); i++)
3999   {
4000     if (ListView_GetItemState(hwnd, i, LVIS_SELECTED) & LVIS_SELECTED)
4001     {
4002       nSelectedCount++;
4003     }
4004   }
4005
4006   return nSelectedCount;
4007 }
4008
4009 /***
4010  * DESCRIPTION:
4011  * Retrieves item index that marks the start of a multiple selection.
4012  *
4013  * PARAMETER(S):
4014  * [I] HWND : window handle
4015  *
4016  * RETURN:
4017  * Index number or -1 if there is no selection mark.
4018  */
4019 static LRESULT LISTVIEW_GetSelectionMark(HWND hwnd)
4020 {
4021   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
4022
4023   return infoPtr->nSelectionMark;
4024 }
4025
4026 /***
4027  * DESCRIPTION:
4028  * Retrieves the width of a string.
4029  *
4030  * PARAMETER(S):
4031  * [I] HWND : window handle
4032  *
4033  * RETURN:
4034  *   SUCCESS : string width (in pixels)
4035  *   FAILURE : zero
4036  */
4037 static LRESULT LISTVIEW_GetStringWidthA(HWND hwnd, LPCSTR lpszText)
4038 {
4039   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
4040   HFONT hFont, hOldFont;
4041   SIZE stringSize;
4042   HDC hdc;
4043
4044   ZeroMemory(&stringSize, sizeof(SIZE));
4045   if (lpszText != NULL)
4046   {
4047     hFont = infoPtr->hFont ? infoPtr->hFont : infoPtr->hDefaultFont;
4048     hdc = GetDC(hwnd);
4049     hOldFont = SelectObject(hdc, hFont);
4050     GetTextExtentPointA(hdc, lpszText, lstrlenA(lpszText), &stringSize);
4051     SelectObject(hdc, hOldFont);
4052     ReleaseDC(hwnd, hdc);
4053   }
4054
4055   return stringSize.cx;
4056 }
4057
4058 /***
4059  * DESCRIPTION:
4060  * Retrieves the text backgound color.
4061  *
4062  * PARAMETER(S):
4063  * [I] HWND : window handle
4064  *
4065  * RETURN:
4066  * COLORREF associated with the the background.
4067  */
4068 static LRESULT LISTVIEW_GetTextBkColor(HWND hwnd)
4069 {
4070   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO*)GetWindowLongA(hwnd, 0);
4071
4072   return infoPtr->clrTextBk;
4073 }
4074
4075 /***
4076  * DESCRIPTION:
4077  * Retrieves the text color.
4078  *
4079  * PARAMETER(S):
4080  * [I] HWND : window handle
4081  *
4082  * RETURN:
4083  * COLORREF associated with the text.
4084  */
4085 static LRESULT LISTVIEW_GetTextColor(HWND hwnd)
4086 {
4087   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO*)GetWindowLongA(hwnd, 0);
4088
4089   return infoPtr->clrText;
4090 }
4091
4092 /***
4093  * DESCRIPTION:
4094  * Set the bounding rectangle of all the items.
4095  *
4096  * PARAMETER(S):
4097  * [I] HWND : window handle
4098  * [I] LPRECT : bounding rectangle
4099  *
4100  * RETURN:
4101  *   SUCCESS : TRUE
4102  *   FAILURE : FALSE
4103  */
4104 static LRESULT LISTVIEW_SetViewRect(HWND hwnd, LPRECT lprcView)
4105 {
4106   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO*)GetWindowLongA(hwnd, 0);
4107   LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
4108   BOOL bResult = FALSE;
4109
4110   TRACE(listview, "(hwnd=%x,lprcView->left=%d,lprcView->top=%d,lprcView->right=%d,lprcView->bottom=%d)\n", hwnd, lprcView->left, lprcView->top, lprcView->right, lprcView->bottom);
4111
4112   if (lprcView != NULL)
4113   {
4114     switch (lStyle & LVS_TYPEMASK)
4115     {
4116     case LVS_ICON:
4117     case LVS_SMALLICON:
4118       bResult = TRUE;
4119       infoPtr->rcView.left = lprcView->left;
4120       infoPtr->rcView.top = lprcView->top;
4121       infoPtr->rcView.right = lprcView->right;
4122       infoPtr->rcView.bottom = lprcView->bottom;
4123       break;
4124     }
4125   }
4126
4127   return bResult;
4128 }
4129
4130 /***
4131  * DESCRIPTION:
4132  * Retrieves the bounding rectangle of all the items.
4133  *
4134  * PARAMETER(S):
4135  * [I] HWND : window handle
4136  * [O] LPRECT : bounding rectangle
4137  *
4138  * RETURN:
4139  *   SUCCESS : TRUE
4140  *   FAILURE : FALSE
4141  */
4142 static LRESULT LISTVIEW_GetViewRect(HWND hwnd, LPRECT lprcView)
4143 {
4144   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO*)GetWindowLongA(hwnd, 0);
4145   BOOL bResult = FALSE;
4146   POINT ptOrigin;
4147
4148   TRACE(listview, "(hwnd=%x,lprcView=%p)\n", hwnd, lprcView);
4149
4150   if (lprcView != NULL)
4151   {
4152     bResult = LISTVIEW_GetOrigin(hwnd, &ptOrigin);
4153     if (bResult != FALSE)
4154     {
4155       lprcView->left = infoPtr->rcView.left + ptOrigin.x;
4156       lprcView->top = infoPtr->rcView.top + ptOrigin.y;
4157       lprcView->right = infoPtr->rcView.right + ptOrigin.x;
4158       lprcView->bottom = infoPtr->rcView.bottom + ptOrigin.y;
4159     }
4160
4161     TRACE(listview, "(lprcView->left=%d,lprcView->top=%d,lprcView->right=%d,lprcView->bottom=%d)\n", lprcView->left, lprcView->top, lprcView->right, lprcView->bottom);
4162
4163   }
4164
4165   return bResult;
4166 }
4167
4168 /***
4169  * DESCRIPTION:
4170  * Determines which section of the item was selected (if any).
4171  *
4172  * PARAMETER(S):
4173  * [I] HWND : window handle
4174  * [IO] LPLVHITTESTINFO : hit test information
4175  *
4176  * RETURN:
4177  *   SUCCESS : item index
4178  *   FAILURE : -1
4179  */
4180 static INT LISTVIEW_HitTestItem(HWND hwnd, LPLVHITTESTINFO lpHitTestInfo)
4181 {
4182   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
4183   RECT rcItem;
4184   INT i;
4185
4186   for (i = 0; i < GETITEMCOUNT(infoPtr); i++)
4187   {
4188     rcItem.left = LVIR_BOUNDS;
4189     if (LISTVIEW_GetItemRect(hwnd, i, &rcItem) != FALSE)
4190     {
4191       rcItem.left = LVIR_ICON;
4192       if (LISTVIEW_GetItemRect(hwnd, i, &rcItem) != FALSE)
4193       {
4194         if ((lpHitTestInfo->pt.x >= rcItem.left) &&
4195             (lpHitTestInfo->pt.x <= rcItem.right) &&
4196             (lpHitTestInfo->pt.y >= rcItem.top) &&
4197             (lpHitTestInfo->pt.y <= rcItem.bottom))
4198         {
4199           lpHitTestInfo->flags = LVHT_ONITEMICON | LVHT_ONITEM;
4200           lpHitTestInfo->iItem = i;
4201           lpHitTestInfo->iSubItem = 0;
4202           return i;
4203         }
4204       }
4205
4206       rcItem.left = LVIR_LABEL;
4207       if (LISTVIEW_GetItemRect(hwnd, i, &rcItem) != FALSE)
4208       {
4209         if ((lpHitTestInfo->pt.x >= rcItem.left) &&
4210             (lpHitTestInfo->pt.x <= rcItem.right) &&
4211             (lpHitTestInfo->pt.y >= rcItem.top) &&
4212             (lpHitTestInfo->pt.y <= rcItem.bottom))
4213         {
4214           lpHitTestInfo->flags = LVHT_ONITEMLABEL | LVHT_ONITEM;
4215           lpHitTestInfo->iItem = i;
4216           lpHitTestInfo->iSubItem = 0;
4217           return i;
4218         }
4219       }
4220
4221       lpHitTestInfo->flags = LVHT_ONITEMSTATEICON | LVHT_ONITEM;
4222       lpHitTestInfo->iItem = i;
4223       lpHitTestInfo->iSubItem = 0;
4224       return i;
4225     }
4226   }
4227
4228   lpHitTestInfo->flags = LVHT_NOWHERE;
4229
4230   return -1;
4231 }
4232
4233 /***
4234  * DESCRIPTION:
4235  * Determines wich listview item is located at the specified position.
4236  *
4237  * PARAMETER(S):
4238  * [I] HWND : window handle
4239  * [IO} LPLVHITTESTINFO : hit test information
4240  *
4241  * RETURN:
4242  *   SUCCESS : item index
4243  *   FAILURE : -1
4244  */
4245 static LRESULT LISTVIEW_HitTest(HWND hwnd, LPLVHITTESTINFO lpHitTestInfo)
4246 {
4247   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
4248   INT nItem = -1;
4249
4250   lpHitTestInfo->flags = 0;
4251   if (infoPtr->rcList.left > lpHitTestInfo->pt.x)
4252   {
4253     lpHitTestInfo->flags = LVHT_TOLEFT;
4254   }
4255   else if (infoPtr->rcList.right < lpHitTestInfo->pt.x)
4256   {
4257     lpHitTestInfo->flags = LVHT_TORIGHT;
4258   }
4259
4260   if (infoPtr->rcList.top > lpHitTestInfo->pt.y)
4261   {
4262     lpHitTestInfo->flags |= LVHT_ABOVE;
4263   }
4264   else if (infoPtr->rcList.bottom < lpHitTestInfo->pt.y)
4265   {
4266     lpHitTestInfo->flags |= LVHT_BELOW;
4267   }
4268
4269   if (lpHitTestInfo->flags == 0)
4270   {
4271     nItem = LISTVIEW_HitTestItem(hwnd, lpHitTestInfo);
4272   }
4273
4274   return nItem;
4275 }
4276
4277 /***
4278  * DESCRIPTION:
4279  * Inserts a new column.
4280  *
4281  * PARAMETER(S):
4282  * [I] HWND : window handle
4283  * [I] INT : column index
4284  * [I] LPLVCOLUMNA : column information
4285  *
4286  * RETURN:
4287  *   SUCCESS : new column index
4288  *   FAILURE : -1
4289  */
4290 static LRESULT LISTVIEW_InsertColumnA(HWND hwnd, INT nColumn,
4291                                       LPLVCOLUMNA lpColumn)
4292 {
4293   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
4294   LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
4295   HDITEMA hdi;
4296   INT nNewColumn = -1;
4297
4298   TRACE(listview,"(hwnd=%x,nColumn=%d,lpColumn=%p)\n",hwnd, nColumn, lpColumn);
4299
4300   if (lpColumn != NULL)
4301   {
4302     /* initialize memory */
4303     ZeroMemory(&hdi, sizeof(HDITEMA));
4304
4305     if (lpColumn->mask & LVCF_FMT)
4306     {
4307       /* format member is valid */
4308       hdi.mask |= HDI_FORMAT;
4309
4310       /* set text alignment (leftmost column must be left-aligned) */
4311       if (nColumn == 0)
4312       {
4313         hdi.fmt |= HDF_LEFT;
4314       }
4315       else
4316       {
4317         if (lpColumn->fmt & LVCFMT_LEFT)
4318         {
4319           hdi.fmt |= HDF_LEFT;
4320         }
4321         else if (lpColumn->fmt & LVCFMT_RIGHT)
4322         {
4323           hdi.fmt |= HDF_RIGHT;
4324         }
4325         else if (lpColumn->fmt & LVCFMT_CENTER)
4326         {
4327           hdi.fmt |= HDF_CENTER;
4328         }
4329       }
4330
4331       if (lpColumn->fmt & LVCFMT_BITMAP_ON_RIGHT)
4332       {
4333         hdi.fmt |= HDF_BITMAP_ON_RIGHT;
4334         /* ??? */
4335       }
4336
4337       if (lpColumn->fmt & LVCFMT_COL_HAS_IMAGES)
4338       {
4339         /* ??? */
4340       }
4341
4342       if (lpColumn->fmt & LVCFMT_IMAGE)
4343       {
4344         hdi.fmt |= HDF_IMAGE;
4345         hdi.iImage = I_IMAGECALLBACK;
4346       }
4347     }
4348
4349     if (lpColumn->mask & LVCF_WIDTH)
4350     {
4351       hdi.mask |= HDI_WIDTH;
4352       hdi.cxy = lpColumn->cx;
4353     }
4354
4355     if (lpColumn->mask & LVCF_TEXT)
4356     {
4357       hdi.mask |= HDI_TEXT | HDI_FORMAT;
4358       hdi.pszText = lpColumn->pszText;
4359       hdi.cchTextMax = lstrlenA(lpColumn->pszText);
4360       hdi.fmt |= HDF_STRING;
4361     }
4362
4363     if (lpColumn->mask & LVCF_IMAGE)
4364     {
4365       hdi.mask |= HDI_IMAGE;
4366       hdi.iImage = lpColumn->iImage;
4367     }
4368
4369     if (lpColumn->mask & LVCF_ORDER)
4370     {
4371       hdi.mask |= HDI_ORDER;
4372       hdi.iOrder = lpColumn->iOrder;
4373     }
4374
4375     /* insert item in header control */
4376     nNewColumn = SendMessageA(infoPtr->hwndHeader, HDM_INSERTITEMA,
4377                              (WPARAM)nColumn, (LPARAM)&hdi);
4378
4379     LISTVIEW_SetScroll(hwnd, lStyle);
4380     InvalidateRect(hwnd, NULL, FALSE);
4381   }
4382
4383   return nNewColumn;
4384 }
4385
4386 /* LISTVIEW_InsertColumnW  */
4387
4388 /***
4389  * DESCRIPTION:
4390  * Inserts a new item in the listview control.
4391  *
4392  * PARAMETER(S):
4393  * [I] HWND : window handle
4394  * [I] LPLVITEMA : item information
4395  *
4396  * RETURN:
4397  *   SUCCESS : new item index
4398  *   FAILURE : -1
4399  */
4400 static LRESULT LISTVIEW_InsertItemA(HWND hwnd, LPLVITEMA lpLVItem)
4401 {
4402   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
4403   LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
4404   LONG lCtrlId = GetWindowLongA(hwnd, GWL_ID);
4405   NMLISTVIEW nmlv;
4406   INT nItem = -1;
4407   HDPA hdpaSubItems;
4408   LISTVIEW_ITEM *lpItem = NULL;
4409
4410   TRACE(listview, "(hwnd=%x,lpLVItem=%p)\n", hwnd, lpLVItem);
4411
4412   if (lpLVItem != NULL)
4413   {
4414     /* make sure it's not a subitem; cannot insert a subitem */
4415     if (lpLVItem->iSubItem == 0)
4416     {
4417       lpItem = (LISTVIEW_ITEM *)COMCTL32_Alloc(sizeof(LISTVIEW_ITEM));
4418       if (lpItem != NULL)
4419       {
4420         ZeroMemory(lpItem, sizeof(LISTVIEW_ITEM));
4421         if (LISTVIEW_InitItem(hwnd, lpItem, lpLVItem) != FALSE)
4422         {
4423           /* insert item in listview control data structure */
4424           hdpaSubItems = DPA_Create(8);
4425           if (hdpaSubItems != NULL)
4426           {
4427             nItem = DPA_InsertPtr(hdpaSubItems, 0, lpItem);
4428             if (nItem != -1)
4429             {
4430               nItem = DPA_InsertPtr(infoPtr->hdpaItems, lpLVItem->iItem,
4431                                     hdpaSubItems);
4432               if (nItem != -1)
4433               {
4434                 /* manage item focus */
4435                 if (lpLVItem->mask & LVIF_STATE)
4436                 {
4437                   if (lpLVItem->stateMask & LVIS_FOCUSED)
4438                   {
4439                     LISTVIEW_SetItemFocus(hwnd, nItem);
4440                   }
4441                 }
4442
4443                 /* send LVN_INSERTITEM notification */
4444                 ZeroMemory(&nmlv, sizeof(NMLISTVIEW));
4445                 nmlv.hdr.hwndFrom = hwnd;
4446                 nmlv.hdr.idFrom = lCtrlId;
4447                 nmlv.hdr.code = LVN_INSERTITEM;
4448                 nmlv.iItem = nItem;
4449                 nmlv.lParam = lpItem->lParam;;
4450                 ListView_LVNotify(GetParent(hwnd), lCtrlId, &nmlv);
4451
4452                 /* align items (set position of each item) */
4453                 switch (lStyle & LVS_TYPEMASK)
4454                 {
4455                 case LVS_ICON:
4456                 case LVS_SMALLICON:
4457                   if (lStyle & LVS_ALIGNLEFT)
4458                   {
4459                     LISTVIEW_AlignLeft(hwnd);
4460                   }
4461                   else
4462                   {
4463                     LISTVIEW_AlignTop(hwnd);
4464                   }
4465                   break;
4466                 }
4467
4468                 LISTVIEW_SetScroll(hwnd, lStyle);
4469                 /* refresh client area */
4470                 InvalidateRect(hwnd, NULL, FALSE);
4471               }
4472             }
4473           }
4474         }
4475       }
4476     }
4477   }
4478
4479   /* free memory if unsuccessful */
4480   if ((nItem == -1) && (lpItem != NULL))
4481   {
4482     COMCTL32_Free(lpItem);
4483   }
4484
4485   return nItem;
4486 }
4487
4488 /* LISTVIEW_InsertItemW */
4489
4490 /***
4491  * DESCRIPTION:
4492  * Redraws a range of items.
4493  *
4494  * PARAMETER(S):
4495  * [I] HWND : window handle
4496  * [I] INT : first item
4497  * [I] INT : last item
4498  *
4499  * RETURN:
4500  *   SUCCESS : TRUE
4501  *   FAILURE : FALSE
4502  */
4503 static LRESULT LISTVIEW_RedrawItems(HWND hwnd, INT nFirst, INT nLast)
4504 {
4505   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
4506   BOOL bResult = FALSE;
4507   RECT rc;
4508
4509   if (nFirst <= nLast)
4510   {
4511     if ((nFirst >= 0) && (nFirst < GETITEMCOUNT(infoPtr)))
4512     {
4513       if ((nLast >= 0) && (nLast < GETITEMCOUNT(infoPtr)))
4514       {
4515         /* bResult = */
4516         InvalidateRect(hwnd, &rc, FALSE);
4517       }
4518     }
4519   }
4520
4521   return bResult;
4522 }
4523
4524 /* LISTVIEW_Scroll */
4525
4526 /***
4527  * DESCRIPTION:
4528  * Sets the background color.
4529  *
4530  * PARAMETER(S):
4531  * [I] HWND : window handle
4532  * [I] COLORREF : background color
4533  *
4534  * RETURN:
4535  *   SUCCESS : TRUE
4536  *   FAILURE : FALSE
4537  */
4538 static LRESULT LISTVIEW_SetBkColor(HWND hwnd, COLORREF clrBk)
4539 {
4540   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
4541
4542   infoPtr->clrBk = clrBk;
4543   InvalidateRect(hwnd, NULL, TRUE);
4544
4545   return TRUE;
4546 }
4547
4548 /***
4549  * DESCRIPTION:
4550  * Sets the callback mask. This mask will be used when the parent
4551  * window stores state information (some or all).
4552  *
4553  * PARAMETER(S):
4554  * [I] HWND : window handle
4555  * [I] UINT : state mask
4556  *
4557  * RETURN:
4558  *   SUCCESS : TRUE
4559  *   FAILURE : FALSE
4560  */
4561 static BOOL LISTVIEW_SetCallbackMask(HWND hwnd, UINT uMask)
4562 {
4563   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
4564
4565   infoPtr->uCallbackMask = uMask;
4566
4567   return TRUE;
4568 }
4569
4570 /***
4571  * DESCRIPTION:
4572  * Sets the attributes of a header item.
4573  *
4574  * PARAMETER(S):
4575  * [I] HWND : window handle
4576  * [I] INT : column index
4577  * [I] LPLVCOLUMNA : column attributes
4578  *
4579  * RETURN:
4580  *   SUCCESS : TRUE
4581  *   FAILURE : FALSE
4582  */
4583 static LRESULT LISTVIEW_SetColumnA(HWND hwnd, INT nColumn,
4584                                    LPLVCOLUMNA lpColumn)
4585 {
4586   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
4587   BOOL bResult = FALSE;
4588   HDITEMA hdi;
4589
4590   if ((lpColumn != NULL) && (nColumn >= 0) &&
4591       (nColumn < Header_GetItemCount(infoPtr->hwndHeader)))
4592   {
4593     /* initialize memory */
4594     ZeroMemory(&hdi, sizeof(HDITEMA));
4595
4596     if (lpColumn->mask & LVCF_FMT)
4597     {
4598       /* format member is valid */
4599       hdi.mask |= HDI_FORMAT;
4600
4601       /* set text alignment (leftmost column must be left-aligned) */
4602       if (nColumn == 0)
4603       {
4604         hdi.fmt |= HDF_LEFT;
4605       }
4606       else
4607       {
4608         if (lpColumn->fmt & LVCFMT_LEFT)
4609         {
4610           hdi.fmt |= HDF_LEFT;
4611         }
4612         else if (lpColumn->fmt & LVCFMT_RIGHT)
4613         {
4614           hdi.fmt |= HDF_RIGHT;
4615         }
4616         else if (lpColumn->fmt & LVCFMT_CENTER)
4617         {
4618           hdi.fmt |= HDF_CENTER;
4619         }
4620       }
4621
4622       if (lpColumn->fmt & LVCFMT_BITMAP_ON_RIGHT)
4623       {
4624         hdi.fmt |= HDF_BITMAP_ON_RIGHT;
4625       }
4626
4627       if (lpColumn->fmt & LVCFMT_COL_HAS_IMAGES)
4628       {
4629         hdi.fmt |= HDF_IMAGE;
4630       }
4631
4632       if (lpColumn->fmt & LVCFMT_IMAGE)
4633       {
4634         hdi.fmt |= HDF_IMAGE;
4635         hdi.iImage = I_IMAGECALLBACK;
4636       }
4637     }
4638
4639     if (lpColumn->mask & LVCF_WIDTH)
4640     {
4641       hdi.mask |= HDI_WIDTH;
4642       hdi.cxy = lpColumn->cx;
4643     }
4644
4645     if (lpColumn->mask & LVCF_TEXT)
4646     {
4647       hdi.mask |= HDI_TEXT | HDI_FORMAT;
4648       hdi.pszText = lpColumn->pszText;
4649       hdi.cchTextMax = lstrlenA(lpColumn->pszText);
4650       hdi.fmt |= HDF_STRING;
4651     }
4652
4653     if (lpColumn->mask & LVCF_IMAGE)
4654     {
4655       hdi.mask |= HDI_IMAGE;
4656       hdi.iImage = lpColumn->iImage;
4657     }
4658
4659     if (lpColumn->mask & LVCF_ORDER)
4660     {
4661       hdi.mask |= HDI_ORDER;
4662       hdi.iOrder = lpColumn->iOrder;
4663     }
4664
4665     /* set header item attributes */
4666     bResult = Header_SetItemA(infoPtr->hwndHeader, nColumn, &hdi);
4667   }
4668
4669   return bResult;
4670 }
4671
4672 /***
4673  * DESCRIPTION:
4674  * Sets the width of a column
4675  *
4676  * PARAMETERS:
4677  * [I] HWND : window handle
4678  * [I] INT : column index
4679  * [I] INT : column width
4680  *
4681  * RETURN:
4682  *   SUCCESS : TRUE
4683  *   FAILURE : FALSE
4684  */
4685 static LRESULT LISTVIEW_SetColumnWidth(HWND hwnd, INT iCol, INT cx)
4686 {
4687     LISTVIEW_INFO *infoPtr;
4688     HDITEMA hdi;
4689     LRESULT lret;
4690     LONG lStyle;
4691
4692     // set column width only if in report mode
4693     lStyle = GetWindowLongA(hwnd, GWL_STYLE);
4694     if ((lStyle & LVS_TYPEMASK) != LVS_REPORT)
4695         return (FALSE);
4696
4697     // make sure we can get the listview info
4698     if (!(infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0)))
4699         return (FALSE);
4700     if (!infoPtr->hwndHeader) // make sure we have a header
4701         return (FALSE);
4702
4703     // FIXME: currently ignoring LVSCW_AUTOSIZE (-1) and
4704     // LVSCV_AUTOSIZE_USEHEADER (-2)
4705     if (cx < 0)
4706         return (FALSE);
4707
4708     hdi.mask = HDI_WIDTH;
4709     hdi.cxy = cx;
4710
4711     // call header to update the column change
4712     lret = Header_SetItemA(infoPtr->hwndHeader, (WPARAM)iCol, (LPARAM)&hdi);
4713
4714     infoPtr->nItemWidth = LISTVIEW_GetItemWidth(hwnd, LVS_REPORT);
4715
4716     InvalidateRect(hwnd, NULL, TRUE); // force redraw of the listview
4717
4718     return lret;
4719 }
4720
4721 /***
4722  * DESCRIPTION:
4723  * Sets image lists.
4724  *
4725  * PARAMETER(S):
4726  * [I] HWND : window handle
4727  * [I] INT : image list type
4728  * [I] HIMAGELIST : image list handle
4729  *
4730  * RETURN:
4731  *   SUCCESS : old image list
4732  *   FAILURE : NULL
4733  */
4734 static LRESULT LISTVIEW_SetImageList(HWND hwnd, INT nType, HIMAGELIST himl)
4735 {
4736   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
4737   HIMAGELIST himlTemp = 0;
4738
4739   switch (nType)
4740   {
4741   case LVSIL_NORMAL:
4742     himlTemp = infoPtr->himlNormal;
4743     infoPtr->himlNormal = himl;
4744     return (LRESULT)himlTemp;
4745
4746   case LVSIL_SMALL:
4747     himlTemp = infoPtr->himlSmall;
4748     infoPtr->himlSmall = himl;
4749     return (LRESULT)himlTemp;
4750
4751   case LVSIL_STATE:
4752     himlTemp = infoPtr->himlState;
4753     infoPtr->himlState = himl;
4754     return (LRESULT)himlTemp;
4755   }
4756
4757   return (LRESULT)NULL;
4758 }
4759
4760
4761 /***
4762  * DESCRIPTION:
4763  * Sets the attributes of an item.
4764  *
4765  * PARAMETER(S):
4766  * [I] HWND : window handle
4767  * [I] LPLVITEM : item information
4768  *
4769  * RETURN:
4770  *   SUCCESS : TRUE
4771  *   FAILURE : FALSE
4772  */
4773 static LRESULT LISTVIEW_SetItemA(HWND hwnd, LPLVITEMA lpLVItem)
4774 {
4775   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
4776   BOOL bResult = FALSE;
4777
4778   if (lpLVItem != NULL)
4779   {
4780     if ((lpLVItem->iItem >= 0) && (lpLVItem->iItem < GETITEMCOUNT(infoPtr)))
4781     {
4782       if (lpLVItem->iSubItem == 0)
4783       {
4784         bResult = LISTVIEW_SetItem(hwnd, lpLVItem);
4785       }
4786       else
4787       {
4788         bResult = LISTVIEW_SetSubItem(hwnd, lpLVItem);
4789       }
4790     }
4791   }
4792
4793
4794   return bResult;
4795 }
4796
4797 /* LISTVIEW_SetItemW  */
4798
4799 /***
4800  * DESCRIPTION:
4801  * Preallocates memory.
4802  *
4803  * PARAMETER(S):
4804  * [I] HWND : window handle
4805  * [I] INT : item count (prjected number of items)
4806  *
4807  * RETURN:
4808  * None
4809  */
4810 static VOID LISTVIEW_SetItemCount(HWND hwnd, INT nItemCount)
4811 {
4812   FIXME (listview, "empty stub!\n");
4813 }
4814
4815 /***
4816  * DESCRIPTION:
4817  * Sets the position of an item.
4818  *
4819  * PARAMETER(S):
4820  * [I] HWND : window handle
4821  * [I] INT : item index
4822  * [I] INT : x coordinate
4823  * [I] INT : y coordinate
4824  *
4825  * RETURN:
4826  *   SUCCESS : TRUE
4827  *   FAILURE : FALSE
4828  */
4829 static BOOL LISTVIEW_SetItemPosition(HWND hwnd, INT nItem,
4830                                      INT nPosX, INT nPosY)
4831 {
4832   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO*)GetWindowLongA(hwnd, 0);
4833   LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
4834   LISTVIEW_ITEM *lpItem;
4835   HDPA hdpaSubItems;
4836   BOOL bResult = FALSE;
4837
4838   TRACE(listview, "(hwnd=%x,nItem=%d,X=%d,Y=%d)\n", hwnd, nItem, nPosX, nPosY);
4839
4840   if ((nItem >= 0) || (nItem < GETITEMCOUNT(infoPtr)))
4841   {
4842     switch (lStyle & LVS_TYPEMASK)
4843     {
4844     case LVS_ICON:
4845     case LVS_SMALLICON:
4846       hdpaSubItems = (HDPA)DPA_GetPtr(infoPtr->hdpaItems, nItem);
4847       if (hdpaSubItems != NULL)
4848       {
4849         lpItem = (LISTVIEW_ITEM *)DPA_GetPtr(hdpaSubItems, 0);
4850         if (lpItem != NULL)
4851         {
4852           bResult = TRUE;
4853           lpItem->ptPosition.x = nPosX;
4854           lpItem->ptPosition.y = nPosY;
4855         }
4856       }
4857       break;
4858     }
4859   }
4860
4861   return bResult;
4862 }
4863
4864 /***
4865  * DESCRIPTION:
4866  * Sets the state of one or many items.
4867  *
4868  * PARAMETER(S):
4869  * [I] HWND : window handle
4870  * [I]INT : item index
4871  * [I] LPLVITEM : item or subitem info
4872  *
4873  * RETURN:
4874  *   SUCCESS : TRUE
4875  *   FAILURE : FALSE
4876  */
4877 static LRESULT LISTVIEW_SetItemState(HWND hwnd, INT nItem, LPLVITEMA lpLVItem)
4878 {
4879   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
4880   BOOL bResult = FALSE;
4881   LVITEMA lvItem;
4882   INT i;
4883
4884   if (nItem == -1)
4885   {
4886     bResult = TRUE;
4887     ZeroMemory(&lvItem, sizeof(LVITEMA));
4888     lvItem.mask = LVIF_STATE;
4889     lvItem.state = lpLVItem->state;
4890     lvItem.stateMask = lpLVItem->stateMask;
4891
4892     /* apply to all items */
4893     for (i = 0; i< GETITEMCOUNT(infoPtr); i++)
4894     {
4895       lvItem.iItem = i;
4896       if (ListView_SetItemA(hwnd, &lvItem) == FALSE)
4897       {
4898         bResult = FALSE;
4899       }
4900     }
4901   }
4902   else
4903   {
4904     ZeroMemory(&lvItem, sizeof(LVITEMA));
4905     lvItem.mask = LVIF_STATE;
4906     lvItem.state = lpLVItem->state;
4907     lvItem.stateMask = lpLVItem->stateMask;
4908     lvItem.iItem = nItem;
4909     bResult = ListView_SetItemA(hwnd, &lvItem);
4910   }
4911
4912   return bResult;
4913 }
4914
4915 /***
4916  * DESCRIPTION:
4917  * Sets the text of an item or subitem.
4918  *
4919  * PARAMETER(S):
4920  * [I] HWND : window handle
4921  * [I] INT : item index
4922  * [I] LPLVITEMA : item or subitem info
4923  *
4924  * RETURN:
4925  *   SUCCESS : TRUE
4926  *   FAILURE : FALSE
4927  */
4928 static BOOL LISTVIEW_SetItemTextA(HWND hwnd, INT nItem, LPLVITEMA lpLVItem)
4929 {
4930   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
4931   BOOL bResult = FALSE;
4932   LVITEMA lvItem;
4933
4934   if ((nItem >= 0) && (nItem < GETITEMCOUNT(infoPtr)))
4935   {
4936     ZeroMemory(&lvItem, sizeof(LVITEMA));
4937     lvItem.mask = LVIF_TEXT;
4938     lvItem.pszText = lpLVItem->pszText;
4939     lvItem.iItem = nItem;
4940     lvItem.iSubItem = lpLVItem->iSubItem;
4941     bResult = ListView_SetItemA(hwnd, &lvItem);
4942   }
4943
4944   return bResult;
4945 }
4946
4947 /***
4948  * DESCRIPTION:
4949  * Sets the text background color.
4950  *
4951  * PARAMETER(S):
4952  * [I] HWND : window handle
4953  * [I] COLORREF : text background color
4954  *
4955  * RETURN:
4956  *   SUCCESS : TRUE
4957  *   FAILURE : FALSE
4958  */
4959 static LRESULT LISTVIEW_SetTextBkColor(HWND hwnd, COLORREF clrTextBk)
4960 {
4961   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
4962
4963   infoPtr->clrTextBk = clrTextBk;
4964   InvalidateRect(hwnd, NULL, TRUE);
4965
4966   return TRUE;
4967 }
4968
4969 /***
4970  * DESCRIPTION:
4971  * Sets the text foreground color.
4972  *
4973  * PARAMETER(S):
4974  * [I] HWND : window handle
4975  * [I] COLORREF : text color
4976  *
4977  * RETURN:
4978  *   SUCCESS : TRUE
4979  *   FAILURE : FALSE
4980  */
4981 static LRESULT LISTVIEW_SetTextColor (HWND hwnd, COLORREF clrText)
4982 {
4983   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
4984
4985   infoPtr->clrText = clrText;
4986   InvalidateRect(hwnd, NULL, TRUE);
4987
4988   return TRUE;
4989 }
4990
4991 /***
4992  * DESCRIPTION:
4993  * Sorts the listview items.
4994  *
4995  * PARAMETER(S):
4996  * [I] HWND : window handle
4997  *
4998  * RETURN:
4999  *   SUCCESS : TRUE
5000  *   FAILURE : FALSE
5001  */
5002 static LRESULT LISTVIEW_SortItems(HWND hwnd, WPARAM wParam, LPARAM lParam)
5003 {
5004   FIXME (listview, "empty stub!\n");
5005
5006   return TRUE;
5007 }
5008
5009 /***
5010  * DESCRIPTION:
5011  * Updates an items or rearranges the listview control.
5012  *
5013  * PARAMETER(S):
5014  * [I] HWND : window handle
5015  * [I] INT : item index
5016  *
5017  * RETURN:
5018  *   SUCCESS : TRUE
5019  *   FAILURE : FALSE
5020  */
5021 static LRESULT LISTVIEW_Update(HWND hwnd, INT nItem)
5022 {
5023   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
5024   LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
5025   BOOL bResult = FALSE;
5026   RECT rc;
5027
5028   if ((nItem >= 0) && (nItem < GETITEMCOUNT(infoPtr)))
5029   {
5030     bResult = TRUE;
5031
5032     /* rearrange with default alignment style */
5033     if ((lStyle & LVS_AUTOARRANGE) && (((lStyle & LVS_TYPEMASK) == LVS_ICON) ||
5034         ((lStyle & LVS_TYPEMASK)  == LVS_SMALLICON)))
5035     {
5036       ListView_Arrange(hwnd, 0);
5037     }
5038     else
5039     {
5040       /* get item bounding rectangle */
5041       rc.left = LVIR_BOUNDS;
5042       ListView_GetItemRect(hwnd, nItem, &rc);
5043       InvalidateRect(hwnd, &rc, FALSE);
5044     }
5045   }
5046
5047   return bResult;
5048 }
5049
5050 /***
5051  * DESCRIPTION:
5052  * Creates the listview control.
5053  *
5054  * PARAMETER(S):
5055  * [I] HWND : window handle
5056  *
5057  * RETURN:
5058  * Zero
5059  */
5060 static LRESULT LISTVIEW_Create(HWND hwnd, WPARAM wParam, LPARAM lParam)
5061 {
5062   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
5063   LPCREATESTRUCTA lpcs = (LPCREATESTRUCTA)lParam;
5064   LOGFONTA logFont;
5065
5066   /* initialize info pointer */
5067   ZeroMemory(infoPtr, sizeof(LISTVIEW_INFO));
5068
5069   /* determine the type of structures to use */
5070   infoPtr->notifyFormat = SendMessageA(GetParent(hwnd), WM_NOTIFYFORMAT,
5071                                        (WPARAM)hwnd, (LPARAM)NF_QUERY);
5072   if (infoPtr->notifyFormat != NFR_ANSI)
5073   {
5074     FIXME (listview, "ANSI notify format is NOT used\n");
5075   }
5076
5077   /* initialize color information  */
5078   infoPtr->clrBk = GetSysColor(COLOR_WINDOW);
5079   infoPtr->clrText = GetSysColor(COLOR_WINDOWTEXT);
5080   infoPtr->clrTextBk = GetSysColor(COLOR_WINDOW);
5081
5082   /* set default values */
5083   infoPtr->uCallbackMask = 0;
5084   infoPtr->nFocusedItem = -1;
5085   infoPtr->nSelectionMark = -1;
5086   infoPtr->iconSpacing.cx = GetSystemMetrics(SM_CXICONSPACING);
5087   infoPtr->iconSpacing.cy = GetSystemMetrics(SM_CYICONSPACING);
5088   ZeroMemory(&infoPtr->rcList, sizeof(RECT));
5089
5090   /* get default font (icon title) */
5091   SystemParametersInfoA(SPI_GETICONTITLELOGFONT, 0, &logFont, 0);
5092   infoPtr->hDefaultFont = CreateFontIndirectA(&logFont);
5093   infoPtr->hFont = infoPtr->hDefaultFont;
5094
5095   /* create header */
5096   infoPtr->hwndHeader = CreateWindowA(WC_HEADERA, (LPCSTR)NULL,
5097                                       WS_CHILD | HDS_HORZ | HDS_BUTTONS,
5098                                       0, 0, 0, 0, hwnd, (HMENU)0,
5099                                       lpcs->hInstance, NULL);
5100
5101   /* set header font */
5102   SendMessageA(infoPtr->hwndHeader, WM_SETFONT, (WPARAM)infoPtr->hFont,
5103                (LPARAM)TRUE);
5104
5105
5106   switch (lpcs->style & LVS_TYPEMASK)
5107   {
5108   case LVS_ICON:
5109     infoPtr->iconSize.cx = GetSystemMetrics(SM_CXICON);
5110     infoPtr->iconSize.cy = GetSystemMetrics(SM_CYICON);
5111     break;
5112
5113   case LVS_REPORT:
5114     ShowWindow(infoPtr->hwndHeader, SW_SHOWNORMAL);
5115   case LVS_SMALLICON:
5116   case LVS_LIST:
5117     infoPtr->iconSize.cx = GetSystemMetrics(SM_CXSMICON);
5118     infoPtr->iconSize.cy = GetSystemMetrics(SM_CYSMICON);
5119     break;
5120   }
5121
5122   /* display unsupported listview window styles */
5123   LISTVIEW_UnsupportedStyles(lpcs->style);
5124
5125   /* allocate memory for the data structure */
5126   infoPtr->hdpaItems = DPA_Create(10);
5127
5128   /* initialize size of items */
5129   infoPtr->nItemWidth = LISTVIEW_GetItemWidth(hwnd, lpcs->style);
5130   infoPtr->nItemHeight = LISTVIEW_GetItemHeight(hwnd, lpcs->style);
5131
5132   return 0;
5133 }
5134
5135 /***
5136  * DESCRIPTION:
5137  * Erases the background of the listview control.
5138  *
5139  * PARAMETER(S):
5140  * [I] HWND : window handle
5141  * [I] WPARAM : device context handle
5142  * [I] LPARAM : not used
5143  *
5144  * RETURN:
5145  *   SUCCESS : TRUE
5146  *   FAILURE : FALSE
5147  */
5148 static LRESULT LISTVIEW_EraseBackground(HWND hwnd, WPARAM wParam,
5149                                         LPARAM lParam)
5150 {
5151   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
5152   BOOL bResult;
5153
5154   if (infoPtr->clrBk == CLR_NONE)
5155   {
5156     bResult = SendMessageA(GetParent(hwnd), WM_ERASEBKGND, wParam, lParam);
5157   }
5158   else
5159   {
5160     RECT rc;
5161     HBRUSH hBrush = CreateSolidBrush(infoPtr->clrBk);
5162     GetClientRect(hwnd, &rc);
5163     FillRect((HDC)wParam, &rc, hBrush);
5164     DeleteObject(hBrush);
5165     bResult = TRUE;
5166   }
5167
5168   return bResult;
5169 }
5170
5171 /***
5172  * DESCRIPTION:
5173  * Retrieves the listview control font.
5174  *
5175  * PARAMETER(S):
5176  * [I] HWND : window handle
5177  *
5178  * RETURN:
5179  * Font handle.
5180  */
5181 static LRESULT LISTVIEW_GetFont(HWND hwnd)
5182 {
5183   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
5184
5185   return infoPtr->hFont;
5186 }
5187
5188 /***
5189  * DESCRIPTION:
5190  * Performs vertical scrolling.
5191  *
5192  * PARAMETER(S):
5193  * [I] HWND : window handle
5194  * [I] INT : scroll code
5195  * [I] INT : scroll position
5196  * [I] HWND : scrollbar control window handle
5197  *
5198  * RETURN:
5199  * Zero
5200  */
5201 static LRESULT LISTVIEW_VScroll(HWND hwnd, INT nScrollCode, INT nScroll,
5202                                 HWND hScrollWnd)
5203 {
5204   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
5205   LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
5206   INT nScrollPosInc = 0;
5207   INT nScrollPos;
5208   INT nMinRange;
5209   INT nMaxRange;
5210
5211   GetScrollRange(hwnd, SB_VERT, &nMinRange, &nMaxRange);
5212   nScrollPos = GetScrollPos(hwnd, SB_VERT);
5213
5214   switch (nScrollCode)
5215   {
5216   case SB_LINEUP:
5217     if (nScrollPos > nMinRange)
5218     {
5219       nScrollPosInc = -1;
5220     }
5221     break;
5222
5223   case SB_LINEDOWN:
5224     if (nScrollPos < nMaxRange)
5225     {
5226       nScrollPosInc = 1;
5227     }
5228     break;
5229
5230   case SB_PAGEUP:
5231     switch (LVS_TYPEMASK & lStyle)
5232     {
5233     case LVS_REPORT:
5234       if (nScrollPos > nMinRange + infoPtr->nCountPerColumn)
5235       {
5236         nScrollPosInc = -infoPtr->nCountPerColumn;
5237       }
5238       else
5239       {
5240         nScrollPosInc = nMinRange - nScrollPos;
5241       }
5242       break;
5243
5244     case LVS_SMALLICON:
5245     case LVS_ICON:
5246       if (nScrollPos > nMinRange + 10)
5247       {
5248         nScrollPosInc = -10;
5249       }
5250       else
5251       {
5252         nScrollPosInc = nMinRange - nScrollPos;
5253       }
5254       break;
5255     }
5256     break;
5257
5258    case SB_PAGEDOWN:
5259      switch (LVS_TYPEMASK & lStyle)
5260      {
5261      case LVS_REPORT:
5262        if (nScrollPos < nMaxRange - infoPtr->nCountPerColumn)
5263        {
5264          nScrollPosInc = infoPtr->nCountPerColumn;
5265        }
5266        else
5267        {
5268          nScrollPosInc = nMaxRange - nScrollPos;
5269        }
5270        break;
5271
5272      case LVS_SMALLICON:
5273      case LVS_ICON:
5274        if (nScrollPos < nMaxRange - 10)
5275        {
5276          nScrollPosInc = 10;
5277        }
5278        else
5279        {
5280          nScrollPosInc = nMaxRange - nScrollPos;
5281        }
5282        break;
5283      }
5284      break;
5285
5286    case SB_THUMBPOSITION:
5287      nScrollPosInc = nScroll - nScrollPos;
5288     break;
5289   }
5290
5291   if (nScrollPosInc != 0)
5292   {
5293     LISTVIEW_ScrollView(hwnd, 0, nScrollPosInc);
5294   }
5295
5296   return 0;
5297 }
5298
5299
5300 /***
5301  * DESCRIPTION:
5302  * Performs horizontal scrolling.
5303  *
5304  * PARAMETER(S):
5305  * [I] HWND : window handle
5306  * [I] INT : scroll code
5307  * [I] INT : scroll position
5308  * [I] HWND : scrollbar control window handle
5309  *
5310  * RETURN:
5311  * Zero
5312  */
5313 static LRESULT LISTVIEW_HScroll(HWND hwnd, INT nScrollCode,
5314                                 INT nScroll, HWND hScrollWnd)
5315 {
5316   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
5317   LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
5318   INT nScrollPosInc = 0;
5319   INT nScrollPos;
5320   INT nMinRange;
5321   INT nMaxRange;
5322
5323   GetScrollRange(hwnd, SB_HORZ, &nMinRange, &nMaxRange);
5324   nScrollPos = GetScrollPos(hwnd, SB_HORZ);
5325
5326   switch (nScrollCode)
5327   {
5328   case SB_LINELEFT:
5329     if (nScrollPos > nMinRange)
5330     {
5331       nScrollPosInc = -1;
5332     }
5333     break;
5334
5335   case SB_LINERIGHT:
5336     if (nScrollPos < nMaxRange)
5337     {
5338       nScrollPosInc = 1;
5339     }
5340     break;
5341
5342   case SB_PAGELEFT:
5343     switch (LVS_TYPEMASK & lStyle)
5344     {
5345     case LVS_LIST:
5346       if (nScrollPos > nMinRange + infoPtr->nCountPerRow)
5347       {
5348         nScrollPosInc = -infoPtr->nCountPerRow;
5349       }
5350       else
5351       {
5352         nScrollPosInc = nMinRange - nScrollPos;
5353       }
5354       break;
5355
5356     case LVS_REPORT:
5357     case LVS_SMALLICON:
5358     case LVS_ICON:
5359       if (nScrollPos > nMinRange + 10)
5360       {
5361         nScrollPosInc = -10;
5362       }
5363       else
5364       {
5365         nScrollPosInc = nMinRange - nScrollPos;
5366       }
5367       break;
5368     }
5369     break;
5370
5371   case SB_PAGERIGHT:
5372     switch (LVS_TYPEMASK & lStyle)
5373     {
5374     case LVS_LIST:
5375       if (nScrollPos < nMaxRange - infoPtr->nCountPerRow)
5376       {
5377         nScrollPosInc = infoPtr->nCountPerRow;
5378       }
5379       else
5380       {
5381         nScrollPosInc = nMaxRange - nScrollPos;
5382       }
5383       break;
5384
5385     case LVS_REPORT:
5386     case LVS_SMALLICON:
5387     case LVS_ICON:
5388       if (nScrollPos < nMaxRange - 10)
5389       {
5390         nScrollPosInc = 10;
5391       }
5392       else
5393       {
5394         nScrollPosInc = nMaxRange - nScrollPos;
5395       }
5396       break;
5397     }
5398     break;
5399
5400   case SB_THUMBPOSITION:
5401     nScrollPosInc = nScroll - nScrollPos;
5402     break;
5403   }
5404
5405   if (nScrollPosInc != 0)
5406   {
5407     LISTVIEW_ScrollView(hwnd, nScrollPosInc, 0);
5408   }
5409
5410   return 0;
5411 }
5412
5413 /***
5414  * DESCRIPTION:
5415  * ???
5416  *
5417  * PARAMETER(S):
5418  * [I] HWND : window handle
5419  * [I] INT : virtual key
5420  * [I] LONG : key data
5421  *
5422  * RETURN:
5423  * Zero
5424  */
5425 static LRESULT LISTVIEW_KeyDown(HWND hwnd, INT nVirtualKey, LONG lKeyData)
5426 {
5427   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
5428   LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
5429   INT nCtrlId = GetWindowLongA(hwnd, GWL_ID);
5430   INT nCountPerColumn;
5431   INT nCountPerRow;
5432   HWND hwndParent = GetParent(hwnd);
5433   NMLVKEYDOWN nmKeyDown;
5434   NMHDR nmh;
5435
5436   /* send LVN_KEYDOWN notification */
5437   ZeroMemory(&nmKeyDown, sizeof(NMLVKEYDOWN));
5438   nmKeyDown.hdr.hwndFrom = hwnd;
5439   nmKeyDown.hdr.idFrom = nCtrlId;
5440   nmKeyDown.hdr.code = LVN_KEYDOWN;
5441   nmKeyDown.wVKey = nVirtualKey;
5442   nmKeyDown.flags = 0;
5443   SendMessageA(hwndParent, WM_NOTIFY, (WPARAM)nCtrlId, (LPARAM)&nmKeyDown);
5444
5445   /* initialize */
5446   nmh.hwndFrom = hwnd;
5447   nmh.idFrom = nCtrlId;
5448
5449   switch (nVirtualKey)
5450   {
5451   case VK_RETURN:
5452     if ((GETITEMCOUNT(infoPtr) > 0) && (infoPtr->nFocusedItem != -1))
5453     {
5454       /* send NM_RETURN notification */
5455       nmh.code = NM_RETURN;
5456       ListView_Notify(hwndParent, nCtrlId, &nmh);
5457
5458       /* send LVN_ITEMACTIVATE notification */
5459       nmh.code = LVN_ITEMACTIVATE;
5460       ListView_Notify(hwndParent, nCtrlId, &nmh);
5461     }
5462     break;
5463
5464   case VK_HOME:
5465     if (GETITEMCOUNT(infoPtr) > 0)
5466     {
5467       LISTVIEW_KeySelection(hwnd, 0);
5468     }
5469     break;
5470
5471   case VK_END:
5472     if (GETITEMCOUNT(infoPtr) > 0)
5473     {
5474       LISTVIEW_KeySelection(hwnd, GETITEMCOUNT(infoPtr) - 1);
5475     }
5476     break;
5477
5478   case VK_LEFT:
5479     switch (LVS_TYPEMASK & lStyle)
5480     {
5481     case LVS_LIST:
5482       if (infoPtr->nFocusedItem >= infoPtr->nCountPerColumn)
5483       {
5484         LISTVIEW_KeySelection(hwnd, infoPtr->nFocusedItem -
5485                               infoPtr->nCountPerColumn);
5486       }
5487       break;
5488
5489     case LVS_SMALLICON:
5490     case LVS_ICON:
5491       if (lStyle & LVS_ALIGNLEFT)
5492       {
5493         nCountPerColumn = max((infoPtr->rcList.bottom - infoPtr->rcList.top) /
5494                               infoPtr->nItemHeight, 1);
5495         if (infoPtr->nFocusedItem >= nCountPerColumn)
5496         {
5497           LISTVIEW_KeySelection(hwnd, infoPtr->nFocusedItem - nCountPerColumn);
5498         }
5499       }
5500       else
5501       {
5502         nCountPerRow = max((infoPtr->rcList.right - infoPtr->rcList.left) /
5503                            infoPtr->nItemWidth, 1);
5504         if (infoPtr->nFocusedItem % nCountPerRow != 0)
5505         {
5506           LISTVIEW_SetSelection(hwnd, infoPtr->nFocusedItem - 1);
5507         }
5508       }
5509       break;
5510     }
5511     break;
5512
5513   case VK_UP:
5514     switch (LVS_TYPEMASK & lStyle)
5515     {
5516     case LVS_LIST:
5517     case LVS_REPORT:
5518       if (infoPtr->nFocusedItem > 0)
5519       {
5520         LISTVIEW_KeySelection(hwnd, infoPtr->nFocusedItem - 1);
5521       }
5522       break;
5523
5524     default:
5525       if (lStyle & LVS_ALIGNLEFT)
5526       {
5527         nCountPerColumn = max((infoPtr->rcList.bottom - infoPtr->rcList.top) /
5528                               infoPtr->nItemHeight, 1);
5529         if (infoPtr->nFocusedItem % nCountPerColumn != 0)
5530         {
5531           LISTVIEW_KeySelection(hwnd, infoPtr->nFocusedItem - 1);
5532         }
5533       }
5534       else
5535       {
5536         nCountPerRow = max((infoPtr->rcList.right - infoPtr->rcList.left) /
5537                            infoPtr->nItemWidth, 1);
5538         if (infoPtr->nFocusedItem >= nCountPerRow)
5539         {
5540           LISTVIEW_KeySelection(hwnd, infoPtr->nFocusedItem - nCountPerRow);
5541         }
5542       }
5543     }
5544     break;
5545
5546   case VK_RIGHT:
5547     switch (LVS_TYPEMASK & lStyle)
5548     {
5549     case LVS_LIST:
5550       if (infoPtr->nFocusedItem < GETITEMCOUNT(infoPtr) -
5551           infoPtr->nCountPerColumn)
5552       {
5553         LISTVIEW_KeySelection(hwnd, infoPtr->nFocusedItem +
5554                               infoPtr->nCountPerColumn);
5555       }
5556       break;
5557
5558     case LVS_ICON:
5559     case LVS_SMALLICON:
5560       if (lStyle & LVS_ALIGNLEFT)
5561       {
5562         nCountPerColumn = max((infoPtr->rcList.bottom - infoPtr->rcList.top) /
5563                               infoPtr->nItemHeight, 1);
5564         if (infoPtr->nFocusedItem < GETITEMCOUNT(infoPtr) - nCountPerColumn)
5565         {
5566           LISTVIEW_KeySelection(hwnd, infoPtr->nFocusedItem + nCountPerColumn);
5567         }
5568       }
5569       else
5570       {
5571         nCountPerRow = max((infoPtr->rcList.right - infoPtr->rcList.left) /
5572                            infoPtr->nItemWidth, 1);
5573         if ((infoPtr->nFocusedItem % nCountPerRow != nCountPerRow - 1) &&
5574             (infoPtr->nFocusedItem < GETITEMCOUNT(infoPtr) - 1))
5575         {
5576           LISTVIEW_KeySelection(hwnd, infoPtr->nFocusedItem + 1);
5577         }
5578       }
5579     }
5580     break;
5581
5582   case VK_DOWN:
5583     switch (LVS_TYPEMASK & lStyle)
5584     {
5585     case LVS_LIST:
5586     case LVS_REPORT:
5587       if (infoPtr->nFocusedItem < GETITEMCOUNT(infoPtr) - 1)
5588       {
5589         LISTVIEW_KeySelection(hwnd, infoPtr->nFocusedItem + 1);
5590       }
5591       break;
5592
5593     case LVS_SMALLICON:
5594     case LVS_ICON:
5595       if (lStyle & LVS_ALIGNLEFT)
5596       {
5597         nCountPerColumn = max((infoPtr->rcList.bottom - infoPtr->rcList.top) /
5598                               infoPtr->nItemHeight, 1);
5599         if (infoPtr->nFocusedItem % nCountPerColumn != nCountPerColumn - 1)
5600         {
5601           LISTVIEW_KeySelection(hwnd, infoPtr->nFocusedItem + 1);
5602         }
5603       }
5604       else
5605       {
5606         nCountPerRow = max((infoPtr->rcList.right - infoPtr->rcList.left) /
5607                            infoPtr->nItemWidth, 1);
5608         if (infoPtr->nFocusedItem < GETITEMCOUNT(infoPtr) - nCountPerRow)
5609         {
5610           LISTVIEW_KeySelection(hwnd, infoPtr->nFocusedItem + nCountPerRow);
5611         }
5612       }
5613     }
5614     break;
5615
5616   case VK_PRIOR:
5617     break;
5618
5619   case VK_NEXT:
5620     break;
5621   }
5622
5623   /* refresh client area */
5624   InvalidateRect(hwnd, NULL, TRUE);
5625
5626   return 0;
5627 }
5628
5629 /***
5630  * DESCRIPTION:
5631  * Kills the focus.
5632  *
5633  * PARAMETER(S):
5634  * [I] HWND : window handle
5635  *
5636  * RETURN:
5637  * Zero
5638  */
5639 static LRESULT LISTVIEW_KillFocus(HWND hwnd)
5640 {
5641   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO*)GetWindowLongA(hwnd, 0);
5642   INT nCtrlId = GetWindowLongA(hwnd, GWL_ID);
5643   NMHDR nmh;
5644
5645   /* send NM_KILLFOCUS notification */
5646   nmh.hwndFrom = hwnd;
5647   nmh.idFrom = nCtrlId;
5648   nmh.code = NM_KILLFOCUS;
5649   ListView_Notify(GetParent(hwnd), nCtrlId, &nmh);
5650
5651   /* set window focus flag */
5652   infoPtr->bFocus = FALSE;
5653
5654   return 0;
5655 }
5656
5657 /***
5658  * DESCRIPTION:
5659  * Processes double click messages (left mouse button).
5660  *
5661  * PARAMETER(S):
5662  * [I] HWND : window handle
5663  * [I] WORD : key flag
5664  * [I] WORD : x coordinate
5665  * [I] WORD : y coordinate
5666  *
5667  * RETURN:
5668  * Zero
5669  */
5670 static LRESULT LISTVIEW_LButtonDblClk(HWND hwnd, WORD wKey, WORD wPosX,
5671                                       WORD wPosY)
5672 {
5673   LONG nCtrlId = GetWindowLongA(hwnd, GWL_ID);
5674   NMHDR nmh;
5675
5676   TRACE(listview, "(hwnd=%x,key=%hu,X=%hu,Y=%hu)\n", hwnd, wKey, wPosX, wPosY);
5677
5678   /* send NM_DBLCLK notification */
5679   nmh.hwndFrom = hwnd;
5680   nmh.idFrom = nCtrlId;
5681   nmh.code = NM_DBLCLK;
5682   ListView_Notify(GetParent(hwnd), nCtrlId, &nmh);
5683
5684   /* send LVN_ITEMACTIVATE notification */
5685   nmh.code = LVN_ITEMACTIVATE;
5686   ListView_Notify(GetParent(hwnd), nCtrlId, &nmh);
5687
5688   return 0;
5689 }
5690
5691 /***
5692  * DESCRIPTION:
5693  * Processes mouse down messages (left mouse button).
5694  *
5695  * PARAMETER(S):
5696  * [I] HWND : window handle
5697  * [I] WORD : key flag
5698  * [I] WORD : x coordinate
5699  * [I] WORD : y coordinate
5700  *
5701  * RETURN:
5702  * Zero
5703  */
5704 static LRESULT LISTVIEW_LButtonDown(HWND hwnd, WORD wKey, WORD wPosX,
5705                                     WORD wPosY)
5706 {
5707   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
5708   INT nCtrlId = GetWindowLongA(hwnd, GWL_ID);
5709   static BOOL bGroupSelect = TRUE;
5710   NMHDR nmh;
5711   INT nItem;
5712
5713   TRACE(listview, "(hwnd=%x,key=%hu,X=%hu,Y=%hu)\n", hwnd, wKey, wPosX, wPosY);
5714
5715   /* send NM_RELEASEDCAPTURE notification */
5716   nmh.hwndFrom = hwnd;
5717   nmh.idFrom = nCtrlId;
5718   nmh.code = NM_RELEASEDCAPTURE;
5719   ListView_Notify(GetParent(hwnd), nCtrlId, &nmh);
5720
5721   if (infoPtr->bFocus == FALSE)
5722   {
5723     SetFocus(hwnd);
5724   }
5725
5726   /* set left button down flag */
5727   infoPtr->bLButtonDown = TRUE;
5728
5729   nItem = LISTVIEW_MouseSelection(hwnd, wPosX, wPosY);
5730   if ((nItem >= 0) && (nItem < GETITEMCOUNT(infoPtr)))
5731   {
5732     if ((wKey & MK_CONTROL) && (wKey & MK_SHIFT))
5733     {
5734       if (bGroupSelect != FALSE)
5735       {
5736         LISTVIEW_AddGroupSelection(hwnd, nItem);
5737       }
5738       else
5739       {
5740         LISTVIEW_AddSelection(hwnd, nItem);
5741       }
5742     }
5743     else if (wKey & MK_CONTROL)
5744     {
5745       bGroupSelect = LISTVIEW_ToggleSelection(hwnd, nItem);
5746     }
5747     else  if (wKey & MK_SHIFT)
5748     {
5749       LISTVIEW_SetGroupSelection(hwnd, nItem);
5750     }
5751     else
5752     {
5753       LISTVIEW_SetSelection(hwnd, nItem);
5754     }
5755   }
5756   else
5757   {
5758     /* remove all selections */
5759     LISTVIEW_RemoveSelections(hwnd, 0, GETITEMCOUNT(infoPtr));
5760   }
5761
5762   InvalidateRect(hwnd, NULL, TRUE);
5763
5764   return 0;
5765 }
5766
5767 /***
5768  * DESCRIPTION:
5769  * Processes mouse up messages (left mouse button).
5770  *
5771  * PARAMETER(S):
5772  * [I] HWND : window handle
5773  * [I] WORD : key flag
5774  * [I] WORD : x coordinate
5775  * [I] WORD : y coordinate
5776  *
5777  * RETURN:
5778  * Zero
5779  */
5780 static LRESULT LISTVIEW_LButtonUp(HWND hwnd, WORD wKey, WORD wPosX,
5781                                   WORD wPosY)
5782 {
5783   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
5784
5785   TRACE(listview, "(hwnd=%x,key=%hu,X=%hu,Y=%hu)\n", hwnd, wKey, wPosX, wPosY);
5786
5787   if (infoPtr->bLButtonDown != FALSE)
5788   {
5789     INT nCtrlId = GetWindowLongA(hwnd, GWL_ID);
5790     NMHDR nmh;
5791
5792     /* send NM_CLICK notification */
5793     nmh.hwndFrom = hwnd;
5794     nmh.idFrom = nCtrlId;
5795     nmh.code = NM_CLICK;
5796     ListView_Notify(GetParent(hwnd), nCtrlId, &nmh);
5797
5798     /* set left button flag */
5799     infoPtr->bLButtonDown = FALSE;
5800   }
5801
5802   return 0;
5803 }
5804
5805 /***
5806  * DESCRIPTION:
5807  * Creates the listview control (called before WM_CREATE).
5808  *
5809  * PARAMETER(S):
5810  * [I] HWND : window handle
5811  * [I] WPARAM : unhandled
5812  * [I] LPARAM : widow creation info
5813  *
5814  * RETURN:
5815  * Zero
5816  */
5817 static LRESULT LISTVIEW_NCCreate(HWND hwnd, WPARAM wParam, LPARAM lParam)
5818 {
5819   LISTVIEW_INFO *infoPtr;
5820
5821   TRACE(listview, "(hwnd=%x,wParam=%x,lParam=%lx)\n", hwnd, wParam, lParam);
5822
5823   /* allocate memory for info structure */
5824   infoPtr = (LISTVIEW_INFO *)COMCTL32_Alloc(sizeof(LISTVIEW_INFO));
5825   SetWindowLongA(hwnd, 0, (LONG)infoPtr);
5826   if (infoPtr == NULL)
5827   {
5828     ERR(listview, "could not allocate info memory!\n");
5829     return 0;
5830   }
5831
5832   if ((LISTVIEW_INFO *)GetWindowLongA(hwnd, 0) != infoPtr)
5833   {
5834     ERR(listview, "pointer assignment error!\n");
5835     return 0;
5836   }
5837
5838   return DefWindowProcA(hwnd, WM_NCCREATE, wParam, lParam);
5839 }
5840
5841 /***
5842  * DESCRIPTION:
5843  * Destroys the listview control (called after WM_DESTROY).
5844  *
5845  * PARAMETER(S):
5846  * [I] HWND : window handle
5847  *
5848  * RETURN:
5849  * Zero
5850  */
5851 static LRESULT LISTVIEW_NCDestroy(HWND hwnd)
5852 {
5853   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
5854
5855   TRACE(listview, "(hwnd=%x)\n", hwnd);
5856
5857   /* delete all items */
5858   LISTVIEW_DeleteAllItems(hwnd);
5859
5860   /* destroy data structure */
5861   DPA_Destroy(infoPtr->hdpaItems);
5862
5863   /* destroy font */
5864   infoPtr->hFont = (HFONT)0;
5865   if (infoPtr->hDefaultFont)
5866   {
5867     DeleteObject(infoPtr->hDefaultFont);
5868   }
5869
5870   /* free listview info pointer*/
5871   COMCTL32_Free(infoPtr);
5872
5873   return 0;
5874 }
5875
5876 /***
5877  * DESCRIPTION:
5878  * Handles notifications from children.
5879  *
5880  * PARAMETER(S):
5881  * [I] HWND : window handle
5882  * [I] INT : control identifier
5883  * [I] LPNMHDR : notification information
5884  *
5885  * RETURN:
5886  * Zero
5887  */
5888 static LRESULT LISTVIEW_Notify(HWND hwnd, INT nCtrlId, LPNMHDR lpnmh)
5889 {
5890   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
5891
5892   if (lpnmh->hwndFrom == infoPtr->hwndHeader)
5893   {
5894     /* handle notification from header control */
5895     if (lpnmh->code == HDN_ENDTRACKA)
5896     {
5897       infoPtr->nItemWidth = LISTVIEW_GetItemWidth(hwnd, LVS_REPORT);
5898       InvalidateRect(hwnd, NULL, TRUE);
5899     }
5900   }
5901
5902   return 0;
5903 }
5904
5905 /***
5906  * DESCRIPTION:
5907  * Determines the type of structure to use.
5908  *
5909  * PARAMETER(S):
5910  * [I] HWND : window handle of the sender
5911  * [I] HWND : listview window handle
5912  * [I] INT : command specifying the nature of the WM_NOTIFYFORMAT
5913  *
5914  * RETURN:
5915  * Zero
5916  */
5917 static LRESULT LISTVIEW_NotifyFormat(HWND hwndFrom, HWND hwnd, INT nCommand)
5918 {
5919   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
5920
5921   if (nCommand == NF_REQUERY)
5922   {
5923     /* determine the type of structure to use */
5924     infoPtr->notifyFormat = SendMessageA(hwndFrom, WM_NOTIFYFORMAT,
5925                                          (WPARAM)hwnd, (LPARAM)NF_QUERY);
5926     if (infoPtr->notifyFormat == NFR_UNICODE)
5927     {
5928       FIXME (listview, "NO support for unicode structures");
5929     }
5930   }
5931
5932   return 0;
5933 }
5934
5935 /***
5936  * DESCRIPTION:
5937  * Paints/Repaints the listview control.
5938  *
5939  * PARAMETER(S):
5940  * [I] HWND : window handle
5941  * [I] HDC : device context handle
5942  *
5943  * RETURN:
5944  * Zero
5945  */
5946 static LRESULT LISTVIEW_Paint(HWND hwnd, HDC hdc)
5947 {
5948   PAINTSTRUCT ps;
5949
5950    TRACE(listview, "(hwnd=%x,hdc=%x)\n", hwnd, hdc);
5951
5952   if (hdc == 0)
5953   {
5954     hdc = BeginPaint(hwnd, &ps);
5955     LISTVIEW_Refresh(hwnd, hdc);
5956     EndPaint(hwnd, &ps);
5957   }
5958   else
5959   {
5960     LISTVIEW_Refresh(hwnd, hdc);
5961   }
5962
5963   return 0;
5964 }
5965
5966 /***
5967  * DESCRIPTION:
5968  * Processes double click messages (right mouse button).
5969  *
5970  * PARAMETER(S):
5971  * [I] HWND : window handle
5972  * [I] WORD : key flag
5973  * [I] WORD : x coordinate
5974  * [I] WORD : y coordinate
5975  *
5976  * RETURN:
5977  * Zero
5978  */
5979 static LRESULT LISTVIEW_RButtonDblClk(HWND hwnd, WORD wKey, WORD wPosX,
5980                                       WORD wPosY)
5981 {
5982   INT nCtrlId = GetWindowLongA(hwnd, GWL_ID);
5983   NMHDR nmh;
5984
5985   TRACE(listview, "(hwnd=%x,key=%hu,X=%hu,Y=%hu)\n", hwnd, wKey, wPosX, wPosY);
5986
5987   /* send NM_RELEASEDCAPTURE notification */
5988   nmh.hwndFrom = hwnd;
5989   nmh.idFrom = nCtrlId;
5990   nmh.code = NM_RELEASEDCAPTURE;
5991   ListView_Notify(GetParent(hwnd), nCtrlId, &nmh);
5992
5993   /* send NM_RDBLCLK notification */
5994   nmh.code = NM_RDBLCLK;
5995   ListView_Notify(GetParent(hwnd), nCtrlId, &nmh);
5996
5997   return 0;
5998 }
5999
6000 /***
6001  * DESCRIPTION:
6002  * Processes mouse down messages (right mouse button).
6003  *
6004  * PARAMETER(S):
6005  * [I] HWND : window handle
6006  * [I] WORD : key flag
6007  * [I] WORD : x coordinate
6008  * [I] WORD : y coordinate
6009  *
6010  * RETURN:
6011  * Zero
6012  */
6013 static LRESULT LISTVIEW_RButtonDown(HWND hwnd, WORD wKey, WORD wPosX,
6014                                     WORD wPosY)
6015 {
6016   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
6017   INT nCtrlId = GetWindowLongA(hwnd, GWL_ID);
6018   NMHDR nmh;
6019   INT nItem;
6020
6021   TRACE(listview, "(hwnd=%x,key=%hu,X=%hu,Y=%hu)\n", hwnd, wKey, wPosX, wPosY);
6022
6023   /* send NM_RELEASEDCAPTURE notification */
6024   nmh.hwndFrom = hwnd;
6025   nmh.idFrom = nCtrlId;
6026   nmh.code = NM_RELEASEDCAPTURE;
6027   ListView_Notify(GetParent(hwnd), nCtrlId, &nmh);
6028
6029   /* make sure the listview control window has the focus */
6030   if (infoPtr->bFocus == FALSE)
6031   {
6032     SetFocus(hwnd);
6033   }
6034
6035   /* set right button down flag */
6036   infoPtr->bRButtonDown = TRUE;
6037
6038   /* determine the index of the selected item */
6039   nItem = LISTVIEW_MouseSelection(hwnd, wPosX, wPosY);
6040   if ((nItem >= 0) && (nItem < GETITEMCOUNT(infoPtr)))
6041   {
6042     if (!((wKey & MK_SHIFT) || (wKey & MK_CONTROL)))
6043     {
6044       LISTVIEW_SetSelection(hwnd, nItem);
6045     }
6046   }
6047   else
6048   {
6049     LISTVIEW_RemoveSelections(hwnd, 0, GETITEMCOUNT(infoPtr));
6050   }
6051
6052   return 0;
6053 }
6054
6055 /***
6056  * DESCRIPTION:
6057  * Processes mouse up messages (right mouse button).
6058  *
6059  * PARAMETER(S):
6060  * [I] HWND : window handle
6061  * [I] WORD : key flag
6062  * [I] WORD : x coordinate
6063  * [I] WORD : y coordinate
6064  *
6065  * RETURN:
6066  * Zero
6067  */
6068 static LRESULT LISTVIEW_RButtonUp(HWND hwnd, WORD wKey, WORD wPosX,
6069                                   WORD wPosY)
6070 {
6071   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
6072   INT nCtrlId = GetWindowLongA(hwnd, GWL_ID);
6073   NMHDR nmh;
6074
6075   TRACE(listview, "(hwnd=%x,key=%hu,X=%hu,Y=%hu)\n", hwnd, wKey, wPosX, wPosY);
6076
6077   if (infoPtr->bRButtonDown != FALSE)
6078   {
6079     /* send NM_RClICK notification */
6080     ZeroMemory(&nmh, sizeof(NMHDR));
6081     nmh.hwndFrom = hwnd;
6082     nmh.idFrom = nCtrlId;
6083     nmh.code = NM_RCLICK;
6084     ListView_Notify(GetParent(hwnd), nCtrlId, &nmh);
6085
6086     /* set button flag */
6087     infoPtr->bRButtonDown = FALSE;
6088   }
6089
6090   return 0;
6091 }
6092
6093 /***
6094  * DESCRIPTION:
6095  * Sets the focus.
6096  *
6097  * PARAMETER(S):
6098  * [I] HWND : window handle
6099  * [I] HWND : window handle of previously focused window
6100  *
6101  * RETURN:
6102  * Zero
6103  */
6104 static LRESULT LISTVIEW_SetFocus(HWND hwnd, HWND hwndLoseFocus)
6105 {
6106   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
6107   INT nCtrlId = GetWindowLongA(hwnd, GWL_ID);
6108   NMHDR nmh;
6109
6110   /* send NM_SETFOCUS notification */
6111   nmh.hwndFrom = hwnd;
6112   nmh.idFrom = nCtrlId;
6113   nmh.code = NM_SETFOCUS;
6114   ListView_Notify(GetParent(hwnd), nCtrlId, &nmh);
6115
6116   /* set window focus flag */
6117   infoPtr->bFocus = TRUE;
6118
6119   return 0;
6120 }
6121
6122 /***
6123  * DESCRIPTION:
6124  * Sets the font.
6125  *
6126  * PARAMETER(S):
6127  * [I] HWND : window handle
6128  * [I] HFONT : font handle
6129  * [I] WORD : redraw flag
6130  *
6131  * RETURN:
6132  * Zero
6133  */
6134 static LRESULT LISTVIEW_SetFont(HWND hwnd, HFONT hFont, WORD fRedraw)
6135 {
6136   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
6137   LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
6138
6139   TRACE(listview, "(hwnd=%x,hfont=%x,redraw=%hu)\n", hwnd, hFont, fRedraw);
6140
6141   if (hFont == 0)
6142   {
6143     infoPtr->hFont = infoPtr->hDefaultFont;
6144   }
6145   else
6146   {
6147     infoPtr->hFont = hFont;
6148   }
6149
6150   if ((LVS_TYPEMASK & lStyle ) == LVS_REPORT)
6151   {
6152     /* set header font */
6153     SendMessageA(infoPtr->hwndHeader, WM_SETFONT, (WPARAM)hFont,
6154                    MAKELPARAM(fRedraw, 0));
6155   }
6156
6157   /* invalidate listview control client area */
6158   InvalidateRect(hwnd, NULL, TRUE);
6159
6160   if (fRedraw != FALSE)
6161   {
6162     UpdateWindow(hwnd);
6163   }
6164
6165   return 0;
6166 }
6167
6168 /***
6169  * DESCRIPTION:
6170  * Resizes the listview control. This function processes WM_SIZE
6171  * messages.  At this time, the width and height are not used.
6172  *
6173  * PARAMETER(S):
6174  * [I] HWND : window handle
6175  * [I] WORD : new width
6176  * [I] WORD : new height
6177  *
6178  * RETURN:
6179  * Zero
6180  */
6181 static LRESULT LISTVIEW_Size(HWND hwnd, int Width, int Height)
6182 {
6183   LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
6184
6185   TRACE(listview, "(hwnd=%x,width=%d,height=%d)\n",hwnd, Width, Height);
6186
6187   LISTVIEW_SetSize(hwnd, lStyle, -1, -1);
6188   switch (lStyle & LVS_TYPEMASK)
6189   {
6190   case LVS_LIST:
6191   case LVS_REPORT:
6192     LISTVIEW_SetViewInfo(hwnd, lStyle);
6193     break;
6194
6195   case LVS_ICON:
6196   case LVS_SMALLICON:
6197     if (lStyle & LVS_ALIGNLEFT)
6198     {
6199       LISTVIEW_AlignLeft(hwnd);
6200     }
6201     else
6202     {
6203       LISTVIEW_AlignTop(hwnd);
6204     }
6205     break;
6206   }
6207
6208   LISTVIEW_SetScroll(hwnd, lStyle);
6209
6210   /* invalidate + erase background */
6211   InvalidateRect(hwnd, NULL, TRUE);
6212
6213   return 0;
6214 }
6215
6216 /***
6217  * DESCRIPTION:
6218  * Sets the size information for a given style.
6219  *
6220  * PARAMETER(S):
6221  * [I] HWND : window handle
6222  * [I] LONG : window style
6223  * [I] WORD : new width
6224  * [I] WORD : new height
6225  *
6226  * RETURN:
6227  * Zero
6228  */
6229 static VOID LISTVIEW_SetSize(HWND hwnd, LONG lStyle, LONG lWidth, LONG lHeight)
6230 {
6231   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
6232   HDLAYOUT hl;
6233   WINDOWPOS wp;
6234   RECT rcList;
6235
6236   GetClientRect(hwnd, &rcList);
6237   if (lWidth == -1)
6238   {
6239     infoPtr->rcList.left = max(rcList.left, 0);
6240     infoPtr->rcList.right = max(rcList.right, 0);
6241   }
6242   else
6243   {
6244     infoPtr->rcList.left = max(rcList.left, 0);
6245     infoPtr->rcList.right = infoPtr->rcList.left + max(lWidth, 0);
6246   }
6247
6248   if (lHeight == -1)
6249   {
6250     infoPtr->rcList.top = max(rcList.top, 0);
6251     infoPtr->rcList.bottom = max(rcList.bottom, 0);
6252   }
6253   else
6254   {
6255     infoPtr->rcList.top = max(rcList.top, 0);
6256     infoPtr->rcList.bottom = infoPtr->rcList.top + max(lHeight, 0);
6257   }
6258
6259   switch (lStyle & LVS_TYPEMASK)
6260   {
6261   case LVS_LIST:
6262     if ((lStyle & WS_HSCROLL) == 0)
6263     {
6264       INT nHScrollHeight;
6265       nHScrollHeight = GetSystemMetrics(SM_CYHSCROLL);
6266       if (infoPtr->rcList.bottom > nHScrollHeight)
6267       {
6268         infoPtr->rcList.bottom -= nHScrollHeight;
6269       }
6270     }
6271     break;
6272
6273   case LVS_REPORT:
6274     hl.prc = &rcList;
6275     hl.pwpos = &wp;
6276     Header_Layout(infoPtr->hwndHeader, &hl);
6277     infoPtr->rcList.top = max(wp.cy, 0);
6278     break;
6279   }
6280 }
6281
6282 /***
6283  * DESCRIPTION:
6284  * Processes WM_STYLECHANGED messages.
6285  *
6286  * PARAMETER(S):
6287  * [I] HWND : window handle
6288  * [I] WPARAM : window style type (normal or extended)
6289  * [I] LPSTYLESTRUCT : window style information
6290  *
6291  * RETURN:
6292  * Zero
6293  */
6294 static INT LISTVIEW_StyleChanged(HWND hwnd, WPARAM wStyleType,
6295                                  LPSTYLESTRUCT lpss)
6296 {
6297   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
6298   RECT rcList = infoPtr->rcList;
6299   HDLAYOUT hl;
6300   WINDOWPOS wp;
6301
6302   TRACE(listview, "(hwnd=%x,styletype=%x,stylestruct=%p)\n",
6303         hwnd, wStyleType, lpss);
6304
6305   if (wStyleType == GWL_STYLE)
6306   {
6307     if ((lpss->styleOld & WS_HSCROLL) != 0)
6308     {
6309       ShowScrollBar(hwnd, SB_HORZ, FALSE);
6310     }
6311
6312     if ((lpss->styleOld & WS_VSCROLL) != 0)
6313     {
6314       ShowScrollBar(hwnd, SB_VERT, FALSE);
6315     }
6316
6317     if ((LVS_TYPEMASK & lpss->styleOld) == LVS_REPORT)
6318     {
6319       /* remove header */
6320       ShowWindow(infoPtr->hwndHeader, SW_HIDE);
6321     }
6322
6323     switch (lpss->styleNew & LVS_TYPEMASK)
6324     {
6325     case LVS_ICON:
6326       infoPtr->iconSize.cx = GetSystemMetrics(SM_CXICON);
6327       infoPtr->iconSize.cy = GetSystemMetrics(SM_CYICON);
6328       LISTVIEW_SetSize(hwnd, lpss->styleNew, -1, -1);
6329       infoPtr->nItemWidth = LISTVIEW_GetItemWidth(hwnd, lpss->styleNew);
6330       infoPtr->nItemHeight = LISTVIEW_GetItemHeight(hwnd, lpss->styleNew);
6331       if (lpss->styleNew & LVS_ALIGNLEFT)
6332       {
6333         LISTVIEW_AlignLeft(hwnd);
6334       }
6335       else
6336       {
6337         LISTVIEW_AlignTop(hwnd);
6338       }
6339       break;
6340
6341     case LVS_REPORT:
6342       hl.prc = &rcList;
6343       hl.pwpos = &wp;
6344       Header_Layout(infoPtr->hwndHeader, &hl);
6345       SetWindowPos(infoPtr->hwndHeader, hwnd, wp.x, wp.y, wp.cx,
6346                    wp.cy, wp.flags);
6347       ShowWindow(infoPtr->hwndHeader, SW_SHOWNORMAL);
6348       infoPtr->iconSize.cx = GetSystemMetrics(SM_CXSMICON);
6349       infoPtr->iconSize.cy = GetSystemMetrics(SM_CYSMICON);
6350       infoPtr->nItemWidth = LISTVIEW_GetItemWidth(hwnd, lpss->styleNew);
6351       infoPtr->nItemHeight = LISTVIEW_GetItemHeight(hwnd, lpss->styleNew);
6352       LISTVIEW_SetSize(hwnd, lpss->styleNew, -1, -1);
6353       LISTVIEW_SetViewInfo(hwnd, lpss->styleNew);
6354       break;
6355
6356     case LVS_LIST:
6357       infoPtr->iconSize.cx = GetSystemMetrics(SM_CXSMICON);
6358       infoPtr->iconSize.cy = GetSystemMetrics(SM_CYSMICON);
6359       infoPtr->nItemWidth = LISTVIEW_GetItemWidth(hwnd, lpss->styleNew);
6360       infoPtr->nItemHeight = LISTVIEW_GetItemHeight(hwnd, lpss->styleNew);
6361       LISTVIEW_SetSize(hwnd, lpss->styleNew, -1, -1);
6362       LISTVIEW_SetViewInfo(hwnd, lpss->styleNew);
6363       break;
6364
6365     case LVS_SMALLICON:
6366       infoPtr->iconSize.cx = GetSystemMetrics(SM_CXSMICON);
6367       infoPtr->iconSize.cy = GetSystemMetrics(SM_CYSMICON);
6368       LISTVIEW_SetSize(hwnd, lpss->styleNew, -1, -1);
6369       infoPtr->nItemWidth = LISTVIEW_GetItemWidth(hwnd, lpss->styleNew);
6370       infoPtr->nItemHeight = LISTVIEW_GetItemHeight(hwnd, lpss->styleNew);
6371       if (lpss->styleNew & LVS_ALIGNLEFT)
6372       {
6373         LISTVIEW_AlignLeft(hwnd);
6374       }
6375       else
6376       {
6377         LISTVIEW_AlignTop(hwnd);
6378       }
6379       break;
6380     }
6381
6382     LISTVIEW_SetScroll(hwnd, lpss->styleNew);
6383
6384     /* print unsupported styles */
6385     LISTVIEW_UnsupportedStyles(lpss->styleNew);
6386
6387     /* invalidate client area */
6388     InvalidateRect(hwnd, NULL, TRUE);
6389   }
6390
6391   return 0;
6392 }
6393
6394 /***
6395  * DESCRIPTION:
6396  * Window procedure of the listview control.
6397  *
6398  * PARAMETER(S):
6399  * [I] HWND :
6400  * [I] UINT :
6401  * [I] WPARAM :
6402  * [I] LPARAM :
6403  *
6404  * RETURN:
6405  *
6406  */
6407 LRESULT WINAPI LISTVIEW_WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam,
6408                                    LPARAM lParam)
6409 {
6410   switch (uMsg)
6411   {
6412   case LVM_APPROXIMATEVIEWRECT:
6413     return LISTVIEW_ApproximateViewRect(hwnd, (INT)wParam,
6414                                         LOWORD(lParam), HIWORD(lParam));
6415   case LVM_ARRANGE:
6416     return LISTVIEW_Arrange(hwnd, (INT)wParam);
6417
6418 /* case LVM_CREATEDRAGIMAGE: */
6419
6420   case LVM_DELETEALLITEMS:
6421     return LISTVIEW_DeleteAllItems(hwnd);
6422
6423   case LVM_DELETECOLUMN:
6424     return LISTVIEW_DeleteColumn(hwnd, (INT)wParam);
6425
6426   case LVM_DELETEITEM:
6427     return LISTVIEW_DeleteItem(hwnd, (INT)wParam);
6428
6429 /*      case LVM_EDITLABEL: */
6430
6431   case LVM_ENSUREVISIBLE:
6432     return LISTVIEW_EnsureVisible(hwnd, (INT)wParam, (BOOL)lParam);
6433
6434   case LVM_FINDITEMA:
6435     return LISTVIEW_FindItem(hwnd, (INT)wParam, (LPLVFINDINFO)lParam);
6436
6437   case LVM_GETBKCOLOR:
6438     return LISTVIEW_GetBkColor(hwnd);
6439
6440 /*      case LVM_GETBKIMAGE: */
6441
6442   case LVM_GETCALLBACKMASK:
6443     return LISTVIEW_GetCallbackMask(hwnd);
6444
6445   case LVM_GETCOLUMNA:
6446     return LISTVIEW_GetColumnA(hwnd, (INT)wParam, (LPLVCOLUMNA)lParam);
6447
6448 /*      case LVM_GETCOLUMNW: */
6449 /*      case LVM_GETCOLUMNORDERARRAY: */
6450
6451   case LVM_GETCOLUMNWIDTH:
6452     return LISTVIEW_GetColumnWidth(hwnd, (INT)wParam);
6453
6454   case LVM_GETCOUNTPERPAGE:
6455     return LISTVIEW_GetCountPerPage(hwnd);
6456
6457 /*      case LVM_GETEDITCONTROL: */
6458 /*      case LVM_GETEXTENDEDLISTVIEWSTYLE: */
6459
6460   case LVM_GETHEADER:
6461     return LISTVIEW_GetHeader(hwnd);
6462
6463 /*      case LVM_GETHOTCURSOR: */
6464 /*      case LVM_GETHOTITEM: */
6465 /*      case LVM_GETHOVERTIME: */
6466
6467   case LVM_GETIMAGELIST:
6468     return LISTVIEW_GetImageList(hwnd, (INT)wParam);
6469
6470 /*      case LVM_GETISEARCHSTRING: */
6471
6472   case LVM_GETITEMA:
6473     return LISTVIEW_GetItemA(hwnd, (LPLVITEMA)lParam);
6474
6475 /*      case LVM_GETITEMW: */
6476
6477   case LVM_GETITEMCOUNT:
6478     return LISTVIEW_GetItemCount(hwnd);
6479
6480   case LVM_GETITEMPOSITION:
6481     return LISTVIEW_GetItemPosition(hwnd, (INT)wParam, (LPPOINT)lParam);
6482
6483   case LVM_GETITEMRECT:
6484     return LISTVIEW_GetItemRect(hwnd, (INT)wParam, (LPRECT)lParam);
6485
6486   case LVM_GETITEMSPACING:
6487     return LISTVIEW_GetItemSpacing(hwnd, (BOOL)wParam);
6488
6489   case LVM_GETITEMSTATE:
6490     return LISTVIEW_GetItemState(hwnd, (INT)wParam, (UINT)lParam);
6491
6492   case LVM_GETITEMTEXTA:
6493     LISTVIEW_GetItemTextA(hwnd, (INT)wParam, (LPLVITEMA)lParam);
6494     break;
6495
6496 /*      case LVM_GETITEMTEXTW: */
6497
6498   case LVM_GETNEXTITEM:
6499     return LISTVIEW_GetNextItem(hwnd, (INT)wParam, LOWORD(lParam));
6500
6501 /*      case LVM_GETNUMBEROFWORKAREAS: */
6502
6503   case LVM_GETORIGIN:
6504     return LISTVIEW_GetOrigin(hwnd, (LPPOINT)lParam);
6505
6506   case LVM_GETSELECTEDCOUNT:
6507     return LISTVIEW_GetSelectedCount(hwnd);
6508
6509   case LVM_GETSELECTIONMARK:
6510     return LISTVIEW_GetSelectionMark(hwnd);
6511
6512   case LVM_GETSTRINGWIDTHA:
6513     return LISTVIEW_GetStringWidthA (hwnd, (LPCSTR)lParam);
6514
6515 /*      case LVM_GETSTRINGWIDTHW: */
6516 /*      case LVM_GETSUBITEMRECT: */
6517
6518   case LVM_GETTEXTBKCOLOR:
6519     return LISTVIEW_GetTextBkColor(hwnd);
6520
6521   case LVM_GETTEXTCOLOR:
6522     return LISTVIEW_GetTextColor(hwnd);
6523
6524 /*      case LVM_GETTOOLTIPS: */
6525
6526   case LVM_GETTOPINDEX:
6527     return LISTVIEW_GetTopIndex(hwnd);
6528
6529 /*      case LVM_GETUNICODEFORMAT: */
6530
6531   case LVM_GETVIEWRECT:
6532     return LISTVIEW_GetViewRect(hwnd, (LPRECT)lParam);
6533
6534 /*      case LVM_GETWORKAREAS: */
6535
6536   case LVM_HITTEST:
6537     return LISTVIEW_HitTest(hwnd, (LPLVHITTESTINFO)lParam);
6538
6539   case LVM_INSERTCOLUMNA:
6540     return LISTVIEW_InsertColumnA(hwnd, (INT)wParam,
6541                                     (LPLVCOLUMNA)lParam);
6542
6543 /*      case LVM_INSERTCOLUMNW: */
6544
6545   case LVM_INSERTITEMA:
6546     return LISTVIEW_InsertItemA(hwnd, (LPLVITEMA)lParam);
6547
6548 /*      case LVM_INSERTITEMW: */
6549
6550   case LVM_REDRAWITEMS:
6551     return LISTVIEW_RedrawItems(hwnd, (INT)wParam, (INT)lParam);
6552
6553 /*   case LVM_SCROLL:  */
6554 /*     return LISTVIEW_Scroll(hwnd, (INT)wParam, (INT)lParam); */
6555
6556   case LVM_SETBKCOLOR:
6557     return LISTVIEW_SetBkColor(hwnd, (COLORREF)lParam);
6558
6559 /*      case LVM_SETBKIMAGE: */
6560
6561   case LVM_SETCALLBACKMASK:
6562     return LISTVIEW_SetCallbackMask(hwnd, (UINT)wParam);
6563
6564   case LVM_SETCOLUMNA:
6565     return LISTVIEW_SetColumnA(hwnd, (INT)wParam, (LPLVCOLUMNA)lParam);
6566
6567 /*      case LVM_SETCOLUMNW: */
6568 /*      case LVM_SETCOLUMNORDERARRAY: */
6569
6570   case LVM_SETCOLUMNWIDTH:
6571     return LISTVIEW_SetColumnWidth(hwnd, (INT)wParam, (INT)lParam);
6572
6573 /*      case LVM_SETEXTENDEDLISTVIEWSTYLE: */
6574 /*      case LVM_SETHOTCURSOR: */
6575 /*      case LVM_SETHOTITEM: */
6576 /*      case LVM_SETHOVERTIME: */
6577 /*      case LVM_SETICONSPACING: */
6578
6579   case LVM_SETIMAGELIST:
6580     return LISTVIEW_SetImageList(hwnd, (INT)wParam, (HIMAGELIST)lParam);
6581
6582   case LVM_SETITEMA:
6583     return LISTVIEW_SetItemA(hwnd, (LPLVITEMA)lParam);
6584
6585 /*      case LVM_SETITEMW: */
6586
6587   case LVM_SETITEMCOUNT:
6588     LISTVIEW_SetItemCount(hwnd, (INT)wParam);
6589     break;
6590
6591   case LVM_SETITEMPOSITION:
6592     return LISTVIEW_SetItemPosition(hwnd, (INT)wParam, (INT)LOWORD(lParam),
6593                                     (INT)HIWORD(lParam));
6594
6595 /*      case LVM_SETITEMPOSITION: */
6596
6597   case LVM_SETITEMSTATE:
6598     return LISTVIEW_SetItemState(hwnd, (INT)wParam, (LPLVITEMA)lParam);
6599
6600   case LVM_SETITEMTEXTA:
6601     return LISTVIEW_SetItemTextA(hwnd, (INT)wParam, (LPLVITEMA)lParam);
6602
6603 /*      case LVM_SETSELECTIONMARK: */
6604
6605   case LVM_SETTEXTBKCOLOR:
6606     return LISTVIEW_SetTextBkColor(hwnd, (COLORREF)lParam);
6607
6608   case LVM_SETTEXTCOLOR:
6609     return LISTVIEW_SetTextColor(hwnd, (COLORREF)lParam);
6610
6611 /*      case LVM_SETTOOLTIPS: */
6612 /*      case LVM_SETUNICODEFORMAT: */
6613 /*      case LVM_SETWORKAREAS: */
6614
6615   case LVM_SORTITEMS:
6616     return LISTVIEW_SortItems(hwnd, wParam, lParam);
6617
6618 /*      case LVM_SUBITEMHITTEST: */
6619
6620   case LVM_UPDATE:
6621     return LISTVIEW_Update(hwnd, (INT)wParam);
6622
6623 /*      case WM_CHAR: */
6624 /*      case WM_COMMAND: */
6625
6626   case WM_CREATE:
6627     return LISTVIEW_Create(hwnd, wParam, lParam);
6628
6629   case WM_ERASEBKGND:
6630     return LISTVIEW_EraseBackground(hwnd, wParam, lParam);
6631
6632   case WM_GETDLGCODE:
6633     return DLGC_WANTTAB | DLGC_WANTARROWS;
6634
6635   case WM_GETFONT:
6636     return LISTVIEW_GetFont(hwnd);
6637
6638   case WM_HSCROLL:
6639     return LISTVIEW_HScroll(hwnd, (INT)LOWORD(wParam),
6640                             (INT)HIWORD(wParam), (HWND)lParam);
6641
6642   case WM_KEYDOWN:
6643     return LISTVIEW_KeyDown(hwnd, (INT)wParam, (LONG)lParam);
6644
6645   case WM_KILLFOCUS:
6646     return LISTVIEW_KillFocus(hwnd);
6647
6648   case WM_LBUTTONDBLCLK:
6649     return LISTVIEW_LButtonDblClk(hwnd, (WORD)wParam, LOWORD(lParam),
6650                                 HIWORD(lParam));
6651
6652   case WM_LBUTTONDOWN:
6653     return LISTVIEW_LButtonDown(hwnd, (WORD)wParam, LOWORD(lParam),
6654                                 HIWORD(lParam));
6655   case WM_LBUTTONUP:
6656     return LISTVIEW_LButtonUp(hwnd, (WORD)wParam, LOWORD(lParam),
6657                               HIWORD(lParam));
6658
6659 /*      case WM_MOUSEMOVE: */
6660 /*          return LISTVIEW_MouseMove (hwnd, wParam, lParam); */
6661
6662   case WM_NCCREATE:
6663     return LISTVIEW_NCCreate(hwnd, wParam, lParam);
6664
6665   case WM_NCDESTROY:
6666     return LISTVIEW_NCDestroy(hwnd);
6667
6668   case WM_NOTIFY:
6669     return LISTVIEW_Notify(hwnd, (INT)wParam, (LPNMHDR)lParam);
6670
6671   case WM_NOTIFYFORMAT:
6672     return LISTVIEW_NotifyFormat(hwnd, (HWND)wParam, (INT)lParam);
6673
6674   case WM_PAINT:
6675     return LISTVIEW_Paint(hwnd, (HDC)wParam);
6676
6677   case WM_RBUTTONDBLCLK:
6678     return LISTVIEW_RButtonDblClk(hwnd, (WORD)wParam, LOWORD(lParam),
6679                                   HIWORD(lParam));
6680
6681   case WM_RBUTTONDOWN:
6682     return LISTVIEW_RButtonDown(hwnd, (WORD)wParam, LOWORD(lParam),
6683                                 HIWORD(lParam));
6684
6685   case WM_RBUTTONUP:
6686     return LISTVIEW_RButtonUp(hwnd, (WORD)wParam, LOWORD(lParam),
6687                               HIWORD(lParam));
6688
6689   case WM_SETFOCUS:
6690     return LISTVIEW_SetFocus(hwnd, (HWND)wParam);
6691
6692   case WM_SETFONT:
6693     return LISTVIEW_SetFont(hwnd, (HFONT)wParam, (WORD)lParam);
6694
6695 /*      case WM_SETREDRAW: */
6696
6697   case WM_SIZE:
6698     return LISTVIEW_Size(hwnd, (int)SLOWORD(lParam), (int)SHIWORD(lParam));
6699
6700   case WM_STYLECHANGED:
6701     return LISTVIEW_StyleChanged(hwnd, wParam, (LPSTYLESTRUCT)lParam);
6702
6703 /*      case WM_TIMER: */
6704
6705   case WM_VSCROLL:
6706     return LISTVIEW_VScroll(hwnd, (INT)LOWORD(wParam),
6707                             (INT)HIWORD(wParam), (HWND)lParam);
6708
6709 /*      case WM_WINDOWPOSCHANGED: */
6710 /*      case WM_WININICHANGE: */
6711
6712   default:
6713     if (uMsg >= WM_USER)
6714     {
6715       ERR(listview, "unknown msg %04x wp=%08x lp=%08lx\n", uMsg, wParam,
6716           lParam);
6717     }
6718
6719     /* call default window procedure */
6720     return DefWindowProcA(hwnd, uMsg, wParam, lParam);
6721   }
6722
6723   return 0;
6724 }
6725
6726 /***
6727  * DESCRIPTION:
6728  * Registers the window class.
6729  *
6730  * PARAMETER(S):
6731  * None
6732  *
6733  * RETURN:
6734  * None
6735  */
6736 VOID LISTVIEW_Register(VOID)
6737 {
6738   WNDCLASSA wndClass;
6739
6740   if (!GlobalFindAtomA(WC_LISTVIEWA))
6741   {
6742     ZeroMemory(&wndClass, sizeof(WNDCLASSA));
6743     wndClass.style = CS_GLOBALCLASS | CS_DBLCLKS;
6744     wndClass.lpfnWndProc = (WNDPROC)LISTVIEW_WindowProc;
6745     wndClass.cbClsExtra = 0;
6746     wndClass.cbWndExtra = sizeof(LISTVIEW_INFO *);
6747     wndClass.hCursor = LoadCursorA(0, IDC_ARROWA);
6748     wndClass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
6749     wndClass.lpszClassName = WC_LISTVIEWA;
6750     RegisterClassA(&wndClass);
6751   }
6752 }
6753
6754 /***
6755  * DESCRIPTION:
6756  * Unregisters the window class.
6757  *
6758  * PARAMETER(S):
6759  * None
6760  *
6761  * RETURN:
6762  * None
6763  */
6764 VOID LISTVIEW_Unregister(VOID)
6765 {
6766   if (GlobalFindAtomA(WC_LISTVIEWA))
6767   {
6768     UnregisterClassA(WC_LISTVIEWA, (HINSTANCE)NULL);
6769   }
6770 }
6771