git.oblomov.eu Git - wine/blob - dlls/comctl32/listview.c

   1 /*
   2  * Listview control
   3  *
   4  * Copyright 1998, 1999 Eric Kohl
   5  * Copyright 1999 Luc Tourangeau
   6  * Copyright 2000 Jason Mawdsley
   7  * Copyright 2001 CodeWeavers Inc.
   8  * Copyright 2002 Dimitrie O. Paun
   9  * Copyright 2009-2013 Nikolay Sivov
  10  * Copyright 2009 Owen Rudge for CodeWeavers
  11  *
  12  * This library is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU Lesser General Public
  14  * License as published by the Free Software Foundation; either
  15  * version 2.1 of the License, or (at your option) any later version.
  16  *
  17  * This library is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20  * Lesser General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU Lesser General Public
  23  * License along with this library; if not, write to the Free Software
  24  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  25  *
  26  * NOTES
  27  *
  28  * This code was audited for completeness against the documented features
  29  * of Comctl32.dll version 6.0 on May. 20, 2005, by James Hawkins.
  30  *
  31  * Unless otherwise noted, we believe this code to be complete, as per
  32  * the specification mentioned above.
  33  * If you discover missing features, or bugs, please note them below.
  34  *
  35  * TODO:
  36  *
  37  * Default Message Processing
  38  *   -- WM_CREATE: create the icon and small icon image lists at this point only if
  39  *      the LVS_SHAREIMAGELISTS style is not specified.
  40  *   -- WM_WINDOWPOSCHANGED: arrange the list items if the current view is icon
  41  *      or small icon and the LVS_AUTOARRANGE style is specified.
  42  *   -- WM_TIMER
  43  *   -- WM_WININICHANGE
  44  *
  45  * Features
  46  *   -- Hot item handling, mouse hovering
  47  *   -- Workareas support
  48  *   -- Tilemode support
  49  *   -- Groups support
  50  *
  51  * Bugs
  52  *   -- Expand large item in ICON mode when the cursor is flying over the icon or text.
  53  *   -- Support CustomDraw options for _WIN32_IE >= 0x560 (see NMLVCUSTOMDRAW docs).
  54  *   -- LVA_SNAPTOGRID not implemented
  55  *   -- LISTVIEW_ApproximateViewRect partially implemented
  56  *   -- LISTVIEW_SetColumnWidth ignores header images & bitmap
  57  *   -- LISTVIEW_SetIconSpacing is incomplete
  58  *   -- LISTVIEW_StyleChanged doesn't handle some changes too well
  59  *
  60  * Speedups
  61  *   -- LISTVIEW_GetNextItem needs to be rewritten. It is currently
  62  *      linear in the number of items in the list, and this is
  63  *      unacceptable for large lists.
  64  *   -- if list is sorted by item text LISTVIEW_InsertItemT could use
  65  *      binary search to calculate item index (e.g. DPA_Search()).
  66  *      This requires sorted state to be reliably tracked in item modifiers.
  67  *   -- we should keep an ordered array of coordinates in iconic mode
  68  *      this would allow to frame items (iterator_frameditems),
  69  *      and find nearest item (LVFI_NEARESTXY) a lot more efficiently
  70  *
  71  * Flags
  72  *   -- LVIF_COLUMNS
  73  *   -- LVIF_GROUPID
  74  *
  75  * States
  76  *   -- LVIS_ACTIVATING (not currently supported by comctl32.dll version 6.0)
  77  *   -- LVIS_DROPHILITED
  78  *   -- LVIS_OVERLAYMASK
  79  *
  80  * Styles
  81  *   -- LVS_NOLABELWRAP
  82  *   -- LVS_NOSCROLL (see Q137520)
  83  *   -- LVS_ALIGNTOP
  84  *
  85  * Extended Styles
  86  *   -- LVS_EX_BORDERSELECT
  87  *   -- LVS_EX_FLATSB
  88  *   -- LVS_EX_INFOTIP
  89  *   -- LVS_EX_LABELTIP
  90  *   -- LVS_EX_MULTIWORKAREAS
  91  *   -- LVS_EX_REGIONAL
  92  *   -- LVS_EX_SIMPLESELECT
  93  *   -- LVS_EX_TWOCLICKACTIVATE
  94  *   -- LVS_EX_UNDERLINECOLD
  95  *   -- LVS_EX_UNDERLINEHOT
  96  *
  97  * Notifications:
  98  *   -- LVN_BEGINSCROLL, LVN_ENDSCROLL
  99  *   -- LVN_GETINFOTIP
 100  *   -- LVN_HOTTRACK
 101  *   -- LVN_SETDISPINFO
 102  *   -- LVN_BEGINRDRAG
 103  *
 104  * Messages:
 105  *   -- LVM_ENABLEGROUPVIEW
 106  *   -- LVM_GETBKIMAGE, LVM_SETBKIMAGE
 107  *   -- LVM_GETGROUPINFO, LVM_SETGROUPINFO
 108  *   -- LVM_GETGROUPMETRICS, LVM_SETGROUPMETRICS
 109  *   -- LVM_GETINSERTMARK, LVM_SETINSERTMARK
 110  *   -- LVM_GETINSERTMARKCOLOR, LVM_SETINSERTMARKCOLOR
 111  *   -- LVM_GETINSERTMARKRECT
 112  *   -- LVM_GETNUMBEROFWORKAREAS
 113  *   -- LVM_GETOUTLINECOLOR, LVM_SETOUTLINECOLOR
 114  *   -- LVM_GETSELECTEDCOLUMN, LVM_SETSELECTEDCOLUMN
 115  *   -- LVM_GETISEARCHSTRINGW, LVM_GETISEARCHSTRINGA
 116  *   -- LVM_GETTILEINFO, LVM_SETTILEINFO
 117  *   -- LVM_GETTILEVIEWINFO, LVM_SETTILEVIEWINFO
 118  *   -- LVM_GETWORKAREAS, LVM_SETWORKAREAS
 119  *   -- LVM_HASGROUP, LVM_INSERTGROUP, LVM_REMOVEGROUP, LVM_REMOVEALLGROUPS
 120  *   -- LVM_INSERTGROUPSORTED
 121  *   -- LVM_INSERTMARKHITTEST
 122  *   -- LVM_ISGROUPVIEWENABLED
 123  *   -- LVM_MOVEGROUP
 124  *   -- LVM_MOVEITEMTOGROUP
 125  *   -- LVM_SETINFOTIP
 126  *   -- LVM_SETTILEWIDTH
 127  *   -- LVM_SORTGROUPS
 128  *
 129  * Macros:
 130  *   -- ListView_GetHoverTime, ListView_SetHoverTime
 131  *   -- ListView_GetISearchString
 132  *   -- ListView_GetNumberOfWorkAreas
 133  *   -- ListView_GetWorkAreas, ListView_SetWorkAreas
 134  *
 135  * Functions:
 136  *   -- LVGroupComparE
 137  *
 138  * Known differences in message stream from native control (not known if
 139  * these differences cause problems):
 140  *   LVM_INSERTITEM issues LVM_SETITEMSTATE and LVM_SETITEM in certain cases.
 141  *   LVM_SETITEM does not always issue LVN_ITEMCHANGING/LVN_ITEMCHANGED.
 142  *   WM_CREATE does not issue WM_QUERYUISTATE and associated registry
 143  *     processing for "USEDOUBLECLICKTIME".
 144  */
 145
 146 #include "config.h"
 147 #include "wine/port.h"
 148
 149 #include <assert.h>
 150 #include <ctype.h>
 151 #include <string.h>
 152 #include <stdlib.h>
 153 #include <stdarg.h>
 154 #include <stdio.h>
 155
 156 #include "windef.h"
 157 #include "winbase.h"
 158 #include "winnt.h"
 159 #include "wingdi.h"
 160 #include "winuser.h"
 161 #include "winnls.h"
 162 #include "commctrl.h"
 163 #include "comctl32.h"
 164 #include "uxtheme.h"
 165
 166 #include "wine/debug.h"
 167 #include "wine/unicode.h"
 168
 169 WINE_DEFAULT_DEBUG_CHANNEL(listview);
 170
 171 typedef struct tagCOLUMN_INFO
 172 {
 173   RECT rcHeader;        /* tracks the header's rectangle */
 174   INT fmt;              /* same as LVCOLUMN.fmt */
 175   INT cxMin;
 176 } COLUMN_INFO;
 177
 178 typedef struct tagITEMHDR
 179 {
 180   LPWSTR pszText;
 181   INT iImage;
 182 } ITEMHDR, *LPITEMHDR;
 183
 184 typedef struct tagSUBITEM_INFO
 185 {
 186   ITEMHDR hdr;
 187   INT iSubItem;
 188 } SUBITEM_INFO;
 189
 190 typedef struct tagITEM_ID ITEM_ID;
 191
 192 typedef struct tagITEM_INFO
 193 {
 194   ITEMHDR hdr;
 195   UINT state;
 196   LPARAM lParam;
 197   INT iIndent;
 198   ITEM_ID *id;
 199 } ITEM_INFO;
 200
 201 struct tagITEM_ID
 202 {
 203   UINT id;   /* item id */
 204   HDPA item; /* link to item data */
 205 };
 206
 207 typedef struct tagRANGE
 208 {
 209   INT lower;
 210   INT upper;
 211 } RANGE;
 212
 213 typedef struct tagRANGES
 214 {
 215   HDPA hdpa;
 216 } *RANGES;
 217
 218 typedef struct tagITERATOR
 219 {
 220   INT nItem;
 221   INT nSpecial;
 222   RANGE range;
 223   RANGES ranges;
 224   INT index;
 225 } ITERATOR;
 226
 227 typedef struct tagDELAYED_ITEM_EDIT
 228 {
 229   BOOL fEnabled;
 230   INT iItem;
 231 } DELAYED_ITEM_EDIT;
 232
 233 typedef struct tagLISTVIEW_INFO
 234 {
 235   /* control window */
 236   HWND hwndSelf;
 237   RECT rcList;                 /* This rectangle is really the window
 238                                 * client rectangle possibly reduced by the
 239                                 * horizontal scroll bar and/or header - see
 240                                 * LISTVIEW_UpdateSize. This rectangle offset
 241                                 * by the LISTVIEW_GetOrigin value is in
 242                                 * client coordinates   */
 243
 244   /* notification window */
 245   SHORT notifyFormat;
 246   HWND hwndNotify;
 247   BOOL bDoChangeNotify;         /* send change notification messages? */
 248   UINT uCallbackMask;
 249
 250   /* tooltips */
 251   HWND hwndToolTip;
 252
 253   /* items */
 254   INT nItemCount;               /* the number of items in the list */
 255   HDPA hdpaItems;               /* array ITEM_INFO pointers */
 256   HDPA hdpaItemIds;             /* array of ITEM_ID pointers */
 257   HDPA hdpaPosX;                /* maintains the (X, Y) coordinates of the */
 258   HDPA hdpaPosY;                /* items in LVS_ICON, and LVS_SMALLICON modes */
 259   RANGES selectionRanges;
 260   INT nSelectionMark;           /* item to start next multiselection from */
 261   INT nHotItem;
 262   BOOL bAutoarrange;            /* Autoarrange flag when NOT in LVS_AUTOARRANGE */
 263
 264   /* columns */
 265   HDPA hdpaColumns;             /* array of COLUMN_INFO pointers */
 266   BOOL colRectsDirty;           /* trigger column rectangles requery from header */
 267
 268   /* item metrics */
 269   BOOL bNoItemMetrics;          /* flags if item metrics are not yet computed */
 270   INT nItemHeight;
 271   INT nItemWidth;
 272
 273   /* sorting */
 274   PFNLVCOMPARE pfnCompare;      /* sorting callback pointer */
 275   LPARAM lParamSort;
 276
 277   /* style */
 278   DWORD dwStyle;                /* the cached window GWL_STYLE */
 279   DWORD dwLvExStyle;            /* extended listview style */
 280   DWORD uView;                  /* current view available through LVM_[G,S]ETVIEW */
 281
 282   /* edit item */
 283   HWND hwndEdit;
 284   WNDPROC EditWndProc;
 285   INT nEditLabelItem;
 286   DELAYED_ITEM_EDIT itemEdit;   /* Pointer to this structure will be the timer ID */
 287
 288   /* icons */
 289   HIMAGELIST himlNormal;
 290   HIMAGELIST himlSmall;
 291   HIMAGELIST himlState;
 292   SIZE iconSize;
 293   SIZE iconSpacing;
 294   SIZE iconStateSize;
 295   POINT currIconPos;        /* this is the position next icon will be placed */
 296
 297   /* header */
 298   HWND hwndHeader;
 299   INT xTrackLine;           /* The x coefficient of the track line or -1 if none */
 300
 301   /* marquee selection */
 302   BOOL bMarqueeSelect;      /* marquee selection/highlight underway */
 303   BOOL bScrolling;
 304   RECT marqueeRect;         /* absolute coordinates of marquee selection */
 305   RECT marqueeDrawRect;     /* relative coordinates for drawing marquee */
 306   POINT marqueeOrigin;      /* absolute coordinates of marquee click origin */
 307
 308   /* focus drawing */
 309   BOOL bFocus;              /* control has focus */
 310   INT nFocusedItem;
 311   RECT rcFocus;             /* focus bounds */
 312
 313   /* colors */
 314   HBRUSH hBkBrush;
 315   COLORREF clrBk;
 316   COLORREF clrText;
 317   COLORREF clrTextBk;
 318
 319   /* font */
 320   HFONT hDefaultFont;
 321   HFONT hFont;
 322   INT ntmHeight;            /* Some cached metrics of the font used */
 323   INT ntmMaxCharWidth;      /* by the listview to draw items */
 324   INT nEllipsisWidth;
 325
 326   /* mouse operation */
 327   BOOL bLButtonDown;
 328   BOOL bRButtonDown;
 329   BOOL bDragging;
 330   POINT ptClickPos;         /* point where the user clicked */
 331   INT nLButtonDownItem;     /* tracks item to reset multiselection on WM_LBUTTONUP */
 332   DWORD dwHoverTime;
 333   HCURSOR hHotCursor;
 334
 335   /* keyboard operation */
 336   DWORD lastKeyPressTimestamp;
 337   WPARAM charCode;
 338   INT nSearchParamLength;
 339   WCHAR szSearchParam[ MAX_PATH ];
 340
 341   /* painting */
 342   DWORD cditemmode;        /* Keep the custom draw flags for an item/row */
 343   BOOL bIsDrawing;         /* Drawing in progress */
 344   INT nMeasureItemHeight;  /* WM_MEASUREITEM result */
 345   BOOL bRedraw;            /* WM_SETREDRAW switch */
 346
 347   /* misc */
 348   DWORD iVersion;          /* CCM_[G,S]ETVERSION */
 349 } LISTVIEW_INFO;
 350
 351 /*
 352  * constants
 353  */
 354 /* How many we debug buffer to allocate */
 355 #define DEBUG_BUFFERS 20
 356 /* The size of a single debug buffer */
 357 #define DEBUG_BUFFER_SIZE 256
 358
 359 /* Internal interface to LISTVIEW_HScroll and LISTVIEW_VScroll */
 360 #define SB_INTERNAL      -1
 361
 362 /* maximum size of a label */
 363 #define DISP_TEXT_SIZE 260
 364
 365 /* padding for items in list and small icon display modes */
 366 #define WIDTH_PADDING 12
 367
 368 /* padding for items in list, report and small icon display modes */
 369 #define HEIGHT_PADDING 1
 370
 371 /* offset of items in report display mode */
 372 #define REPORT_MARGINX 2
 373
 374 /* padding for icon in large icon display mode
 375  *   ICON_TOP_PADDING_NOTHITABLE - space between top of box and area
 376  *                                 that HITTEST will see.
 377  *   ICON_TOP_PADDING_HITABLE - spacing between above and icon.
 378  *   ICON_TOP_PADDING - sum of the two above.
 379  *   ICON_BOTTOM_PADDING - between bottom of icon and top of text
 380  *   LABEL_HOR_PADDING - between text and sides of box
 381  *   LABEL_VERT_PADDING - between bottom of text and end of box
 382  *
 383  *   ICON_LR_PADDING - additional width above icon size.
 384  *   ICON_LR_HALF - half of the above value
 385  */
 386 #define ICON_TOP_PADDING_NOTHITABLE  2
 387 #define ICON_TOP_PADDING_HITABLE     2
 388 #define ICON_TOP_PADDING (ICON_TOP_PADDING_NOTHITABLE + ICON_TOP_PADDING_HITABLE)
 389 #define ICON_BOTTOM_PADDING          4
 390 #define LABEL_HOR_PADDING            5
 391 #define LABEL_VERT_PADDING           7
 392 #define ICON_LR_PADDING              16
 393 #define ICON_LR_HALF                 (ICON_LR_PADDING/2)
 394
 395 /* default label width for items in list and small icon display modes */
 396 #define DEFAULT_LABEL_WIDTH 40
 397 /* maximum select rectangle width for empty text item in LV_VIEW_DETAILS */
 398 #define MAX_EMPTYTEXT_SELECT_WIDTH 80
 399
 400 /* default column width for items in list display mode */
 401 #define DEFAULT_COLUMN_WIDTH 128
 402
 403 /* Size of "line" scroll for V & H scrolls */
 404 #define LISTVIEW_SCROLL_ICON_LINE_SIZE 37
 405
 406 /* Padding between image and label */
 407 #define IMAGE_PADDING  2
 408
 409 /* Padding behind the label */
 410 #define TRAILING_LABEL_PADDING  12
 411 #define TRAILING_HEADER_PADDING  11
 412
 413 /* Border for the icon caption */
 414 #define CAPTION_BORDER  2
 415
 416 /* Standard DrawText flags */
 417 #define LV_ML_DT_FLAGS  (DT_TOP | DT_NOPREFIX | DT_EDITCONTROL | DT_CENTER | DT_WORDBREAK | DT_WORD_ELLIPSIS | DT_END_ELLIPSIS)
 418 #define LV_FL_DT_FLAGS  (DT_TOP | DT_NOPREFIX | DT_EDITCONTROL | DT_CENTER | DT_WORDBREAK | DT_NOCLIP)
 419 #define LV_SL_DT_FLAGS  (DT_VCENTER | DT_NOPREFIX | DT_EDITCONTROL | DT_SINGLELINE | DT_WORD_ELLIPSIS | DT_END_ELLIPSIS)
 420
 421 /* Image index from state */
 422 #define STATEIMAGEINDEX(x) (((x) & LVIS_STATEIMAGEMASK) >> 12)
 423
 424 /* The time in milliseconds to reset the search in the list */
 425 #define KEY_DELAY       450
 426
 427 /* Dump the LISTVIEW_INFO structure to the debug channel */
 428 #define LISTVIEW_DUMP(iP) do { \
 429   TRACE("hwndSelf=%p, clrBk=0x%06x, clrText=0x%06x, clrTextBk=0x%06x, ItemHeight=%d, ItemWidth=%d, Style=0x%08x\n", \
 430         iP->hwndSelf, iP->clrBk, iP->clrText, iP->clrTextBk, \
 431         iP->nItemHeight, iP->nItemWidth, iP->dwStyle); \
 432   TRACE("hwndSelf=%p, himlNor=%p, himlSml=%p, himlState=%p, Focused=%d, Hot=%d, exStyle=0x%08x, Focus=%d\n", \
 433         iP->hwndSelf, iP->himlNormal, iP->himlSmall, iP->himlState, \
 434         iP->nFocusedItem, iP->nHotItem, iP->dwLvExStyle, iP->bFocus ); \
 435   TRACE("hwndSelf=%p, ntmH=%d, icSz.cx=%d, icSz.cy=%d, icSp.cx=%d, icSp.cy=%d, notifyFmt=%d\n", \
 436         iP->hwndSelf, iP->ntmHeight, iP->iconSize.cx, iP->iconSize.cy, \
 437         iP->iconSpacing.cx, iP->iconSpacing.cy, iP->notifyFormat); \
 438   TRACE("hwndSelf=%p, rcList=%s\n", iP->hwndSelf, wine_dbgstr_rect(&iP->rcList)); \
 439 } while(0)
 440
 441 static const WCHAR themeClass[] = {'L','i','s','t','V','i','e','w',0};
 442
 443 /*
 444  * forward declarations
 445  */
 446 static BOOL LISTVIEW_GetItemT(const LISTVIEW_INFO *, LPLVITEMW, BOOL);
 447 static void LISTVIEW_GetItemBox(const LISTVIEW_INFO *, INT, LPRECT);
 448 static void LISTVIEW_GetItemOrigin(const LISTVIEW_INFO *, INT, LPPOINT);
 449 static BOOL LISTVIEW_GetItemPosition(const LISTVIEW_INFO *, INT, LPPOINT);
 450 static BOOL LISTVIEW_GetItemRect(const LISTVIEW_INFO *, INT, LPRECT);
 451 static void LISTVIEW_GetOrigin(const LISTVIEW_INFO *, LPPOINT);
 452 static BOOL LISTVIEW_GetViewRect(const LISTVIEW_INFO *, LPRECT);
 453 static void LISTVIEW_UpdateSize(LISTVIEW_INFO *);
 454 static LRESULT LISTVIEW_Command(LISTVIEW_INFO *, WPARAM, LPARAM);
 455 static INT LISTVIEW_GetStringWidthT(const LISTVIEW_INFO *, LPCWSTR, BOOL);
 456 static BOOL LISTVIEW_KeySelection(LISTVIEW_INFO *, INT, BOOL);
 457 static UINT LISTVIEW_GetItemState(const LISTVIEW_INFO *, INT, UINT);
 458 static BOOL LISTVIEW_SetItemState(LISTVIEW_INFO *, INT, const LVITEMW *);
 459 static LRESULT LISTVIEW_VScroll(LISTVIEW_INFO *, INT, INT);
 460 static LRESULT LISTVIEW_HScroll(LISTVIEW_INFO *, INT, INT);
 461 static BOOL LISTVIEW_EnsureVisible(LISTVIEW_INFO *, INT, BOOL);
 462 static HIMAGELIST LISTVIEW_SetImageList(LISTVIEW_INFO *, INT, HIMAGELIST);
 463 static INT LISTVIEW_HitTest(const LISTVIEW_INFO *, LPLVHITTESTINFO, BOOL, BOOL);
 464 static BOOL LISTVIEW_EndEditLabelT(LISTVIEW_INFO *, BOOL, BOOL);
 465 static BOOL LISTVIEW_Scroll(LISTVIEW_INFO *, INT, INT);
 466
 467 /******** Text handling functions *************************************/
 468
 469 /* A text pointer is either NULL, LPSTR_TEXTCALLBACK, or points to a
 470  * text string. The string may be ANSI or Unicode, in which case
 471  * the boolean isW tells us the type of the string.
 472  *
 473  * The name of the function tell what type of strings it expects:
 474  *   W: Unicode, T: ANSI/Unicode - function of isW
 475  */
 476
 477 static inline BOOL is_text(LPCWSTR text)
 478 {
 479     return text != NULL && text != LPSTR_TEXTCALLBACKW;
 480 }
 481
 482 static inline int textlenT(LPCWSTR text, BOOL isW)
 483 {
 484     return !is_text(text) ? 0 :
 485            isW ? lstrlenW(text) : lstrlenA((LPCSTR)text);
 486 }
 487
 488 static inline void textcpynT(LPWSTR dest, BOOL isDestW, LPCWSTR src, BOOL isSrcW, INT max)
 489 {
 490     if (isDestW)
 491         if (isSrcW) lstrcpynW(dest, src, max);
 492         else MultiByteToWideChar(CP_ACP, 0, (LPCSTR)src, -1, dest, max);
 493     else
 494         if (isSrcW) WideCharToMultiByte(CP_ACP, 0, src, -1, (LPSTR)dest, max, NULL, NULL);
 495         else lstrcpynA((LPSTR)dest, (LPCSTR)src, max);
 496 }
 497
 498 static inline LPWSTR textdupTtoW(LPCWSTR text, BOOL isW)
 499 {
 500     LPWSTR wstr = (LPWSTR)text;
 501
 502     if (!isW && is_text(text))
 503     {
 504         INT len = MultiByteToWideChar(CP_ACP, 0, (LPCSTR)text, -1, NULL, 0);
 505         wstr = Alloc(len * sizeof(WCHAR));
 506         if (wstr) MultiByteToWideChar(CP_ACP, 0, (LPCSTR)text, -1, wstr, len);
 507     }
 508     TRACE("   wstr=%s\n", text == LPSTR_TEXTCALLBACKW ?  "(callback)" : debugstr_w(wstr));
 509     return wstr;
 510 }
 511
 512 static inline void textfreeT(LPWSTR wstr, BOOL isW)
 513 {
 514     if (!isW && is_text(wstr)) Free (wstr);
 515 }
 516
 517 /*
 518  * dest is a pointer to a Unicode string
 519  * src is a pointer to a string (Unicode if isW, ANSI if !isW)
 520  */
 521 static BOOL textsetptrT(LPWSTR *dest, LPCWSTR src, BOOL isW)
 522 {
 523     BOOL bResult = TRUE;
 524
 525     if (src == LPSTR_TEXTCALLBACKW)
 526     {
 527         if (is_text(*dest)) Free(*dest);
 528         *dest = LPSTR_TEXTCALLBACKW;
 529     }
 530     else
 531     {
 532         LPWSTR pszText = textdupTtoW(src, isW);
 533         if (*dest == LPSTR_TEXTCALLBACKW) *dest = NULL;
 534         bResult = Str_SetPtrW(dest, pszText);
 535         textfreeT(pszText, isW);
 536     }
 537     return bResult;
 538 }
 539
 540 /*
 541  * compares a Unicode to a Unicode/ANSI text string
 542  */
 543 static inline int textcmpWT(LPCWSTR aw, LPCWSTR bt, BOOL isW)
 544 {
 545     if (!aw) return bt ? -1 : 0;
 546     if (!bt) return 1;
 547     if (aw == LPSTR_TEXTCALLBACKW)
 548         return bt == LPSTR_TEXTCALLBACKW ? 1 : -1;
 549     if (bt != LPSTR_TEXTCALLBACKW)
 550     {
 551         LPWSTR bw = textdupTtoW(bt, isW);
 552         int r = bw ? lstrcmpW(aw, bw) : 1;
 553         textfreeT(bw, isW);
 554         return r;
 555     }
 556
 557     return 1;
 558 }
 559
 560 static inline int lstrncmpiW(LPCWSTR s1, LPCWSTR s2, int n)
 561 {
 562     n = min(min(n, lstrlenW(s1)), lstrlenW(s2));
 563     return CompareStringW(LOCALE_USER_DEFAULT, NORM_IGNORECASE, s1, n, s2, n) - CSTR_EQUAL;
 564 }
 565
 566 /******** Debugging functions *****************************************/
 567
 568 static inline LPCSTR debugtext_t(LPCWSTR text, BOOL isW)
 569 {
 570     if (text == LPSTR_TEXTCALLBACKW) return "(callback)";
 571     return isW ? debugstr_w(text) : debugstr_a((LPCSTR)text);
 572 }
 573
 574 static inline LPCSTR debugtext_tn(LPCWSTR text, BOOL isW, INT n)
 575 {
 576     if (text == LPSTR_TEXTCALLBACKW) return "(callback)";
 577     n = min(textlenT(text, isW), n);
 578     return isW ? debugstr_wn(text, n) : debugstr_an((LPCSTR)text, n);
 579 }
 580
 581 static char* debug_getbuf(void)
 582 {
 583     static int index = 0;
 584     static char buffers[DEBUG_BUFFERS][DEBUG_BUFFER_SIZE];
 585     return buffers[index++ % DEBUG_BUFFERS];
 586 }
 587
 588 static inline const char* debugrange(const RANGE *lprng)
 589 {
 590     if (!lprng) return "(null)";
 591     return wine_dbg_sprintf("[%d, %d]", lprng->lower, lprng->upper);
 592 }
 593
 594 static const char* debugscrollinfo(const SCROLLINFO *pScrollInfo)
 595 {
 596     char* buf = debug_getbuf(), *text = buf;
 597     int len, size = DEBUG_BUFFER_SIZE;
 598
 599     if (pScrollInfo == NULL) return "(null)";
 600     len = snprintf(buf, size, "{cbSize=%d, ", pScrollInfo->cbSize);
 601     if (len == -1) goto end; buf += len; size -= len;
 602     if (pScrollInfo->fMask & SIF_RANGE)
 603         len = snprintf(buf, size, "nMin=%d, nMax=%d, ", pScrollInfo->nMin, pScrollInfo->nMax);
 604     else len = 0;
 605     if (len == -1) goto end; buf += len; size -= len;
 606     if (pScrollInfo->fMask & SIF_PAGE)
 607         len = snprintf(buf, size, "nPage=%u, ", pScrollInfo->nPage);
 608     else len = 0;
 609     if (len == -1) goto end; buf += len; size -= len;
 610     if (pScrollInfo->fMask & SIF_POS)
 611         len = snprintf(buf, size, "nPos=%d, ", pScrollInfo->nPos);
 612     else len = 0;
 613     if (len == -1) goto end; buf += len; size -= len;
 614     if (pScrollInfo->fMask & SIF_TRACKPOS)
 615         len = snprintf(buf, size, "nTrackPos=%d, ", pScrollInfo->nTrackPos);
 616     else len = 0;
 617     if (len == -1) goto end; buf += len;
 618     goto undo;
 619 end:
 620     buf = text + strlen(text);
 621 undo:
 622     if (buf - text > 2) { buf[-2] = '}'; buf[-1] = 0; }
 623     return text;
 624 }
 625
 626 static const char* debugnmlistview(const NMLISTVIEW *plvnm)
 627 {
 628     if (!plvnm) return "(null)";
 629     return wine_dbg_sprintf("iItem=%d, iSubItem=%d, uNewState=0x%x,"
 630                  " uOldState=0x%x, uChanged=0x%x, ptAction=%s, lParam=%ld",
 631                  plvnm->iItem, plvnm->iSubItem, plvnm->uNewState, plvnm->uOldState,
 632                  plvnm->uChanged, wine_dbgstr_point(&plvnm->ptAction), plvnm->lParam);
 633 }
 634
 635 static const char* debuglvitem_t(const LVITEMW *lpLVItem, BOOL isW)
 636 {
 637     char* buf = debug_getbuf(), *text = buf;
 638     int len, size = DEBUG_BUFFER_SIZE;
 639
 640     if (lpLVItem == NULL) return "(null)";
 641     len = snprintf(buf, size, "{iItem=%d, iSubItem=%d, ", lpLVItem->iItem, lpLVItem->iSubItem);
 642     if (len == -1) goto end; buf += len; size -= len;
 643     if (lpLVItem->mask & LVIF_STATE)
 644         len = snprintf(buf, size, "state=%x, stateMask=%x, ", lpLVItem->state, lpLVItem->stateMask);
 645     else len = 0;
 646     if (len == -1) goto end; buf += len; size -= len;
 647     if (lpLVItem->mask & LVIF_TEXT)
 648         len = snprintf(buf, size, "pszText=%s, cchTextMax=%d, ", debugtext_tn(lpLVItem->pszText, isW, 80), lpLVItem->cchTextMax);
 649     else len = 0;
 650     if (len == -1) goto end; buf += len; size -= len;
 651     if (lpLVItem->mask & LVIF_IMAGE)
 652         len = snprintf(buf, size, "iImage=%d, ", lpLVItem->iImage);
 653     else len = 0;
 654     if (len == -1) goto end; buf += len; size -= len;
 655     if (lpLVItem->mask & LVIF_PARAM)
 656         len = snprintf(buf, size, "lParam=%lx, ", lpLVItem->lParam);
 657     else len = 0;
 658     if (len == -1) goto end; buf += len; size -= len;
 659     if (lpLVItem->mask & LVIF_INDENT)
 660         len = snprintf(buf, size, "iIndent=%d, ", lpLVItem->iIndent);
 661     else len = 0;
 662     if (len == -1) goto end; buf += len;
 663     goto undo;
 664 end:
 665     buf = text + strlen(text);
 666 undo:
 667     if (buf - text > 2) { buf[-2] = '}'; buf[-1] = 0; }
 668     return text;
 669 }
 670
 671 static const char* debuglvcolumn_t(const LVCOLUMNW *lpColumn, BOOL isW)
 672 {
 673     char* buf = debug_getbuf(), *text = buf;
 674     int len, size = DEBUG_BUFFER_SIZE;
 675
 676     if (lpColumn == NULL) return "(null)";
 677     len = snprintf(buf, size, "{");
 678     if (len == -1) goto end; buf += len; size -= len;
 679     if (lpColumn->mask & LVCF_SUBITEM)
 680         len = snprintf(buf, size, "iSubItem=%d, ",  lpColumn->iSubItem);
 681     else len = 0;
 682     if (len == -1) goto end; buf += len; size -= len;
 683     if (lpColumn->mask & LVCF_FMT)
 684         len = snprintf(buf, size, "fmt=%x, ", lpColumn->fmt);
 685     else len = 0;
 686     if (len == -1) goto end; buf += len; size -= len;
 687     if (lpColumn->mask & LVCF_WIDTH)
 688         len = snprintf(buf, size, "cx=%d, ", lpColumn->cx);
 689     else len = 0;
 690     if (len == -1) goto end; buf += len; size -= len;
 691     if (lpColumn->mask & LVCF_TEXT)
 692         len = snprintf(buf, size, "pszText=%s, cchTextMax=%d, ", debugtext_tn(lpColumn->pszText, isW, 80), lpColumn->cchTextMax);
 693     else len = 0;
 694     if (len == -1) goto end; buf += len; size -= len;
 695     if (lpColumn->mask & LVCF_IMAGE)
 696         len = snprintf(buf, size, "iImage=%d, ", lpColumn->iImage);
 697     else len = 0;
 698     if (len == -1) goto end; buf += len; size -= len;
 699     if (lpColumn->mask & LVCF_ORDER)
 700         len = snprintf(buf, size, "iOrder=%d, ", lpColumn->iOrder);
 701     else len = 0;
 702     if (len == -1) goto end; buf += len;
 703     goto undo;
 704 end:
 705     buf = text + strlen(text);
 706 undo:
 707     if (buf - text > 2) { buf[-2] = '}'; buf[-1] = 0; }
 708     return text;
 709 }
 710
 711 static const char* debuglvhittestinfo(const LVHITTESTINFO *lpht)
 712 {
 713     if (!lpht) return "(null)";
 714
 715     return wine_dbg_sprintf("{pt=%s, flags=0x%x, iItem=%d, iSubItem=%d}",
 716                  wine_dbgstr_point(&lpht->pt), lpht->flags, lpht->iItem, lpht->iSubItem);
 717 }
 718
 719 /* Return the corresponding text for a given scroll value */
 720 static inline LPCSTR debugscrollcode(int nScrollCode)
 721 {
 722   switch(nScrollCode)
 723   {
 724   case SB_LINELEFT: return "SB_LINELEFT";
 725   case SB_LINERIGHT: return "SB_LINERIGHT";
 726   case SB_PAGELEFT: return "SB_PAGELEFT";
 727   case SB_PAGERIGHT: return "SB_PAGERIGHT";
 728   case SB_THUMBPOSITION: return "SB_THUMBPOSITION";
 729   case SB_THUMBTRACK: return "SB_THUMBTRACK";
 730   case SB_ENDSCROLL: return "SB_ENDSCROLL";
 731   case SB_INTERNAL: return "SB_INTERNAL";
 732   default: return "unknown";
 733   }
 734 }
 735
 736
 737 /******** Notification functions ************************************/
 738
 739 static int get_ansi_notification(UINT unicodeNotificationCode)
 740 {
 741     switch (unicodeNotificationCode)
 742     {
 743     case LVN_BEGINLABELEDITA:
 744     case LVN_BEGINLABELEDITW: return LVN_BEGINLABELEDITA;
 745     case LVN_ENDLABELEDITA:
 746     case LVN_ENDLABELEDITW: return LVN_ENDLABELEDITA;
 747     case LVN_GETDISPINFOA:
 748     case LVN_GETDISPINFOW: return LVN_GETDISPINFOA;
 749     case LVN_SETDISPINFOA:
 750     case LVN_SETDISPINFOW: return LVN_SETDISPINFOA;
 751     case LVN_ODFINDITEMA:
 752     case LVN_ODFINDITEMW: return LVN_ODFINDITEMA;
 753     case LVN_GETINFOTIPA:
 754     case LVN_GETINFOTIPW: return LVN_GETINFOTIPA;
 755     /* header forwards */
 756     case HDN_TRACKA:
 757     case HDN_TRACKW: return HDN_TRACKA;
 758     case HDN_ENDTRACKA:
 759     case HDN_ENDTRACKW: return HDN_ENDTRACKA;
 760     case HDN_BEGINDRAG: return HDN_BEGINDRAG;
 761     case HDN_ENDDRAG: return HDN_ENDDRAG;
 762     case HDN_ITEMCHANGINGA:
 763     case HDN_ITEMCHANGINGW: return HDN_ITEMCHANGINGA;
 764     case HDN_ITEMCHANGEDA:
 765     case HDN_ITEMCHANGEDW: return HDN_ITEMCHANGEDA;
 766     case HDN_ITEMCLICKA:
 767     case HDN_ITEMCLICKW: return HDN_ITEMCLICKA;
 768     case HDN_DIVIDERDBLCLICKA:
 769     case HDN_DIVIDERDBLCLICKW: return HDN_DIVIDERDBLCLICKA;
 770     default: break;
 771     }
 772     FIXME("unknown notification %x\n", unicodeNotificationCode);
 773     return unicodeNotificationCode;
 774 }
 775
 776 /* forwards header notifications to listview parent */
 777 static LRESULT notify_forward_header(const LISTVIEW_INFO *infoPtr, NMHEADERW *lpnmhW)
 778 {
 779     LPCWSTR text = NULL, filter = NULL;
 780     LRESULT ret;
 781     NMHEADERA *lpnmh = (NMHEADERA*) lpnmhW;
 782
 783     /* on unicode format exit earlier */
 784     if (infoPtr->notifyFormat == NFR_UNICODE)
 785         return SendMessageW(infoPtr->hwndNotify, WM_NOTIFY, lpnmh->hdr.idFrom,
 786                             (LPARAM)lpnmh);
 787
 788     /* header always supplies unicode notifications,
 789        all we have to do is to convert strings to ANSI */
 790     if (lpnmh->pitem)
 791     {
 792         /* convert item text */
 793         if (lpnmh->pitem->mask & HDI_TEXT)
 794         {
 795             text = (LPCWSTR)lpnmh->pitem->pszText;
 796             Str_SetPtrWtoA(&lpnmh->pitem->pszText, text);
 797         }
 798         /* convert filter text */
 799         if ((lpnmh->pitem->mask & HDI_FILTER) && (lpnmh->pitem->type == HDFT_ISSTRING) &&
 800              lpnmh->pitem->pvFilter)
 801         {
 802             filter = (LPCWSTR)((HD_TEXTFILTERA*)lpnmh->pitem->pvFilter)->pszText;
 803             Str_SetPtrWtoA(&((HD_TEXTFILTERA*)lpnmh->pitem->pvFilter)->pszText, filter);
 804         }
 805     }
 806     lpnmh->hdr.code = get_ansi_notification(lpnmh->hdr.code);
 807
 808     ret = SendMessageW(infoPtr->hwndNotify, WM_NOTIFY, lpnmh->hdr.idFrom,
 809                        (LPARAM)lpnmh);
 810
 811     /* cleanup */
 812     if(text)
 813     {
 814         Free(lpnmh->pitem->pszText);
 815         lpnmh->pitem->pszText = (LPSTR)text;
 816     }
 817     if(filter)
 818     {
 819         Free(((HD_TEXTFILTERA*)lpnmh->pitem->pvFilter)->pszText);
 820         ((HD_TEXTFILTERA*)lpnmh->pitem->pvFilter)->pszText = (LPSTR)filter;
 821     }
 822
 823     return ret;
 824 }
 825
 826 static LRESULT notify_hdr(const LISTVIEW_INFO *infoPtr, INT code, LPNMHDR pnmh)
 827 {
 828     LRESULT result;
 829
 830     TRACE("(code=%d)\n", code);
 831
 832     pnmh->hwndFrom = infoPtr->hwndSelf;
 833     pnmh->idFrom = GetWindowLongPtrW(infoPtr->hwndSelf, GWLP_ID);
 834     pnmh->code = code;
 835     result = SendMessageW(infoPtr->hwndNotify, WM_NOTIFY, pnmh->idFrom, (LPARAM)pnmh);
 836
 837     TRACE("  <= %ld\n", result);
 838
 839     return result;
 840 }
 841
 842 static inline BOOL notify(const LISTVIEW_INFO *infoPtr, INT code)
 843 {
 844     NMHDR nmh;
 845     HWND hwnd = infoPtr->hwndSelf;
 846     notify_hdr(infoPtr, code, &nmh);
 847     return IsWindow(hwnd);
 848 }
 849
 850 static inline void notify_itemactivate(const LISTVIEW_INFO *infoPtr, const LVHITTESTINFO *htInfo)
 851 {
 852     NMITEMACTIVATE nmia;
 853     LVITEMW item;
 854
 855     if (htInfo) {
 856       nmia.uNewState = 0;
 857       nmia.uOldState = 0;
 858       nmia.uChanged  = 0;
 859       nmia.uKeyFlags = 0;
 860
 861       item.mask = LVIF_PARAM|LVIF_STATE;
 862       item.iItem = htInfo->iItem;
 863       item.iSubItem = 0;
 864       item.stateMask = (UINT)-1;
 865       if (LISTVIEW_GetItemT(infoPtr, &item, TRUE)) {
 866           nmia.lParam = item.lParam;
 867           nmia.uOldState = item.state;
 868           nmia.uNewState = item.state | LVIS_ACTIVATING;
 869           nmia.uChanged  = LVIF_STATE;
 870       }
 871
 872       nmia.iItem = htInfo->iItem;
 873       nmia.iSubItem = htInfo->iSubItem;
 874       nmia.ptAction = htInfo->pt;
 875
 876       if (GetKeyState(VK_SHIFT) & 0x8000) nmia.uKeyFlags |= LVKF_SHIFT;
 877       if (GetKeyState(VK_CONTROL) & 0x8000) nmia.uKeyFlags |= LVKF_CONTROL;
 878       if (GetKeyState(VK_MENU) & 0x8000) nmia.uKeyFlags |= LVKF_ALT;
 879     }
 880     notify_hdr(infoPtr, LVN_ITEMACTIVATE, (LPNMHDR)&nmia);
 881 }
 882
 883 static inline LRESULT notify_listview(const LISTVIEW_INFO *infoPtr, INT code, LPNMLISTVIEW plvnm)
 884 {
 885     TRACE("(code=%d, plvnm=%s)\n", code, debugnmlistview(plvnm));
 886     return notify_hdr(infoPtr, code, (LPNMHDR)plvnm);
 887 }
 888
 889 static BOOL notify_click(const LISTVIEW_INFO *infoPtr, INT code, const LVHITTESTINFO *lvht)
 890 {
 891     NMITEMACTIVATE nmia;
 892     LVITEMW item;
 893     HWND hwnd = infoPtr->hwndSelf;
 894
 895     TRACE("code=%d, lvht=%s\n", code, debuglvhittestinfo(lvht));
 896     ZeroMemory(&nmia, sizeof(nmia));
 897     nmia.iItem = lvht->iItem;
 898     nmia.iSubItem = lvht->iSubItem;
 899     nmia.ptAction = lvht->pt;
 900     item.mask = LVIF_PARAM;
 901     item.iItem = lvht->iItem;
 902     item.iSubItem = 0;
 903     if (LISTVIEW_GetItemT(infoPtr, &item, TRUE)) nmia.lParam = item.lParam;
 904     notify_hdr(infoPtr, code, (LPNMHDR)&nmia);
 905     return IsWindow(hwnd);
 906 }
 907
 908 static BOOL notify_deleteitem(const LISTVIEW_INFO *infoPtr, INT nItem)
 909 {
 910     NMLISTVIEW nmlv;
 911     LVITEMW item;
 912     HWND hwnd = infoPtr->hwndSelf;
 913
 914     ZeroMemory(&nmlv, sizeof (NMLISTVIEW));
 915     nmlv.iItem = nItem;
 916     item.mask = LVIF_PARAM;
 917     item.iItem = nItem;
 918     item.iSubItem = 0;
 919     if (LISTVIEW_GetItemT(infoPtr, &item, TRUE)) nmlv.lParam = item.lParam;
 920     notify_listview(infoPtr, LVN_DELETEITEM, &nmlv);
 921     return IsWindow(hwnd);
 922 }
 923
 924 /*
 925   Send notification. depends on dispinfoW having same
 926   structure as dispinfoA.
 927   infoPtr : listview struct
 928   code : *Unicode* notification code
 929   pdi : dispinfo structure (can be unicode or ansi)
 930   isW : TRUE if dispinfo is Unicode
 931 */
 932 static BOOL notify_dispinfoT(const LISTVIEW_INFO *infoPtr, UINT code, LPNMLVDISPINFOW pdi, BOOL isW)
 933 {
 934     INT length = 0, ret_length;
 935     LPWSTR buffer = NULL, ret_text;
 936     BOOL return_ansi = FALSE;
 937     BOOL return_unicode = FALSE;
 938     BOOL ret;
 939
 940     if ((pdi->item.mask & LVIF_TEXT) && is_text(pdi->item.pszText))
 941     {
 942         return_unicode = ( isW && infoPtr->notifyFormat == NFR_ANSI);
 943         return_ansi    = (!isW && infoPtr->notifyFormat == NFR_UNICODE);
 944     }
 945
 946     ret_length = pdi->item.cchTextMax;
 947     ret_text = pdi->item.pszText;
 948
 949     if (return_unicode || return_ansi)
 950     {
 951         if (code != LVN_GETDISPINFOW)
 952         {
 953             length = return_ansi ?
 954                 MultiByteToWideChar(CP_ACP, 0, (LPCSTR)pdi->item.pszText, -1, NULL, 0):
 955                 WideCharToMultiByte(CP_ACP, 0, pdi->item.pszText, -1, NULL, 0, NULL, NULL);
 956         }
 957         else
 958         {
 959             length = pdi->item.cchTextMax;
 960             *pdi->item.pszText = 0; /* make sure we don't process garbage */
 961         }
 962
 963         buffer = Alloc( (return_ansi ? sizeof(WCHAR) : sizeof(CHAR)) * length);
 964         if (!buffer) return FALSE;
 965
 966         if (return_ansi)
 967             MultiByteToWideChar(CP_ACP, 0, (LPCSTR)pdi->item.pszText, -1,
 968                                 buffer, length);
 969         else
 970             WideCharToMultiByte(CP_ACP, 0, pdi->item.pszText, -1, (LPSTR) buffer,
 971                                 length, NULL, NULL);
 972
 973         pdi->item.pszText = buffer;
 974         pdi->item.cchTextMax = length;
 975     }
 976
 977     if (infoPtr->notifyFormat == NFR_ANSI)
 978         code = get_ansi_notification(code);
 979
 980     TRACE(" pdi->item=%s\n", debuglvitem_t(&pdi->item, infoPtr->notifyFormat != NFR_ANSI));
 981     ret = notify_hdr(infoPtr, code, &pdi->hdr);
 982     TRACE(" resulting code=%d\n", pdi->hdr.code);
 983
 984     if (return_ansi || return_unicode)
 985     {
 986         if (return_ansi && (pdi->hdr.code == LVN_GETDISPINFOA))
 987         {
 988             strcpy((char*)ret_text, (char*)pdi->item.pszText);
 989         }
 990         else if (return_unicode && (pdi->hdr.code == LVN_GETDISPINFOW))
 991         {
 992             strcpyW(ret_text, pdi->item.pszText);
 993         }
 994         else if (return_ansi) /* note : pointer can be changed by app ! */
 995         {
 996             WideCharToMultiByte(CP_ACP, 0, pdi->item.pszText, -1, (LPSTR) ret_text,
 997                 ret_length, NULL, NULL);
 998         }
 999         else
1000             MultiByteToWideChar(CP_ACP, 0, (LPSTR) pdi->item.pszText, -1,
1001                 ret_text, ret_length);
1002
1003         pdi->item.pszText = ret_text; /* restores our buffer */
1004         pdi->item.cchTextMax = ret_length;
1005
1006         Free(buffer);
1007         return ret;
1008     }
1009
1010     /* if dipsinfo holder changed notification code then convert */
1011     if (!isW && (pdi->hdr.code == LVN_GETDISPINFOW) && (pdi->item.mask & LVIF_TEXT))
1012     {
1013         length = WideCharToMultiByte(CP_ACP, 0, pdi->item.pszText, -1, NULL, 0, NULL, NULL);
1014
1015         buffer = Alloc(length * sizeof(CHAR));
1016         if (!buffer) return FALSE;
1017
1018         WideCharToMultiByte(CP_ACP, 0, pdi->item.pszText, -1, (LPSTR) buffer,
1019                 ret_length, NULL, NULL);
1020
1021         strcpy((LPSTR)pdi->item.pszText, (LPSTR)buffer);
1022         Free(buffer);
1023     }
1024
1025     return ret;
1026 }
1027
1028 static void customdraw_fill(NMLVCUSTOMDRAW *lpnmlvcd, const LISTVIEW_INFO *infoPtr, HDC hdc,
1029                             const RECT *rcBounds, const LVITEMW *lplvItem)
1030 {
1031     ZeroMemory(lpnmlvcd, sizeof(NMLVCUSTOMDRAW));
1032     lpnmlvcd->nmcd.hdc = hdc;
1033     lpnmlvcd->nmcd.rc = *rcBounds;
1034     lpnmlvcd->clrTextBk = infoPtr->clrTextBk;
1035     lpnmlvcd->clrText   = infoPtr->clrText;
1036     if (!lplvItem) return;
1037     lpnmlvcd->nmcd.dwItemSpec = lplvItem->iItem + 1;
1038     lpnmlvcd->iSubItem = lplvItem->iSubItem;
1039     if (lplvItem->state & LVIS_SELECTED) lpnmlvcd->nmcd.uItemState |= CDIS_SELECTED;
1040     if (lplvItem->state & LVIS_FOCUSED) lpnmlvcd->nmcd.uItemState |= CDIS_FOCUS;
1041     if (lplvItem->iItem == infoPtr->nHotItem) lpnmlvcd->nmcd.uItemState |= CDIS_HOT;
1042     lpnmlvcd->nmcd.lItemlParam = lplvItem->lParam;
1043 }
1044
1045 static inline DWORD notify_customdraw (const LISTVIEW_INFO *infoPtr, DWORD dwDrawStage, NMLVCUSTOMDRAW *lpnmlvcd)
1046 {
1047     BOOL isForItem = (lpnmlvcd->nmcd.dwItemSpec != 0);
1048     DWORD result;
1049
1050     lpnmlvcd->nmcd.dwDrawStage = dwDrawStage;
1051     if (isForItem) lpnmlvcd->nmcd.dwDrawStage |= CDDS_ITEM;
1052     if (lpnmlvcd->iSubItem) lpnmlvcd->nmcd.dwDrawStage |= CDDS_SUBITEM;
1053     if (isForItem) lpnmlvcd->nmcd.dwItemSpec--;
1054     result = notify_hdr(infoPtr, NM_CUSTOMDRAW, &lpnmlvcd->nmcd.hdr);
1055     if (isForItem) lpnmlvcd->nmcd.dwItemSpec++;
1056     return result;
1057 }
1058
1059 static void prepaint_setup (const LISTVIEW_INFO *infoPtr, HDC hdc, NMLVCUSTOMDRAW *lpnmlvcd, BOOL SubItem)
1060 {
1061     if (lpnmlvcd->clrTextBk == CLR_DEFAULT)
1062         lpnmlvcd->clrTextBk = comctl32_color.clrWindow;
1063     if (lpnmlvcd->clrText == CLR_DEFAULT)
1064         lpnmlvcd->clrText = comctl32_color.clrWindowText;
1065
1066     /* apparently, for selected items, we have to override the returned values */
1067     if (!SubItem)
1068     {
1069         if (lpnmlvcd->nmcd.uItemState & CDIS_SELECTED)
1070         {
1071             if (infoPtr->bFocus)
1072             {
1073                 lpnmlvcd->clrTextBk = comctl32_color.clrHighlight;
1074                 lpnmlvcd->clrText   = comctl32_color.clrHighlightText;
1075             }
1076             else if (infoPtr->dwStyle & LVS_SHOWSELALWAYS)
1077             {
1078                 lpnmlvcd->clrTextBk = comctl32_color.clr3dFace;
1079                 lpnmlvcd->clrText   = comctl32_color.clrBtnText;
1080             }
1081         }
1082     }
1083
1084     /* Set the text attributes */
1085     if (lpnmlvcd->clrTextBk != CLR_NONE)
1086     {
1087         SetBkMode(hdc, OPAQUE);
1088         SetBkColor(hdc,lpnmlvcd->clrTextBk);
1089     }
1090     else
1091         SetBkMode(hdc, TRANSPARENT);
1092     SetTextColor(hdc, lpnmlvcd->clrText);
1093 }
1094
1095 static inline DWORD notify_postpaint (const LISTVIEW_INFO *infoPtr, NMLVCUSTOMDRAW *lpnmlvcd)
1096 {
1097     return notify_customdraw(infoPtr, CDDS_POSTPAINT, lpnmlvcd);
1098 }
1099
1100 /* returns TRUE when repaint needed, FALSE otherwise */
1101 static BOOL notify_measureitem(LISTVIEW_INFO *infoPtr)
1102 {
1103     MEASUREITEMSTRUCT mis;
1104     mis.CtlType = ODT_LISTVIEW;
1105     mis.CtlID = GetWindowLongPtrW(infoPtr->hwndSelf, GWLP_ID);
1106     mis.itemID = -1;
1107     mis.itemWidth = 0;
1108     mis.itemData = 0;
1109     mis.itemHeight= infoPtr->nItemHeight;
1110     SendMessageW(infoPtr->hwndNotify, WM_MEASUREITEM, mis.CtlID, (LPARAM)&mis);
1111     if (infoPtr->nItemHeight != max(mis.itemHeight, 1))
1112     {
1113         infoPtr->nMeasureItemHeight = infoPtr->nItemHeight = max(mis.itemHeight, 1);
1114         return TRUE;
1115     }
1116     return FALSE;
1117 }
1118
1119 /******** Item iterator functions **********************************/
1120
1121 static RANGES ranges_create(int count);
1122 static void ranges_destroy(RANGES ranges);
1123 static BOOL ranges_add(RANGES ranges, RANGE range);
1124 static BOOL ranges_del(RANGES ranges, RANGE range);
1125 static void ranges_dump(RANGES ranges);
1126
1127 static inline BOOL ranges_additem(RANGES ranges, INT nItem)
1128 {
1129     RANGE range = { nItem, nItem + 1 };
1130
1131     return ranges_add(ranges, range);
1132 }
1133
1134 static inline BOOL ranges_delitem(RANGES ranges, INT nItem)
1135 {
1136     RANGE range = { nItem, nItem + 1 };
1137
1138     return ranges_del(ranges, range);
1139 }
1140
1141 /***
1142  * ITERATOR DOCUMENTATION
1143  *
1144  * The iterator functions allow for easy, and convenient iteration
1145  * over items of interest in the list. Typically, you create a
1146  * iterator, use it, and destroy it, as such:
1147  *   ITERATOR i;
1148  *
1149  *   iterator_xxxitems(&i, ...);
1150  *   while (iterator_{prev,next}(&i)
1151  *   {
1152  *       //code which uses i.nItem
1153  *   }
1154  *   iterator_destroy(&i);
1155  *
1156  *   where xxx is either: framed, or visible.
1157  * Note that it is important that the code destroys the iterator
1158  * after it's done with it, as the creation of the iterator may
1159  * allocate memory, which thus needs to be freed.
1160  *
1161  * You can iterate both forwards, and backwards through the list,
1162  * by using iterator_next or iterator_prev respectively.
1163  *
1164  * Lower numbered items are draw on top of higher number items in
1165  * LVS_ICON, and LVS_SMALLICON (which are the only modes where
1166  * items may overlap). So, to test items, you should use
1167  *    iterator_next
1168  * which lists the items top to bottom (in Z-order).
1169  * For drawing items, you should use
1170  *    iterator_prev
1171  * which lists the items bottom to top (in Z-order).
1172  * If you keep iterating over the items after the end-of-items
1173  * marker (-1) is returned, the iterator will start from the
1174  * beginning. Typically, you don't need to test for -1,
1175  * because iterator_{next,prev} will return TRUE if more items
1176  * are to be iterated over, or FALSE otherwise.
1177  *
1178  * Note: the iterator is defined to be bidirectional. That is,
1179  *       any number of prev followed by any number of next, or
1180  *       five versa, should leave the iterator at the same item:
1181  *           prev * n, next * n = next * n, prev * n
1182  *
1183  * The iterator has a notion of an out-of-order, special item,
1184  * which sits at the start of the list. This is used in
1185  * LVS_ICON, and LVS_SMALLICON mode to handle the focused item,
1186  * which needs to be first, as it may overlap other items.
1187  *
1188  * The code is a bit messy because we have:
1189  *   - a special item to deal with
1190  *   - simple range, or composite range
1191  *   - empty range.
1192  * If you find bugs, or want to add features, please make sure you
1193  * always check/modify *both* iterator_prev, and iterator_next.
1194  */
1195
1196 /****
1197  * This function iterates through the items in increasing order,
1198  * but prefixed by the special item, then -1. That is:
1199  *    special, 1, 2, 3, ..., n, -1.
1200  * Each item is listed only once.
1201  */
1202 static inline BOOL iterator_next(ITERATOR* i)
1203 {
1204     if (i->nItem == -1)
1205     {
1206         i->nItem = i->nSpecial;
1207         if (i->nItem != -1) return TRUE;
1208     }
1209     if (i->nItem == i->nSpecial)
1210     {
1211         if (i->ranges) i->index = 0;
1212         goto pickarange;
1213     }
1214
1215     i->nItem++;
1216 testitem:
1217     if (i->nItem == i->nSpecial) i->nItem++;
1218     if (i->nItem < i->range.upper) return TRUE;
1219
1220 pickarange:
1221     if (i->ranges)
1222     {
1223         if (i->index < DPA_GetPtrCount(i->ranges->hdpa))
1224             i->range = *(RANGE*)DPA_GetPtr(i->ranges->hdpa, i->index++);
1225         else goto end;
1226     }
1227     else if (i->nItem >= i->range.upper) goto end;
1228
1229     i->nItem = i->range.lower;
1230     if (i->nItem >= 0) goto testitem;
1231 end:
1232     i->nItem = -1;
1233     return FALSE;
1234 }
1235
1236 /****
1237  * This function iterates through the items in decreasing order,
1238  * followed by the special item, then -1. That is:
1239  *    n, n-1, ..., 3, 2, 1, special, -1.
1240  * Each item is listed only once.
1241  */
1242 static inline BOOL iterator_prev(ITERATOR* i)
1243 {
1244     BOOL start = FALSE;
1245
1246     if (i->nItem == -1)
1247     {
1248         start = TRUE;
1249         if (i->ranges) i->index = DPA_GetPtrCount(i->ranges->hdpa);
1250         goto pickarange;
1251     }
1252     if (i->nItem == i->nSpecial)
1253     {
1254         i->nItem = -1;
1255         return FALSE;
1256     }
1257
1258 testitem:
1259     i->nItem--;
1260     if (i->nItem == i->nSpecial) i->nItem--;
1261     if (i->nItem >= i->range.lower) return TRUE;
1262
1263 pickarange:
1264     if (i->ranges)
1265     {
1266         if (i->index > 0)
1267             i->range = *(RANGE*)DPA_GetPtr(i->ranges->hdpa, --i->index);
1268         else goto end;
1269     }
1270     else if (!start && i->nItem < i->range.lower) goto end;
1271
1272     i->nItem = i->range.upper;
1273     if (i->nItem > 0) goto testitem;
1274 end:
1275     return (i->nItem = i->nSpecial) != -1;
1276 }
1277
1278 static RANGE iterator_range(const ITERATOR *i)
1279 {
1280     RANGE range;
1281
1282     if (!i->ranges) return i->range;
1283
1284     if (DPA_GetPtrCount(i->ranges->hdpa) > 0)
1285     {
1286         range.lower = (*(RANGE*)DPA_GetPtr(i->ranges->hdpa, 0)).lower;
1287         range.upper = (*(RANGE*)DPA_GetPtr(i->ranges->hdpa, DPA_GetPtrCount(i->ranges->hdpa) - 1)).upper;
1288     }
1289     else range.lower = range.upper = 0;
1290
1291     return range;
1292 }
1293
1294 /***
1295  * Releases resources associated with this iterator.
1296  */
1297 static inline void iterator_destroy(const ITERATOR *i)
1298 {
1299     ranges_destroy(i->ranges);
1300 }
1301
1302 /***
1303  * Create an empty iterator.
1304  */
1305 static inline BOOL iterator_empty(ITERATOR* i)
1306 {
1307     ZeroMemory(i, sizeof(*i));
1308     i->nItem = i->nSpecial = i->range.lower = i->range.upper = -1;
1309     return TRUE;
1310 }
1311
1312 /***
1313  * Create an iterator over a range.
1314  */
1315 static inline BOOL iterator_rangeitems(ITERATOR* i, RANGE range)
1316 {
1317     iterator_empty(i);
1318     i->range = range;
1319     return TRUE;
1320 }
1321
1322 /***
1323  * Create an iterator over a bunch of ranges.
1324  * Please note that the iterator will take ownership of the ranges,
1325  * and will free them upon destruction.
1326  */
1327 static inline BOOL iterator_rangesitems(ITERATOR* i, RANGES ranges)
1328 {
1329     iterator_empty(i);
1330     i->ranges = ranges;
1331     return TRUE;
1332 }
1333
1334 /***
1335  * Creates an iterator over the items which intersect frame.
1336  * Uses absolute coordinates rather than compensating for the current offset.
1337  */
1338 static BOOL iterator_frameditems_absolute(ITERATOR* i, const LISTVIEW_INFO* infoPtr, const RECT *frame)
1339 {
1340     RECT rcItem, rcTemp;
1341
1342     /* in case we fail, we want to return an empty iterator */
1343     if (!iterator_empty(i)) return FALSE;
1344
1345     TRACE("(frame=%s)\n", wine_dbgstr_rect(frame));
1346
1347     if (infoPtr->uView == LV_VIEW_ICON || infoPtr->uView == LV_VIEW_SMALLICON)
1348     {
1349         INT nItem;
1350
1351         if (infoPtr->uView == LV_VIEW_ICON && infoPtr->nFocusedItem != -1)
1352         {
1353             LISTVIEW_GetItemBox(infoPtr, infoPtr->nFocusedItem, &rcItem);
1354             if (IntersectRect(&rcTemp, &rcItem, frame))
1355                 i->nSpecial = infoPtr->nFocusedItem;
1356         }
1357         if (!(iterator_rangesitems(i, ranges_create(50)))) return FALSE;
1358         /* to do better here, we need to have PosX, and PosY sorted */
1359         TRACE("building icon ranges:\n");
1360         for (nItem = 0; nItem < infoPtr->nItemCount; nItem++)
1361         {
1362             rcItem.left = (LONG_PTR)DPA_GetPtr(infoPtr->hdpaPosX, nItem);
1363             rcItem.top = (LONG_PTR)DPA_GetPtr(infoPtr->hdpaPosY, nItem);
1364             rcItem.right = rcItem.left + infoPtr->nItemWidth;
1365             rcItem.bottom = rcItem.top + infoPtr->nItemHeight;
1366             if (IntersectRect(&rcTemp, &rcItem, frame))
1367                 ranges_additem(i->ranges, nItem);
1368         }
1369         return TRUE;
1370     }
1371     else if (infoPtr->uView == LV_VIEW_DETAILS)
1372     {
1373         RANGE range;
1374
1375         if (frame->left >= infoPtr->nItemWidth) return TRUE;
1376         if (frame->top >= infoPtr->nItemHeight * infoPtr->nItemCount) return TRUE;
1377
1378         range.lower = max(frame->top / infoPtr->nItemHeight, 0);
1379         range.upper = min((frame->bottom - 1) / infoPtr->nItemHeight, infoPtr->nItemCount - 1) + 1;
1380         if (range.upper <= range.lower) return TRUE;
1381         if (!iterator_rangeitems(i, range)) return FALSE;
1382         TRACE("    report=%s\n", debugrange(&i->range));
1383     }
1384     else
1385     {
1386         INT nPerCol = max((infoPtr->rcList.bottom - infoPtr->rcList.top) / infoPtr->nItemHeight, 1);
1387         INT nFirstRow = max(frame->top / infoPtr->nItemHeight, 0);
1388         INT nLastRow = min((frame->bottom - 1) / infoPtr->nItemHeight, nPerCol - 1);
1389         INT nFirstCol;
1390         INT nLastCol;
1391         INT lower;
1392         RANGE item_range;
1393         INT nCol;
1394
1395         if (infoPtr->nItemWidth)
1396         {
1397             nFirstCol = max(frame->left / infoPtr->nItemWidth, 0);
1398             nLastCol  = min((frame->right - 1) / infoPtr->nItemWidth, (infoPtr->nItemCount + nPerCol - 1) / nPerCol);
1399         }
1400         else
1401         {
1402             nFirstCol = max(frame->left, 0);
1403             nLastCol  = min(frame->right - 1, (infoPtr->nItemCount + nPerCol - 1) / nPerCol);
1404         }
1405
1406         lower = nFirstCol * nPerCol + nFirstRow;
1407
1408         TRACE("nPerCol=%d, nFirstRow=%d, nLastRow=%d, nFirstCol=%d, nLastCol=%d, lower=%d\n",
1409               nPerCol, nFirstRow, nLastRow, nFirstCol, nLastCol, lower);
1410
1411         if (nLastCol < nFirstCol || nLastRow < nFirstRow) return TRUE;
1412
1413         if (!(iterator_rangesitems(i, ranges_create(nLastCol - nFirstCol + 1)))) return FALSE;
1414         TRACE("building list ranges:\n");
1415         for (nCol = nFirstCol; nCol <= nLastCol; nCol++)
1416         {
1417             item_range.lower = nCol * nPerCol + nFirstRow;
1418             if(item_range.lower >= infoPtr->nItemCount) break;
1419             item_range.upper = min(nCol * nPerCol + nLastRow + 1, infoPtr->nItemCount);
1420             TRACE("   list=%s\n", debugrange(&item_range));
1421             ranges_add(i->ranges, item_range);
1422         }
1423     }
1424
1425     return TRUE;
1426 }
1427
1428 /***
1429  * Creates an iterator over the items which intersect lprc.
1430  */
1431 static BOOL iterator_frameditems(ITERATOR* i, const LISTVIEW_INFO* infoPtr, const RECT *lprc)
1432 {
1433     RECT frame = *lprc;
1434     POINT Origin;
1435
1436     TRACE("(lprc=%s)\n", wine_dbgstr_rect(lprc));
1437
1438     LISTVIEW_GetOrigin(infoPtr, &Origin);
1439     OffsetRect(&frame, -Origin.x, -Origin.y);
1440
1441     return iterator_frameditems_absolute(i, infoPtr, &frame);
1442 }
1443
1444 /***
1445  * Creates an iterator over the items which intersect the visible region of hdc.
1446  */
1447 static BOOL iterator_visibleitems(ITERATOR *i, const LISTVIEW_INFO *infoPtr, HDC  hdc)
1448 {
1449     POINT Origin, Position;
1450     RECT rcItem, rcClip;
1451     INT rgntype;
1452
1453     rgntype = GetClipBox(hdc, &rcClip);
1454     if (rgntype == NULLREGION) return iterator_empty(i);
1455     if (!iterator_frameditems(i, infoPtr, &rcClip)) return FALSE;
1456     if (rgntype == SIMPLEREGION) return TRUE;
1457
1458     /* first deal with the special item */
1459     if (i->nSpecial != -1)
1460     {
1461         LISTVIEW_GetItemBox(infoPtr, i->nSpecial, &rcItem);
1462         if (!RectVisible(hdc, &rcItem)) i->nSpecial = -1;
1463     }
1464
1465     /* if we can't deal with the region, we'll just go with the simple range */
1466     LISTVIEW_GetOrigin(infoPtr, &Origin);
1467     TRACE("building visible range:\n");
1468     if (!i->ranges && i->range.lower < i->range.upper)
1469     {
1470         if (!(i->ranges = ranges_create(50))) return TRUE;
1471         if (!ranges_add(i->ranges, i->range))
1472         {
1473             ranges_destroy(i->ranges);
1474             i->ranges = 0;
1475             return TRUE;
1476         }
1477     }
1478
1479     /* now delete the invisible items from the list */
1480     while(iterator_next(i))
1481     {
1482         LISTVIEW_GetItemOrigin(infoPtr, i->nItem, &Position);
1483         rcItem.left = (infoPtr->uView == LV_VIEW_DETAILS) ? Origin.x : Position.x + Origin.x;
1484         rcItem.top = Position.y + Origin.y;
1485         rcItem.right = rcItem.left + infoPtr->nItemWidth;
1486         rcItem.bottom = rcItem.top + infoPtr->nItemHeight;
1487         if (!RectVisible(hdc, &rcItem))
1488             ranges_delitem(i->ranges, i->nItem);
1489     }
1490     /* the iterator should restart on the next iterator_next */
1491     TRACE("done\n");
1492
1493     return TRUE;
1494 }
1495
1496 /* Remove common elements from two iterators */
1497 /* Passed iterators have to point on the first elements */
1498 static BOOL iterator_remove_common_items(ITERATOR *iter1, ITERATOR *iter2)
1499 {
1500     if(!iter1->ranges || !iter2->ranges) {
1501         int lower, upper;
1502
1503         if(iter1->ranges || iter2->ranges ||
1504                 (iter1->range.lower<iter2->range.lower && iter1->range.upper>iter2->range.upper) ||
1505                 (iter1->range.lower>iter2->range.lower && iter1->range.upper<iter2->range.upper)) {
1506             ERR("result is not a one range iterator\n");
1507             return FALSE;
1508         }
1509
1510         if(iter1->range.lower==-1 || iter2->range.lower==-1)
1511             return TRUE;
1512
1513         lower = iter1->range.lower;
1514         upper = iter1->range.upper;
1515
1516         if(lower < iter2->range.lower)
1517             iter1->range.upper = iter2->range.lower;
1518         else if(upper > iter2->range.upper)
1519             iter1->range.lower = iter2->range.upper;
1520         else
1521             iter1->range.lower = iter1->range.upper = -1;
1522
1523         if(iter2->range.lower < lower)
1524             iter2->range.upper = lower;
1525         else if(iter2->range.upper > upper)
1526             iter2->range.lower = upper;
1527         else
1528             iter2->range.lower = iter2->range.upper = -1;
1529
1530         return TRUE;
1531     }
1532
1533     iterator_next(iter1);
1534     iterator_next(iter2);
1535
1536     while(1) {
1537         if(iter1->nItem==-1 || iter2->nItem==-1)
1538             break;
1539
1540         if(iter1->nItem == iter2->nItem) {
1541             int delete = iter1->nItem;
1542
1543             iterator_prev(iter1);
1544             iterator_prev(iter2);
1545             ranges_delitem(iter1->ranges, delete);
1546             ranges_delitem(iter2->ranges, delete);
1547             iterator_next(iter1);
1548             iterator_next(iter2);
1549         } else if(iter1->nItem > iter2->nItem)
1550             iterator_next(iter2);
1551         else
1552             iterator_next(iter1);
1553     }
1554
1555     iter1->nItem = iter1->range.lower = iter1->range.upper = -1;
1556     iter2->nItem = iter2->range.lower = iter2->range.upper = -1;
1557     return TRUE;
1558 }
1559
1560 /******** Misc helper functions ************************************/
1561
1562 static inline LRESULT CallWindowProcT(WNDPROC proc, HWND hwnd, UINT uMsg,
1563                                       WPARAM wParam, LPARAM lParam, BOOL isW)
1564 {
1565     if (isW) return CallWindowProcW(proc, hwnd, uMsg, wParam, lParam);
1566     else return CallWindowProcA(proc, hwnd, uMsg, wParam, lParam);
1567 }
1568
1569 static inline BOOL is_autoarrange(const LISTVIEW_INFO *infoPtr)
1570 {
1571     return ((infoPtr->dwStyle & LVS_AUTOARRANGE) || infoPtr->bAutoarrange) &&
1572            (infoPtr->uView == LV_VIEW_ICON || infoPtr->uView == LV_VIEW_SMALLICON);
1573 }
1574
1575 static void toggle_checkbox_state(LISTVIEW_INFO *infoPtr, INT nItem)
1576 {
1577     DWORD state = STATEIMAGEINDEX(LISTVIEW_GetItemState(infoPtr, nItem, LVIS_STATEIMAGEMASK));
1578     if(state == 1 || state == 2)
1579     {
1580         LVITEMW lvitem;
1581         state ^= 3;
1582         lvitem.state = INDEXTOSTATEIMAGEMASK(state);
1583         lvitem.stateMask = LVIS_STATEIMAGEMASK;
1584         LISTVIEW_SetItemState(infoPtr, nItem, &lvitem);
1585     }
1586 }
1587
1588 /* this should be called after window style got updated,
1589    it used to reset view state to match current window style */
1590 static inline void map_style_view(LISTVIEW_INFO *infoPtr)
1591 {
1592     switch (infoPtr->dwStyle & LVS_TYPEMASK)
1593     {
1594     case LVS_ICON:
1595         infoPtr->uView = LV_VIEW_ICON;
1596         break;
1597     case LVS_REPORT:
1598         infoPtr->uView = LV_VIEW_DETAILS;
1599         break;
1600     case LVS_SMALLICON:
1601         infoPtr->uView = LV_VIEW_SMALLICON;
1602         break;
1603     case LVS_LIST:
1604         infoPtr->uView = LV_VIEW_LIST;
1605     }
1606 }
1607
1608 /* computes next item id value */
1609 static DWORD get_next_itemid(const LISTVIEW_INFO *infoPtr)
1610 {
1611     INT count = DPA_GetPtrCount(infoPtr->hdpaItemIds);
1612
1613     if (count > 0)
1614     {
1615         ITEM_ID *lpID = DPA_GetPtr(infoPtr->hdpaItemIds, count - 1);
1616         return lpID->id + 1;
1617     }
1618     return 0;
1619 }
1620
1621 /******** Internal API functions ************************************/
1622
1623 static inline COLUMN_INFO * LISTVIEW_GetColumnInfo(const LISTVIEW_INFO *infoPtr, INT nSubItem)
1624 {
1625     static COLUMN_INFO mainItem;
1626
1627     if (nSubItem == 0 && DPA_GetPtrCount(infoPtr->hdpaColumns) == 0) return &mainItem;
1628     assert (nSubItem >= 0 && nSubItem < DPA_GetPtrCount(infoPtr->hdpaColumns));
1629
1630     /* update cached column rectangles */
1631     if (infoPtr->colRectsDirty)
1632     {
1633         COLUMN_INFO *info;
1634         LISTVIEW_INFO *Ptr = (LISTVIEW_INFO*)infoPtr;
1635         INT i;
1636
1637         for (i = 0; i < DPA_GetPtrCount(infoPtr->hdpaColumns); i++) {
1638             info = DPA_GetPtr(infoPtr->hdpaColumns, i);
1639             SendMessageW(infoPtr->hwndHeader, HDM_GETITEMRECT, i, (LPARAM)&info->rcHeader);
1640         }
1641         Ptr->colRectsDirty = FALSE;
1642     }
1643
1644     return DPA_GetPtr(infoPtr->hdpaColumns, nSubItem);
1645 }
1646
1647 static INT LISTVIEW_CreateHeader(LISTVIEW_INFO *infoPtr)
1648 {
1649     DWORD dFlags = WS_CHILD | HDS_HORZ | HDS_FULLDRAG | HDS_DRAGDROP;
1650     HINSTANCE hInst;
1651
1652     if (infoPtr->hwndHeader) return 0;
1653
1654     TRACE("Creating header for list %p\n", infoPtr->hwndSelf);
1655
1656     /* setup creation flags */
1657     dFlags |= (LVS_NOSORTHEADER & infoPtr->dwStyle) ? 0 : HDS_BUTTONS;
1658     dFlags |= (LVS_NOCOLUMNHEADER & infoPtr->dwStyle) ? HDS_HIDDEN : 0;
1659
1660     hInst = (HINSTANCE)GetWindowLongPtrW(infoPtr->hwndSelf, GWLP_HINSTANCE);
1661
1662     /* create header */
1663     infoPtr->hwndHeader = CreateWindowW(WC_HEADERW, NULL, dFlags,
1664       0, 0, 0, 0, infoPtr->hwndSelf, NULL, hInst, NULL);
1665     if (!infoPtr->hwndHeader) return -1;
1666
1667     /* set header unicode format */
1668     SendMessageW(infoPtr->hwndHeader, HDM_SETUNICODEFORMAT, TRUE, 0);
1669
1670     /* set header font */
1671     SendMessageW(infoPtr->hwndHeader, WM_SETFONT, (WPARAM)infoPtr->hFont, TRUE);
1672
1673     /* set header image list */
1674     if (infoPtr->himlSmall)
1675         SendMessageW(infoPtr->hwndHeader, HDM_SETIMAGELIST, 0, (LPARAM)infoPtr->himlSmall);
1676
1677     LISTVIEW_UpdateSize(infoPtr);
1678
1679     return 0;
1680 }
1681
1682 static inline void LISTVIEW_GetHeaderRect(const LISTVIEW_INFO *infoPtr, INT nSubItem, LPRECT lprc)
1683 {
1684     *lprc = LISTVIEW_GetColumnInfo(infoPtr, nSubItem)->rcHeader;
1685 }
1686
1687 static inline BOOL LISTVIEW_IsHeaderEnabled(const LISTVIEW_INFO *infoPtr)
1688 {
1689     return (infoPtr->uView == LV_VIEW_DETAILS ||
1690             infoPtr->dwLvExStyle & LVS_EX_HEADERINALLVIEWS) &&
1691           !(infoPtr->dwStyle & LVS_NOCOLUMNHEADER);
1692 }
1693
1694 static inline BOOL LISTVIEW_GetItemW(const LISTVIEW_INFO *infoPtr, LPLVITEMW lpLVItem)
1695 {
1696     return LISTVIEW_GetItemT(infoPtr, lpLVItem, TRUE);
1697 }
1698
1699 /* used to handle collapse main item column case */
1700 static inline BOOL LISTVIEW_DrawFocusRect(const LISTVIEW_INFO *infoPtr, HDC hdc)
1701 {
1702     return (infoPtr->rcFocus.left < infoPtr->rcFocus.right) ?
1703             DrawFocusRect(hdc, &infoPtr->rcFocus) : FALSE;
1704 }
1705
1706 /* Listview invalidation functions: use _only_ these functions to invalidate */
1707
1708 static inline BOOL is_redrawing(const LISTVIEW_INFO *infoPtr)
1709 {
1710     return infoPtr->bRedraw;
1711 }
1712
1713 static inline void LISTVIEW_InvalidateRect(const LISTVIEW_INFO *infoPtr, const RECT* rect)
1714 {
1715     if(!is_redrawing(infoPtr)) return;
1716     TRACE(" invalidating rect=%s\n", wine_dbgstr_rect(rect));
1717     InvalidateRect(infoPtr->hwndSelf, rect, TRUE);
1718 }
1719
1720 static inline void LISTVIEW_InvalidateItem(const LISTVIEW_INFO *infoPtr, INT nItem)
1721 {
1722     RECT rcBox;
1723
1724     if(!is_redrawing(infoPtr)) return;
1725     LISTVIEW_GetItemBox(infoPtr, nItem, &rcBox);
1726     LISTVIEW_InvalidateRect(infoPtr, &rcBox);
1727 }
1728
1729 static inline void LISTVIEW_InvalidateSubItem(const LISTVIEW_INFO *infoPtr, INT nItem, INT nSubItem)
1730 {
1731     POINT Origin, Position;
1732     RECT rcBox;
1733
1734     if(!is_redrawing(infoPtr)) return;
1735     assert (infoPtr->uView == LV_VIEW_DETAILS);
1736     LISTVIEW_GetOrigin(infoPtr, &Origin);
1737     LISTVIEW_GetItemOrigin(infoPtr, nItem, &Position);
1738     LISTVIEW_GetHeaderRect(infoPtr, nSubItem, &rcBox);
1739     rcBox.top = 0;
1740     rcBox.bottom = infoPtr->nItemHeight;
1741     OffsetRect(&rcBox, Origin.x + Position.x, Origin.y + Position.y);
1742     LISTVIEW_InvalidateRect(infoPtr, &rcBox);
1743 }
1744
1745 static inline void LISTVIEW_InvalidateList(const LISTVIEW_INFO *infoPtr)
1746 {
1747     LISTVIEW_InvalidateRect(infoPtr, NULL);
1748 }
1749
1750 static inline void LISTVIEW_InvalidateColumn(const LISTVIEW_INFO *infoPtr, INT nColumn)
1751 {
1752     RECT rcCol;
1753
1754     if(!is_redrawing(infoPtr)) return;
1755     LISTVIEW_GetHeaderRect(infoPtr, nColumn, &rcCol);
1756     rcCol.top = infoPtr->rcList.top;
1757     rcCol.bottom = infoPtr->rcList.bottom;
1758     LISTVIEW_InvalidateRect(infoPtr, &rcCol);
1759 }
1760
1761 /***
1762  * DESCRIPTION:
1763  * Retrieves the number of items that can fit vertically in the client area.
1764  *
1765  * PARAMETER(S):
1766  * [I] infoPtr : valid pointer to the listview structure
1767  *
1768  * RETURN:
1769  * Number of items per row.
1770  */
1771 static inline INT LISTVIEW_GetCountPerRow(const LISTVIEW_INFO *infoPtr)
1772 {
1773     INT nListWidth = infoPtr->rcList.right - infoPtr->rcList.left;
1774
1775     return max(nListWidth/(infoPtr->nItemWidth ? infoPtr->nItemWidth : 1), 1);
1776 }
1777
1778 /***
1779  * DESCRIPTION:
1780  * Retrieves the number of items that can fit horizontally in the client
1781  * area.
1782  *
1783  * PARAMETER(S):
1784  * [I] infoPtr : valid pointer to the listview structure
1785  *
1786  * RETURN:
1787  * Number of items per column.
1788  */
1789 static inline INT LISTVIEW_GetCountPerColumn(const LISTVIEW_INFO *infoPtr)
1790 {
1791     INT nListHeight = infoPtr->rcList.bottom - infoPtr->rcList.top;
1792
1793     return max(nListHeight / infoPtr->nItemHeight, 1);
1794 }
1795
1796
1797 /*************************************************************************
1798  *              LISTVIEW_ProcessLetterKeys
1799  *
1800  *  Processes keyboard messages generated by pressing the letter keys
1801  *  on the keyboard.
1802  *  What this does is perform a case insensitive search from the
1803  *  current position with the following quirks:
1804  *  - If two chars or more are pressed in quick succession we search
1805  *    for the corresponding string (e.g. 'abc').
1806  *  - If there is a delay we wipe away the current search string and
1807  *    restart with just that char.
1808  *  - If the user keeps pressing the same character, whether slowly or
1809  *    fast, so that the search string is entirely composed of this
1810  *    character ('aaaaa' for instance), then we search for first item
1811  *    that starting with that character.
1812  *  - If the user types the above character in quick succession, then
1813  *    we must also search for the corresponding string ('aaaaa'), and
1814  *    go to that string if there is a match.
1815  *
1816  * PARAMETERS
1817  *   [I] hwnd : handle to the window
1818  *   [I] charCode : the character code, the actual character
1819  *   [I] keyData : key data
1820  *
1821  * RETURNS
1822  *
1823  *  Zero.
1824  *
1825  * BUGS
1826  *
1827  *  - The current implementation has a list of characters it will
1828  *    accept and it ignores everything else. In particular it will
1829  *    ignore accentuated characters which seems to match what
1830  *    Windows does. But I'm not sure it makes sense to follow
1831  *    Windows there.
1832  *  - We don't sound a beep when the search fails.
1833  *
1834  * SEE ALSO
1835  *
1836  *  TREEVIEW_ProcessLetterKeys
1837  */
1838 static INT LISTVIEW_ProcessLetterKeys(LISTVIEW_INFO *infoPtr, WPARAM charCode, LPARAM keyData)
1839 {
1840     WCHAR buffer[MAX_PATH];
1841     INT endidx, startidx;
1842     DWORD prevTime;
1843     LVITEMW item;
1844     INT nItem;
1845     INT diff;
1846
1847     /* simple parameter checking */
1848     if (!charCode || !keyData || infoPtr->nItemCount == 0) return 0;
1849
1850     /* only allow the valid WM_CHARs through */
1851     if (!isalnumW(charCode) &&
1852         charCode != '.' && charCode != '`' && charCode != '!' &&
1853         charCode != '@' && charCode != '#' && charCode != '$' &&
1854         charCode != '%' && charCode != '^' && charCode != '&' &&
1855         charCode != '*' && charCode != '(' && charCode != ')' &&
1856         charCode != '-' && charCode != '_' && charCode != '+' &&
1857         charCode != '=' && charCode != '\\'&& charCode != ']' &&
1858         charCode != '}' && charCode != '[' && charCode != '{' &&
1859         charCode != '/' && charCode != '?' && charCode != '>' &&
1860         charCode != '<' && charCode != ',' && charCode != '~')
1861         return 0;
1862
1863     /* update the search parameters */
1864     prevTime = infoPtr->lastKeyPressTimestamp;
1865     infoPtr->lastKeyPressTimestamp = GetTickCount();
1866     diff = infoPtr->lastKeyPressTimestamp - prevTime;
1867
1868     if (diff >= 0 && diff < KEY_DELAY)
1869     {
1870         if (infoPtr->nSearchParamLength < MAX_PATH - 1)
1871             infoPtr->szSearchParam[infoPtr->nSearchParamLength++] = charCode;
1872
1873         if (infoPtr->charCode != charCode)
1874             infoPtr->charCode = charCode = 0;
1875     }
1876     else
1877     {
1878         infoPtr->charCode = charCode;
1879         infoPtr->szSearchParam[0] = charCode;
1880         infoPtr->nSearchParamLength = 1;
1881     }
1882
1883     /* and search from the current position */
1884     nItem = -1;
1885     endidx = infoPtr->nItemCount;
1886
1887     /* should start from next after focused item, so next item that matches
1888        will be selected, if there isn't any and focused matches it will be selected
1889        on second search stage from beginning of the list */
1890     if (infoPtr->nFocusedItem >= 0 && infoPtr->nItemCount > 1)
1891         startidx = infoPtr->nFocusedItem + 1;
1892     else
1893         startidx = 0;
1894
1895     /* let application handle this for virtual listview */
1896     if (infoPtr->dwStyle & LVS_OWNERDATA)
1897     {
1898         NMLVFINDITEMW nmlv;
1899
1900         memset(&nmlv.lvfi, 0, sizeof(nmlv.lvfi));
1901         nmlv.lvfi.flags = (LVFI_WRAP | LVFI_PARTIAL);
1902         nmlv.lvfi.psz = infoPtr->szSearchParam;
1903         nmlv.iStart = startidx;
1904
1905         infoPtr->szSearchParam[infoPtr->nSearchParamLength] = 0;
1906
1907         nItem = notify_hdr(infoPtr, LVN_ODFINDITEMW, (LPNMHDR)&nmlv.hdr);
1908     }
1909     else
1910     {
1911         INT i = startidx;
1912
1913         /* first search in [startidx, endidx), on failure continue in [0, startidx) */
1914         while (1)
1915         {
1916             /* start from first item if not found with >= startidx */
1917             if (i == infoPtr->nItemCount && startidx > 0)
1918             {
1919                 endidx = startidx;
1920                 startidx = 0;
1921             }
1922
1923             for (i = startidx; i < endidx; i++)
1924             {
1925                 /* retrieve text */
1926                 item.mask = LVIF_TEXT;
1927                 item.iItem = i;
1928                 item.iSubItem = 0;
1929                 item.pszText = buffer;
1930                 item.cchTextMax = MAX_PATH;
1931                 if (!LISTVIEW_GetItemW(infoPtr, &item)) return 0;
1932
1933                 if (lstrncmpiW(item.pszText, infoPtr->szSearchParam, infoPtr->nSearchParamLength) == 0)
1934                 {
1935                     nItem = i;
1936                     break;
1937                 }
1938                 else if (nItem == -1 && lstrncmpiW(item.pszText, infoPtr->szSearchParam, 1) == 0)
1939                 {
1940                     /* this would work but we must keep looking for a longer match */
1941                     nItem = i;
1942                 }
1943             }
1944
1945             if ( nItem != -1 || /* found something */
1946                  endidx != infoPtr->nItemCount || /* second search done */
1947                 (startidx == 0 && endidx == infoPtr->nItemCount) /* full range for first search */ )
1948                 break;
1949         };
1950     }
1951
1952     if (nItem != -1)
1953         LISTVIEW_KeySelection(infoPtr, nItem, FALSE);
1954
1955     return 0;
1956 }
1957
1958 /*************************************************************************
1959  * LISTVIEW_UpdateHeaderSize [Internal]
1960  *
1961  * Function to resize the header control
1962  *
1963  * PARAMS
1964  * [I]  hwnd : handle to a window
1965  * [I]  nNewScrollPos : scroll pos to set
1966  *
1967  * RETURNS
1968  * None.
1969  */
1970 static void LISTVIEW_UpdateHeaderSize(const LISTVIEW_INFO *infoPtr, INT nNewScrollPos)
1971 {
1972     RECT winRect;
1973     POINT point[2];
1974
1975     TRACE("nNewScrollPos=%d\n", nNewScrollPos);
1976
1977     if (!infoPtr->hwndHeader)  return;
1978
1979     GetWindowRect(infoPtr->hwndHeader, &winRect);
1980     point[0].x = winRect.left;
1981     point[0].y = winRect.top;
1982     point[1].x = winRect.right;
1983     point[1].y = winRect.bottom;
1984
1985     MapWindowPoints(HWND_DESKTOP, infoPtr->hwndSelf, point, 2);
1986     point[0].x = -nNewScrollPos;
1987     point[1].x += nNewScrollPos;
1988
1989     SetWindowPos(infoPtr->hwndHeader,0,
1990         point[0].x,point[0].y,point[1].x,point[1].y,
1991         (infoPtr->dwStyle & LVS_NOCOLUMNHEADER) ? SWP_HIDEWINDOW : SWP_SHOWWINDOW |
1992         SWP_NOZORDER | SWP_NOACTIVATE);
1993 }
1994
1995 /***
1996  * DESCRIPTION:
1997  * Update the scrollbars. This functions should be called whenever
1998  * the content, size or view changes.
1999  *
2000  * PARAMETER(S):
2001  * [I] infoPtr : valid pointer to the listview structure
2002  *
2003  * RETURN:
2004  * None
2005  */
2006 static void LISTVIEW_UpdateScroll(const LISTVIEW_INFO *infoPtr)
2007 {
2008     SCROLLINFO horzInfo, vertInfo;
2009     INT dx, dy;
2010
2011     if ((infoPtr->dwStyle & LVS_NOSCROLL) || !is_redrawing(infoPtr)) return;
2012
2013     ZeroMemory(&horzInfo, sizeof(SCROLLINFO));
2014     horzInfo.cbSize = sizeof(SCROLLINFO);
2015     horzInfo.nPage = infoPtr->rcList.right - infoPtr->rcList.left;
2016
2017     /* for now, we'll set info.nMax to the _count_, and adjust it later */
2018     if (infoPtr->uView == LV_VIEW_LIST)
2019     {
2020         INT nPerCol = LISTVIEW_GetCountPerColumn(infoPtr);
2021         horzInfo.nMax = (infoPtr->nItemCount + nPerCol - 1) / nPerCol;
2022
2023         /* scroll by at least one column per page */
2024         if(horzInfo.nPage < infoPtr->nItemWidth)
2025                 horzInfo.nPage = infoPtr->nItemWidth;
2026
2027         if (infoPtr->nItemWidth)
2028             horzInfo.nPage /= infoPtr->nItemWidth;
2029     }
2030     else if (infoPtr->uView == LV_VIEW_DETAILS)
2031     {
2032         horzInfo.nMax = infoPtr->nItemWidth;
2033     }
2034     else /* LV_VIEW_ICON, or LV_VIEW_SMALLICON */
2035     {
2036         RECT rcView;
2037
2038         if (LISTVIEW_GetViewRect(infoPtr, &rcView)) horzInfo.nMax = rcView.right - rcView.left;
2039     }
2040
2041     if (LISTVIEW_IsHeaderEnabled(infoPtr))
2042     {
2043         if (DPA_GetPtrCount(infoPtr->hdpaColumns))
2044         {
2045             RECT rcHeader;
2046             INT index;
2047
2048             index = SendMessageW(infoPtr->hwndHeader, HDM_ORDERTOINDEX,
2049                                  DPA_GetPtrCount(infoPtr->hdpaColumns) - 1, 0);
2050
2051             LISTVIEW_GetHeaderRect(infoPtr, index, &rcHeader);
2052             horzInfo.nMax = rcHeader.right;
2053             TRACE("horzInfo.nMax=%d\n", horzInfo.nMax);
2054         }
2055     }
2056
2057     horzInfo.fMask = SIF_RANGE | SIF_PAGE;
2058     horzInfo.nMax = max(horzInfo.nMax - 1, 0);
2059     dx = GetScrollPos(infoPtr->hwndSelf, SB_HORZ);
2060     dx -= SetScrollInfo(infoPtr->hwndSelf, SB_HORZ, &horzInfo, TRUE);
2061     TRACE("horzInfo=%s\n", debugscrollinfo(&horzInfo));
2062
2063     /* Setting the horizontal scroll can change the listview size
2064      * (and potentially everything else) so we need to recompute
2065      * everything again for the vertical scroll
2066      */
2067
2068     ZeroMemory(&vertInfo, sizeof(SCROLLINFO));
2069     vertInfo.cbSize = sizeof(SCROLLINFO);
2070     vertInfo.nPage = infoPtr->rcList.bottom - infoPtr->rcList.top;
2071
2072     if (infoPtr->uView == LV_VIEW_DETAILS)
2073     {
2074         vertInfo.nMax = infoPtr->nItemCount;
2075
2076         /* scroll by at least one page */
2077         if(vertInfo.nPage < infoPtr->nItemHeight)
2078           vertInfo.nPage = infoPtr->nItemHeight;
2079
2080         if (infoPtr->nItemHeight > 0)
2081             vertInfo.nPage /= infoPtr->nItemHeight;
2082     }
2083     else if (infoPtr->uView != LV_VIEW_LIST) /* LV_VIEW_ICON, or LV_VIEW_SMALLICON */
2084     {
2085         RECT rcView;
2086
2087         if (LISTVIEW_GetViewRect(infoPtr, &rcView)) vertInfo.nMax = rcView.bottom - rcView.top;
2088     }
2089
2090     vertInfo.fMask = SIF_RANGE | SIF_PAGE;
2091     vertInfo.nMax = max(vertInfo.nMax - 1, 0);
2092     dy = GetScrollPos(infoPtr->hwndSelf, SB_VERT);
2093     dy -= SetScrollInfo(infoPtr->hwndSelf, SB_VERT, &vertInfo, TRUE);
2094     TRACE("vertInfo=%s\n", debugscrollinfo(&vertInfo));
2095
2096     /* Change of the range may have changed the scroll pos. If so move the content */
2097     if (dx != 0 || dy != 0)
2098     {
2099         RECT listRect;
2100         listRect = infoPtr->rcList;
2101         ScrollWindowEx(infoPtr->hwndSelf, dx, dy, &listRect, &listRect, 0, 0,
2102             SW_ERASE | SW_INVALIDATE);
2103     }
2104
2105     /* Update the Header Control */
2106     if (infoPtr->hwndHeader)
2107     {
2108         horzInfo.fMask = SIF_POS;
2109         GetScrollInfo(infoPtr->hwndSelf, SB_HORZ, &horzInfo);
2110         LISTVIEW_UpdateHeaderSize(infoPtr, horzInfo.nPos);
2111     }
2112 }
2113
2114
2115 /***
2116  * DESCRIPTION:
2117  * Shows/hides the focus rectangle.
2118  *
2119  * PARAMETER(S):
2120  * [I] infoPtr : valid pointer to the listview structure
2121  * [I] fShow : TRUE to show the focus, FALSE to hide it.
2122  *
2123  * RETURN:
2124  * None
2125  */
2126 static void LISTVIEW_ShowFocusRect(const LISTVIEW_INFO *infoPtr, BOOL fShow)
2127 {
2128     HDC hdc;
2129
2130     TRACE("fShow=%d, nItem=%d\n", fShow, infoPtr->nFocusedItem);
2131
2132     if (infoPtr->nFocusedItem < 0) return;
2133
2134     /* we need some gymnastics in ICON mode to handle large items */
2135     if (infoPtr->uView == LV_VIEW_ICON)
2136     {
2137         RECT rcBox;
2138
2139         LISTVIEW_GetItemBox(infoPtr, infoPtr->nFocusedItem, &rcBox);
2140         if ((rcBox.bottom - rcBox.top) > infoPtr->nItemHeight)
2141         {
2142             LISTVIEW_InvalidateRect(infoPtr, &rcBox);
2143             return;
2144         }
2145     }
2146
2147     if (!(hdc = GetDC(infoPtr->hwndSelf))) return;
2148
2149     /* for some reason, owner draw should work only in report mode */
2150     if ((infoPtr->dwStyle & LVS_OWNERDRAWFIXED) && (infoPtr->uView == LV_VIEW_DETAILS))
2151     {
2152         DRAWITEMSTRUCT dis;
2153         LVITEMW item;
2154
2155         HFONT hFont = infoPtr->hFont ? infoPtr->hFont : infoPtr->hDefaultFont;
2156         HFONT hOldFont = SelectObject(hdc, hFont);
2157
2158         item.iItem = infoPtr->nFocusedItem;
2159         item.iSubItem = 0;
2160         item.mask = LVIF_PARAM;
2161         if (!LISTVIEW_GetItemW(infoPtr, &item)) goto done;
2162
2163         ZeroMemory(&dis, sizeof(dis));
2164         dis.CtlType = ODT_LISTVIEW;
2165         dis.CtlID = (UINT)GetWindowLongPtrW(infoPtr->hwndSelf, GWLP_ID);
2166         dis.itemID = item.iItem;
2167         dis.itemAction = ODA_FOCUS;
2168         if (fShow) dis.itemState |= ODS_FOCUS;
2169         dis.hwndItem = infoPtr->hwndSelf;
2170         dis.hDC = hdc;
2171         LISTVIEW_GetItemBox(infoPtr, dis.itemID, &dis.rcItem);
2172         dis.itemData = item.lParam;
2173
2174         SendMessageW(infoPtr->hwndNotify, WM_DRAWITEM, dis.CtlID, (LPARAM)&dis);
2175
2176         SelectObject(hdc, hOldFont);
2177     }
2178     else
2179     {
2180         LISTVIEW_DrawFocusRect(infoPtr, hdc);
2181     }
2182 done:
2183     ReleaseDC(infoPtr->hwndSelf, hdc);
2184 }
2185
2186 /***
2187  * Invalidates all visible selected items.
2188  */
2189 static void LISTVIEW_InvalidateSelectedItems(const LISTVIEW_INFO *infoPtr)
2190 {
2191     ITERATOR i;
2192
2193     iterator_frameditems(&i, infoPtr, &infoPtr->rcList);
2194     while(iterator_next(&i))
2195     {
2196         if (LISTVIEW_GetItemState(infoPtr, i.nItem, LVIS_SELECTED))
2197             LISTVIEW_InvalidateItem(infoPtr, i.nItem);
2198     }
2199     iterator_destroy(&i);
2200 }
2201
2202
2203 /***
2204  * DESCRIPTION:            [INTERNAL]
2205  * Computes an item's (left,top) corner, relative to rcView.
2206  * That is, the position has NOT been made relative to the Origin.
2207  * This is deliberate, to avoid computing the Origin over, and
2208  * over again, when this function is called in a loop. Instead,
2209  * one can factor the computation of the Origin before the loop,
2210  * and offset the value returned by this function, on every iteration.
2211  *
2212  * PARAMETER(S):
2213  * [I] infoPtr : valid pointer to the listview structure
2214  * [I] nItem  : item number
2215  * [O] lpptOrig : item top, left corner
2216  *
2217  * RETURN:
2218  *   None.
2219  */
2220 static void LISTVIEW_GetItemOrigin(const LISTVIEW_INFO *infoPtr, INT nItem, LPPOINT lpptPosition)
2221 {
2222     assert(nItem >= 0 && nItem < infoPtr->nItemCount);
2223
2224     if ((infoPtr->uView == LV_VIEW_SMALLICON) || (infoPtr->uView == LV_VIEW_ICON))
2225     {
2226         lpptPosition->x = (LONG_PTR)DPA_GetPtr(infoPtr->hdpaPosX, nItem);
2227         lpptPosition->y = (LONG_PTR)DPA_GetPtr(infoPtr->hdpaPosY, nItem);
2228     }
2229     else if (infoPtr->uView == LV_VIEW_LIST)
2230     {
2231         INT nCountPerColumn = LISTVIEW_GetCountPerColumn(infoPtr);
2232         lpptPosition->x = nItem / nCountPerColumn * infoPtr->nItemWidth;
2233         lpptPosition->y = nItem % nCountPerColumn * infoPtr->nItemHeight;
2234     }
2235     else /* LV_VIEW_DETAILS */
2236     {
2237         lpptPosition->x = REPORT_MARGINX;
2238         /* item is always at zero indexed column */
2239         if (DPA_GetPtrCount(infoPtr->hdpaColumns) > 0)
2240             lpptPosition->x += LISTVIEW_GetColumnInfo(infoPtr, 0)->rcHeader.left;
2241         lpptPosition->y = nItem * infoPtr->nItemHeight;
2242     }
2243 }
2244
2245 /***
2246  * DESCRIPTION:            [INTERNAL]
2247  * Compute the rectangles of an item.  This is to localize all
2248  * the computations in one place. If you are not interested in some
2249  * of these values, simply pass in a NULL -- the function is smart
2250  * enough to compute only what's necessary. The function computes
2251  * the standard rectangles (BOUNDS, ICON, LABEL) plus a non-standard
2252  * one, the BOX rectangle. This rectangle is very cheap to compute,
2253  * and is guaranteed to contain all the other rectangles. Computing
2254  * the ICON rect is also cheap, but all the others are potentially
2255  * expensive. This gives an easy and effective optimization when
2256  * searching (like point inclusion, or rectangle intersection):
2257  * first test against the BOX, and if TRUE, test against the desired
2258  * rectangle.
2259  * If the function does not have all the necessary information
2260  * to computed the requested rectangles, will crash with a
2261  * failed assertion. This is done so we catch all programming
2262  * errors, given that the function is called only from our code.
2263  *
2264  * We have the following 'special' meanings for a few fields:
2265  *   * If LVIS_FOCUSED is set, we assume the item has the focus
2266  *     This is important in ICON mode, where it might get a larger
2267  *     then usual rectangle
2268  *
2269  * Please note that subitem support works only in REPORT mode.
2270  *
2271  * PARAMETER(S):
2272  * [I] infoPtr : valid pointer to the listview structure
2273  * [I] lpLVItem : item to compute the measures for
2274  * [O] lprcBox : ptr to Box rectangle
2275  *                Same as LVM_GETITEMRECT with LVIR_BOUNDS
2276  * [0] lprcSelectBox : ptr to select box rectangle
2277  *                Same as LVM_GETITEMRECT with LVIR_SELECTEDBOUNDS
2278  * [O] lprcIcon : ptr to Icon rectangle
2279  *                Same as LVM_GETITEMRECT with LVIR_ICON
2280  * [O] lprcStateIcon: ptr to State Icon rectangle
2281  * [O] lprcLabel : ptr to Label rectangle
2282  *                Same as LVM_GETITEMRECT with LVIR_LABEL
2283  *
2284  * RETURN:
2285  *   None.
2286  */
2287 static void LISTVIEW_GetItemMetrics(const LISTVIEW_INFO *infoPtr, const LVITEMW *lpLVItem,
2288                                     LPRECT lprcBox, LPRECT lprcSelectBox,
2289                                     LPRECT lprcIcon, LPRECT lprcStateIcon, LPRECT lprcLabel)
2290 {
2291     BOOL doSelectBox = FALSE, doIcon = FALSE, doLabel = FALSE, oversizedBox = FALSE;
2292     RECT Box, SelectBox, Icon, Label;
2293     COLUMN_INFO *lpColumnInfo = NULL;
2294     SIZE labelSize = { 0, 0 };
2295
2296     TRACE("(lpLVItem=%s)\n", debuglvitem_t(lpLVItem, TRUE));
2297
2298     /* Be smart and try to figure out the minimum we have to do */
2299     if (lpLVItem->iSubItem) assert(infoPtr->uView == LV_VIEW_DETAILS);
2300     if (infoPtr->uView == LV_VIEW_ICON && (lprcBox || lprcLabel))
2301     {
2302         assert((lpLVItem->mask & LVIF_STATE) && (lpLVItem->stateMask & LVIS_FOCUSED));
2303         if (lpLVItem->state & LVIS_FOCUSED) oversizedBox = doLabel = TRUE;
2304     }
2305     if (lprcSelectBox) doSelectBox = TRUE;
2306     if (lprcLabel) doLabel = TRUE;
2307     if (doLabel || lprcIcon || lprcStateIcon) doIcon = TRUE;
2308     if (doSelectBox)
2309     {
2310         doIcon = TRUE;
2311         doLabel = TRUE;
2312     }
2313
2314     /************************************************************/
2315     /* compute the box rectangle (it should be cheap to do)     */
2316     /************************************************************/
2317     if (lpLVItem->iSubItem || infoPtr->uView == LV_VIEW_DETAILS)
2318         lpColumnInfo = LISTVIEW_GetColumnInfo(infoPtr, lpLVItem->iSubItem);
2319
2320     if (lpLVItem->iSubItem)
2321     {
2322         Box = lpColumnInfo->rcHeader;
2323     }
2324     else
2325     {
2326         Box.left = 0;
2327         Box.right = infoPtr->nItemWidth;
2328     }
2329     Box.top = 0;
2330     Box.bottom = infoPtr->nItemHeight;
2331
2332     /******************************************************************/
2333     /* compute ICON bounding box (ala LVM_GETITEMRECT) and STATEICON  */
2334     /******************************************************************/
2335     if (doIcon)
2336     {
2337         LONG state_width = 0;
2338
2339         if (infoPtr->himlState && lpLVItem->iSubItem == 0)
2340             state_width = infoPtr->iconStateSize.cx;
2341
2342         if (infoPtr->uView == LV_VIEW_ICON)
2343         {
2344             Icon.left   = Box.left + state_width;
2345             if (infoPtr->himlNormal)
2346                 Icon.left += (infoPtr->nItemWidth - infoPtr->iconSize.cx - state_width) / 2;
2347             Icon.top    = Box.top + ICON_TOP_PADDING;
2348             Icon.right  = Icon.left;
2349             Icon.bottom = Icon.top;
2350             if (infoPtr->himlNormal)
2351             {
2352                 Icon.right  += infoPtr->iconSize.cx;
2353                 Icon.bottom += infoPtr->iconSize.cy;
2354             }
2355         }
2356         else /* LV_VIEW_SMALLICON, LV_VIEW_LIST or LV_VIEW_DETAILS */
2357         {
2358             Icon.left   = Box.left + state_width;
2359
2360             if (infoPtr->uView == LV_VIEW_DETAILS && lpLVItem->iSubItem == 0)
2361             {
2362                 /* we need the indent in report mode */
2363                 assert(lpLVItem->mask & LVIF_INDENT);
2364                 Icon.left += infoPtr->iconSize.cx * lpLVItem->iIndent + REPORT_MARGINX;
2365             }
2366
2367             Icon.top    = Box.top;
2368             Icon.right  = Icon.left;
2369             if (infoPtr->himlSmall &&
2370                 (!lpColumnInfo || lpLVItem->iSubItem == 0 ||
2371                  ((infoPtr->dwLvExStyle & LVS_EX_SUBITEMIMAGES) && lpLVItem->iImage != I_IMAGECALLBACK)))
2372                 Icon.right += infoPtr->iconSize.cx;
2373             Icon.bottom = Icon.top + infoPtr->iconSize.cy;
2374         }
2375         if(lprcIcon) *lprcIcon = Icon;
2376         TRACE("    - icon=%s\n", wine_dbgstr_rect(&Icon));
2377
2378         /* TODO: is this correct? */
2379         if (lprcStateIcon)
2380         {
2381             lprcStateIcon->left = Icon.left - state_width;
2382             lprcStateIcon->right = Icon.left;
2383             lprcStateIcon->top = Icon.top;
2384             lprcStateIcon->bottom = lprcStateIcon->top + infoPtr->iconSize.cy;
2385             TRACE("    - state icon=%s\n", wine_dbgstr_rect(lprcStateIcon));
2386         }
2387      }
2388      else Icon.right = 0;
2389
2390     /************************************************************/
2391     /* compute LABEL bounding box (ala LVM_GETITEMRECT)         */
2392     /************************************************************/
2393     if (doLabel)
2394     {
2395         /* calculate how far to the right can the label stretch */
2396         Label.right = Box.right;
2397         if (infoPtr->uView == LV_VIEW_DETAILS)
2398         {
2399             if (lpLVItem->iSubItem == 0)
2400             {
2401                 /* we need a zero based rect here */
2402                 Label = lpColumnInfo->rcHeader;
2403                 OffsetRect(&Label, -Label.left, 0);
2404             }
2405         }
2406
2407         if (lpLVItem->iSubItem || ((infoPtr->dwStyle & LVS_OWNERDRAWFIXED) && infoPtr->uView == LV_VIEW_DETAILS))
2408         {
2409            labelSize.cx = infoPtr->nItemWidth;
2410            labelSize.cy = infoPtr->nItemHeight;
2411            goto calc_label;
2412         }
2413
2414         /* we need the text in non owner draw mode */
2415         assert(lpLVItem->mask & LVIF_TEXT);
2416         if (is_text(lpLVItem->pszText))
2417         {
2418             HFONT hFont = infoPtr->hFont ? infoPtr->hFont : infoPtr->hDefaultFont;
2419             HDC hdc = GetDC(infoPtr->hwndSelf);
2420             HFONT hOldFont = SelectObject(hdc, hFont);
2421             UINT uFormat;
2422             RECT rcText;
2423
2424             /* compute rough rectangle where the label will go */
2425             SetRectEmpty(&rcText);
2426             rcText.right = infoPtr->nItemWidth - TRAILING_LABEL_PADDING;
2427             rcText.bottom = infoPtr->nItemHeight;
2428             if (infoPtr->uView == LV_VIEW_ICON)
2429                 rcText.bottom -= ICON_TOP_PADDING + infoPtr->iconSize.cy + ICON_BOTTOM_PADDING;
2430
2431             /* now figure out the flags */
2432             if (infoPtr->uView == LV_VIEW_ICON)
2433                 uFormat = oversizedBox ? LV_FL_DT_FLAGS : LV_ML_DT_FLAGS;
2434             else
2435                 uFormat = LV_SL_DT_FLAGS;
2436
2437             DrawTextW (hdc, lpLVItem->pszText, -1, &rcText, uFormat | DT_CALCRECT);
2438
2439             if (rcText.right != rcText.left)
2440                 labelSize.cx = min(rcText.right - rcText.left + TRAILING_LABEL_PADDING, infoPtr->nItemWidth);
2441
2442             labelSize.cy = rcText.bottom - rcText.top;
2443
2444             SelectObject(hdc, hOldFont);
2445             ReleaseDC(infoPtr->hwndSelf, hdc);
2446         }
2447
2448 calc_label:
2449         if (infoPtr->uView == LV_VIEW_ICON)
2450         {
2451             Label.left = Box.left + (infoPtr->nItemWidth - labelSize.cx) / 2;
2452             Label.top  = Box.top + ICON_TOP_PADDING_HITABLE +
2453                          infoPtr->iconSize.cy + ICON_BOTTOM_PADDING;
2454             Label.right = Label.left + labelSize.cx;
2455             Label.bottom = Label.top + infoPtr->nItemHeight;
2456             if (!oversizedBox && labelSize.cy > infoPtr->ntmHeight)
2457             {
2458                 labelSize.cy = min(Box.bottom - Label.top, labelSize.cy);
2459                 labelSize.cy /= infoPtr->ntmHeight;
2460                 labelSize.cy = max(labelSize.cy, 1);
2461                 labelSize.cy *= infoPtr->ntmHeight;
2462              }
2463              Label.bottom = Label.top + labelSize.cy + HEIGHT_PADDING;
2464         }
2465         else if (infoPtr->uView == LV_VIEW_DETAILS)
2466         {
2467             Label.left = Icon.right;
2468             Label.top = Box.top;
2469             Label.right = lpLVItem->iSubItem ? lpColumnInfo->rcHeader.right :
2470                           lpColumnInfo->rcHeader.right - lpColumnInfo->rcHeader.left;
2471             Label.bottom = Label.top + infoPtr->nItemHeight;
2472         }
2473         else /* LV_VIEW_SMALLICON or LV_VIEW_LIST */
2474         {
2475             Label.left = Icon.right;
2476             Label.top = Box.top;
2477             Label.right = min(Label.left + labelSize.cx, Label.right);
2478             Label.bottom = Label.top + infoPtr->nItemHeight;
2479         }
2480
2481         if (lprcLabel) *lprcLabel = Label;
2482         TRACE("    - label=%s\n", wine_dbgstr_rect(&Label));
2483     }
2484
2485     /************************************************************/
2486     /* compute SELECT bounding box                              */
2487     /************************************************************/
2488     if (doSelectBox)
2489     {
2490         if (infoPtr->uView == LV_VIEW_DETAILS)
2491         {
2492             SelectBox.left = Icon.left;
2493             SelectBox.top = Box.top;
2494             SelectBox.bottom = Box.bottom;
2495
2496             if (labelSize.cx)
2497                 SelectBox.right = min(Label.left + labelSize.cx, Label.right);
2498             else
2499                 SelectBox.right = min(Label.left + MAX_EMPTYTEXT_SELECT_WIDTH, Label.right);
2500         }
2501         else
2502         {
2503             UnionRect(&SelectBox, &Icon, &Label);
2504         }
2505         if (lprcSelectBox) *lprcSelectBox = SelectBox;
2506         TRACE("    - select box=%s\n", wine_dbgstr_rect(&SelectBox));
2507     }
2508
2509     /* Fix the Box if necessary */
2510     if (lprcBox)
2511     {
2512         if (oversizedBox) UnionRect(lprcBox, &Box, &Label);
2513         else *lprcBox = Box;
2514     }
2515     TRACE("    - box=%s\n", wine_dbgstr_rect(&Box));
2516 }
2517
2518 /***
2519  * DESCRIPTION:            [INTERNAL]
2520  *
2521  * PARAMETER(S):
2522  * [I] infoPtr : valid pointer to the listview structure
2523  * [I] nItem : item number
2524  * [O] lprcBox : ptr to Box rectangle
2525  *
2526  * RETURN:
2527  *   None.
2528  */
2529 static void LISTVIEW_GetItemBox(const LISTVIEW_INFO *infoPtr, INT nItem, LPRECT lprcBox)
2530 {
2531     WCHAR szDispText[DISP_TEXT_SIZE] = { '\0' };
2532     POINT Position, Origin;
2533     LVITEMW lvItem;
2534
2535     LISTVIEW_GetOrigin(infoPtr, &Origin);
2536     LISTVIEW_GetItemOrigin(infoPtr, nItem, &Position);
2537
2538     /* Be smart and try to figure out the minimum we have to do */
2539     lvItem.mask = 0;
2540     if (infoPtr->uView == LV_VIEW_ICON && infoPtr->bFocus && LISTVIEW_GetItemState(infoPtr, nItem, LVIS_FOCUSED))
2541         lvItem.mask |= LVIF_TEXT;
2542     lvItem.iItem = nItem;
2543     lvItem.iSubItem = 0;
2544     lvItem.pszText = szDispText;
2545     lvItem.cchTextMax = DISP_TEXT_SIZE;
2546     if (lvItem.mask) LISTVIEW_GetItemW(infoPtr, &lvItem);
2547     if (infoPtr->uView == LV_VIEW_ICON)
2548     {
2549         lvItem.mask |= LVIF_STATE;
2550         lvItem.stateMask = LVIS_FOCUSED;
2551         lvItem.state = (lvItem.mask & LVIF_TEXT ? LVIS_FOCUSED : 0);
2552     }
2553     LISTVIEW_GetItemMetrics(infoPtr, &lvItem, lprcBox, 0, 0, 0, 0);
2554
2555     if (infoPtr->uView == LV_VIEW_DETAILS && infoPtr->dwLvExStyle & LVS_EX_FULLROWSELECT &&
2556         SendMessageW(infoPtr->hwndHeader, HDM_ORDERTOINDEX, 0, 0))
2557     {
2558         OffsetRect(lprcBox, Origin.x, Position.y + Origin.y);
2559     }
2560     else
2561         OffsetRect(lprcBox, Position.x + Origin.x, Position.y + Origin.y);
2562 }
2563
2564 /* LISTVIEW_MapIdToIndex helper */
2565 static INT CALLBACK MapIdSearchCompare(LPVOID p1, LPVOID p2, LPARAM lParam)
2566 {
2567     ITEM_ID *id1 = (ITEM_ID*)p1;
2568     ITEM_ID *id2 = (ITEM_ID*)p2;
2569
2570     if (id1->id == id2->id) return 0;
2571
2572     return (id1->id < id2->id) ? -1 : 1;
2573 }
2574
2575 /***
2576  * DESCRIPTION:
2577  * Returns the item index for id specified.
2578  *
2579  * PARAMETER(S):
2580  * [I] infoPtr : valid pointer to the listview structure
2581  * [I] iID : item id to get index for
2582  *
2583  * RETURN:
2584  * Item index, or -1 on failure.
2585  */
2586 static INT LISTVIEW_MapIdToIndex(const LISTVIEW_INFO *infoPtr, UINT iID)
2587 {
2588     ITEM_ID ID;
2589     INT index;
2590
2591     TRACE("iID=%d\n", iID);
2592
2593     if (infoPtr->dwStyle & LVS_OWNERDATA) return -1;
2594     if (infoPtr->nItemCount == 0) return -1;
2595
2596     ID.id = iID;
2597     index = DPA_Search(infoPtr->hdpaItemIds, &ID, -1, MapIdSearchCompare, 0, DPAS_SORTED);
2598
2599     if (index != -1)
2600     {
2601         ITEM_ID *lpID = DPA_GetPtr(infoPtr->hdpaItemIds, index);
2602         return DPA_GetPtrIndex(infoPtr->hdpaItems, lpID->item);
2603     }
2604
2605     return -1;
2606 }
2607
2608 /***
2609  * DESCRIPTION:
2610  * Returns the item id for index given.
2611  *
2612  * PARAMETER(S):
2613  * [I] infoPtr : valid pointer to the listview structure
2614  * [I] iItem : item index to get id for
2615  *
2616  * RETURN:
2617  * Item id.
2618  */
2619 static DWORD LISTVIEW_MapIndexToId(const LISTVIEW_INFO *infoPtr, INT iItem)
2620 {
2621     ITEM_INFO *lpItem;
2622     HDPA hdpaSubItems;
2623
2624     TRACE("iItem=%d\n", iItem);
2625
2626     if (infoPtr->dwStyle & LVS_OWNERDATA) return -1;
2627     if (iItem < 0 || iItem >= infoPtr->nItemCount) return -1;
2628
2629     hdpaSubItems = DPA_GetPtr(infoPtr->hdpaItems, iItem);
2630     lpItem = DPA_GetPtr(hdpaSubItems, 0);
2631
2632     return lpItem->id->id;
2633 }
2634
2635 /***
2636  * DESCRIPTION:
2637  * Returns the current icon position, and advances it along the top.
2638  * The returned position is not offset by Origin.
2639  *
2640  * PARAMETER(S):
2641  * [I] infoPtr : valid pointer to the listview structure
2642  * [O] lpPos : will get the current icon position
2643  *
2644  * RETURN:
2645  * None
2646  */
2647 static void LISTVIEW_NextIconPosTop(LISTVIEW_INFO *infoPtr, LPPOINT lpPos)
2648 {
2649     INT nListWidth = infoPtr->rcList.right - infoPtr->rcList.left;
2650
2651     *lpPos = infoPtr->currIconPos;
2652
2653     infoPtr->currIconPos.x += infoPtr->nItemWidth;
2654     if (infoPtr->currIconPos.x + infoPtr->nItemWidth <= nListWidth) return;
2655
2656     infoPtr->currIconPos.x  = 0;
2657     infoPtr->currIconPos.y += infoPtr->nItemHeight;
2658 }
2659
2660
2661 /***
2662  * DESCRIPTION:
2663  * Returns the current icon position, and advances it down the left edge.
2664  * The returned position is not offset by Origin.
2665  *
2666  * PARAMETER(S):
2667  * [I] infoPtr : valid pointer to the listview structure
2668  * [O] lpPos : will get the current icon position
2669  *
2670  * RETURN:
2671  * None
2672  */
2673 static void LISTVIEW_NextIconPosLeft(LISTVIEW_INFO *infoPtr, LPPOINT lpPos)
2674 {
2675     INT nListHeight = infoPtr->rcList.bottom - infoPtr->rcList.top;
2676
2677     *lpPos = infoPtr->currIconPos;
2678
2679     infoPtr->currIconPos.y += infoPtr->nItemHeight;
2680     if (infoPtr->currIconPos.y + infoPtr->nItemHeight <= nListHeight) return;
2681
2682     infoPtr->currIconPos.x += infoPtr->nItemWidth;
2683     infoPtr->currIconPos.y  = 0;
2684 }
2685
2686
2687 /***
2688  * DESCRIPTION:
2689  * Moves an icon to the specified position.
2690  * It takes care of invalidating the item, etc.
2691  *
2692  * PARAMETER(S):
2693  * [I] infoPtr : valid pointer to the listview structure
2694  * [I] nItem : the item to move
2695  * [I] lpPos : the new icon position
2696  * [I] isNew : flags the item as being new
2697  *
2698  * RETURN:
2699  *   Success: TRUE
2700  *   Failure: FALSE
2701  */
2702 static BOOL LISTVIEW_MoveIconTo(const LISTVIEW_INFO *infoPtr, INT nItem, const POINT *lppt, BOOL isNew)
2703 {
2704     POINT old;
2705
2706     if (!isNew)
2707     {
2708         old.x = (LONG_PTR)DPA_GetPtr(infoPtr->hdpaPosX, nItem);
2709         old.y = (LONG_PTR)DPA_GetPtr(infoPtr->hdpaPosY, nItem);
2710
2711         if (lppt->x == old.x && lppt->y == old.y) return TRUE;
2712         LISTVIEW_InvalidateItem(infoPtr, nItem);
2713     }
2714
2715     /* Allocating a POINTER for every item is too resource intensive,
2716      * so we'll keep the (x,y) in different arrays */
2717     if (!DPA_SetPtr(infoPtr->hdpaPosX, nItem, (void *)(LONG_PTR)lppt->x)) return FALSE;
2718     if (!DPA_SetPtr(infoPtr->hdpaPosY, nItem, (void *)(LONG_PTR)lppt->y)) return FALSE;
2719
2720     LISTVIEW_InvalidateItem(infoPtr, nItem);
2721
2722     return TRUE;
2723 }
2724
2725 /***
2726  * DESCRIPTION:
2727  * Arranges listview items in icon display mode.
2728  *
2729  * PARAMETER(S):
2730  * [I] infoPtr : valid pointer to the listview structure
2731  * [I] nAlignCode : alignment code
2732  *
2733  * RETURN:
2734  *   SUCCESS : TRUE
2735  *   FAILURE : FALSE
2736  */
2737 static BOOL LISTVIEW_Arrange(LISTVIEW_INFO *infoPtr, INT nAlignCode)
2738 {
2739     void (*next_pos)(LISTVIEW_INFO *, LPPOINT);
2740     POINT pos;
2741     INT i;
2742
2743     if (infoPtr->uView != LV_VIEW_ICON && infoPtr->uView != LV_VIEW_SMALLICON) return FALSE;
2744
2745     TRACE("nAlignCode=%d\n", nAlignCode);
2746
2747     if (nAlignCode == LVA_DEFAULT)
2748     {
2749         if (infoPtr->dwStyle & LVS_ALIGNLEFT) nAlignCode = LVA_ALIGNLEFT;
2750         else nAlignCode = LVA_ALIGNTOP;
2751     }
2752
2753     switch (nAlignCode)
2754     {
2755     case LVA_ALIGNLEFT:  next_pos = LISTVIEW_NextIconPosLeft; break;
2756     case LVA_ALIGNTOP:   next_pos = LISTVIEW_NextIconPosTop;  break;
2757     case LVA_SNAPTOGRID: next_pos = LISTVIEW_NextIconPosTop;  break; /* FIXME */
2758     default: return FALSE;
2759     }
2760
2761     infoPtr->bAutoarrange = TRUE;
2762     infoPtr->currIconPos.x = infoPtr->currIconPos.y = 0;
2763     for (i = 0; i < infoPtr->nItemCount; i++)
2764     {
2765         next_pos(infoPtr, &pos);
2766         LISTVIEW_MoveIconTo(infoPtr, i, &pos, FALSE);
2767     }
2768
2769     return TRUE;
2770 }
2771
2772 /***
2773  * DESCRIPTION:
2774  * Retrieves the bounding rectangle of all the items, not offset by Origin.
2775  * For LVS_REPORT always returns empty rectangle.
2776  *
2777  * PARAMETER(S):
2778  * [I] infoPtr : valid pointer to the listview structure
2779  * [O] lprcView : bounding rectangle
2780  *
2781  * RETURN:
2782  *   SUCCESS : TRUE
2783  *   FAILURE : FALSE
2784  */
2785 static void LISTVIEW_GetAreaRect(const LISTVIEW_INFO *infoPtr, LPRECT lprcView)
2786 {
2787     INT i, x, y;
2788
2789     SetRectEmpty(lprcView);
2790
2791     switch (infoPtr->uView)
2792     {
2793     case LV_VIEW_ICON:
2794     case LV_VIEW_SMALLICON:
2795         for (i = 0; i < infoPtr->nItemCount; i++)
2796         {
2797             x = (LONG_PTR)DPA_GetPtr(infoPtr->hdpaPosX, i);
2798             y = (LONG_PTR)DPA_GetPtr(infoPtr->hdpaPosY, i);
2799             lprcView->right = max(lprcView->right, x);
2800             lprcView->bottom = max(lprcView->bottom, y);
2801         }
2802         if (infoPtr->nItemCount > 0)
2803         {
2804             lprcView->right += infoPtr->nItemWidth;
2805             lprcView->bottom += infoPtr->nItemHeight;
2806         }
2807         break;
2808
2809     case LV_VIEW_LIST:
2810         y = LISTVIEW_GetCountPerColumn(infoPtr);
2811         x = infoPtr->nItemCount / y;
2812         if (infoPtr->nItemCount % y) x++;
2813         lprcView->right = x * infoPtr->nItemWidth;
2814         lprcView->bottom = y * infoPtr->nItemHeight;
2815         break;
2816     }
2817 }
2818
2819 /***
2820  * DESCRIPTION:
2821  * Retrieves the bounding rectangle of all the items.
2822  *
2823  * PARAMETER(S):
2824  * [I] infoPtr : valid pointer to the listview structure
2825  * [O] lprcView : bounding rectangle
2826  *
2827  * RETURN:
2828  *   SUCCESS : TRUE
2829  *   FAILURE : FALSE
2830  */
2831 static BOOL LISTVIEW_GetViewRect(const LISTVIEW_INFO *infoPtr, LPRECT lprcView)
2832 {
2833     POINT ptOrigin;
2834
2835     TRACE("(lprcView=%p)\n", lprcView);
2836
2837     if (!lprcView) return FALSE;
2838
2839     LISTVIEW_GetAreaRect(infoPtr, lprcView);
2840
2841     if (infoPtr->uView != LV_VIEW_DETAILS)
2842     {
2843         LISTVIEW_GetOrigin(infoPtr, &ptOrigin);
2844         OffsetRect(lprcView, ptOrigin.x, ptOrigin.y);
2845     }
2846
2847     TRACE("lprcView=%s\n", wine_dbgstr_rect(lprcView));
2848
2849     return TRUE;
2850 }
2851
2852 /***
2853  * DESCRIPTION:
2854  * Retrieves the subitem pointer associated with the subitem index.
2855  *
2856  * PARAMETER(S):
2857  * [I] hdpaSubItems : DPA handle for a specific item
2858  * [I] nSubItem : index of subitem
2859  *
2860  * RETURN:
2861  *   SUCCESS : subitem pointer
2862  *   FAILURE : NULL
2863  */
2864 static SUBITEM_INFO* LISTVIEW_GetSubItemPtr(HDPA hdpaSubItems, INT nSubItem)
2865 {
2866     SUBITEM_INFO *lpSubItem;
2867     INT i;
2868
2869     /* we should binary search here if need be */
2870     for (i = 1; i < DPA_GetPtrCount(hdpaSubItems); i++)
2871     {
2872         lpSubItem = DPA_GetPtr(hdpaSubItems, i);
2873         if (lpSubItem->iSubItem == nSubItem)
2874             return lpSubItem;
2875     }
2876
2877     return NULL;
2878 }
2879
2880
2881 /***
2882  * DESCRIPTION:
2883  * Calculates the desired item width.
2884  *
2885  * PARAMETER(S):
2886  * [I] infoPtr : valid pointer to the listview structure
2887  *
2888  * RETURN:
2889  *  The desired item width.
2890  */
2891 static INT LISTVIEW_CalculateItemWidth(const LISTVIEW_INFO *infoPtr)
2892 {
2893     INT nItemWidth = 0;
2894
2895     TRACE("uView=%d\n", infoPtr->uView);
2896
2897     if (infoPtr->uView == LV_VIEW_ICON)
2898         nItemWidth = infoPtr->iconSpacing.cx;
2899     else if (infoPtr->uView == LV_VIEW_DETAILS)
2900     {
2901         if (DPA_GetPtrCount(infoPtr->hdpaColumns) > 0)
2902         {
2903             RECT rcHeader;
2904             INT index;
2905
2906             index = SendMessageW(infoPtr->hwndHeader, HDM_ORDERTOINDEX,
2907                                  DPA_GetPtrCount(infoPtr->hdpaColumns) - 1, 0);
2908
2909             LISTVIEW_GetHeaderRect(infoPtr, index, &rcHeader);
2910             nItemWidth = rcHeader.right;
2911         }
2912     }
2913     else /* LV_VIEW_SMALLICON, or LV_VIEW_LIST */
2914     {
2915         WCHAR szDispText[DISP_TEXT_SIZE] = { '\0' };
2916         LVITEMW lvItem;
2917         INT i;
2918
2919         lvItem.mask = LVIF_TEXT;
2920         lvItem.iSubItem = 0;
2921
2922         for (i = 0; i < infoPtr->nItemCount; i++)
2923         {
2924             lvItem.iItem = i;
2925             lvItem.pszText = szDispText;
2926             lvItem.cchTextMax = DISP_TEXT_SIZE;
2927             if (LISTVIEW_GetItemW(infoPtr, &lvItem))
2928                 nItemWidth = max(LISTVIEW_GetStringWidthT(infoPtr, lvItem.pszText, TRUE),
2929                                  nItemWidth);
2930         }
2931
2932         if (infoPtr->himlSmall) nItemWidth += infoPtr->iconSize.cx;
2933         if (infoPtr->himlState) nItemWidth += infoPtr->iconStateSize.cx;
2934
2935         nItemWidth = max(DEFAULT_COLUMN_WIDTH, nItemWidth + WIDTH_PADDING);
2936     }
2937
2938     return nItemWidth;
2939 }
2940
2941 /***
2942  * DESCRIPTION:
2943  * Calculates the desired item height.
2944  *
2945  * PARAMETER(S):
2946  * [I] infoPtr : valid pointer to the listview structure
2947  *
2948  * RETURN:
2949  *  The desired item height.
2950  */
2951 static INT LISTVIEW_CalculateItemHeight(const LISTVIEW_INFO *infoPtr)
2952 {
2953     INT nItemHeight;
2954
2955     TRACE("uView=%d\n", infoPtr->uView);
2956
2957     if (infoPtr->uView == LV_VIEW_ICON)
2958         nItemHeight = infoPtr->iconSpacing.cy;
2959     else
2960     {
2961         nItemHeight = infoPtr->ntmHeight;
2962         if (infoPtr->himlState)
2963             nItemHeight = max(nItemHeight, infoPtr->iconStateSize.cy);
2964         if (infoPtr->himlSmall)
2965             nItemHeight = max(nItemHeight, infoPtr->iconSize.cy);
2966         nItemHeight += HEIGHT_PADDING;
2967     if (infoPtr->nMeasureItemHeight > 0)
2968         nItemHeight = infoPtr->nMeasureItemHeight;
2969     }
2970
2971     return max(nItemHeight, 1);
2972 }
2973
2974 /***
2975  * DESCRIPTION:
2976  * Updates the width, and height of an item.
2977  *
2978  * PARAMETER(S):
2979  * [I] infoPtr : valid pointer to the listview structure
2980  *
2981  * RETURN:
2982  *  None.
2983  */
2984 static inline void LISTVIEW_UpdateItemSize(LISTVIEW_INFO *infoPtr)
2985 {
2986     infoPtr->nItemWidth = LISTVIEW_CalculateItemWidth(infoPtr);
2987     infoPtr->nItemHeight = LISTVIEW_CalculateItemHeight(infoPtr);
2988 }
2989
2990
2991 /***
2992  * DESCRIPTION:
2993  * Retrieves and saves important text metrics info for the current
2994  * Listview font.
2995  *
2996  * PARAMETER(S):
2997  * [I] infoPtr : valid pointer to the listview structure
2998  *
2999  */
3000 static void LISTVIEW_SaveTextMetrics(LISTVIEW_INFO *infoPtr)
3001 {
3002     HDC hdc = GetDC(infoPtr->hwndSelf);
3003     HFONT hFont = infoPtr->hFont ? infoPtr->hFont : infoPtr->hDefaultFont;
3004     HFONT hOldFont = SelectObject(hdc, hFont);
3005     TEXTMETRICW tm;
3006     SIZE sz;
3007
3008     if (GetTextMetricsW(hdc, &tm))
3009     {
3010         infoPtr->ntmHeight = tm.tmHeight;
3011         infoPtr->ntmMaxCharWidth = tm.tmMaxCharWidth;
3012     }
3013
3014     if (GetTextExtentPoint32A(hdc, "...", 3, &sz))
3015         infoPtr->nEllipsisWidth = sz.cx;
3016
3017     SelectObject(hdc, hOldFont);
3018     ReleaseDC(infoPtr->hwndSelf, hdc);
3019
3020     TRACE("tmHeight=%d\n", infoPtr->ntmHeight);
3021 }
3022
3023 /***
3024  * DESCRIPTION:
3025  * A compare function for ranges
3026  *
3027  * PARAMETER(S)
3028  * [I] range1 : pointer to range 1;
3029  * [I] range2 : pointer to range 2;
3030  * [I] flags : flags
3031  *
3032  * RETURNS:
3033  * > 0 : if range 1 > range 2
3034  * < 0 : if range 2 > range 1
3035  * = 0 : if range intersects range 2
3036  */
3037 static INT CALLBACK ranges_cmp(LPVOID range1, LPVOID range2, LPARAM flags)
3038 {
3039     INT cmp;
3040
3041     if (((RANGE*)range1)->upper <= ((RANGE*)range2)->lower)
3042         cmp = -1;
3043     else if (((RANGE*)range2)->upper <= ((RANGE*)range1)->lower)
3044         cmp = 1;
3045     else
3046         cmp = 0;
3047
3048     TRACE("range1=%s, range2=%s, cmp=%d\n", debugrange(range1), debugrange(range2), cmp);
3049
3050     return cmp;
3051 }
3052
3053 #define ranges_check(ranges, desc) if (TRACE_ON(listview)) ranges_assert(ranges, desc, __FILE__, __LINE__)
3054
3055 static void ranges_assert(RANGES ranges, LPCSTR desc, const char *file, int line)
3056 {
3057     INT i;
3058     RANGE *prev, *curr;
3059
3060     TRACE("*** Checking %s:%d:%s ***\n", file, line, desc);
3061     assert (ranges);
3062     assert (DPA_GetPtrCount(ranges->hdpa) >= 0);
3063     ranges_dump(ranges);
3064     if (DPA_GetPtrCount(ranges->hdpa) > 0)
3065     {
3066         prev = DPA_GetPtr(ranges->hdpa, 0);
3067         assert (prev->lower >= 0 && prev->lower < prev->upper);
3068         for (i = 1; i < DPA_GetPtrCount(ranges->hdpa); i++)
3069         {
3070             curr = DPA_GetPtr(ranges->hdpa, i);
3071             assert (prev->upper <= curr->lower);
3072             assert (curr->lower < curr->upper);
3073             prev = curr;
3074         }
3075     }
3076     TRACE("--- Done checking---\n");
3077 }
3078
3079 static RANGES ranges_create(int count)
3080 {
3081     RANGES ranges = Alloc(sizeof(struct tagRANGES));
3082     if (!ranges) return NULL;
3083     ranges->hdpa = DPA_Create(count);
3084     if (ranges->hdpa) return ranges;
3085     Free(ranges);
3086     return NULL;
3087 }
3088
3089 static void ranges_clear(RANGES ranges)
3090 {
3091     INT i;
3092
3093     for(i = 0; i < DPA_GetPtrCount(ranges->hdpa); i++)
3094         Free(DPA_GetPtr(ranges->hdpa, i));
3095     DPA_DeleteAllPtrs(ranges->hdpa);
3096 }
3097
3098
3099 static void ranges_destroy(RANGES ranges)
3100 {
3101     if (!ranges) return;
3102     ranges_clear(ranges);
3103     DPA_Destroy(ranges->hdpa);
3104     Free(ranges);
3105 }
3106
3107 static RANGES ranges_clone(RANGES ranges)
3108 {
3109     RANGES clone;
3110     INT i;
3111
3112     if (!(clone = ranges_create(DPA_GetPtrCount(ranges->hdpa)))) goto fail;
3113
3114     for (i = 0; i < DPA_GetPtrCount(ranges->hdpa); i++)
3115     {
3116         RANGE *newrng = Alloc(sizeof(RANGE));
3117         if (!newrng) goto fail;
3118         *newrng = *((RANGE*)DPA_GetPtr(ranges->hdpa, i));
3119         DPA_SetPtr(clone->hdpa, i, newrng);
3120     }
3121     return clone;
3122
3123 fail:
3124     TRACE ("clone failed\n");
3125     ranges_destroy(clone);
3126     return NULL;
3127 }
3128
3129 static RANGES ranges_diff(RANGES ranges, RANGES sub)
3130 {
3131     INT i;
3132
3133     for (i = 0; i < DPA_GetPtrCount(sub->hdpa); i++)
3134         ranges_del(ranges, *((RANGE *)DPA_GetPtr(sub->hdpa, i)));
3135
3136     return ranges;
3137 }
3138
3139 static void ranges_dump(RANGES ranges)
3140 {
3141     INT i;
3142
3143     for (i = 0; i < DPA_GetPtrCount(ranges->hdpa); i++)
3144         TRACE("   %s\n", debugrange(DPA_GetPtr(ranges->hdpa, i)));
3145 }
3146
3147 static inline BOOL ranges_contain(RANGES ranges, INT nItem)
3148 {
3149     RANGE srchrng = { nItem, nItem + 1 };
3150
3151     TRACE("(nItem=%d)\n", nItem);
3152     ranges_check(ranges, "before contain");
3153     return DPA_Search(ranges->hdpa, &srchrng, 0, ranges_cmp, 0, DPAS_SORTED) != -1;
3154 }
3155
3156 static INT ranges_itemcount(RANGES ranges)
3157 {
3158     INT i, count = 0;
3159
3160     for (i = 0; i < DPA_GetPtrCount(ranges->hdpa); i++)
3161     {
3162         RANGE *sel = DPA_GetPtr(ranges->hdpa, i);
3163         count += sel->upper - sel->lower;
3164     }
3165
3166     return count;
3167 }
3168
3169 static BOOL ranges_shift(RANGES ranges, INT nItem, INT delta, INT nUpper)
3170 {
3171     RANGE srchrng = { nItem, nItem + 1 }, *chkrng;
3172     INT index;
3173
3174     index = DPA_Search(ranges->hdpa, &srchrng, 0, ranges_cmp, 0, DPAS_SORTED | DPAS_INSERTAFTER);
3175     if (index == -1) return TRUE;
3176
3177     for (; index < DPA_GetPtrCount(ranges->hdpa); index++)
3178     {
3179         chkrng = DPA_GetPtr(ranges->hdpa, index);
3180         if (chkrng->lower >= nItem)
3181             chkrng->lower = max(min(chkrng->lower + delta, nUpper - 1), 0);
3182         if (chkrng->upper > nItem)
3183             chkrng->upper = max(min(chkrng->upper + delta, nUpper), 0);
3184     }
3185     return TRUE;
3186 }
3187
3188 static BOOL ranges_add(RANGES ranges, RANGE range)
3189 {
3190     RANGE srchrgn;
3191     INT index;
3192
3193     TRACE("(%s)\n", debugrange(&range));
3194     ranges_check(ranges, "before add");
3195
3196     /* try find overlapping regions first */
3197     srchrgn.lower = range.lower - 1;
3198     srchrgn.upper = range.upper + 1;
3199     index = DPA_Search(ranges->hdpa, &srchrgn, 0, ranges_cmp, 0, DPAS_SORTED);
3200
3201     if (index == -1)
3202     {
3203         RANGE *newrgn;
3204
3205         TRACE("Adding new range\n");
3206
3207         /* create the brand new range to insert */
3208         newrgn = Alloc(sizeof(RANGE));
3209         if(!newrgn) goto fail;
3210         *newrgn = range;
3211
3212         /* figure out where to insert it */
3213         index = DPA_Search(ranges->hdpa, newrgn, 0, ranges_cmp, 0, DPAS_SORTED | DPAS_INSERTAFTER);
3214         TRACE("index=%d\n", index);
3215         if (index == -1) index = 0;
3216
3217         /* and get it over with */
3218         if (DPA_InsertPtr(ranges->hdpa, index, newrgn) == -1)
3219         {
3220             Free(newrgn);
3221             goto fail;
3222         }
3223     }
3224     else
3225     {
3226         RANGE *chkrgn, *mrgrgn;
3227         INT fromindex, mergeindex;
3228
3229         chkrgn = DPA_GetPtr(ranges->hdpa, index);
3230         TRACE("Merge with %s @%d\n", debugrange(chkrgn), index);
3231
3232         chkrgn->lower = min(range.lower, chkrgn->lower);
3233         chkrgn->upper = max(range.upper, chkrgn->upper);
3234
3235         TRACE("New range %s @%d\n", debugrange(chkrgn), index);
3236
3237         /* merge now common ranges */
3238         fromindex = 0;
3239         srchrgn.lower = chkrgn->lower - 1;
3240         srchrgn.upper = chkrgn->upper + 1;
3241
3242         do
3243         {
3244             mergeindex = DPA_Search(ranges->hdpa, &srchrgn, fromindex, ranges_cmp, 0, 0);
3245             if (mergeindex == -1) break;
3246             if (mergeindex == index)
3247             {
3248                 fromindex = index + 1;
3249                 continue;
3250             }
3251
3252             TRACE("Merge with index %i\n", mergeindex);
3253
3254             mrgrgn = DPA_GetPtr(ranges->hdpa, mergeindex);
3255             chkrgn->lower = min(chkrgn->lower, mrgrgn->lower);
3256             chkrgn->upper = max(chkrgn->upper, mrgrgn->upper);
3257             Free(mrgrgn);
3258             DPA_DeletePtr(ranges->hdpa, mergeindex);
3259             if (mergeindex < index) index --;
3260         } while(1);
3261     }
3262
3263     ranges_check(ranges, "after add");
3264     return TRUE;
3265
3266 fail:
3267     ranges_check(ranges, "failed add");
3268     return FALSE;
3269 }
3270
3271 static BOOL ranges_del(RANGES ranges, RANGE range)
3272 {
3273     RANGE *chkrgn;
3274     INT index;
3275
3276     TRACE("(%s)\n", debugrange(&range));
3277     ranges_check(ranges, "before del");
3278
3279     /* we don't use DPAS_SORTED here, since we need *
3280      * to find the first overlapping range          */
3281     index = DPA_Search(ranges->hdpa, &range, 0, ranges_cmp, 0, 0);
3282     while(index != -1)
3283     {
3284         chkrgn = DPA_GetPtr(ranges->hdpa, index);
3285
3286         TRACE("Matches range %s @%d\n", debugrange(chkrgn), index);
3287
3288         /* case 1: Same range */
3289         if ( (chkrgn->upper == range.upper) &&
3290              (chkrgn->lower == range.lower) )
3291         {
3292             DPA_DeletePtr(ranges->hdpa, index);
3293             Free(chkrgn);
3294             break;
3295         }
3296         /* case 2: engulf */
3297         else if ( (chkrgn->upper <= range.upper) &&
3298                   (chkrgn->lower >= range.lower) )
3299         {
3300             DPA_DeletePtr(ranges->hdpa, index);
3301             Free(chkrgn);
3302         }
3303         /* case 3: overlap upper */
3304         else if ( (chkrgn->upper <= range.upper) &&
3305                   (chkrgn->lower < range.lower) )
3306         {
3307             chkrgn->upper = range.lower;
3308         }
3309         /* case 4: overlap lower */
3310         else if ( (chkrgn->upper > range.upper) &&
3311                   (chkrgn->lower >= range.lower) )
3312         {
3313             chkrgn->lower = range.upper;
3314             break;
3315         }
3316         /* case 5: fully internal */
3317         else
3318         {
3319             RANGE *newrgn;
3320
3321             if (!(newrgn = Alloc(sizeof(RANGE)))) goto fail;
3322             newrgn->lower = chkrgn->lower;
3323             newrgn->upper = range.lower;
3324             chkrgn->lower = range.upper;
3325             if (DPA_InsertPtr(ranges->hdpa, index, newrgn) == -1)
3326             {
3327                 Free(newrgn);
3328                 goto fail;
3329             }
3330             break;
3331         }
3332
3333         index = DPA_Search(ranges->hdpa, &range, index, ranges_cmp, 0, 0);
3334     }
3335
3336     ranges_check(ranges, "after del");
3337     return TRUE;
3338
3339 fail:
3340     ranges_check(ranges, "failed del");
3341     return FALSE;
3342 }
3343
3344 /***
3345 * DESCRIPTION:
3346 * Removes all selection ranges
3347 *
3348 * Parameters(s):
3349 * [I] infoPtr : valid pointer to the listview structure
3350 * [I] toSkip : item range to skip removing the selection
3351 *
3352 * RETURNS:
3353 *   SUCCESS : TRUE
3354 *   FAILURE : FALSE
3355 */
3356 static BOOL LISTVIEW_DeselectAllSkipItems(LISTVIEW_INFO *infoPtr, RANGES toSkip)
3357 {
3358     LVITEMW lvItem;
3359     ITERATOR i;
3360     RANGES clone;
3361
3362     TRACE("()\n");
3363
3364     lvItem.state = 0;
3365     lvItem.stateMask = LVIS_SELECTED;
3366
3367     /* need to clone the DPA because callbacks can change it */
3368     if (!(clone = ranges_clone(infoPtr->selectionRanges))) return FALSE;
3369     iterator_rangesitems(&i, ranges_diff(clone, toSkip));
3370     while(iterator_next(&i))
3371         LISTVIEW_SetItemState(infoPtr, i.nItem, &lvItem);
3372     /* note that the iterator destructor will free the cloned range */
3373     iterator_destroy(&i);
3374
3375     return TRUE;
3376 }
3377
3378 static inline BOOL LISTVIEW_DeselectAllSkipItem(LISTVIEW_INFO *infoPtr, INT nItem)
3379 {
3380     RANGES toSkip;
3381
3382     if (!(toSkip = ranges_create(1))) return FALSE;
3383     if (nItem != -1) ranges_additem(toSkip, nItem);
3384     LISTVIEW_DeselectAllSkipItems(infoPtr, toSkip);
3385     ranges_destroy(toSkip);
3386     return TRUE;
3387 }
3388
3389 static inline BOOL LISTVIEW_DeselectAll(LISTVIEW_INFO *infoPtr)
3390 {
3391     return LISTVIEW_DeselectAllSkipItem(infoPtr, -1);
3392 }
3393
3394 /***
3395  * DESCRIPTION:
3396  * Retrieves the number of items that are marked as selected.
3397  *
3398  * PARAMETER(S):
3399  * [I] infoPtr : valid pointer to the listview structure
3400  *
3401  * RETURN:
3402  * Number of items selected.
3403  */
3404 static INT LISTVIEW_GetSelectedCount(const LISTVIEW_INFO *infoPtr)
3405 {
3406     INT nSelectedCount = 0;
3407
3408     if (infoPtr->uCallbackMask & LVIS_SELECTED)
3409     {
3410         INT i;
3411         for (i = 0; i < infoPtr->nItemCount; i++)
3412         {
3413             if (LISTVIEW_GetItemState(infoPtr, i, LVIS_SELECTED))
3414                 nSelectedCount++;
3415         }
3416     }
3417     else
3418         nSelectedCount = ranges_itemcount(infoPtr->selectionRanges);
3419
3420     TRACE("nSelectedCount=%d\n", nSelectedCount);
3421     return nSelectedCount;
3422 }
3423
3424 /***
3425  * DESCRIPTION:
3426  * Manages the item focus.
3427  *
3428  * PARAMETER(S):
3429  * [I] infoPtr : valid pointer to the listview structure
3430  * [I] nItem : item index
3431  *
3432  * RETURN:
3433  *   TRUE : focused item changed
3434  *   FALSE : focused item has NOT changed
3435  */
3436 static inline BOOL LISTVIEW_SetItemFocus(LISTVIEW_INFO *infoPtr, INT nItem)
3437 {
3438     INT oldFocus = infoPtr->nFocusedItem;
3439     LVITEMW lvItem;
3440
3441     if (nItem == infoPtr->nFocusedItem) return FALSE;
3442
3443     lvItem.state =  nItem == -1 ? 0 : LVIS_FOCUSED;
3444     lvItem.stateMask = LVIS_FOCUSED;
3445     LISTVIEW_SetItemState(infoPtr, nItem == -1 ? infoPtr->nFocusedItem : nItem, &lvItem);
3446
3447     return oldFocus != infoPtr->nFocusedItem;
3448 }
3449
3450 /* Helper function for LISTVIEW_ShiftIndices *only* */
3451 static INT shift_item(const LISTVIEW_INFO *infoPtr, INT nShiftItem, INT nItem, INT direction)
3452 {
3453     if (nShiftItem < nItem) return nShiftItem;
3454
3455     if (nShiftItem > nItem) return nShiftItem + direction;
3456
3457     if (direction > 0) return nShiftItem + direction;
3458
3459     return min(nShiftItem, infoPtr->nItemCount - 1);
3460 }
3461
3462 /**
3463 * DESCRIPTION:
3464 * Updates the various indices after an item has been inserted or deleted.
3465 *
3466 * PARAMETER(S):
3467 * [I] infoPtr : valid pointer to the listview structure
3468 * [I] nItem : item index
3469 * [I] direction : Direction of shift, +1 or -1.
3470 *
3471 * RETURN:
3472 * None
3473 */
3474 static void LISTVIEW_ShiftIndices(LISTVIEW_INFO *infoPtr, INT nItem, INT direction)
3475 {
3476     INT nNewFocus;
3477     BOOL bOldChange;
3478
3479     /* temporarily disable change notification while shifting items */
3480     bOldChange = infoPtr->bDoChangeNotify;
3481     infoPtr->bDoChangeNotify = FALSE;
3482
3483     TRACE("Shifting %iu, %i steps\n", nItem, direction);
3484
3485     ranges_shift(infoPtr->selectionRanges, nItem, direction, infoPtr->nItemCount);
3486
3487     assert(abs(direction) == 1);
3488
3489     infoPtr->nSelectionMark = shift_item(infoPtr, infoPtr->nSelectionMark, nItem, direction);
3490
3491     nNewFocus = shift_item(infoPtr, infoPtr->nFocusedItem, nItem, direction);
3492     if (nNewFocus != infoPtr->nFocusedItem)
3493         LISTVIEW_SetItemFocus(infoPtr, nNewFocus);
3494
3495     /* But we are not supposed to modify nHotItem! */
3496
3497     infoPtr->bDoChangeNotify = bOldChange;
3498 }
3499
3500
3501 /**
3502  * DESCRIPTION:
3503  * Adds a block of selections.
3504  *
3505  * PARAMETER(S):
3506  * [I] infoPtr : valid pointer to the listview structure
3507  * [I] nItem : item index
3508  *
3509  * RETURN:
3510  * Whether the window is still valid.
3511  */
3512 static BOOL LISTVIEW_AddGroupSelection(LISTVIEW_INFO *infoPtr, INT nItem)
3513 {
3514     INT nFirst = min(infoPtr->nSelectionMark, nItem);
3515     INT nLast = max(infoPtr->nSelectionMark, nItem);
3516     HWND hwndSelf = infoPtr->hwndSelf;
3517     NMLVODSTATECHANGE nmlv;
3518     LVITEMW item;
3519     BOOL bOldChange;
3520     INT i;
3521
3522     /* Temporarily disable change notification
3523      * If the control is LVS_OWNERDATA, we need to send
3524      * only one LVN_ODSTATECHANGED notification.
3525      * See MSDN documentation for LVN_ITEMCHANGED.
3526      */
3527     bOldChange = infoPtr->bDoChangeNotify;
3528     if (infoPtr->dwStyle & LVS_OWNERDATA) infoPtr->bDoChangeNotify = FALSE;
3529
3530     if (nFirst == -1) nFirst = nItem;
3531
3532     item.state = LVIS_SELECTED;
3533     item.stateMask = LVIS_SELECTED;
3534
3535     for (i = nFirst; i <= nLast; i++)
3536         LISTVIEW_SetItemState(infoPtr,i,&item);
3537
3538     ZeroMemory(&nmlv, sizeof(nmlv));
3539     nmlv.iFrom = nFirst;
3540     nmlv.iTo = nLast;
3541     nmlv.uNewState = 0;
3542     nmlv.uOldState = item.state;
3543
3544     notify_hdr(infoPtr, LVN_ODSTATECHANGED, (LPNMHDR)&nmlv);
3545     if (!IsWindow(hwndSelf))
3546         return FALSE;
3547     infoPtr->bDoChangeNotify = bOldChange;
3548     return TRUE;
3549 }
3550
3551
3552 /***
3553  * DESCRIPTION:
3554  * Sets a single group selection.
3555  *
3556  * PARAMETER(S):
3557  * [I] infoPtr : valid pointer to the listview structure
3558  * [I] nItem : item index
3559  *
3560  * RETURN:
3561  * None
3562  */
3563 static void LISTVIEW_SetGroupSelection(LISTVIEW_INFO *infoPtr, INT nItem)
3564 {
3565     RANGES selection;
3566     LVITEMW item;
3567     ITERATOR i;
3568     BOOL bOldChange;
3569
3570     if (!(selection = ranges_create(100))) return;
3571
3572     item.state = LVIS_SELECTED;
3573     item.stateMask = LVIS_SELECTED;
3574
3575     if ((infoPtr->uView == LV_VIEW_LIST) || (infoPtr->uView == LV_VIEW_DETAILS))
3576     {
3577         if (infoPtr->nSelectionMark == -1)
3578         {
3579             infoPtr->nSelectionMark = nItem;
3580             ranges_additem(selection, nItem);
3581         }
3582         else
3583         {
3584             RANGE sel;
3585
3586             sel.lower = min(infoPtr->nSelectionMark, nItem);
3587             sel.upper = max(infoPtr->nSelectionMark, nItem) + 1;
3588             ranges_add(selection, sel);
3589         }
3590     }
3591     else
3592     {
3593         RECT rcItem, rcSel, rcSelMark;
3594         POINT ptItem;
3595
3596         rcItem.left = LVIR_BOUNDS;
3597         if (!LISTVIEW_GetItemRect(infoPtr, nItem, &rcItem)) {
3598              ranges_destroy (selection);
3599              return;
3600         }
3601         rcSelMark.left = LVIR_BOUNDS;
3602         if (!LISTVIEW_GetItemRect(infoPtr, infoPtr->nSelectionMark, &rcSelMark)) {
3603              ranges_destroy (selection);
3604              return;
3605         }
3606         UnionRect(&rcSel, &rcItem, &rcSelMark);
3607         iterator_frameditems(&i, infoPtr, &rcSel);
3608         while(iterator_next(&i))
3609         {
3610             LISTVIEW_GetItemPosition(infoPtr, i.nItem, &ptItem);
3611             if (PtInRect(&rcSel, ptItem)) ranges_additem(selection, i.nItem);
3612         }
3613         iterator_destroy(&i);
3614     }
3615
3616     /* disable per item notifications on LVS_OWNERDATA style
3617        FIXME: single LVN_ODSTATECHANGED should be used */
3618     bOldChange = infoPtr->bDoChangeNotify;
3619     if (infoPtr->dwStyle & LVS_OWNERDATA) infoPtr->bDoChangeNotify = FALSE;
3620
3621     LISTVIEW_DeselectAllSkipItems(infoPtr, selection);
3622
3623
3624     iterator_rangesitems(&i, selection);
3625     while(iterator_next(&i))
3626         LISTVIEW_SetItemState(infoPtr, i.nItem, &item);
3627     /* this will also destroy the selection */
3628     iterator_destroy(&i);
3629
3630     infoPtr->bDoChangeNotify = bOldChange;
3631
3632     LISTVIEW_SetItemFocus(infoPtr, nItem);
3633 }
3634
3635 /***
3636  * DESCRIPTION:
3637  * Sets a single selection.
3638  *
3639  * PARAMETER(S):
3640  * [I] infoPtr : valid pointer to the listview structure
3641  * [I] nItem : item index
3642  *
3643  * RETURN:
3644  * None
3645  */
3646 static void LISTVIEW_SetSelection(LISTVIEW_INFO *infoPtr, INT nItem)
3647 {
3648     LVITEMW lvItem;
3649
3650     TRACE("nItem=%d\n", nItem);
3651
3652     LISTVIEW_DeselectAllSkipItem(infoPtr, nItem);
3653
3654     lvItem.state = LVIS_FOCUSED | LVIS_SELECTED;
3655     lvItem.stateMask = LVIS_FOCUSED | LVIS_SELECTED;
3656     LISTVIEW_SetItemState(infoPtr, nItem, &lvItem);
3657
3658     infoPtr->nSelectionMark = nItem;
3659 }
3660
3661 /***
3662  * DESCRIPTION:
3663  * Set selection(s) with keyboard.
3664  *
3665  * PARAMETER(S):
3666  * [I] infoPtr : valid pointer to the listview structure
3667  * [I] nItem : item index
3668  * [I] space : VK_SPACE code sent
3669  *
3670  * RETURN:
3671  *   SUCCESS : TRUE (needs to be repainted)
3672  *   FAILURE : FALSE (nothing has changed)
3673  */
3674 static BOOL LISTVIEW_KeySelection(LISTVIEW_INFO *infoPtr, INT nItem, BOOL space)
3675 {
3676   /* FIXME: pass in the state */
3677   WORD wShift = HIWORD(GetKeyState(VK_SHIFT));
3678   WORD wCtrl = HIWORD(GetKeyState(VK_CONTROL));
3679   BOOL bResult = FALSE;
3680
3681   TRACE("nItem=%d, wShift=%d, wCtrl=%d\n", nItem, wShift, wCtrl);
3682   if ((nItem >= 0) && (nItem < infoPtr->nItemCount))
3683   {
3684     bResult = TRUE;
3685
3686     if (infoPtr->dwStyle & LVS_SINGLESEL || (wShift == 0 && wCtrl == 0))
3687       LISTVIEW_SetSelection(infoPtr, nItem);
3688     else
3689     {
3690       if (wShift)
3691         LISTVIEW_SetGroupSelection(infoPtr, nItem);
3692       else if (wCtrl)
3693       {
3694         LVITEMW lvItem;
3695         lvItem.state = ~LISTVIEW_GetItemState(infoPtr, nItem, LVIS_SELECTED);
3696         lvItem.stateMask = LVIS_SELECTED;
3697         if (space)
3698         {
3699             LISTVIEW_SetItemState(infoPtr, nItem, &lvItem);
3700             if (lvItem.state & LVIS_SELECTED)
3701                 infoPtr->nSelectionMark = nItem;
3702         }
3703         bResult = LISTVIEW_SetItemFocus(infoPtr, nItem);
3704       }
3705     }
3706     LISTVIEW_EnsureVisible(infoPtr, nItem, FALSE);
3707   }
3708
3709   UpdateWindow(infoPtr->hwndSelf); /* update client area */
3710   return bResult;
3711 }
3712
3713 static BOOL LISTVIEW_GetItemAtPt(const LISTVIEW_INFO *infoPtr, LPLVITEMW lpLVItem, POINT pt)
3714 {
3715     LVHITTESTINFO lvHitTestInfo;
3716
3717     ZeroMemory(&lvHitTestInfo, sizeof(lvHitTestInfo));
3718     lvHitTestInfo.pt.x = pt.x;
3719     lvHitTestInfo.pt.y = pt.y;
3720
3721     LISTVIEW_HitTest(infoPtr, &lvHitTestInfo, TRUE, FALSE);
3722
3723     lpLVItem->mask = LVIF_PARAM;
3724     lpLVItem->iItem = lvHitTestInfo.iItem;
3725     lpLVItem->iSubItem = 0;
3726
3727     return LISTVIEW_GetItemT(infoPtr, lpLVItem, TRUE);
3728 }
3729
3730 static inline BOOL LISTVIEW_IsHotTracking(const LISTVIEW_INFO *infoPtr)
3731 {
3732     return ((infoPtr->dwLvExStyle & LVS_EX_TRACKSELECT) ||
3733             (infoPtr->dwLvExStyle & LVS_EX_ONECLICKACTIVATE) ||
3734             (infoPtr->dwLvExStyle & LVS_EX_TWOCLICKACTIVATE));
3735 }
3736
3737 /***
3738  * DESCRIPTION:
3739  * Called when the mouse is being actively tracked and has hovered for a specified
3740  * amount of time
3741  *
3742  * PARAMETER(S):
3743  * [I] infoPtr : valid pointer to the listview structure
3744  * [I] fwKeys : key indicator
3745  * [I] x,y : mouse position
3746  *
3747  * RETURN:
3748  *   0 if the message was processed, non-zero if there was an error
3749  *
3750  * INFO:
3751  * LVS_EX_TRACKSELECT: An item is automatically selected when the cursor remains
3752  * over the item for a certain period of time.
3753  *
3754  */
3755 static LRESULT LISTVIEW_MouseHover(LISTVIEW_INFO *infoPtr, INT x, INT y)
3756 {
3757     NMHDR hdr;
3758
3759     if (notify_hdr(infoPtr, NM_HOVER, &hdr)) return 0;
3760
3761     if (LISTVIEW_IsHotTracking(infoPtr))
3762     {
3763         LVITEMW item;
3764         POINT pt;
3765
3766         pt.x = x;
3767         pt.y = y;
3768
3769         if (LISTVIEW_GetItemAtPt(infoPtr, &item, pt))
3770             LISTVIEW_SetSelection(infoPtr, item.iItem);
3771
3772         SetFocus(infoPtr->hwndSelf);
3773     }
3774
3775     return 0;
3776 }
3777
3778 #define SCROLL_LEFT   0x1
3779 #define SCROLL_RIGHT  0x2
3780 #define SCROLL_UP     0x4
3781 #define SCROLL_DOWN   0x8
3782
3783 /***
3784  * DESCRIPTION:
3785  * Utility routine to draw and highlight items within a marquee selection rectangle.
3786  *
3787  * PARAMETER(S):
3788  * [I] infoPtr     : valid pointer to the listview structure
3789  * [I] coords_orig : original co-ordinates of the cursor
3790  * [I] coords_offs : offsetted coordinates of the cursor
3791  * [I] offset      : offset amount
3792  * [I] scroll      : Bitmask of which directions we should scroll, if at all
3793  *
3794  * RETURN:
3795  *   None.
3796  */
3797 static void LISTVIEW_MarqueeHighlight(LISTVIEW_INFO *infoPtr, const POINT *coords_orig,
3798                                       const POINT *coords_offs, const POINT *offset,
3799                                       INT scroll)
3800 {
3801     BOOL controlDown = FALSE;
3802     LVITEMW item;
3803     ITERATOR old_elems, new_elems;
3804     RECT rect;
3805
3806     if (coords_offs->x > infoPtr->marqueeOrigin.x)
3807     {
3808         rect.left = infoPtr->marqueeOrigin.x;
3809         rect.right = coords_offs->x;
3810     }
3811     else
3812     {
3813         rect.left = coords_offs->x;
3814         rect.right = infoPtr->marqueeOrigin.x;
3815     }
3816
3817     if (coords_offs->y > infoPtr->marqueeOrigin.y)
3818     {
3819         rect.top = infoPtr->marqueeOrigin.y;
3820         rect.bottom = coords_offs->y;
3821     }
3822     else
3823     {
3824         rect.top = coords_offs->y;
3825         rect.bottom = infoPtr->marqueeOrigin.y;
3826     }
3827
3828     /* Cancel out the old marquee rectangle and draw the new one */
3829     LISTVIEW_InvalidateRect(infoPtr, &infoPtr->marqueeDrawRect);
3830
3831     /* Scroll by the appropriate distance if applicable - speed up scrolling as
3832        the cursor is further away */
3833
3834     if ((scroll & SCROLL_LEFT) && (coords_orig->x <= 0))
3835         LISTVIEW_Scroll(infoPtr, coords_orig->x, 0);
3836
3837     if ((scroll & SCROLL_RIGHT) && (coords_orig->x >= infoPtr->rcList.right))
3838         LISTVIEW_Scroll(infoPtr, (coords_orig->x - infoPtr->rcList.right), 0);
3839
3840     if ((scroll & SCROLL_UP) && (coords_orig->y <= 0))
3841         LISTVIEW_Scroll(infoPtr, 0, coords_orig->y);
3842
3843     if ((scroll & SCROLL_DOWN) && (coords_orig->y >= infoPtr->rcList.bottom))
3844         LISTVIEW_Scroll(infoPtr, 0, (coords_orig->y - infoPtr->rcList.bottom));
3845
3846     iterator_frameditems_absolute(&old_elems, infoPtr, &infoPtr->marqueeRect);
3847
3848     CopyRect(&infoPtr->marqueeRect, &rect);
3849
3850     CopyRect(&infoPtr->marqueeDrawRect, &rect);
3851     OffsetRect(&infoPtr->marqueeDrawRect, offset->x, offset->y);
3852
3853     iterator_frameditems_absolute(&new_elems, infoPtr, &infoPtr->marqueeRect);
3854     iterator_remove_common_items(&old_elems, &new_elems);
3855
3856     /* Iterate over no longer selected items */
3857     while (iterator_next(&old_elems))
3858     {
3859         if (old_elems.nItem > -1)
3860         {
3861             if (LISTVIEW_GetItemState(infoPtr, old_elems.nItem, LVIS_SELECTED) == LVIS_SELECTED)
3862                 item.state = 0;
3863             else
3864                 item.state = LVIS_SELECTED;
3865
3866             item.stateMask = LVIS_SELECTED;
3867
3868             LISTVIEW_SetItemState(infoPtr, old_elems.nItem, &item);
3869         }
3870     }
3871     iterator_destroy(&old_elems);
3872
3873
3874     /* Iterate over newly selected items */
3875     if (GetKeyState(VK_CONTROL) & 0x8000)
3876         controlDown = TRUE;
3877
3878     while (iterator_next(&new_elems))
3879     {
3880         if (new_elems.nItem > -1)
3881         {
3882             /* If CTRL is pressed, invert. If not, always select the item. */
3883             if ((controlDown) && (LISTVIEW_GetItemState(infoPtr, new_elems.nItem, LVIS_SELECTED)))
3884                 item.state = 0;
3885             else
3886                 item.state = LVIS_SELECTED;
3887
3888             item.stateMask = LVIS_SELECTED;
3889
3890             LISTVIEW_SetItemState(infoPtr, new_elems.nItem, &item);
3891         }
3892     }
3893     iterator_destroy(&new_elems);
3894
3895     LISTVIEW_InvalidateRect(infoPtr, &infoPtr->marqueeDrawRect);
3896 }
3897
3898 /***
3899  * DESCRIPTION:
3900  * Called when we are in a marquee selection that involves scrolling the listview (ie,
3901  * the cursor is outside the bounds of the client area). This is a TIMERPROC.
3902  *
3903  * PARAMETER(S):
3904  * [I] hwnd : Handle to the listview
3905  * [I] uMsg : WM_TIMER (ignored)
3906  * [I] idEvent : The timer ID interpreted as a pointer to a LISTVIEW_INFO struct
3907  * [I] dwTimer : The elapsed time (ignored)
3908  *
3909  * RETURN:
3910  *   None.
3911  */
3912 static VOID CALLBACK LISTVIEW_ScrollTimer(HWND hWnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
3913 {
3914     LISTVIEW_INFO *infoPtr;
3915     SCROLLINFO scrollInfo;
3916     POINT coords_orig;
3917     POINT coords_offs;
3918     POINT offset;
3919     INT scroll = 0;
3920
3921     infoPtr = (LISTVIEW_INFO *) idEvent;
3922
3923     if (!infoPtr)
3924         return;
3925
3926     /* Get the current cursor position and convert to client coordinates */
3927     GetCursorPos(&coords_orig);
3928     ScreenToClient(hWnd, &coords_orig);
3929
3930     /* Ensure coordinates are within client bounds */
3931     coords_offs.x = max(min(coords_orig.x, infoPtr->rcList.right), 0);
3932     coords_offs.y = max(min(coords_orig.y, infoPtr->rcList.bottom), 0);
3933
3934     /* Get offset */
3935     LISTVIEW_GetOrigin(infoPtr, &offset);
3936
3937     /* Offset coordinates by the appropriate amount */
3938     coords_offs.x -= offset.x;
3939     coords_offs.y -= offset.y;
3940
3941     scrollInfo.cbSize = sizeof(SCROLLINFO);
3942     scrollInfo.fMask = SIF_ALL;
3943
3944     /* Work out in which directions we can scroll */
3945     if (GetScrollInfo(infoPtr->hwndSelf, SB_VERT, &scrollInfo))
3946     {
3947         if (scrollInfo.nPos != scrollInfo.nMin)
3948             scroll |= SCROLL_UP;
3949
3950         if (((scrollInfo.nPage + scrollInfo.nPos) - 1) != scrollInfo.nMax)
3951             scroll |= SCROLL_DOWN;
3952     }
3953
3954     if (GetScrollInfo(infoPtr->hwndSelf, SB_HORZ, &scrollInfo))
3955     {
3956         if (scrollInfo.nPos != scrollInfo.nMin)
3957             scroll |= SCROLL_LEFT;
3958
3959         if (((scrollInfo.nPage + scrollInfo.nPos) - 1) != scrollInfo.nMax)
3960             scroll |= SCROLL_RIGHT;
3961     }
3962
3963     if (((coords_orig.x <= 0) && (scroll & SCROLL_LEFT)) ||
3964         ((coords_orig.y <= 0) && (scroll & SCROLL_UP))   ||
3965         ((coords_orig.x >= infoPtr->rcList.right) && (scroll & SCROLL_RIGHT)) ||
3966         ((coords_orig.y >= infoPtr->rcList.bottom) && (scroll & SCROLL_DOWN)))
3967     {
3968         LISTVIEW_MarqueeHighlight(infoPtr, &coords_orig, &coords_offs, &offset, scroll);
3969     }
3970 }
3971
3972 /***
3973  * DESCRIPTION:
3974  * Called whenever WM_MOUSEMOVE is received.
3975  *
3976  * PARAMETER(S):
3977  * [I] infoPtr : valid pointer to the listview structure
3978  * [I] fwKeys : key indicator
3979  * [I] x,y : mouse position
3980  *
3981  * RETURN:
3982  *   0 if the message is processed, non-zero if there was an error
3983  */
3984 static LRESULT LISTVIEW_MouseMove(LISTVIEW_INFO *infoPtr, WORD fwKeys, INT x, INT y)
3985 {
3986     if (!(fwKeys & MK_LBUTTON))
3987         infoPtr->bLButtonDown = FALSE;
3988
3989     if (infoPtr->bLButtonDown)
3990     {
3991         POINT tmp;
3992         RECT rect;
3993         LVHITTESTINFO lvHitTestInfo;
3994         WORD wDragWidth = GetSystemMetrics(SM_CXDRAG);
3995         WORD wDragHeight= GetSystemMetrics(SM_CYDRAG);
3996
3997         if (infoPtr->bMarqueeSelect)
3998         {
3999             POINT coords_orig;
4000             POINT coords_offs;
4001             POINT offset;
4002
4003             coords_orig.x = x;
4004             coords_orig.y = y;
4005
4006             /* Get offset */
4007             LISTVIEW_GetOrigin(infoPtr, &offset);
4008
4009             /* Ensure coordinates are within client bounds */
4010             coords_offs.x = max(min(x, infoPtr->rcList.right), 0);
4011             coords_offs.y = max(min(y, infoPtr->rcList.bottom), 0);
4012
4013             /* Offset coordinates by the appropriate amount */
4014             coords_offs.x -= offset.x;
4015             coords_offs.y -= offset.y;
4016
4017             /* Enable the timer if we're going outside our bounds, in case the user doesn't
4018                move the mouse again */
4019
4020             if ((x <= 0) || (y <= 0) || (x >= infoPtr->rcList.right) ||
4021                 (y >= infoPtr->rcList.bottom))
4022             {
4023                 if (!infoPtr->bScrolling)
4024                 {
4025                     infoPtr->bScrolling = TRUE;
4026                     SetTimer(infoPtr->hwndSelf, (UINT_PTR) infoPtr, 1, LISTVIEW_ScrollTimer);
4027                 }
4028             }
4029             else
4030             {
4031                 infoPtr->bScrolling = FALSE;
4032                 KillTimer(infoPtr->hwndSelf, (UINT_PTR) infoPtr);
4033             }
4034
4035             LISTVIEW_MarqueeHighlight(infoPtr, &coords_orig, &coords_offs, &offset, 0);
4036             return 0;
4037         }
4038
4039         rect.left = infoPtr->ptClickPos.x - wDragWidth;
4040         rect.right = infoPtr->ptClickPos.x + wDragWidth;
4041         rect.top = infoPtr->ptClickPos.y - wDragHeight;
4042         rect.bottom = infoPtr->ptClickPos.y + wDragHeight;
4043
4044         tmp.x = x;
4045         tmp.y = y;
4046
4047         lvHitTestInfo.pt = tmp;
4048         LISTVIEW_HitTest(infoPtr, &lvHitTestInfo, TRUE, TRUE);
4049
4050         /* reset item marker */
4051         if (infoPtr->nLButtonDownItem != lvHitTestInfo.iItem)
4052             infoPtr->nLButtonDownItem = -1;
4053
4054         if (!PtInRect(&rect, tmp))
4055         {
4056             /* this path covers the following:
4057                1. WM_LBUTTONDOWN over selected item (sets focus on it)
4058                2. change focus with keys
4059                3. move mouse over item from step 1 selects it and moves focus on it */
4060             if (infoPtr->nLButtonDownItem != -1 &&
4061                !LISTVIEW_GetItemState(infoPtr, infoPtr->nLButtonDownItem, LVIS_SELECTED))
4062             {
4063                 LVITEMW lvItem;
4064
4065                 lvItem.state =  LVIS_FOCUSED | LVIS_SELECTED;
4066                 lvItem.stateMask = LVIS_FOCUSED | LVIS_SELECTED;
4067
4068                 LISTVIEW_SetItemState(infoPtr, infoPtr->nLButtonDownItem, &lvItem);
4069                 infoPtr->nLButtonDownItem = -1;
4070             }
4071
4072             if (!infoPtr->bDragging)
4073             {
4074                 lvHitTestInfo.pt = infoPtr->ptClickPos;
4075                 LISTVIEW_HitTest(infoPtr, &lvHitTestInfo, TRUE, TRUE);
4076
4077                 /* If the click is outside the range of an item, begin a
4078                    highlight. If not, begin an item drag. */
4079                 if (lvHitTestInfo.iItem == -1)
4080                 {
4081                     NMHDR hdr;
4082
4083                     /* If we're allowing multiple selections, send notification.
4084                        If return value is non-zero, cancel. */
4085                     if (!(infoPtr->dwStyle & LVS_SINGLESEL) && (notify_hdr(infoPtr, LVN_MARQUEEBEGIN, &hdr) == 0))
4086                     {
4087                         /* Store the absolute coordinates of the click */
4088                         POINT offset;
4089                         LISTVIEW_GetOrigin(infoPtr, &offset);
4090
4091                         infoPtr->marqueeOrigin.x = infoPtr->ptClickPos.x - offset.x;
4092                         infoPtr->marqueeOrigin.y = infoPtr->ptClickPos.y - offset.y;
4093
4094                         /* Begin selection and capture mouse */
4095                         infoPtr->bMarqueeSelect = TRUE;
4096                         SetCapture(infoPtr->hwndSelf);
4097                     }
4098                 }
4099                 else
4100                 {
4101                     NMLISTVIEW nmlv;
4102
4103                     ZeroMemory(&nmlv, sizeof(nmlv));
4104                     nmlv.iItem = lvHitTestInfo.iItem;
4105                     nmlv.ptAction = infoPtr->ptClickPos;
4106
4107                     notify_listview(infoPtr, LVN_BEGINDRAG, &nmlv);
4108                     infoPtr->bDragging = TRUE;
4109                 }
4110             }
4111
4112             return 0;
4113         }
4114     }
4115
4116     /* see if we are supposed to be tracking mouse hovering */
4117     if (LISTVIEW_IsHotTracking(infoPtr)) {
4118         TRACKMOUSEEVENT trackinfo;
4119
4120         trackinfo.cbSize = sizeof(TRACKMOUSEEVENT);
4121         trackinfo.dwFlags = TME_QUERY;
4122
4123         /* see if we are already tracking this hwnd */
4124         _TrackMouseEvent(&trackinfo);
4125
4126         if(!(trackinfo.dwFlags & TME_HOVER) || trackinfo.hwndTrack != infoPtr->hwndSelf) {
4127             trackinfo.dwFlags     = TME_HOVER;
4128             trackinfo.dwHoverTime = infoPtr->dwHoverTime;
4129             trackinfo.hwndTrack   = infoPtr->hwndSelf;
4130
4131             /* call TRACKMOUSEEVENT so we receive WM_MOUSEHOVER messages */
4132             _TrackMouseEvent(&trackinfo);
4133         }
4134     }
4135
4136     return 0;
4137 }
4138
4139
4140 /***
4141  * Tests whether the item is assignable to a list with style lStyle
4142  */
4143 static inline BOOL is_assignable_item(const LVITEMW *lpLVItem, LONG lStyle)
4144 {
4145     if ( (lpLVItem->mask & LVIF_TEXT) &&
4146         (lpLVItem->pszText == LPSTR_TEXTCALLBACKW) &&
4147         (lStyle & (LVS_SORTASCENDING | LVS_SORTDESCENDING)) ) return FALSE;
4148
4149     return TRUE;
4150 }
4151
4152
4153 /***
4154  * DESCRIPTION:
4155  * Helper for LISTVIEW_SetItemT *only*: sets item attributes.
4156  *
4157  * PARAMETER(S):
4158  * [I] infoPtr : valid pointer to the listview structure
4159  * [I] lpLVItem : valid pointer to new item attributes
4160  * [I] isNew : the item being set is being inserted
4161  * [I] isW : TRUE if lpLVItem is Unicode, FALSE if it's ANSI
4162  * [O] bChanged : will be set to TRUE if the item really changed
4163  *
4164  * RETURN:
4165  *   SUCCESS : TRUE
4166  *   FAILURE : FALSE
4167  */
4168 static BOOL set_main_item(LISTVIEW_INFO *infoPtr, const LVITEMW *lpLVItem, BOOL isNew, BOOL isW, BOOL *bChanged)
4169 {
4170     ITEM_INFO *lpItem;
4171     NMLISTVIEW nmlv;
4172     UINT uChanged = 0;
4173     LVITEMW item;
4174     /* stateMask is ignored for LVM_INSERTITEM */
4175     UINT stateMask = isNew ? ~0 : lpLVItem->stateMask;
4176
4177     TRACE("()\n");
4178
4179     assert(lpLVItem->iItem >= 0 && lpLVItem->iItem < infoPtr->nItemCount);
4180
4181     if (lpLVItem->mask == 0) return TRUE;
4182
4183     if (infoPtr->dwStyle & LVS_OWNERDATA)
4184     {
4185         /* a virtual listview only stores selection and focus */
4186         if (lpLVItem->mask & ~LVIF_STATE)
4187             return FALSE;
4188         lpItem = NULL;
4189     }
4190     else
4191     {
4192         HDPA hdpaSubItems = DPA_GetPtr(infoPtr->hdpaItems, lpLVItem->iItem);
4193         lpItem = DPA_GetPtr(hdpaSubItems, 0);
4194         assert (lpItem);
4195     }
4196
4197     /* we need to get the lParam and state of the item */
4198     item.iItem = lpLVItem->iItem;
4199     item.iSubItem = lpLVItem->iSubItem;
4200     item.mask = LVIF_STATE | LVIF_PARAM;
4201     item.stateMask = (infoPtr->dwStyle & LVS_OWNERDATA) ? LVIS_FOCUSED | LVIS_SELECTED : ~0;
4202
4203     item.state = 0;
4204     item.lParam = 0;
4205     if (!isNew && !LISTVIEW_GetItemW(infoPtr, &item)) return FALSE;
4206
4207     TRACE("oldState=%x, newState=%x\n", item.state, lpLVItem->state);
4208     /* determine what fields will change */
4209     if ((lpLVItem->mask & LVIF_STATE) && ((item.state ^ lpLVItem->state) & stateMask & ~infoPtr->uCallbackMask))
4210         uChanged |= LVIF_STATE;
4211
4212     if ((lpLVItem->mask & LVIF_IMAGE) && (lpItem->hdr.iImage != lpLVItem->iImage))
4213         uChanged |= LVIF_IMAGE;
4214
4215     if ((lpLVItem->mask & LVIF_PARAM) && (lpItem->lParam != lpLVItem->lParam))
4216         uChanged |= LVIF_PARAM;
4217
4218     if ((lpLVItem->mask & LVIF_INDENT) && (lpItem->iIndent != lpLVItem->iIndent))
4219         uChanged |= LVIF_INDENT;
4220
4221     if ((lpLVItem->mask & LVIF_TEXT) && textcmpWT(lpItem->hdr.pszText, lpLVItem->pszText, isW))
4222         uChanged |= LVIF_TEXT;
4223
4224     TRACE("uChanged=0x%x\n", uChanged);
4225     if (!uChanged) return TRUE;
4226     *bChanged = TRUE;
4227
4228     ZeroMemory(&nmlv, sizeof(NMLISTVIEW));
4229     nmlv.iItem = lpLVItem->iItem;
4230     nmlv.uNewState = (item.state & ~stateMask) | (lpLVItem->state & stateMask);
4231     nmlv.uOldState = item.state;
4232     nmlv.uChanged = uChanged;
4233     nmlv.lParam = item.lParam;
4234
4235     /* send LVN_ITEMCHANGING notification, if the item is not being inserted */
4236     /* and we are _NOT_ virtual (LVS_OWNERDATA), and change notifications */
4237     /* are enabled */
4238     if(lpItem && !isNew && infoPtr->bDoChangeNotify)
4239     {
4240       HWND hwndSelf = infoPtr->hwndSelf;
4241
4242       if (notify_listview(infoPtr, LVN_ITEMCHANGING, &nmlv))
4243         return FALSE;
4244       if (!IsWindow(hwndSelf))
4245         return FALSE;
4246     }
4247
4248     /* copy information */
4249     if (lpLVItem->mask & LVIF_TEXT)
4250         textsetptrT(&lpItem->hdr.pszText, lpLVItem->pszText, isW);
4251
4252     if (lpLVItem->mask & LVIF_IMAGE)
4253         lpItem->hdr.iImage = lpLVItem->iImage;
4254
4255     if (lpLVItem->mask & LVIF_PARAM)
4256         lpItem->lParam = lpLVItem->lParam;
4257
4258     if (lpLVItem->mask & LVIF_INDENT)
4259         lpItem->iIndent = lpLVItem->iIndent;
4260
4261     if (uChanged & LVIF_STATE)
4262     {
4263         if (lpItem && (stateMask & ~infoPtr->uCallbackMask))
4264         {
4265             lpItem->state &= ~stateMask;
4266             lpItem->state |= (lpLVItem->state & stateMask);
4267         }
4268         if (lpLVItem->state & stateMask & ~infoPtr->uCallbackMask & LVIS_SELECTED)
4269         {
4270             if (infoPtr->dwStyle & LVS_SINGLESEL) LISTVIEW_DeselectAllSkipItem(infoPtr, lpLVItem->iItem);
4271             ranges_additem(infoPtr->selectionRanges, lpLVItem->iItem);
4272         }
4273         else if (stateMask & LVIS_SELECTED)
4274         {
4275             ranges_delitem(infoPtr->selectionRanges, lpLVItem->iItem);
4276         }
4277         /* if we are asked to change focus, and we manage it, do it */
4278         if (stateMask & ~infoPtr->uCallbackMask & LVIS_FOCUSED)
4279         {
4280             if (lpLVItem->state & LVIS_FOCUSED)
4281             {
4282                 /* update selection mark */
4283                 if (infoPtr->nFocusedItem == -1 && infoPtr->nSelectionMark == -1)
4284                     infoPtr->nSelectionMark = lpLVItem->iItem;
4285
4286                 if (infoPtr->nFocusedItem != -1)
4287                 {
4288                     /* remove current focus */
4289                     item.mask  = LVIF_STATE;
4290                     item.state = 0;
4291                     item.stateMask = LVIS_FOCUSED;
4292
4293                     /* recurse with redrawing an item */
4294                     LISTVIEW_SetItemState(infoPtr, infoPtr->nFocusedItem, &item);
4295                 }
4296
4297                 infoPtr->nFocusedItem = lpLVItem->iItem;
4298                 LISTVIEW_EnsureVisible(infoPtr, lpLVItem->iItem, infoPtr->uView == LV_VIEW_LIST);
4299             }
4300             else if (infoPtr->nFocusedItem == lpLVItem->iItem)
4301             {
4302                 infoPtr->nFocusedItem = -1;
4303             }
4304         }
4305     }
4306
4307     /* if we're inserting the item, we're done */
4308     if (isNew) return TRUE;
4309
4310     /* send LVN_ITEMCHANGED notification */
4311     if (lpLVItem->mask & LVIF_PARAM) nmlv.lParam = lpLVItem->lParam;
4312     if (infoPtr->bDoChangeNotify) notify_listview(infoPtr, LVN_ITEMCHANGED, &nmlv);
4313
4314     return TRUE;
4315 }
4316
4317 /***
4318  * DESCRIPTION:
4319  * Helper for LISTVIEW_{Set,Insert}ItemT *only*: sets subitem attributes.
4320  *
4321  * PARAMETER(S):
4322  * [I] infoPtr : valid pointer to the listview structure
4323  * [I] lpLVItem : valid pointer to new subitem attributes
4324  * [I] isW : TRUE if lpLVItem is Unicode, FALSE if it's ANSI
4325  * [O] bChanged : will be set to TRUE if the item really changed
4326  *
4327  * RETURN:
4328  *   SUCCESS : TRUE
4329  *   FAILURE : FALSE
4330  */
4331 static BOOL set_sub_item(const LISTVIEW_INFO *infoPtr, const LVITEMW *lpLVItem, BOOL isW, BOOL *bChanged)
4332 {
4333     HDPA hdpaSubItems;
4334     SUBITEM_INFO *lpSubItem;
4335
4336     /* we do not support subitems for virtual listviews */
4337     if (infoPtr->dwStyle & LVS_OWNERDATA) return FALSE;
4338
4339     /* set subitem only if column is present */
4340     if (lpLVItem->iSubItem >= DPA_GetPtrCount(infoPtr->hdpaColumns)) return FALSE;
4341
4342     /* First do some sanity checks */
4343     /* The LVIF_STATE flag is valid for subitems, but does not appear to be
4344        particularly useful. We currently do not actually do anything with
4345        the flag on subitems.
4346     */
4347     if (lpLVItem->mask & ~(LVIF_TEXT | LVIF_IMAGE | LVIF_STATE | LVIF_DI_SETITEM)) return FALSE;
4348     if (!(lpLVItem->mask & (LVIF_TEXT | LVIF_IMAGE | LVIF_STATE))) return TRUE;
4349
4350     /* get the subitem structure, and create it if not there */
4351     hdpaSubItems = DPA_GetPtr(infoPtr->hdpaItems, lpLVItem->iItem);
4352     assert (hdpaSubItems);
4353
4354     lpSubItem = LISTVIEW_GetSubItemPtr(hdpaSubItems, lpLVItem->iSubItem);
4355     if (!lpSubItem)
4356     {
4357         SUBITEM_INFO *tmpSubItem;
4358         INT i;
4359
4360         lpSubItem = Alloc(sizeof(SUBITEM_INFO));
4361         if (!lpSubItem) return FALSE;
4362         /* we could binary search here, if need be...*/
4363         for (i = 1; i < DPA_GetPtrCount(hdpaSubItems); i++)
4364         {
4365             tmpSubItem = DPA_GetPtr(hdpaSubItems, i);
4366             if (tmpSubItem->iSubItem > lpLVItem->iSubItem) break;
4367         }
4368         if (DPA_InsertPtr(hdpaSubItems, i, lpSubItem) == -1)
4369         {
4370             Free(lpSubItem);
4371             return FALSE;
4372         }
4373         lpSubItem->iSubItem = lpLVItem->iSubItem;
4374         lpSubItem->hdr.iImage = I_IMAGECALLBACK;
4375         *bChanged = TRUE;
4376     }
4377
4378     if ((lpLVItem->mask & LVIF_IMAGE) && (lpSubItem->hdr.iImage != lpLVItem->iImage))
4379     {
4380         lpSubItem->hdr.iImage = lpLVItem->iImage;
4381         *bChanged = TRUE;
4382     }
4383
4384     if ((lpLVItem->mask & LVIF_TEXT) && textcmpWT(lpSubItem->hdr.pszText, lpLVItem->pszText, isW))
4385     {
4386         textsetptrT(&lpSubItem->hdr.pszText, lpLVItem->pszText, isW);
4387         *bChanged = TRUE;
4388     }
4389
4390     return TRUE;
4391 }
4392
4393 /***
4394  * DESCRIPTION:
4395  * Sets item attributes.
4396  *
4397  * PARAMETER(S):
4398  * [I] infoPtr : valid pointer to the listview structure
4399  * [I] lpLVItem : new item attributes
4400  * [I] isW : TRUE if lpLVItem is Unicode, FALSE if it's ANSI
4401  *
4402  * RETURN:
4403  *   SUCCESS : TRUE
4404  *   FAILURE : FALSE
4405  */
4406 static BOOL LISTVIEW_SetItemT(LISTVIEW_INFO *infoPtr, LVITEMW *lpLVItem, BOOL isW)
4407 {
4408     HWND hwndSelf = infoPtr->hwndSelf;
4409     LPWSTR pszText = NULL;
4410     BOOL bResult, bChanged = FALSE;
4411     RECT oldItemArea;
4412
4413     TRACE("(lpLVItem=%s, isW=%d)\n", debuglvitem_t(lpLVItem, isW), isW);
4414
4415     if (!lpLVItem || lpLVItem->iItem < 0 || lpLVItem->iItem >= infoPtr->nItemCount)
4416         return FALSE;
4417
4418     /* Store old item area */
4419     LISTVIEW_GetItemBox(infoPtr, lpLVItem->iItem, &oldItemArea);
4420
4421     /* For efficiency, we transform the lpLVItem->pszText to Unicode here */
4422     if ((lpLVItem->mask & LVIF_TEXT) && is_text(lpLVItem->pszText))
4423     {
4424         pszText = lpLVItem->pszText;
4425         lpLVItem->pszText = textdupTtoW(lpLVItem->pszText, isW);
4426     }
4427
4428     /* actually set the fields */
4429     if (!is_assignable_item(lpLVItem, infoPtr->dwStyle)) return FALSE;
4430
4431     if (lpLVItem->iSubItem)
4432         bResult = set_sub_item(infoPtr, lpLVItem, TRUE, &bChanged);
4433     else
4434         bResult = set_main_item(infoPtr, lpLVItem, FALSE, TRUE, &bChanged);
4435     if (!IsWindow(hwndSelf))
4436         return FALSE;
4437
4438     /* redraw item, if necessary */
4439     if (bChanged && !infoPtr->bIsDrawing)
4440     {
4441         /* this little optimization eliminates some nasty flicker */
4442         if ( infoPtr->uView == LV_VIEW_DETAILS && !(infoPtr->dwStyle & LVS_OWNERDRAWFIXED) &&
4443              !(infoPtr->dwLvExStyle & LVS_EX_FULLROWSELECT) &&
4444              lpLVItem->iSubItem > 0 && lpLVItem->iSubItem <= DPA_GetPtrCount(infoPtr->hdpaColumns) )
4445             LISTVIEW_InvalidateSubItem(infoPtr, lpLVItem->iItem, lpLVItem->iSubItem);
4446         else
4447         {
4448             LISTVIEW_InvalidateRect(infoPtr, &oldItemArea);
4449             LISTVIEW_InvalidateItem(infoPtr, lpLVItem->iItem);
4450         }
4451     }
4452     /* restore text */
4453     if (pszText)
4454     {
4455         textfreeT(lpLVItem->pszText, isW);
4456         lpLVItem->pszText = pszText;
4457     }
4458
4459     return bResult;
4460 }
4461
4462 /***
4463  * DESCRIPTION:
4464  * Retrieves the index of the item at coordinate (0, 0) of the client area.
4465  *
4466  * PARAMETER(S):
4467  * [I] infoPtr : valid pointer to the listview structure
4468  *
4469  * RETURN:
4470  * item index
4471  */
4472 static INT LISTVIEW_GetTopIndex(const LISTVIEW_INFO *infoPtr)
4473 {
4474     INT nItem = 0;
4475     SCROLLINFO scrollInfo;
4476
4477     scrollInfo.cbSize = sizeof(SCROLLINFO);
4478     scrollInfo.fMask = SIF_POS;
4479
4480     if (infoPtr->uView == LV_VIEW_LIST)
4481     {
4482         if (GetScrollInfo(infoPtr->hwndSelf, SB_HORZ, &scrollInfo))
4483             nItem = scrollInfo.nPos * LISTVIEW_GetCountPerColumn(infoPtr);
4484     }
4485     else if (infoPtr->uView == LV_VIEW_DETAILS)
4486     {
4487         if (GetScrollInfo(infoPtr->hwndSelf, SB_VERT, &scrollInfo))
4488             nItem = scrollInfo.nPos;
4489     }
4490     else
4491     {
4492         if (GetScrollInfo(infoPtr->hwndSelf, SB_VERT, &scrollInfo))
4493             nItem = LISTVIEW_GetCountPerRow(infoPtr) * (scrollInfo.nPos / infoPtr->nItemHeight);
4494     }
4495
4496     TRACE("nItem=%d\n", nItem);
4497
4498     return nItem;
4499 }
4500
4501
4502 /***
4503  * DESCRIPTION:
4504  * Erases the background of the given rectangle
4505  *
4506  * PARAMETER(S):
4507  * [I] infoPtr : valid pointer to the listview structure
4508  * [I] hdc : device context handle
4509  * [I] lprcBox : clipping rectangle
4510  *
4511  * RETURN:
4512  *   Success: TRUE
4513  *   Failure: FALSE
4514  */
4515 static inline BOOL LISTVIEW_FillBkgnd(const LISTVIEW_INFO *infoPtr, HDC hdc, const RECT *lprcBox)
4516 {
4517     if (!infoPtr->hBkBrush) return FALSE;
4518
4519     TRACE("(hdc=%p, lprcBox=%s, hBkBrush=%p)\n", hdc, wine_dbgstr_rect(lprcBox), infoPtr->hBkBrush);
4520
4521     return FillRect(hdc, lprcBox, infoPtr->hBkBrush);
4522 }
4523
4524 /***
4525  * DESCRIPTION:
4526  * Draws an item.
4527  *
4528  * PARAMETER(S):
4529  * [I] infoPtr : valid pointer to the listview structure
4530  * [I] hdc : device context handle
4531  * [I] nItem : item index
4532  * [I] nSubItem : subitem index
4533  * [I] pos : item position in client coordinates
4534  * [I] cdmode : custom draw mode
4535  *
4536  * RETURN:
4537  *   Success: TRUE
4538  *   Failure: FALSE
4539  */
4540 static BOOL LISTVIEW_DrawItem(LISTVIEW_INFO *infoPtr, HDC hdc, INT nItem, INT nSubItem, POINT pos, DWORD cdmode)
4541 {
4542     UINT uFormat;
4543     WCHAR szDispText[DISP_TEXT_SIZE] = { '\0' };
4544     static WCHAR szCallback[] = { '(', 'c', 'a', 'l', 'l', 'b', 'a', 'c', 'k', ')', 0 };
4545     DWORD cdsubitemmode = CDRF_DODEFAULT;
4546     LPRECT lprcFocus;
4547     RECT rcSelect, rcBox, rcIcon, rcLabel, rcStateIcon;
4548     NMLVCUSTOMDRAW nmlvcd;
4549     HIMAGELIST himl;
4550     LVITEMW lvItem;
4551     HFONT hOldFont;
4552
4553     TRACE("(hdc=%p, nItem=%d, nSubItem=%d, pos=%s)\n", hdc, nItem, nSubItem, wine_dbgstr_point(&pos));
4554
4555     /* get information needed for drawing the item */
4556     lvItem.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM;
4557     if (nSubItem == 0) lvItem.mask |= LVIF_STATE;
4558     if (infoPtr->uView == LV_VIEW_DETAILS) lvItem.mask |= LVIF_INDENT;
4559     lvItem.stateMask = LVIS_SELECTED | LVIS_FOCUSED | LVIS_STATEIMAGEMASK | LVIS_CUT;
4560     lvItem.iItem = nItem;
4561     lvItem.iSubItem = nSubItem;
4562     lvItem.state = 0;
4563     lvItem.lParam = 0;
4564     lvItem.cchTextMax = DISP_TEXT_SIZE;
4565     lvItem.pszText = szDispText;
4566     if (!LISTVIEW_GetItemW(infoPtr, &lvItem)) return FALSE;
4567     if (nSubItem > 0 && (infoPtr->dwLvExStyle & LVS_EX_FULLROWSELECT))
4568         lvItem.state = LISTVIEW_GetItemState(infoPtr, nItem, LVIS_SELECTED);
4569     if (lvItem.pszText == LPSTR_TEXTCALLBACKW) lvItem.pszText = szCallback;
4570     TRACE("   lvItem=%s\n", debuglvitem_t(&lvItem, TRUE));
4571
4572     /* now check if we need to update the focus rectangle */
4573     lprcFocus = infoPtr->bFocus && (lvItem.state & LVIS_FOCUSED) ? &infoPtr->rcFocus : 0;
4574
4575     if (!lprcFocus) lvItem.state &= ~LVIS_FOCUSED;
4576     LISTVIEW_GetItemMetrics(infoPtr, &lvItem, &rcBox, &rcSelect, &rcIcon, &rcStateIcon, &rcLabel);
4577     OffsetRect(&rcBox, pos.x, pos.y);
4578     OffsetRect(&rcSelect, pos.x, pos.y);
4579     OffsetRect(&rcIcon, pos.x, pos.y);
4580     OffsetRect(&rcStateIcon, pos.x, pos.y);
4581     OffsetRect(&rcLabel, pos.x, pos.y);
4582     TRACE("    rcBox=%s, rcSelect=%s, rcIcon=%s. rcLabel=%s\n",
4583         wine_dbgstr_rect(&rcBox), wine_dbgstr_rect(&rcSelect),
4584         wine_dbgstr_rect(&rcIcon), wine_dbgstr_rect(&rcLabel));
4585
4586     /* fill in the custom draw structure */
4587     customdraw_fill(&nmlvcd, infoPtr, hdc, &rcBox, &lvItem);
4588
4589     hOldFont = GetCurrentObject(hdc, OBJ_FONT);
4590     if (nSubItem > 0) cdmode = infoPtr->cditemmode;
4591     if (cdmode & CDRF_SKIPDEFAULT) goto postpaint;
4592     if (cdmode & CDRF_NOTIFYITEMDRAW)
4593         cdsubitemmode = notify_customdraw(infoPtr, CDDS_PREPAINT, &nmlvcd);
4594     if (nSubItem == 0) infoPtr->cditemmode = cdsubitemmode;
4595     if (cdsubitemmode & CDRF_SKIPDEFAULT) goto postpaint;
4596     /* we have to send a CDDS_SUBITEM customdraw explicitly for subitem 0 */
4597     if (nSubItem == 0 && cdsubitemmode == CDRF_NOTIFYITEMDRAW)
4598     {
4599         cdsubitemmode = notify_customdraw(infoPtr, CDDS_SUBITEM | CDDS_ITEMPREPAINT, &nmlvcd);
4600         if (cdsubitemmode & CDRF_SKIPDEFAULT) goto postpaint;
4601     }
4602     if (nSubItem == 0 || (cdmode & CDRF_NOTIFYITEMDRAW))
4603         prepaint_setup(infoPtr, hdc, &nmlvcd, FALSE);
4604     else if ((infoPtr->dwLvExStyle & LVS_EX_FULLROWSELECT) == FALSE)
4605         prepaint_setup(infoPtr, hdc, &nmlvcd, TRUE);
4606
4607     /* in full row select, subitems, will just use main item's colors */
4608     if (nSubItem && infoPtr->uView == LV_VIEW_DETAILS && (infoPtr->dwLvExStyle & LVS_EX_FULLROWSELECT))
4609         nmlvcd.clrTextBk = CLR_NONE;
4610
4611     /* FIXME: temporary hack */
4612     rcSelect.left = rcLabel.left;
4613
4614     /* draw the selection background, if we're drawing the main item */
4615     if (nSubItem == 0)
4616     {
4617         /* in icon mode, the label rect is really what we want to draw the
4618          * background for */
4619         if (infoPtr->uView == LV_VIEW_ICON)
4620             rcSelect = rcLabel;
4621
4622         if (infoPtr->uView == LV_VIEW_DETAILS && (infoPtr->dwLvExStyle & LVS_EX_FULLROWSELECT))
4623         {
4624             /* we have to update left focus bound too if item isn't in leftmost column
4625                and reduce right box bound */
4626             if (DPA_GetPtrCount(infoPtr->hdpaColumns) > 0)
4627             {
4628                 INT leftmost;
4629
4630                 if ((leftmost = SendMessageW(infoPtr->hwndHeader, HDM_ORDERTOINDEX, 0, 0)))
4631                 {
4632                     INT Originx = pos.x - LISTVIEW_GetColumnInfo(infoPtr, 0)->rcHeader.left;
4633                     INT index = SendMessageW(infoPtr->hwndHeader, HDM_ORDERTOINDEX,
4634                                 DPA_GetPtrCount(infoPtr->hdpaColumns) - 1, 0);
4635
4636                     rcBox.right   = LISTVIEW_GetColumnInfo(infoPtr, index)->rcHeader.right + Originx;
4637                     rcSelect.left = LISTVIEW_GetColumnInfo(infoPtr, leftmost)->rcHeader.left + Originx;
4638                 }
4639             }
4640
4641             rcSelect.right = rcBox.right;
4642         }
4643
4644         if (nmlvcd.clrTextBk != CLR_NONE)
4645             ExtTextOutW(hdc, rcSelect.left, rcSelect.top, ETO_OPAQUE, &rcSelect, NULL, 0, NULL);
4646         /* store new focus rectangle */
4647         if (infoPtr->nFocusedItem == nItem) infoPtr->rcFocus = rcSelect;
4648     }
4649
4650     /* state icons */
4651     if (infoPtr->himlState && STATEIMAGEINDEX(lvItem.state) && (nSubItem == 0))
4652     {
4653         UINT uStateImage = STATEIMAGEINDEX(lvItem.state);
4654         if (uStateImage)
4655         {
4656              TRACE("uStateImage=%d\n", uStateImage);
4657              ImageList_Draw(infoPtr->himlState, uStateImage - 1, hdc,
4658                  rcStateIcon.left, rcStateIcon.top, ILD_NORMAL);
4659         }
4660     }
4661
4662     /* item icons */
4663     himl = (infoPtr->uView == LV_VIEW_ICON ? infoPtr->himlNormal : infoPtr->himlSmall);
4664     if (himl && lvItem.iImage >= 0 && !IsRectEmpty(&rcIcon))
4665     {
4666         UINT style;
4667
4668         TRACE("iImage=%d\n", lvItem.iImage);
4669
4670         if (lvItem.state & (LVIS_SELECTED | LVIS_CUT) && infoPtr->bFocus)
4671             style = ILD_SELECTED;
4672         else
4673             style = ILD_NORMAL;
4674
4675         ImageList_DrawEx(himl, lvItem.iImage, hdc, rcIcon.left, rcIcon.top,
4676                          rcIcon.right - rcIcon.left, rcIcon.bottom - rcIcon.top, infoPtr->clrBk,
4677                          lvItem.state & LVIS_CUT ? RGB(255, 255, 255) : CLR_DEFAULT,
4678                          style);
4679     }
4680
4681     /* Don't bother painting item being edited */
4682     if (infoPtr->hwndEdit && nItem == infoPtr->nEditLabelItem && nSubItem == 0) goto postpaint;
4683
4684     /* figure out the text drawing flags */
4685     uFormat = (infoPtr->uView == LV_VIEW_ICON ? (lprcFocus ? LV_FL_DT_FLAGS : LV_ML_DT_FLAGS) : LV_SL_DT_FLAGS);
4686     if (infoPtr->uView == LV_VIEW_ICON)
4687         uFormat = (lprcFocus ? LV_FL_DT_FLAGS : LV_ML_DT_FLAGS);
4688     else if (nSubItem)
4689     {
4690         switch (LISTVIEW_GetColumnInfo(infoPtr, nSubItem)->fmt & LVCFMT_JUSTIFYMASK)
4691         {
4692         case LVCFMT_RIGHT:  uFormat |= DT_RIGHT;  break;
4693         case LVCFMT_CENTER: uFormat |= DT_CENTER; break;
4694         default:            uFormat |= DT_LEFT;
4695         }
4696     }
4697     if (!(uFormat & (DT_RIGHT | DT_CENTER)))
4698     {
4699         if (himl && lvItem.iImage >= 0 && !IsRectEmpty(&rcIcon)) rcLabel.left += IMAGE_PADDING;
4700         else rcLabel.left += LABEL_HOR_PADDING;
4701     }
4702     else if (uFormat & DT_RIGHT) rcLabel.right -= LABEL_HOR_PADDING;
4703
4704     /* for GRIDLINES reduce the bottom so the text formats correctly */
4705     if (infoPtr->uView == LV_VIEW_DETAILS && infoPtr->dwLvExStyle & LVS_EX_GRIDLINES)
4706         rcLabel.bottom--;
4707
4708     DrawTextW(hdc, lvItem.pszText, -1, &rcLabel, uFormat);
4709
4710 postpaint:
4711     if (cdsubitemmode & CDRF_NOTIFYPOSTPAINT)
4712         notify_postpaint(infoPtr, &nmlvcd);
4713     if (cdsubitemmode & CDRF_NEWFONT)
4714         SelectObject(hdc, hOldFont);
4715     return TRUE;
4716 }
4717
4718 /***
4719  * DESCRIPTION:
4720  * Draws listview items when in owner draw mode.
4721  *
4722  * PARAMETER(S):
4723  * [I] infoPtr : valid pointer to the listview structure
4724  * [I] hdc : device context handle
4725  *
4726  * RETURN:
4727  * None
4728  */
4729 static void LISTVIEW_RefreshOwnerDraw(const LISTVIEW_INFO *infoPtr, ITERATOR *i, HDC hdc, DWORD cdmode)
4730 {
4731     UINT uID = (UINT)GetWindowLongPtrW(infoPtr->hwndSelf, GWLP_ID);
4732     DWORD cditemmode = CDRF_DODEFAULT;
4733     NMLVCUSTOMDRAW nmlvcd;
4734     POINT Origin, Position;
4735     DRAWITEMSTRUCT dis;
4736     LVITEMW item;
4737
4738     TRACE("()\n");
4739
4740     ZeroMemory(&dis, sizeof(dis));
4741
4742     /* Get scroll info once before loop */
4743     LISTVIEW_GetOrigin(infoPtr, &Origin);
4744
4745     /* iterate through the invalidated rows */
4746     while(iterator_next(i))
4747     {
4748         item.iItem = i->nItem;
4749         item.iSubItem = 0;
4750         item.mask = LVIF_PARAM | LVIF_STATE;
4751         item.stateMask = LVIS_SELECTED | LVIS_FOCUSED;
4752         if (!LISTVIEW_GetItemW(infoPtr, &item)) continue;
4753
4754         dis.CtlType = ODT_LISTVIEW;
4755         dis.CtlID = uID;
4756         dis.itemID = item.iItem;
4757         dis.itemAction = ODA_DRAWENTIRE;
4758         dis.itemState = 0;
4759         if (item.state & LVIS_SELECTED) dis.itemState |= ODS_SELECTED;
4760         if (infoPtr->bFocus && (item.state & LVIS_FOCUSED)) dis.itemState |= ODS_FOCUS;
4761         dis.hwndItem = infoPtr->hwndSelf;
4762         dis.hDC = hdc;
4763         LISTVIEW_GetItemOrigin(infoPtr, dis.itemID, &Position);
4764         dis.rcItem.left = Position.x + Origin.x;
4765         dis.rcItem.right = dis.rcItem.left + infoPtr->nItemWidth;
4766         dis.rcItem.top = Position.y + Origin.y;
4767         dis.rcItem.bottom = dis.rcItem.top + infoPtr->nItemHeight;
4768         dis.itemData = item.lParam;
4769
4770         TRACE("item=%s, rcItem=%s\n", debuglvitem_t(&item, TRUE), wine_dbgstr_rect(&dis.rcItem));
4771
4772     /*
4773      * Even if we do not send the CDRF_NOTIFYITEMDRAW we need to fill the nmlvcd
4774      * structure for the rest. of the paint cycle
4775      */
4776         customdraw_fill(&nmlvcd, infoPtr, hdc, &dis.rcItem, &item);
4777         if (cdmode & CDRF_NOTIFYITEMDRAW)
4778             cditemmode = notify_customdraw(infoPtr, CDDS_PREPAINT, &nmlvcd);
4779
4780         if (!(cditemmode & CDRF_SKIPDEFAULT))
4781         {
4782             prepaint_setup (infoPtr, hdc, &nmlvcd, FALSE);
4783             SendMessageW(infoPtr->hwndNotify, WM_DRAWITEM, dis.CtlID, (LPARAM)&dis);
4784         }
4785
4786         if (cditemmode & CDRF_NOTIFYPOSTPAINT)
4787             notify_postpaint(infoPtr, &nmlvcd);
4788     }
4789 }
4790
4791 /***
4792  * DESCRIPTION:
4793  * Draws listview items when in report display mode.
4794  *
4795  * PARAMETER(S):
4796  * [I] infoPtr : valid pointer to the listview structure
4797  * [I] hdc : device context handle
4798  * [I] cdmode : custom draw mode
4799  *
4800  * RETURN:
4801  * None
4802  */
4803 static void LISTVIEW_RefreshReport(LISTVIEW_INFO *infoPtr, ITERATOR *i, HDC hdc, DWORD cdmode)
4804 {
4805     INT rgntype;
4806     RECT rcClip, rcItem;
4807     POINT Origin, Position;
4808     RANGES colRanges;
4809     INT col, index;
4810     ITERATOR j;
4811
4812     TRACE("()\n");
4813
4814     /* figure out what to draw */
4815     rgntype = GetClipBox(hdc, &rcClip);
4816     if (rgntype == NULLREGION) return;
4817
4818     /* Get scroll info once before loop */
4819     LISTVIEW_GetOrigin(infoPtr, &Origin);
4820
4821     colRanges = ranges_create(DPA_GetPtrCount(infoPtr->hdpaColumns));
4822
4823     /* narrow down the columns we need to paint */
4824     for(col = 0; col < DPA_GetPtrCount(infoPtr->hdpaColumns); col++)
4825     {
4826         index = SendMessageW(infoPtr->hwndHeader, HDM_ORDERTOINDEX, col, 0);
4827
4828         LISTVIEW_GetHeaderRect(infoPtr, index, &rcItem);
4829         if ((rcItem.right + Origin.x >= rcClip.left) && (rcItem.left + Origin.x < rcClip.right))
4830             ranges_additem(colRanges, index);
4831     }
4832     iterator_rangesitems(&j, colRanges);
4833
4834     /* in full row select, we _have_ to draw the main item */
4835     if (infoPtr->dwLvExStyle & LVS_EX_FULLROWSELECT)
4836         j.nSpecial = 0;
4837
4838     /* iterate through the invalidated rows */
4839     while(iterator_next(i))
4840     {
4841         LISTVIEW_GetItemOrigin(infoPtr, i->nItem, &Position);
4842         Position.y += Origin.y;
4843
4844         /* iterate through the invalidated columns */
4845         while(iterator_next(&j))
4846         {
4847             LISTVIEW_GetHeaderRect(infoPtr, j.nItem, &rcItem);
4848             Position.x = (j.nItem == 0) ? rcItem.left + Origin.x : Origin.x;
4849
4850             if (rgntype == COMPLEXREGION && !((infoPtr->dwLvExStyle & LVS_EX_FULLROWSELECT) && j.nItem == 0))
4851             {
4852                 rcItem.top = 0;
4853                 rcItem.bottom = infoPtr->nItemHeight;
4854                 OffsetRect(&rcItem, Origin.x, Position.y);
4855                 if (!RectVisible(hdc, &rcItem)) continue;
4856             }
4857
4858             LISTVIEW_DrawItem(infoPtr, hdc, i->nItem, j.nItem, Position, cdmode);
4859         }
4860     }
4861     iterator_destroy(&j);
4862 }
4863
4864 /***
4865  * DESCRIPTION:
4866  * Draws the gridlines if necessary when in report display mode.
4867  *
4868  * PARAMETER(S):
4869  * [I] infoPtr : valid pointer to the listview structure
4870  * [I] hdc : device context handle
4871  *
4872  * RETURN:
4873  * None
4874  */
4875 static void LISTVIEW_RefreshReportGrid(LISTVIEW_INFO *infoPtr, HDC hdc)
4876 {
4877     INT rgntype;
4878     INT y, itemheight;
4879     INT col, index;
4880     HPEN hPen, hOldPen;
4881     RECT rcClip, rcItem = {0};
4882     POINT Origin;
4883     RANGES colRanges;
4884     ITERATOR j;
4885     BOOL rmost = FALSE;
4886
4887     TRACE("()\n");
4888
4889     /* figure out what to draw */
4890     rgntype = GetClipBox(hdc, &rcClip);
4891     if (rgntype == NULLREGION) return;
4892
4893     /* Get scroll info once before loop */
4894     LISTVIEW_GetOrigin(infoPtr, &Origin);
4895
4896     colRanges = ranges_create(DPA_GetPtrCount(infoPtr->hdpaColumns));
4897
4898     /* narrow down the columns we need to paint */
4899     for(col = 0; col < DPA_GetPtrCount(infoPtr->hdpaColumns); col++)
4900     {
4901         index = SendMessageW(infoPtr->hwndHeader, HDM_ORDERTOINDEX, col, 0);
4902
4903         LISTVIEW_GetHeaderRect(infoPtr, index, &rcItem);
4904         if ((rcItem.right + Origin.x >= rcClip.left) && (rcItem.left + Origin.x < rcClip.right))
4905             ranges_additem(colRanges, index);
4906     }
4907
4908     /* is right most vertical line visible? */
4909     if (DPA_GetPtrCount(infoPtr->hdpaColumns) > 0)
4910     {
4911         index = SendMessageW(infoPtr->hwndHeader, HDM_ORDERTOINDEX, DPA_GetPtrCount(infoPtr->hdpaColumns) - 1, 0);
4912         LISTVIEW_GetHeaderRect(infoPtr, index, &rcItem);
4913         rmost = (rcItem.right + Origin.x < rcClip.right);
4914     }
4915
4916     if ((hPen = CreatePen( PS_SOLID, 1, comctl32_color.clr3dFace )))
4917     {
4918         hOldPen = SelectObject ( hdc, hPen );
4919
4920         /* draw the vertical lines for the columns */
4921         iterator_rangesitems(&j, colRanges);
4922         while(iterator_next(&j))
4923         {
4924             LISTVIEW_GetHeaderRect(infoPtr, j.nItem, &rcItem);
4925             if (rcItem.left == 0) continue; /* skip leftmost column */
4926             rcItem.left += Origin.x;
4927             rcItem.right += Origin.x;
4928             rcItem.top = infoPtr->rcList.top;
4929             rcItem.bottom = infoPtr->rcList.bottom;
4930             TRACE("vert col=%d, rcItem=%s\n", j.nItem, wine_dbgstr_rect(&rcItem));
4931             MoveToEx (hdc, rcItem.left, rcItem.top, NULL);
4932             LineTo (hdc, rcItem.left, rcItem.bottom);
4933         }
4934         iterator_destroy(&j);
4935         /* draw rightmost grid line if visible */
4936         if (rmost)
4937         {
4938             index = SendMessageW(infoPtr->hwndHeader, HDM_ORDERTOINDEX,
4939                                  DPA_GetPtrCount(infoPtr->hdpaColumns) - 1, 0);
4940             LISTVIEW_GetHeaderRect(infoPtr, index, &rcItem);
4941
4942             rcItem.right += Origin.x;
4943
4944             MoveToEx (hdc, rcItem.right, infoPtr->rcList.top, NULL);
4945             LineTo (hdc, rcItem.right, infoPtr->rcList.bottom);
4946         }
4947
4948         /* draw the horizontal lines for the rows */
4949         itemheight =  LISTVIEW_CalculateItemHeight(infoPtr);
4950         rcItem.left   = infoPtr->rcList.left;
4951         rcItem.right  = infoPtr->rcList.right;
4952         for(y = Origin.y > 1 ? Origin.y - 1 : itemheight - 1 + Origin.y % itemheight; y<=infoPtr->rcList.bottom; y+=itemheight)
4953         {
4954             rcItem.bottom = rcItem.top = y;
4955             TRACE("horz rcItem=%s\n", wine_dbgstr_rect(&rcItem));
4956             MoveToEx (hdc, rcItem.left, rcItem.top, NULL);
4957             LineTo (hdc, rcItem.right, rcItem.top);
4958         }
4959
4960         SelectObject( hdc, hOldPen );
4961         DeleteObject( hPen );
4962     }
4963     else
4964         ranges_destroy(colRanges);
4965 }
4966
4967 /***
4968  * DESCRIPTION:
4969  * Draws listview items when in list display mode.
4970  *
4971  * PARAMETER(S):
4972  * [I] infoPtr : valid pointer to the listview structure
4973  * [I] hdc : device context handle
4974  * [I] cdmode : custom draw mode
4975  *
4976  * RETURN:
4977  * None
4978  */
4979 static void LISTVIEW_RefreshList(LISTVIEW_INFO *infoPtr, ITERATOR *i, HDC hdc, DWORD cdmode)
4980 {
4981     POINT Origin, Position;
4982
4983     /* Get scroll info once before loop */
4984     LISTVIEW_GetOrigin(infoPtr, &Origin);
4985
4986     while(iterator_prev(i))
4987     {
4988         LISTVIEW_GetItemOrigin(infoPtr, i->nItem, &Position);
4989         Position.x += Origin.x;
4990         Position.y += Origin.y;
4991
4992         LISTVIEW_DrawItem(infoPtr, hdc, i->nItem, 0, Position, cdmode);
4993     }
4994 }
4995
4996
4997 /***
4998  * DESCRIPTION:
4999  * Draws listview items.
5000  *
5001  * PARAMETER(S):
5002  * [I] infoPtr : valid pointer to the listview structure
5003  * [I] hdc : device context handle
5004  * [I] prcErase : rect to be erased before refresh (may be NULL)
5005  *
5006  * RETURN:
5007  * NoneX
5008  */
5009 static void LISTVIEW_Refresh(LISTVIEW_INFO *infoPtr, HDC hdc, const RECT *prcErase)
5010 {
5011     COLORREF oldTextColor = 0, oldBkColor = 0, oldClrTextBk, oldClrText;
5012     NMLVCUSTOMDRAW nmlvcd;
5013     HFONT hOldFont = 0;
5014     DWORD cdmode;
5015     INT oldBkMode = 0;
5016     RECT rcClient;
5017     ITERATOR i;
5018     HDC hdcOrig = hdc;
5019     HBITMAP hbmp = NULL;
5020     RANGE range;
5021
5022     LISTVIEW_DUMP(infoPtr);
5023
5024     if (infoPtr->dwLvExStyle & LVS_EX_DOUBLEBUFFER) {
5025         TRACE("double buffering\n");
5026
5027         hdc = CreateCompatibleDC(hdcOrig);
5028         if (!hdc) {
5029             ERR("Failed to create DC for backbuffer\n");
5030             return;
5031         }
5032         hbmp = CreateCompatibleBitmap(hdcOrig, infoPtr->rcList.right,
5033                                       infoPtr->rcList.bottom);
5034         if (!hbmp) {
5035             ERR("Failed to create bitmap for backbuffer\n");
5036             DeleteDC(hdc);
5037             return;
5038         }
5039
5040         SelectObject(hdc, hbmp);
5041         SelectObject(hdc, infoPtr->hFont);
5042
5043         if(GetClipBox(hdcOrig, &rcClient))
5044             IntersectClipRect(hdc, rcClient.left, rcClient.top, rcClient.right, rcClient.bottom);
5045     } else {
5046         /* Save dc values we're gonna trash while drawing
5047          * FIXME: Should be done in LISTVIEW_DrawItem() */
5048         hOldFont = SelectObject(hdc, infoPtr->hFont);
5049         oldBkMode = GetBkMode(hdc);
5050         oldBkColor = GetBkColor(hdc);
5051         oldTextColor = GetTextColor(hdc);
5052     }
5053
5054     infoPtr->bIsDrawing = TRUE;
5055
5056     if (prcErase) {
5057         LISTVIEW_FillBkgnd(infoPtr, hdc, prcErase);
5058     } else if (infoPtr->dwLvExStyle & LVS_EX_DOUBLEBUFFER) {
5059         /* If no erasing was done (usually because RedrawWindow was called
5060          * with RDW_INVALIDATE only) we need to copy the old contents into
5061          * the backbuffer before continuing. */
5062         BitBlt(hdc, infoPtr->rcList.left, infoPtr->rcList.top,
5063                infoPtr->rcList.right - infoPtr->rcList.left,
5064                infoPtr->rcList.bottom - infoPtr->rcList.top,
5065                hdcOrig, infoPtr->rcList.left, infoPtr->rcList.top, SRCCOPY);
5066     }
5067
5068     /* FIXME: Shouldn't need to do this */
5069     oldClrTextBk = infoPtr->clrTextBk;
5070     oldClrText   = infoPtr->clrText;
5071
5072     infoPtr->cditemmode = CDRF_DODEFAULT;
5073
5074     GetClientRect(infoPtr->hwndSelf, &rcClient);
5075     customdraw_fill(&nmlvcd, infoPtr, hdc, &rcClient, 0);
5076     cdmode = notify_customdraw(infoPtr, CDDS_PREPAINT, &nmlvcd);
5077     if (cdmode & CDRF_SKIPDEFAULT) goto enddraw;
5078     prepaint_setup(infoPtr, hdc, &nmlvcd, FALSE);
5079
5080     /* Use these colors to draw the items */
5081     infoPtr->clrTextBk = nmlvcd.clrTextBk;
5082     infoPtr->clrText = nmlvcd.clrText;
5083
5084     /* nothing to draw */
5085     if(infoPtr->nItemCount == 0) goto enddraw;
5086
5087     /* figure out what we need to draw */
5088     iterator_visibleitems(&i, infoPtr, hdc);
5089     range = iterator_range(&i);
5090
5091     /* send cache hint notification */
5092     if (infoPtr->dwStyle & LVS_OWNERDATA)
5093     {
5094         NMLVCACHEHINT nmlv;
5095
5096         ZeroMemory(&nmlv, sizeof(NMLVCACHEHINT));
5097         nmlv.iFrom = range.lower;
5098         nmlv.iTo   = range.upper - 1;
5099         notify_hdr(infoPtr, LVN_ODCACHEHINT, &nmlv.hdr);
5100     }
5101
5102     if ((infoPtr->dwStyle & LVS_OWNERDRAWFIXED) && (infoPtr->uView == LV_VIEW_DETAILS))
5103         LISTVIEW_RefreshOwnerDraw(infoPtr, &i, hdc, cdmode);
5104     else
5105     {
5106         if (infoPtr->uView == LV_VIEW_DETAILS)
5107             LISTVIEW_RefreshReport(infoPtr, &i, hdc, cdmode);
5108         else /* LV_VIEW_LIST, LV_VIEW_ICON or LV_VIEW_SMALLICON */
5109             LISTVIEW_RefreshList(infoPtr, &i, hdc, cdmode);
5110
5111         /* if we have a focus rect and it's visible, draw it */
5112         if (infoPtr->bFocus && range.lower <= infoPtr->nFocusedItem &&
5113                         (range.upper - 1) >= infoPtr->nFocusedItem)
5114             LISTVIEW_DrawFocusRect(infoPtr, hdc);
5115     }
5116     iterator_destroy(&i);
5117
5118 enddraw:
5119     /* For LVS_EX_GRIDLINES go and draw lines */
5120     /*  This includes the case where there were *no* items */
5121     if ((infoPtr->uView == LV_VIEW_DETAILS) && infoPtr->dwLvExStyle & LVS_EX_GRIDLINES)
5122         LISTVIEW_RefreshReportGrid(infoPtr, hdc);
5123
5124     /* Draw marquee rectangle if appropriate */
5125     if (infoPtr->bMarqueeSelect)
5126         DrawFocusRect(hdc, &infoPtr->marqueeDrawRect);
5127
5128     if (cdmode & CDRF_NOTIFYPOSTPAINT)
5129         notify_postpaint(infoPtr, &nmlvcd);
5130
5131     infoPtr->clrTextBk = oldClrTextBk;
5132     infoPtr->clrText = oldClrText;
5133
5134     if(hbmp) {
5135         BitBlt(hdcOrig, infoPtr->rcList.left, infoPtr->rcList.top,
5136                infoPtr->rcList.right - infoPtr->rcList.left,
5137                infoPtr->rcList.bottom - infoPtr->rcList.top,
5138                hdc, infoPtr->rcList.left, infoPtr->rcList.top, SRCCOPY);
5139
5140         DeleteObject(hbmp);
5141         DeleteDC(hdc);
5142     } else {
5143         SelectObject(hdc, hOldFont);
5144         SetBkMode(hdc, oldBkMode);
5145         SetBkColor(hdc, oldBkColor);
5146         SetTextColor(hdc, oldTextColor);
5147     }
5148
5149     infoPtr->bIsDrawing = FALSE;
5150 }
5151
5152
5153 /***
5154  * DESCRIPTION:
5155  * Calculates the approximate width and height of a given number of items.
5156  *
5157  * PARAMETER(S):
5158  * [I] infoPtr : valid pointer to the listview structure
5159  * [I] nItemCount : number of items
5160  * [I] wWidth : width
5161  * [I] wHeight : height
5162  *
5163  * RETURN:
5164  * Returns a DWORD. The width in the low word and the height in high word.
5165  */
5166 static DWORD LISTVIEW_ApproximateViewRect(const LISTVIEW_INFO *infoPtr, INT nItemCount,
5167                                             WORD wWidth, WORD wHeight)
5168 {
5169   DWORD dwViewRect = 0;
5170
5171   if (nItemCount == -1)
5172     nItemCount = infoPtr->nItemCount;
5173
5174   if (infoPtr->uView == LV_VIEW_LIST)
5175   {
5176     INT nItemCountPerColumn = 1;
5177     INT nColumnCount = 0;
5178
5179     if (wHeight == 0xFFFF)
5180     {
5181       /* use current height */
5182       wHeight = infoPtr->rcList.bottom - infoPtr->rcList.top;
5183     }
5184
5185     if (wHeight < infoPtr->nItemHeight)
5186       wHeight = infoPtr->nItemHeight;
5187
5188     if (nItemCount > 0)
5189     {
5190       if (infoPtr->nItemHeight > 0)
5191       {
5192         nItemCountPerColumn = wHeight / infoPtr->nItemHeight;
5193         if (nItemCountPerColumn == 0)
5194           nItemCountPerColumn = 1;
5195
5196         if (nItemCount % nItemCountPerColumn != 0)
5197           nColumnCount = nItemCount / nItemCountPerColumn;
5198         else
5199           nColumnCount = nItemCount / nItemCountPerColumn + 1;
5200       }
5201     }
5202
5203     /* Microsoft padding magic */
5204     wHeight = nItemCountPerColumn * infoPtr->nItemHeight + 2;
5205     wWidth = nColumnCount * infoPtr->nItemWidth + 2;
5206
5207     dwViewRect = MAKELONG(wWidth, wHeight);
5208   }
5209   else if (infoPtr->uView == LV_VIEW_DETAILS)
5210   {
5211     RECT rcBox;
5212
5213     if (infoPtr->nItemCount > 0)
5214     {
5215       LISTVIEW_GetItemBox(infoPtr, 0, &rcBox);
5216       wWidth = rcBox.right - rcBox.left;
5217       wHeight = (rcBox.bottom - rcBox.top) * nItemCount;
5218     }
5219     else
5220     {
5221       /* use current height and width */
5222       if (wHeight == 0xffff)
5223           wHeight = infoPtr->rcList.bottom - infoPtr->rcList.top;
5224       if (wWidth == 0xffff)
5225           wWidth = infoPtr->rcList.right - infoPtr->rcList.left;
5226     }
5227
5228     dwViewRect = MAKELONG(wWidth, wHeight);
5229   }
5230   else if (infoPtr->uView == LV_VIEW_ICON)
5231   {
5232     UINT rows,cols;
5233     UINT nItemWidth;
5234     UINT nItemHeight;
5235
5236     nItemWidth = infoPtr->iconSpacing.cx;
5237     nItemHeight = infoPtr->iconSpacing.cy;
5238
5239     if (wWidth == 0xffff)
5240       wWidth = infoPtr->rcList.right - infoPtr->rcList.left;
5241
5242     if (wWidth < nItemWidth)
5243       wWidth = nItemWidth;
5244
5245     cols = wWidth / nItemWidth;
5246     if (cols > nItemCount)
5247       cols = nItemCount;
5248     if (cols < 1)
5249         cols = 1;
5250
5251     if (nItemCount)
5252     {
5253       rows = nItemCount / cols;
5254       if (nItemCount % cols)
5255         rows++;
5256     }
5257     else
5258       rows = 0;
5259
5260     wHeight = (nItemHeight * rows)+2;
5261     wWidth = (nItemWidth * cols)+2;
5262
5263     dwViewRect = MAKELONG(wWidth, wHeight);
5264   }
5265   else if (infoPtr->uView == LV_VIEW_SMALLICON)
5266     FIXME("uView == LV_VIEW_SMALLICON: not implemented\n");
5267
5268   return dwViewRect;
5269 }
5270
5271 /***
5272  * DESCRIPTION:
5273  * Cancel edit label with saving item text.
5274  *
5275  * PARAMETER(S):
5276  * [I] infoPtr : valid pointer to the listview structure
5277  *
5278  * RETURN:
5279  * Always returns TRUE.
5280  */
5281 static LRESULT LISTVIEW_CancelEditLabel(LISTVIEW_INFO *infoPtr)
5282 {
5283     if (infoPtr->hwndEdit)
5284     {
5285         /* handle value will be lost after LISTVIEW_EndEditLabelT */
5286         HWND edit = infoPtr->hwndEdit;
5287
5288         LISTVIEW_EndEditLabelT(infoPtr, TRUE, IsWindowUnicode(infoPtr->hwndEdit));
5289         SendMessageW(edit, WM_CLOSE, 0, 0);
5290     }
5291
5292     return TRUE;
5293 }
5294
5295 /***
5296  * DESCRIPTION:
5297  * Create a drag image list for the specified item.
5298  *
5299  * PARAMETER(S):
5300  * [I] infoPtr : valid pointer to the listview structure
5301  * [I] iItem   : index of item
5302  * [O] lppt    : Upper-left corner of the image
5303  *
5304  * RETURN:
5305  * Returns a handle to the image list if successful, NULL otherwise.
5306  */
5307 static HIMAGELIST LISTVIEW_CreateDragImage(LISTVIEW_INFO *infoPtr, INT iItem, LPPOINT lppt)
5308 {
5309     RECT rcItem;
5310     SIZE size;
5311     POINT pos;
5312     HDC hdc, hdcOrig;
5313     HBITMAP hbmp, hOldbmp;
5314     HIMAGELIST dragList = 0;
5315     TRACE("iItem=%d Count=%d\n", iItem, infoPtr->nItemCount);
5316
5317     if (iItem < 0 || iItem >= infoPtr->nItemCount || !lppt)
5318         return 0;
5319
5320     rcItem.left = LVIR_BOUNDS;
5321     if (!LISTVIEW_GetItemRect(infoPtr, iItem, &rcItem))
5322         return 0;
5323
5324     lppt->x = rcItem.left;
5325     lppt->y = rcItem.top;
5326
5327     size.cx = rcItem.right - rcItem.left;
5328     size.cy = rcItem.bottom - rcItem.top;
5329
5330     hdcOrig = GetDC(infoPtr->hwndSelf);
5331     hdc = CreateCompatibleDC(hdcOrig);
5332     hbmp = CreateCompatibleBitmap(hdcOrig, size.cx, size.cy);
5333     hOldbmp = SelectObject(hdc, hbmp);
5334
5335     rcItem.left = rcItem.top = 0;
5336     rcItem.right = size.cx;
5337     rcItem.bottom = size.cy;
5338     FillRect(hdc, &rcItem, infoPtr->hBkBrush);
5339
5340     pos.x = pos.y = 0;
5341     if (LISTVIEW_DrawItem(infoPtr, hdc, iItem, 0, pos, infoPtr->cditemmode))
5342     {
5343         dragList = ImageList_Create(size.cx, size.cy, ILC_COLOR, 10, 10);
5344         SelectObject(hdc, hOldbmp);
5345         ImageList_Add(dragList, hbmp, 0);
5346     }
5347     else
5348         SelectObject(hdc, hOldbmp);
5349
5350     DeleteObject(hbmp);
5351     DeleteDC(hdc);
5352     ReleaseDC(infoPtr->hwndSelf, hdcOrig);
5353
5354     TRACE("ret=%p\n", dragList);
5355
5356     return dragList;
5357 }
5358
5359
5360 /***
5361  * DESCRIPTION:
5362  * Removes all listview items and subitems.
5363  *
5364  * PARAMETER(S):
5365  * [I] infoPtr : valid pointer to the listview structure
5366  *
5367  * RETURN:
5368  *   SUCCESS : TRUE
5369  *   FAILURE : FALSE
5370  */
5371 static BOOL LISTVIEW_DeleteAllItems(LISTVIEW_INFO *infoPtr, BOOL destroy)
5372 {
5373     NMLISTVIEW nmlv;
5374     HDPA hdpaSubItems = NULL;
5375     BOOL bSuppress;
5376     ITEMHDR *hdrItem;
5377     ITEM_INFO *lpItem;
5378     ITEM_ID *lpID;
5379     INT i, j;
5380
5381     TRACE("()\n");
5382
5383     /* we do it directly, to avoid notifications */
5384     ranges_clear(infoPtr->selectionRanges);
5385     infoPtr->nSelectionMark = -1;
5386     infoPtr->nFocusedItem = -1;
5387     SetRectEmpty(&infoPtr->rcFocus);
5388     /* But we are supposed to leave nHotItem as is! */
5389
5390
5391     /* send LVN_DELETEALLITEMS notification */
5392     ZeroMemory(&nmlv, sizeof(NMLISTVIEW));
5393     nmlv.iItem = -1;
5394     bSuppress = notify_listview(infoPtr, LVN_DELETEALLITEMS, &nmlv);
5395
5396     for (i = infoPtr->nItemCount - 1; i >= 0; i--)
5397     {
5398         if (!(infoPtr->dwStyle & LVS_OWNERDATA))
5399         {
5400             /* send LVN_DELETEITEM notification, if not suppressed
5401                and if it is not a virtual listview */
5402             if (!bSuppress) notify_deleteitem(infoPtr, i);
5403             hdpaSubItems = DPA_GetPtr(infoPtr->hdpaItems, i);
5404             lpItem = DPA_GetPtr(hdpaSubItems, 0);
5405             /* free id struct */
5406             j = DPA_GetPtrIndex(infoPtr->hdpaItemIds, lpItem->id);
5407             lpID = DPA_GetPtr(infoPtr->hdpaItemIds, j);
5408             DPA_DeletePtr(infoPtr->hdpaItemIds, j);
5409             Free(lpID);
5410             /* both item and subitem start with ITEMHDR header */
5411             for (j = 0; j < DPA_GetPtrCount(hdpaSubItems); j++)
5412             {
5413                 hdrItem = DPA_GetPtr(hdpaSubItems, j);
5414                 if (is_text(hdrItem->pszText)) Free(hdrItem->pszText);
5415                 Free(hdrItem);
5416             }
5417             DPA_Destroy(hdpaSubItems);
5418             DPA_DeletePtr(infoPtr->hdpaItems, i);
5419         }
5420         DPA_DeletePtr(infoPtr->hdpaPosX, i);
5421         DPA_DeletePtr(infoPtr->hdpaPosY, i);
5422         infoPtr->nItemCount --;
5423     }
5424
5425     if (!destroy)
5426     {
5427         LISTVIEW_Arrange(infoPtr, LVA_DEFAULT);
5428         LISTVIEW_UpdateScroll(infoPtr);
5429     }
5430     LISTVIEW_InvalidateList(infoPtr);
5431
5432     return TRUE;
5433 }
5434
5435 /***
5436  * DESCRIPTION:
5437  * Scrolls, and updates the columns, when a column is changing width.
5438  *
5439  * PARAMETER(S):
5440  * [I] infoPtr : valid pointer to the listview structure
5441  * [I] nColumn : column to scroll
5442  * [I] dx : amount of scroll, in pixels
5443  *
5444  * RETURN:
5445  *   None.
5446  */
5447 static void LISTVIEW_ScrollColumns(LISTVIEW_INFO *infoPtr, INT nColumn, INT dx)
5448 {
5449     COLUMN_INFO *lpColumnInfo;
5450     RECT rcOld, rcCol;
5451     POINT ptOrigin;
5452     INT nCol;
5453     HDITEMW hdi;
5454
5455     if (nColumn < 0 || DPA_GetPtrCount(infoPtr->hdpaColumns) < 1) return;
5456     lpColumnInfo = LISTVIEW_GetColumnInfo(infoPtr, min(nColumn, DPA_GetPtrCount(infoPtr->hdpaColumns) - 1));
5457     rcCol = lpColumnInfo->rcHeader;
5458     if (nColumn >= DPA_GetPtrCount(infoPtr->hdpaColumns))
5459         rcCol.left = rcCol.right;
5460
5461     /* adjust the other columns */
5462     hdi.mask = HDI_ORDER;
5463     if (SendMessageW(infoPtr->hwndHeader, HDM_GETITEMW, nColumn, (LPARAM)&hdi))
5464     {
5465         INT nOrder = hdi.iOrder;
5466         for (nCol = 0; nCol < DPA_GetPtrCount(infoPtr->hdpaColumns); nCol++)
5467         {
5468             hdi.mask = HDI_ORDER;
5469             SendMessageW(infoPtr->hwndHeader, HDM_GETITEMW, nCol, (LPARAM)&hdi);
5470             if (hdi.iOrder >= nOrder) {
5471                 lpColumnInfo = LISTVIEW_GetColumnInfo(infoPtr, nCol);
5472                 lpColumnInfo->rcHeader.left  += dx;
5473                 lpColumnInfo->rcHeader.right += dx;
5474             }
5475         }
5476     }
5477
5478     /* do not update screen if not in report mode */
5479     if (!is_redrawing(infoPtr) || infoPtr->uView != LV_VIEW_DETAILS) return;
5480
5481     /* Need to reset the item width when inserting a new column */
5482     infoPtr->nItemWidth += dx;
5483
5484     LISTVIEW_UpdateScroll(infoPtr);
5485     LISTVIEW_GetOrigin(infoPtr, &ptOrigin);
5486
5487     /* scroll to cover the deleted column, and invalidate for redraw */
5488     rcOld = infoPtr->rcList;
5489     rcOld.left = ptOrigin.x + rcCol.left + dx;
5490     ScrollWindowEx(infoPtr->hwndSelf, dx, 0, &rcOld, &rcOld, 0, 0, SW_ERASE | SW_INVALIDATE);
5491 }
5492
5493 /***
5494  * DESCRIPTION:
5495  * Removes a column from the listview control.
5496  *
5497  * PARAMETER(S):
5498  * [I] infoPtr : valid pointer to the listview structure
5499  * [I] nColumn : column index
5500  *
5501  * RETURN:
5502  *   SUCCESS : TRUE
5503  *   FAILURE : FALSE
5504  */
5505 static BOOL LISTVIEW_DeleteColumn(LISTVIEW_INFO *infoPtr, INT nColumn)
5506 {
5507     RECT rcCol;
5508
5509     TRACE("nColumn=%d\n", nColumn);
5510
5511     if (nColumn < 0 || DPA_GetPtrCount(infoPtr->hdpaColumns) == 0
5512            || nColumn >= DPA_GetPtrCount(infoPtr->hdpaColumns)) return FALSE;
5513
5514     /* While the MSDN specifically says that column zero should not be deleted,
5515        what actually happens is that the column itself is deleted but no items or subitems
5516        are removed.
5517      */
5518
5519     LISTVIEW_GetHeaderRect(infoPtr, nColumn, &rcCol);
5520
5521     if (!SendMessageW(infoPtr->hwndHeader, HDM_DELETEITEM, nColumn, 0))
5522         return FALSE;
5523
5524     Free(DPA_GetPtr(infoPtr->hdpaColumns, nColumn));
5525     DPA_DeletePtr(infoPtr->hdpaColumns, nColumn);
5526
5527     if (!(infoPtr->dwStyle & LVS_OWNERDATA) && nColumn)
5528     {
5529         SUBITEM_INFO *lpSubItem, *lpDelItem;
5530         HDPA hdpaSubItems;
5531         INT nItem, nSubItem, i;
5532
5533         for (nItem = 0; nItem < infoPtr->nItemCount; nItem++)
5534         {
5535             hdpaSubItems = DPA_GetPtr(infoPtr->hdpaItems, nItem);
5536             nSubItem = 0;
5537             lpDelItem = 0;
5538             for (i = 1; i < DPA_GetPtrCount(hdpaSubItems); i++)
5539             {
5540                 lpSubItem = DPA_GetPtr(hdpaSubItems, i);
5541                 if (lpSubItem->iSubItem == nColumn)
5542                 {
5543                     nSubItem = i;
5544                     lpDelItem = lpSubItem;
5545                 }
5546                 else if (lpSubItem->iSubItem > nColumn)
5547                 {
5548                     lpSubItem->iSubItem--;
5549                 }
5550             }
5551
5552             /* if we found our subitem, zap it */
5553             if (nSubItem > 0)
5554             {
5555                 /* free string */
5556                 if (is_text(lpDelItem->hdr.pszText))
5557                     Free(lpDelItem->hdr.pszText);
5558
5559                 /* free item */
5560                 Free(lpDelItem);
5561
5562                 /* free dpa memory */
5563                 DPA_DeletePtr(hdpaSubItems, nSubItem);
5564             }
5565         }
5566     }
5567
5568     /* update the other column info */
5569     LISTVIEW_UpdateItemSize(infoPtr);
5570     if(DPA_GetPtrCount(infoPtr->hdpaColumns) == 0)
5571         LISTVIEW_InvalidateList(infoPtr);
5572     else
5573         LISTVIEW_ScrollColumns(infoPtr, nColumn, -(rcCol.right - rcCol.left));
5574
5575     return TRUE;
5576 }
5577
5578 /***
5579  * DESCRIPTION:
5580  * Invalidates the listview after an item's insertion or deletion.
5581  *
5582  * PARAMETER(S):
5583  * [I] infoPtr : valid pointer to the listview structure
5584  * [I] nItem : item index
5585  * [I] dir : -1 if deleting, 1 if inserting
5586  *
5587  * RETURN:
5588  *   None
5589  */
5590 static void LISTVIEW_ScrollOnInsert(LISTVIEW_INFO *infoPtr, INT nItem, INT dir)
5591 {
5592     INT nPerCol, nItemCol, nItemRow;
5593     RECT rcScroll;
5594     POINT Origin;
5595
5596     /* if we don't refresh, what's the point of scrolling? */
5597     if (!is_redrawing(infoPtr)) return;
5598
5599     assert (abs(dir) == 1);
5600
5601     /* arrange icons if autoarrange is on */
5602     if (is_autoarrange(infoPtr))
5603     {
5604         BOOL arrange = TRUE;
5605         if (dir < 0 && nItem >= infoPtr->nItemCount) arrange = FALSE;
5606         if (dir > 0 && nItem == infoPtr->nItemCount - 1) arrange = FALSE;
5607         if (arrange) LISTVIEW_Arrange(infoPtr, LVA_DEFAULT);
5608     }
5609
5610     /* scrollbars need updating */
5611     LISTVIEW_UpdateScroll(infoPtr);
5612
5613     /* figure out the item's position */
5614     if (infoPtr->uView == LV_VIEW_DETAILS)
5615         nPerCol = infoPtr->nItemCount + 1;
5616     else if (infoPtr->uView == LV_VIEW_LIST)
5617         nPerCol = LISTVIEW_GetCountPerColumn(infoPtr);
5618     else /* LV_VIEW_ICON, or LV_VIEW_SMALLICON */
5619         return;
5620
5621     nItemCol = nItem / nPerCol;
5622     nItemRow = nItem % nPerCol;
5623     LISTVIEW_GetOrigin(infoPtr, &Origin);
5624
5625     /* move the items below up a slot */
5626     rcScroll.left = nItemCol * infoPtr->nItemWidth;
5627     rcScroll.top = nItemRow * infoPtr->nItemHeight;
5628     rcScroll.right = rcScroll.left + infoPtr->nItemWidth;
5629     rcScroll.bottom = nPerCol * infoPtr->nItemHeight;
5630     OffsetRect(&rcScroll, Origin.x, Origin.y);
5631     TRACE("rcScroll=%s, dx=%d\n", wine_dbgstr_rect(&rcScroll), dir * infoPtr->nItemHeight);
5632     if (IntersectRect(&rcScroll, &rcScroll, &infoPtr->rcList))
5633     {
5634         TRACE("Invalidating rcScroll=%s, rcList=%s\n", wine_dbgstr_rect(&rcScroll), wine_dbgstr_rect(&infoPtr->rcList));
5635         InvalidateRect(infoPtr->hwndSelf, &rcScroll, TRUE);
5636     }
5637
5638     /* report has only that column, so we're done */
5639     if (infoPtr->uView == LV_VIEW_DETAILS) return;
5640
5641     /* now for LISTs, we have to deal with the columns to the right */
5642     rcScroll.left = (nItemCol + 1) * infoPtr->nItemWidth;
5643     rcScroll.top = 0;
5644     rcScroll.right = (infoPtr->nItemCount / nPerCol + 1) * infoPtr->nItemWidth;
5645     rcScroll.bottom = nPerCol * infoPtr->nItemHeight;
5646     OffsetRect(&rcScroll, Origin.x, Origin.y);
5647     if (IntersectRect(&rcScroll, &rcScroll, &infoPtr->rcList))
5648         InvalidateRect(infoPtr->hwndSelf, &rcScroll, TRUE);
5649 }
5650
5651 /***
5652  * DESCRIPTION:
5653  * Removes an item from the listview control.
5654  *
5655  * PARAMETER(S):
5656  * [I] infoPtr : valid pointer to the listview structure
5657  * [I] nItem : item index
5658  *
5659  * RETURN:
5660  *   SUCCESS : TRUE
5661  *   FAILURE : FALSE
5662  */
5663 static BOOL LISTVIEW_DeleteItem(LISTVIEW_INFO *infoPtr, INT nItem)
5664 {
5665     LVITEMW item;
5666     const BOOL is_icon = (infoPtr->uView == LV_VIEW_SMALLICON || infoPtr->uView == LV_VIEW_ICON);
5667
5668     TRACE("(nItem=%d)\n", nItem);
5669
5670     if (nItem < 0 || nItem >= infoPtr->nItemCount) return FALSE;
5671
5672     /* remove selection, and focus */
5673     item.state = 0;
5674     item.stateMask = LVIS_SELECTED | LVIS_FOCUSED;
5675     LISTVIEW_SetItemState(infoPtr, nItem, &item);
5676
5677     /* send LVN_DELETEITEM notification. */
5678     if (!notify_deleteitem(infoPtr, nItem)) return FALSE;
5679
5680     /* we need to do this here, because we'll be deleting stuff */
5681     if (is_icon)
5682         LISTVIEW_InvalidateItem(infoPtr, nItem);
5683
5684     if (!(infoPtr->dwStyle & LVS_OWNERDATA))
5685     {
5686         HDPA hdpaSubItems;
5687         ITEMHDR *hdrItem;
5688         ITEM_INFO *lpItem;
5689         ITEM_ID *lpID;
5690         INT i;
5691
5692         hdpaSubItems = DPA_DeletePtr(infoPtr->hdpaItems, nItem);
5693         lpItem = DPA_GetPtr(hdpaSubItems, 0);
5694
5695         /* free id struct */
5696         i = DPA_GetPtrIndex(infoPtr->hdpaItemIds, lpItem->id);
5697         lpID = DPA_GetPtr(infoPtr->hdpaItemIds, i);
5698         DPA_DeletePtr(infoPtr->hdpaItemIds, i);
5699         Free(lpID);
5700         for (i = 0; i < DPA_GetPtrCount(hdpaSubItems); i++)
5701         {
5702             hdrItem = DPA_GetPtr(hdpaSubItems, i);
5703             if (is_text(hdrItem->pszText)) Free(hdrItem->pszText);
5704             Free(hdrItem);
5705         }
5706         DPA_Destroy(hdpaSubItems);
5707     }
5708
5709     if (is_icon)
5710     {
5711         DPA_DeletePtr(infoPtr->hdpaPosX, nItem);
5712         DPA_DeletePtr(infoPtr->hdpaPosY, nItem);
5713     }
5714
5715     infoPtr->nItemCount--;
5716     LISTVIEW_ShiftIndices(infoPtr, nItem, -1);
5717
5718     /* now is the invalidation fun */
5719     if (!is_icon)
5720         LISTVIEW_ScrollOnInsert(infoPtr, nItem, -1);
5721     return TRUE;
5722 }
5723
5724
5725 /***
5726  * DESCRIPTION:
5727  * Callback implementation for editlabel control
5728  *
5729  * PARAMETER(S):
5730  * [I] infoPtr : valid pointer to the listview structure
5731  * [I] storeText : store edit box text as item text
5732  * [I] isW : TRUE if psxText is Unicode, FALSE if it's ANSI
5733  *
5734  * RETURN:
5735  *   SUCCESS : TRUE
5736  *   FAILURE : FALSE
5737  */
5738 static BOOL LISTVIEW_EndEditLabelT(LISTVIEW_INFO *infoPtr, BOOL storeText, BOOL isW)
5739 {
5740     HWND hwndSelf = infoPtr->hwndSelf;
5741     WCHAR szDispText[DISP_TEXT_SIZE] = { 0 };
5742     NMLVDISPINFOW dispInfo;
5743     INT editedItem = infoPtr->nEditLabelItem;
5744     BOOL same;
5745     WCHAR *pszText = NULL;
5746     BOOL res;
5747
5748     if (storeText)
5749     {
5750         DWORD len = isW ? GetWindowTextLengthW(infoPtr->hwndEdit) : GetWindowTextLengthA(infoPtr->hwndEdit);
5751
5752         if (len)
5753         {
5754             if ((pszText = Alloc((len+1) * (isW ? sizeof(WCHAR) : sizeof(CHAR)))))
5755             {
5756                 if (isW) GetWindowTextW(infoPtr->hwndEdit, pszText, len+1);
5757                 else GetWindowTextA(infoPtr->hwndEdit, (CHAR*)pszText, len+1);
5758             }
5759         }
5760     }
5761
5762     TRACE("(pszText=%s, isW=%d)\n", debugtext_t(pszText, isW), isW);
5763
5764     ZeroMemory(&dispInfo, sizeof(dispInfo));
5765     dispInfo.item.mask = LVIF_PARAM | LVIF_STATE | LVIF_TEXT;
5766     dispInfo.item.iItem = editedItem;
5767     dispInfo.item.iSubItem = 0;
5768     dispInfo.item.stateMask = ~0;
5769     dispInfo.item.pszText = szDispText;
5770     dispInfo.item.cchTextMax = DISP_TEXT_SIZE;
5771     if (!LISTVIEW_GetItemT(infoPtr, &dispInfo.item, isW))
5772     {
5773        res = FALSE;
5774        goto cleanup;
5775     }
5776
5777     if (isW)
5778         same = (lstrcmpW(dispInfo.item.pszText, pszText) == 0);
5779     else
5780     {
5781         LPWSTR tmp = textdupTtoW(pszText, FALSE);
5782         same = (lstrcmpW(dispInfo.item.pszText, tmp) == 0);
5783         textfreeT(tmp, FALSE);
5784     }
5785
5786     /* add the text from the edit in */
5787     dispInfo.item.mask |= LVIF_TEXT;
5788     dispInfo.item.pszText = same ? NULL : pszText;
5789     dispInfo.item.cchTextMax = textlenT(dispInfo.item.pszText, isW);
5790
5791     /* Do we need to update the Item Text */
5792     res = notify_dispinfoT(infoPtr, LVN_ENDLABELEDITW, &dispInfo, isW);
5793
5794     infoPtr->nEditLabelItem = -1;
5795     infoPtr->hwndEdit = 0;
5796
5797     if (!res) goto cleanup;
5798
5799     if (!IsWindow(hwndSelf))
5800     {
5801         res = FALSE;
5802         goto cleanup;
5803     }
5804     if (!pszText) return TRUE;
5805     if (same)
5806     {
5807         res = TRUE;
5808         goto cleanup;
5809     }
5810
5811     if (!(infoPtr->dwStyle & LVS_OWNERDATA))
5812     {
5813         HDPA hdpaSubItems = DPA_GetPtr(infoPtr->hdpaItems, editedItem);
5814         ITEM_INFO* lpItem = DPA_GetPtr(hdpaSubItems, 0);
5815         if (lpItem && lpItem->hdr.pszText == LPSTR_TEXTCALLBACKW)
5816         {
5817             LISTVIEW_InvalidateItem(infoPtr, editedItem);
5818             res = TRUE;
5819             goto cleanup;
5820         }
5821     }
5822
5823     ZeroMemory(&dispInfo, sizeof(dispInfo));
5824     dispInfo.item.mask = LVIF_TEXT;
5825     dispInfo.item.iItem = editedItem;
5826     dispInfo.item.iSubItem = 0;
5827     dispInfo.item.pszText = pszText;
5828     dispInfo.item.cchTextMax = textlenT(pszText, isW);
5829     res = LISTVIEW_SetItemT(infoPtr, &dispInfo.item, isW);
5830
5831 cleanup:
5832     Free(pszText);
5833
5834     return res;
5835 }
5836
5837 /***
5838  * DESCRIPTION:
5839  * Subclassed edit control windproc function
5840  *
5841  * PARAMETER(S):
5842  * [I] hwnd : the edit window handle
5843  * [I] uMsg : the message that is to be processed
5844  * [I] wParam : first message parameter
5845  * [I] lParam : second message parameter
5846  * [I] isW : TRUE if input is Unicode
5847  *
5848  * RETURN:
5849  *   Zero.
5850  */
5851 static LRESULT EditLblWndProcT(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL isW)
5852 {
5853     LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongPtrW(GetParent(hwnd), 0);
5854     BOOL save = TRUE;
5855
5856     TRACE("(hwnd=%p, uMsg=%x, wParam=%lx, lParam=%lx, isW=%d)\n",
5857           hwnd, uMsg, wParam, lParam, isW);
5858
5859     switch (uMsg)
5860     {
5861         case WM_GETDLGCODE:
5862           return DLGC_WANTARROWS | DLGC_WANTALLKEYS;
5863
5864         case WM_DESTROY:
5865         {
5866             WNDPROC editProc = infoPtr->EditWndProc;
5867             infoPtr->EditWndProc = 0;
5868             SetWindowLongPtrW(hwnd, GWLP_WNDPROC, (DWORD_PTR)editProc);
5869             return CallWindowProcT(editProc, hwnd, uMsg, wParam, lParam, isW);
5870         }
5871
5872         case WM_KEYDOWN:
5873             if (VK_ESCAPE == (INT)wParam)
5874             {
5875                 save = FALSE;
5876                 break;
5877             }
5878             else if (VK_RETURN == (INT)wParam)
5879                 break;
5880
5881         default:
5882             return CallWindowProcT(infoPtr->EditWndProc, hwnd, uMsg, wParam, lParam, isW);
5883     }
5884
5885     /* kill the edit */
5886     if (infoPtr->hwndEdit)
5887         LISTVIEW_EndEditLabelT(infoPtr, save, isW);
5888
5889     SendMessageW(hwnd, WM_CLOSE, 0, 0);
5890     return 0;
5891 }
5892
5893 /***
5894  * DESCRIPTION:
5895  * Subclassed edit control Unicode windproc function
5896  *
5897  * PARAMETER(S):
5898  * [I] hwnd : the edit window handle
5899  * [I] uMsg : the message that is to be processed
5900  * [I] wParam : first message parameter
5901  * [I] lParam : second message parameter
5902  *
5903  * RETURN:
5904  */
5905 static LRESULT CALLBACK EditLblWndProcW(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
5906 {
5907     return EditLblWndProcT(hwnd, uMsg, wParam, lParam, TRUE);
5908 }
5909
5910 /***
5911  * DESCRIPTION:
5912  * Subclassed edit control ANSI windproc function
5913  *
5914  * PARAMETER(S):
5915  * [I] hwnd : the edit window handle
5916  * [I] uMsg : the message that is to be processed
5917  * [I] wParam : first message parameter
5918  * [I] lParam : second message parameter
5919  *
5920  * RETURN:
5921  */
5922 static LRESULT CALLBACK EditLblWndProcA(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
5923 {
5924     return EditLblWndProcT(hwnd, uMsg, wParam, lParam, FALSE);
5925 }
5926
5927 /***
5928  * DESCRIPTION:
5929  * Creates a subclassed edit control
5930  *
5931  * PARAMETER(S):
5932  * [I] infoPtr : valid pointer to the listview structure
5933  * [I] text : initial text for the edit
5934  * [I] style : the window style
5935  * [I] isW : TRUE if input is Unicode
5936  *
5937  * RETURN:
5938  */
5939 static HWND CreateEditLabelT(LISTVIEW_INFO *infoPtr, LPCWSTR text, BOOL isW)
5940 {
5941     static const DWORD style = WS_CHILDWINDOW|WS_CLIPSIBLINGS|ES_LEFT|ES_AUTOHSCROLL|WS_BORDER|WS_VISIBLE;
5942     HINSTANCE hinst = (HINSTANCE)GetWindowLongPtrW(infoPtr->hwndSelf, GWLP_HINSTANCE);
5943     HWND hedit;
5944
5945     TRACE("(%p, text=%s, isW=%d)\n", infoPtr, debugtext_t(text, isW), isW);
5946
5947     /* window will be resized and positioned after LVN_BEGINLABELEDIT */
5948     if (isW)
5949         hedit = CreateWindowW(WC_EDITW, text, style, 0, 0, 0, 0, infoPtr->hwndSelf, 0, hinst, 0);
5950     else
5951         hedit = CreateWindowA(WC_EDITA, (LPCSTR)text, style, 0, 0, 0, 0, infoPtr->hwndSelf, 0, hinst, 0);
5952
5953     if (!hedit) return 0;
5954
5955     infoPtr->EditWndProc = (WNDPROC)
5956         (isW ? SetWindowLongPtrW(hedit, GWLP_WNDPROC, (DWORD_PTR)EditLblWndProcW) :
5957                SetWindowLongPtrA(hedit, GWLP_WNDPROC, (DWORD_PTR)EditLblWndProcA) );
5958
5959     SendMessageW(hedit, WM_SETFONT, (WPARAM)infoPtr->hFont, FALSE);
5960     SendMessageW(hedit, EM_SETLIMITTEXT, DISP_TEXT_SIZE-1, 0);
5961
5962     return hedit;
5963 }
5964
5965 /***
5966  * DESCRIPTION:
5967  * Begin in place editing of specified list view item
5968  *
5969  * PARAMETER(S):
5970  * [I] infoPtr : valid pointer to the listview structure
5971  * [I] nItem : item index
5972  * [I] isW : TRUE if it's a Unicode req, FALSE if ASCII
5973  *
5974  * RETURN:
5975  *   SUCCESS : TRUE
5976  *   FAILURE : FALSE
5977  */
5978 static HWND LISTVIEW_EditLabelT(LISTVIEW_INFO *infoPtr, INT nItem, BOOL isW)
5979 {
5980     WCHAR disptextW[DISP_TEXT_SIZE] = { 0 };
5981     HWND hwndSelf = infoPtr->hwndSelf;
5982     NMLVDISPINFOW dispInfo;
5983     HFONT hOldFont = NULL;
5984     TEXTMETRICW tm;
5985     RECT rect;
5986     SIZE sz;
5987     HDC hdc;
5988
5989     TRACE("(nItem=%d, isW=%d)\n", nItem, isW);
5990
5991     if (~infoPtr->dwStyle & LVS_EDITLABELS) return 0;
5992
5993     /* remove existing edit box */
5994     if (infoPtr->hwndEdit)
5995     {
5996         SetFocus(infoPtr->hwndSelf);
5997         infoPtr->hwndEdit = 0;
5998     }
5999
6000     if (nItem < 0 || nItem >= infoPtr->nItemCount) return 0;
6001
6002     infoPtr->nEditLabelItem = nItem;
6003
6004     LISTVIEW_SetSelection(infoPtr, nItem);
6005     LISTVIEW_SetItemFocus(infoPtr, nItem);
6006     LISTVIEW_InvalidateItem(infoPtr, nItem);
6007
6008     rect.left = LVIR_LABEL;
6009     if (!LISTVIEW_GetItemRect(infoPtr, nItem, &rect)) return 0;
6010
6011     ZeroMemory(&dispInfo, sizeof(dispInfo));
6012     dispInfo.item.mask = LVIF_PARAM | LVIF_STATE | LVIF_TEXT;
6013     dispInfo.item.iItem = nItem;
6014     dispInfo.item.iSubItem = 0;
6015     dispInfo.item.stateMask = ~0;
6016     dispInfo.item.pszText = disptextW;
6017     dispInfo.item.cchTextMax = DISP_TEXT_SIZE;
6018     if (!LISTVIEW_GetItemT(infoPtr, &dispInfo.item, isW)) return 0;
6019
6020     infoPtr->hwndEdit = CreateEditLabelT(infoPtr, dispInfo.item.pszText, isW);
6021     if (!infoPtr->hwndEdit) return 0;
6022
6023     if (notify_dispinfoT(infoPtr, LVN_BEGINLABELEDITW, &dispInfo, isW))
6024     {
6025         if (!IsWindow(hwndSelf))
6026             return 0;
6027         SendMessageW(infoPtr->hwndEdit, WM_CLOSE, 0, 0);
6028         infoPtr->hwndEdit = 0;
6029         return 0;
6030     }
6031
6032     TRACE("disp text=%s\n", debugtext_t(dispInfo.item.pszText, isW));
6033
6034     /* position and display edit box */
6035     hdc = GetDC(infoPtr->hwndSelf);
6036
6037     /* select the font to get appropriate metric dimensions */
6038     if (infoPtr->hFont)
6039         hOldFont = SelectObject(hdc, infoPtr->hFont);
6040
6041     /* use real edit box content, it could be altered during LVN_BEGINLABELEDIT notification */
6042     GetWindowTextW(infoPtr->hwndEdit, disptextW, DISP_TEXT_SIZE);
6043     TRACE("edit box text=%s\n", debugstr_w(disptextW));
6044
6045     /* get string length in pixels */
6046     GetTextExtentPoint32W(hdc, disptextW, lstrlenW(disptextW), &sz);
6047
6048     /* add extra spacing for the next character */
6049     GetTextMetricsW(hdc, &tm);
6050     sz.cx += tm.tmMaxCharWidth * 2;
6051
6052     if (infoPtr->hFont)
6053         SelectObject(hdc, hOldFont);
6054
6055     ReleaseDC(infoPtr->hwndSelf, hdc);
6056
6057     sz.cy = rect.bottom - rect.top + 2;
6058     rect.left -= 2;
6059     rect.top  -= 1;
6060     TRACE("moving edit=(%d,%d)-(%d,%d)\n", rect.left, rect.top, sz.cx, sz.cy);
6061     MoveWindow(infoPtr->hwndEdit, rect.left, rect.top, sz.cx, sz.cy, FALSE);
6062     ShowWindow(infoPtr->hwndEdit, SW_NORMAL);
6063     SetFocus(infoPtr->hwndEdit);
6064     SendMessageW(infoPtr->hwndEdit, EM_SETSEL, 0, -1);
6065     return infoPtr->hwndEdit;
6066 }
6067
6068
6069 /***
6070  * DESCRIPTION:
6071  * Ensures the specified item is visible, scrolling into view if necessary.
6072  *
6073  * PARAMETER(S):
6074  * [I] infoPtr : valid pointer to the listview structure
6075  * [I] nItem : item index
6076  * [I] bPartial : partially or entirely visible
6077  *
6078  * RETURN:
6079  *   SUCCESS : TRUE
6080  *   FAILURE : FALSE
6081  */
6082 static BOOL LISTVIEW_EnsureVisible(LISTVIEW_INFO *infoPtr, INT nItem, BOOL bPartial)
6083 {
6084     INT nScrollPosHeight = 0;
6085     INT nScrollPosWidth = 0;
6086     INT nHorzAdjust = 0;
6087     INT nVertAdjust = 0;
6088     INT nHorzDiff = 0;
6089     INT nVertDiff = 0;
6090     RECT rcItem, rcTemp;
6091
6092     rcItem.left = LVIR_BOUNDS;
6093     if (!LISTVIEW_GetItemRect(infoPtr, nItem, &rcItem)) return FALSE;
6094
6095     if (bPartial && IntersectRect(&rcTemp, &infoPtr->rcList, &rcItem)) return TRUE;
6096
6097     if (rcItem.left < infoPtr->rcList.left || rcItem.right > infoPtr->rcList.right)
6098     {
6099         /* scroll left/right, but in LV_VIEW_DETAILS mode */
6100         if (infoPtr->uView == LV_VIEW_LIST)
6101             nScrollPosWidth = infoPtr->nItemWidth;
6102         else if ((infoPtr->uView == LV_VIEW_SMALLICON) || (infoPtr->uView == LV_VIEW_ICON))
6103             nScrollPosWidth = 1;
6104
6105         if (rcItem.left < infoPtr->rcList.left)
6106         {
6107             nHorzAdjust = -1;
6108             if (infoPtr->uView != LV_VIEW_DETAILS) nHorzDiff = rcItem.left - infoPtr->rcList.left;
6109         }
6110         else
6111         {
6112             nHorzAdjust = 1;
6113             if (infoPtr->uView != LV_VIEW_DETAILS) nHorzDiff = rcItem.right - infoPtr->rcList.right;
6114         }
6115     }
6116
6117     if (rcItem.top < infoPtr->rcList.top || rcItem.bottom > infoPtr->rcList.bottom)
6118     {
6119         /* scroll up/down, but not in LVS_LIST mode */
6120         if (infoPtr->uView == LV_VIEW_DETAILS)
6121             nScrollPosHeight = infoPtr->nItemHeight;
6122         else if ((infoPtr->uView == LV_VIEW_ICON) || (infoPtr->uView == LV_VIEW_SMALLICON))
6123             nScrollPosHeight = 1;
6124
6125         if (rcItem.top < infoPtr->rcList.top)
6126         {
6127             nVertAdjust = -1;
6128             if (infoPtr->uView != LV_VIEW_LIST) nVertDiff = rcItem.top - infoPtr->rcList.top;
6129         }
6130         else
6131         {
6132             nVertAdjust = 1;
6133             if (infoPtr->uView != LV_VIEW_LIST) nVertDiff = rcItem.bottom - infoPtr->rcList.bottom;
6134         }
6135     }
6136
6137     if (!nScrollPosWidth && !nScrollPosHeight) return TRUE;
6138
6139     if (nScrollPosWidth)
6140     {
6141         INT diff = nHorzDiff / nScrollPosWidth;
6142         if (nHorzDiff % nScrollPosWidth) diff += nHorzAdjust;
6143         LISTVIEW_HScroll(infoPtr, SB_INTERNAL, diff);
6144     }
6145
6146     if (nScrollPosHeight)
6147     {
6148         INT diff = nVertDiff / nScrollPosHeight;
6149         if (nVertDiff % nScrollPosHeight) diff += nVertAdjust;
6150         LISTVIEW_VScroll(infoPtr, SB_INTERNAL, diff);
6151     }
6152
6153     return TRUE;
6154 }
6155
6156 /***
6157  * DESCRIPTION:
6158  * Searches for an item with specific characteristics.
6159  *
6160  * PARAMETER(S):
6161  * [I] hwnd : window handle
6162  * [I] nStart : base item index
6163  * [I] lpFindInfo : item information to look for
6164  *
6165  * RETURN:
6166  *   SUCCESS : index of item
6167  *   FAILURE : -1
6168  */
6169 static INT LISTVIEW_FindItemW(const LISTVIEW_INFO *infoPtr, INT nStart,
6170                               const LVFINDINFOW *lpFindInfo)
6171 {
6172     WCHAR szDispText[DISP_TEXT_SIZE] = { '\0' };
6173     BOOL bWrap = FALSE, bNearest = FALSE;
6174     INT nItem = nStart + 1, nLast = infoPtr->nItemCount, nNearestItem = -1;
6175     ULONG xdist, ydist, dist, mindist = 0x7fffffff;
6176     POINT Position, Destination;
6177     LVITEMW lvItem;
6178
6179     /* Search in virtual listviews should be done by application, not by
6180        listview control, so we just send LVN_ODFINDITEMW and return the result */
6181     if (infoPtr->dwStyle & LVS_OWNERDATA)
6182     {
6183         NMLVFINDITEMW nmlv;
6184
6185         nmlv.iStart = nStart;
6186         nmlv.lvfi = *lpFindInfo;
6187         return notify_hdr(infoPtr, LVN_ODFINDITEMW, (LPNMHDR)&nmlv.hdr);
6188     }
6189
6190     if (!lpFindInfo || nItem < 0) return -1;
6191
6192     lvItem.mask = 0;
6193     if (lpFindInfo->flags & (LVFI_STRING | LVFI_PARTIAL) ||
6194         lpFindInfo->flags &  LVFI_SUBSTRING)
6195     {
6196         lvItem.mask |= LVIF_TEXT;
6197         lvItem.pszText = szDispText;
6198         lvItem.cchTextMax = DISP_TEXT_SIZE;
6199     }
6200
6201     if (lpFindInfo->flags & LVFI_WRAP)
6202         bWrap = TRUE;
6203
6204     if ((lpFindInfo->flags & LVFI_NEARESTXY) &&
6205         (infoPtr->uView == LV_VIEW_ICON || infoPtr->uView == LV_VIEW_SMALLICON))
6206     {
6207         POINT Origin;
6208         RECT rcArea;
6209
6210         LISTVIEW_GetOrigin(infoPtr, &Origin);
6211         Destination.x = lpFindInfo->pt.x - Origin.x;
6212         Destination.y = lpFindInfo->pt.y - Origin.y;
6213         switch(lpFindInfo->vkDirection)
6214         {
6215         case VK_DOWN:  Destination.y += infoPtr->nItemHeight; break;
6216         case VK_UP:    Destination.y -= infoPtr->nItemHeight; break;
6217         case VK_RIGHT: Destination.x += infoPtr->nItemWidth; break;
6218         case VK_LEFT:  Destination.x -= infoPtr->nItemWidth; break;
6219         case VK_HOME:  Destination.x = Destination.y = 0; break;
6220         case VK_NEXT:  Destination.y += infoPtr->rcList.bottom - infoPtr->rcList.top; break;
6221         case VK_PRIOR: Destination.y -= infoPtr->rcList.bottom - infoPtr->rcList.top; break;
6222         case VK_END:
6223             LISTVIEW_GetAreaRect(infoPtr, &rcArea);
6224             Destination.x = rcArea.right;
6225             Destination.y = rcArea.bottom;
6226             break;
6227         default: ERR("Unknown vkDirection=%d\n", lpFindInfo->vkDirection);
6228         }
6229         bNearest = TRUE;
6230     }
6231     else Destination.x = Destination.y = 0;
6232
6233     /* if LVFI_PARAM is specified, all other flags are ignored */
6234     if (lpFindInfo->flags & LVFI_PARAM)
6235     {
6236         lvItem.mask |= LVIF_PARAM;
6237         bNearest = FALSE;
6238         lvItem.mask &= ~LVIF_TEXT;
6239     }
6240
6241 again:
6242     for (; nItem < nLast; nItem++)
6243     {
6244         lvItem.iItem = nItem;
6245         lvItem.iSubItem = 0;
6246         if (!LISTVIEW_GetItemW(infoPtr, &lvItem)) continue;
6247
6248         if (lvItem.mask & LVIF_PARAM)
6249         {
6250             if (lpFindInfo->lParam == lvItem.lParam)
6251                 return nItem;
6252             else
6253                 continue;
6254         }
6255
6256         if (lvItem.mask & LVIF_TEXT)
6257         {
6258             if (lpFindInfo->flags & (LVFI_PARTIAL | LVFI_SUBSTRING))
6259             {
6260                 WCHAR *p = strstrW(lvItem.pszText, lpFindInfo->psz);
6261                 if (!p || p != lvItem.pszText) continue;
6262             }
6263             else
6264             {
6265                 if (lstrcmpW(lvItem.pszText, lpFindInfo->psz) != 0) continue;
6266             }
6267         }
6268
6269         if (!bNearest) return nItem;
6270
6271         /* This is very inefficient. To do a good job here,
6272          * we need a sorted array of (x,y) item positions */
6273         LISTVIEW_GetItemOrigin(infoPtr, nItem, &Position);
6274
6275         /* compute the distance^2 to the destination */
6276         xdist = Destination.x - Position.x;
6277         ydist = Destination.y - Position.y;
6278         dist = xdist * xdist + ydist * ydist;
6279
6280         /* remember the distance, and item if it's closer */
6281         if (dist < mindist)
6282         {
6283             mindist = dist;
6284             nNearestItem = nItem;
6285         }
6286     }
6287
6288     if (bWrap)
6289     {
6290         nItem = 0;
6291         nLast = min(nStart + 1, infoPtr->nItemCount);
6292         bWrap = FALSE;
6293         goto again;
6294     }
6295
6296     return nNearestItem;
6297 }
6298
6299 /***
6300  * DESCRIPTION:
6301  * Searches for an item with specific characteristics.
6302  *
6303  * PARAMETER(S):
6304  * [I] hwnd : window handle
6305  * [I] nStart : base item index
6306  * [I] lpFindInfo : item information to look for
6307  *
6308  * RETURN:
6309  *   SUCCESS : index of item
6310  *   FAILURE : -1
6311  */
6312 static INT LISTVIEW_FindItemA(const LISTVIEW_INFO *infoPtr, INT nStart,
6313                               const LVFINDINFOA *lpFindInfo)
6314 {
6315     BOOL hasText = lpFindInfo->flags & (LVFI_STRING | LVFI_PARTIAL) ||
6316                    lpFindInfo->flags &  LVFI_SUBSTRING;
6317     LVFINDINFOW fiw;
6318     INT res;
6319     LPWSTR strW = NULL;
6320
6321     memcpy(&fiw, lpFindInfo, sizeof(fiw));
6322     if (hasText) fiw.psz = strW = textdupTtoW((LPCWSTR)lpFindInfo->psz, FALSE);
6323     res = LISTVIEW_FindItemW(infoPtr, nStart, &fiw);
6324     textfreeT(strW, FALSE);
6325     return res;
6326 }
6327
6328 /***
6329  * DESCRIPTION:
6330  * Retrieves column attributes.
6331  *
6332  * PARAMETER(S):
6333  * [I] infoPtr : valid pointer to the listview structure
6334  * [I] nColumn :  column index
6335  * [IO] lpColumn : column information
6336  * [I] isW : if TRUE, then lpColumn is a LPLVCOLUMNW
6337  *           otherwise it is in fact a LPLVCOLUMNA
6338  *
6339  * RETURN:
6340  *   SUCCESS : TRUE
6341  *   FAILURE : FALSE
6342  */
6343 static BOOL LISTVIEW_GetColumnT(const LISTVIEW_INFO *infoPtr, INT nColumn, LPLVCOLUMNW lpColumn, BOOL isW)
6344 {
6345     COLUMN_INFO *lpColumnInfo;
6346     HDITEMW hdi;
6347
6348     if (!lpColumn || nColumn < 0 || nColumn >= DPA_GetPtrCount(infoPtr->hdpaColumns)) return FALSE;
6349     lpColumnInfo = LISTVIEW_GetColumnInfo(infoPtr, nColumn);
6350
6351     /* initialize memory */
6352     ZeroMemory(&hdi, sizeof(hdi));
6353
6354     if (lpColumn->mask & LVCF_TEXT)
6355     {
6356         hdi.mask |= HDI_TEXT;
6357         hdi.pszText = lpColumn->pszText;
6358         hdi.cchTextMax = lpColumn->cchTextMax;
6359     }
6360
6361     if (lpColumn->mask & LVCF_IMAGE)
6362         hdi.mask |= HDI_IMAGE;
6363
6364     if (lpColumn->mask & LVCF_ORDER)
6365         hdi.mask |= HDI_ORDER;
6366
6367     if (lpColumn->mask & LVCF_SUBITEM)
6368         hdi.mask |= HDI_LPARAM;
6369
6370     if (!SendMessageW(infoPtr->hwndHeader, isW ? HDM_GETITEMW : HDM_GETITEMA, nColumn, (LPARAM)&hdi)) return FALSE;
6371
6372     if (lpColumn->mask & LVCF_FMT)
6373         lpColumn->fmt = lpColumnInfo->fmt;
6374
6375     if (lpColumn->mask & LVCF_WIDTH)
6376         lpColumn->cx = lpColumnInfo->rcHeader.right - lpColumnInfo->rcHeader.left;
6377
6378     if (lpColumn->mask & LVCF_IMAGE)
6379         lpColumn->iImage = hdi.iImage;
6380
6381     if (lpColumn->mask & LVCF_ORDER)
6382         lpColumn->iOrder = hdi.iOrder;
6383
6384     if (lpColumn->mask & LVCF_SUBITEM)
6385         lpColumn->iSubItem = hdi.lParam;
6386
6387     if (lpColumn->mask & LVCF_MINWIDTH)
6388         lpColumn->cxMin = lpColumnInfo->cxMin;
6389
6390     return TRUE;
6391 }
6392
6393
6394 static BOOL LISTVIEW_GetColumnOrderArray(const LISTVIEW_INFO *infoPtr, INT iCount, LPINT lpiArray)
6395 {
6396     TRACE("iCount=%d, lpiArray=%p\n", iCount, lpiArray);
6397
6398     if (!lpiArray)
6399         return FALSE;
6400
6401     return SendMessageW(infoPtr->hwndHeader, HDM_GETORDERARRAY, iCount, (LPARAM)lpiArray);
6402 }
6403
6404 /***
6405  * DESCRIPTION:
6406  * Retrieves the column width.
6407  *
6408  * PARAMETER(S):
6409  * [I] infoPtr : valid pointer to the listview structure
6410  * [I] int : column index
6411  *
6412  * RETURN:
6413  *   SUCCESS : column width
6414  *   FAILURE : zero
6415  */
6416 static INT LISTVIEW_GetColumnWidth(const LISTVIEW_INFO *infoPtr, INT nColumn)
6417 {
6418     INT nColumnWidth = 0;
6419     HDITEMW hdItem;
6420
6421     TRACE("nColumn=%d\n", nColumn);
6422
6423     /* we have a 'column' in LIST and REPORT mode only */
6424     switch(infoPtr->uView)
6425     {
6426     case LV_VIEW_LIST:
6427         nColumnWidth = infoPtr->nItemWidth;
6428         break;
6429     case LV_VIEW_DETAILS:
6430         /* We are not using LISTVIEW_GetHeaderRect as this data is updated only after a HDN_ITEMCHANGED.
6431          * There is an application that subclasses the listview, calls LVM_GETCOLUMNWIDTH in the
6432          * HDN_ITEMCHANGED handler and goes into infinite recursion if it receives old data.
6433          *
6434          * TODO: should we do the same in LVM_GETCOLUMN?
6435          */
6436         hdItem.mask = HDI_WIDTH;
6437         if (!SendMessageW(infoPtr->hwndHeader, HDM_GETITEMW, nColumn, (LPARAM)&hdItem))
6438         {
6439             WARN("(%p): HDM_GETITEMW failed for item %d\n", infoPtr->hwndSelf, nColumn);
6440             return 0;
6441         }
6442         nColumnWidth = hdItem.cxy;
6443         break;
6444     }
6445
6446     TRACE("nColumnWidth=%d\n", nColumnWidth);
6447     return nColumnWidth;
6448 }
6449
6450 /***
6451  * DESCRIPTION:
6452  * In list or report display mode, retrieves the number of items that can fit
6453  * vertically in the visible area. In icon or small icon display mode,
6454  * retrieves the total number of visible items.
6455  *
6456  * PARAMETER(S):
6457  * [I] infoPtr : valid pointer to the listview structure
6458  *
6459  * RETURN:
6460  * Number of fully visible items.
6461  */
6462 static INT LISTVIEW_GetCountPerPage(const LISTVIEW_INFO *infoPtr)
6463 {
6464     switch (infoPtr->uView)
6465     {
6466     case LV_VIEW_ICON:
6467     case LV_VIEW_SMALLICON:
6468         return infoPtr->nItemCount;
6469     case LV_VIEW_DETAILS:
6470         return LISTVIEW_GetCountPerColumn(infoPtr);
6471     case LV_VIEW_LIST:
6472         return LISTVIEW_GetCountPerRow(infoPtr) * LISTVIEW_GetCountPerColumn(infoPtr);
6473     }
6474     assert(FALSE);
6475     return 0;
6476 }
6477
6478 /***
6479  * DESCRIPTION:
6480  * Retrieves an image list handle.
6481  *
6482  * PARAMETER(S):
6483  * [I] infoPtr : valid pointer to the listview structure
6484  * [I] nImageList : image list identifier
6485  *
6486  * RETURN:
6487  *   SUCCESS : image list handle
6488  *   FAILURE : NULL
6489  */
6490 static HIMAGELIST LISTVIEW_GetImageList(const LISTVIEW_INFO *infoPtr, INT nImageList)
6491 {
6492     switch (nImageList)
6493     {
6494     case LVSIL_NORMAL: return infoPtr->himlNormal;
6495     case LVSIL_SMALL:  return infoPtr->himlSmall;
6496     case LVSIL_STATE:  return infoPtr->himlState;
6497     case LVSIL_GROUPHEADER:
6498         FIXME("LVSIL_GROUPHEADER not supported\n");
6499         break;
6500     default:
6501         WARN("got unknown imagelist index - %d\n", nImageList);
6502     }
6503     return NULL;
6504 }
6505
6506 /* LISTVIEW_GetISearchString */
6507
6508 /***
6509  * DESCRIPTION:
6510  * Retrieves item attributes.
6511  *
6512  * PARAMETER(S):
6513  * [I] hwnd : window handle
6514  * [IO] lpLVItem : item info
6515  * [I] isW : if TRUE, then lpLVItem is a LPLVITEMW,
6516  *           if FALSE, then lpLVItem is a LPLVITEMA.
6517  *
6518  * NOTE:
6519  *   This is the internal 'GetItem' interface -- it tries to
6520  *   be smart and avoid text copies, if possible, by modifying
6521  *   lpLVItem->pszText to point to the text string. Please note
6522  *   that this is not always possible (e.g. OWNERDATA), so on
6523  *   entry you *must* supply valid values for pszText, and cchTextMax.
6524  *   The only difference to the documented interface is that upon
6525  *   return, you should use *only* the lpLVItem->pszText, rather than
6526  *   the buffer pointer you provided on input. Most code already does
6527  *   that, so it's not a problem.
6528  *   For the two cases when the text must be copied (that is,
6529  *   for LVM_GETITEM, and LVM_GETITEMTEXT), use LISTVIEW_GetItemExtT.
6530  *
6531  * RETURN:
6532  *   SUCCESS : TRUE
6533  *   FAILURE : FALSE
6534  */
6535 static BOOL LISTVIEW_GetItemT(const LISTVIEW_INFO *infoPtr, LPLVITEMW lpLVItem, BOOL isW)
6536 {
6537     ITEMHDR callbackHdr = { LPSTR_TEXTCALLBACKW, I_IMAGECALLBACK };
6538     NMLVDISPINFOW dispInfo;
6539     ITEM_INFO *lpItem;
6540     ITEMHDR* pItemHdr;
6541     HDPA hdpaSubItems;
6542     INT isubitem;
6543
6544     TRACE("(item=%s, isW=%d)\n", debuglvitem_t(lpLVItem, isW), isW);
6545
6546     if (!lpLVItem || lpLVItem->iItem < 0 || lpLVItem->iItem >= infoPtr->nItemCount)
6547         return FALSE;
6548
6549     if (lpLVItem->mask == 0) return TRUE;
6550     TRACE("mask=%x\n", lpLVItem->mask);
6551
6552     /* make a local copy */
6553     isubitem = lpLVItem->iSubItem;
6554
6555     /* a quick optimization if all we're asked is the focus state
6556      * these queries are worth optimising since they are common,
6557      * and can be answered in constant time, without the heavy accesses */
6558     if ( (lpLVItem->mask == LVIF_STATE) && (lpLVItem->stateMask == LVIS_FOCUSED) &&
6559          !(infoPtr->uCallbackMask & LVIS_FOCUSED) )
6560     {
6561         lpLVItem->state = 0;
6562         if (infoPtr->nFocusedItem == lpLVItem->iItem)
6563             lpLVItem->state |= LVIS_FOCUSED;
6564         return TRUE;
6565     }
6566
6567     ZeroMemory(&dispInfo, sizeof(dispInfo));
6568
6569     /* if the app stores all the data, handle it separately */
6570     if (infoPtr->dwStyle & LVS_OWNERDATA)
6571     {
6572         dispInfo.item.state = 0;
6573
6574         /* apparently, we should not callback for lParam in LVS_OWNERDATA */
6575         if ((lpLVItem->mask & ~(LVIF_STATE | LVIF_PARAM)) ||
6576            ((lpLVItem->mask & LVIF_STATE) && (infoPtr->uCallbackMask & lpLVItem->stateMask)))
6577         {
6578             UINT mask = lpLVItem->mask;
6579
6580             /* NOTE: copy only fields which we _know_ are initialized, some apps
6581              *       depend on the uninitialized fields being 0 */
6582             dispInfo.item.mask = lpLVItem->mask & ~LVIF_PARAM;
6583             dispInfo.item.iItem = lpLVItem->iItem;
6584             dispInfo.item.iSubItem = isubitem;
6585             if (lpLVItem->mask & LVIF_TEXT)
6586             {
6587                 if (lpLVItem->mask & LVIF_NORECOMPUTE)
6588                     /* reset mask */
6589                     dispInfo.item.mask &= ~(LVIF_TEXT | LVIF_NORECOMPUTE);
6590                 else
6591                 {
6592                     dispInfo.item.pszText = lpLVItem->pszText;
6593                     dispInfo.item.cchTextMax = lpLVItem->cchTextMax;
6594                 }
6595             }
6596             if (lpLVItem->mask & LVIF_STATE)
6597                 dispInfo.item.stateMask = lpLVItem->stateMask & infoPtr->uCallbackMask;
6598             /* could be zeroed on LVIF_NORECOMPUTE case */
6599             if (dispInfo.item.mask)
6600             {
6601                 notify_dispinfoT(infoPtr, LVN_GETDISPINFOW, &dispInfo, isW);
6602                 dispInfo.item.stateMask = lpLVItem->stateMask;
6603                 if (lpLVItem->mask & (LVIF_GROUPID|LVIF_COLUMNS))
6604                 {
6605                     /* full size structure expected - _WIN32IE >= 0x560 */
6606                     *lpLVItem = dispInfo.item;
6607                 }
6608                 else if (lpLVItem->mask & LVIF_INDENT)
6609                 {
6610                     /* indent member expected - _WIN32IE >= 0x300 */
6611                     memcpy(lpLVItem, &dispInfo.item, offsetof( LVITEMW, iGroupId ));
6612                 }
6613                 else
6614                 {
6615                     /* minimal structure expected */
6616                     memcpy(lpLVItem, &dispInfo.item, offsetof( LVITEMW, iIndent ));
6617                 }
6618                 lpLVItem->mask = mask;
6619                 TRACE("   getdispinfo(1):lpLVItem=%s\n", debuglvitem_t(lpLVItem, isW));
6620             }
6621         }
6622
6623         /* make sure lParam is zeroed out */
6624         if (lpLVItem->mask & LVIF_PARAM) lpLVItem->lParam = 0;
6625
6626         /* callback marked pointer required here */
6627         if ((lpLVItem->mask & LVIF_TEXT) && (lpLVItem->mask & LVIF_NORECOMPUTE))
6628             lpLVItem->pszText = LPSTR_TEXTCALLBACKW;
6629
6630         /* we store only a little state, so if we're not asked, we're done */
6631         if (!(lpLVItem->mask & LVIF_STATE) || isubitem) return TRUE;
6632
6633         /* if focus is handled by us, report it */
6634         if ( lpLVItem->stateMask & ~infoPtr->uCallbackMask & LVIS_FOCUSED )
6635         {
6636             lpLVItem->state &= ~LVIS_FOCUSED;
6637             if (infoPtr->nFocusedItem == lpLVItem->iItem)
6638                 lpLVItem->state |= LVIS_FOCUSED;
6639         }
6640
6641         /* and do the same for selection, if we handle it */
6642         if ( lpLVItem->stateMask & ~infoPtr->uCallbackMask & LVIS_SELECTED )
6643         {
6644             lpLVItem->state &= ~LVIS_SELECTED;
6645             if (ranges_contain(infoPtr->selectionRanges, lpLVItem->iItem))
6646                 lpLVItem->state |= LVIS_SELECTED;
6647         }
6648
6649         return TRUE;
6650     }
6651
6652     /* find the item and subitem structures before we proceed */
6653     hdpaSubItems = DPA_GetPtr(infoPtr->hdpaItems, lpLVItem->iItem);
6654     lpItem = DPA_GetPtr(hdpaSubItems, 0);
6655     assert (lpItem);
6656
6657     if (isubitem)
6658     {
6659         SUBITEM_INFO *lpSubItem = LISTVIEW_GetSubItemPtr(hdpaSubItems, isubitem);
6660         pItemHdr = lpSubItem ? &lpSubItem->hdr : &callbackHdr;
6661         if (!lpSubItem)
6662         {
6663             WARN(" iSubItem invalid (%08x), ignored.\n", isubitem);
6664             isubitem = 0;
6665         }
6666     }
6667     else
6668         pItemHdr = &lpItem->hdr;
6669
6670     /* Do we need to query the state from the app? */
6671     if ((lpLVItem->mask & LVIF_STATE) && infoPtr->uCallbackMask && isubitem == 0)
6672     {
6673         dispInfo.item.mask |= LVIF_STATE;
6674         dispInfo.item.stateMask = infoPtr->uCallbackMask;
6675     }
6676
6677     /* Do we need to enquire about the image? */
6678     if ((lpLVItem->mask & LVIF_IMAGE) && pItemHdr->iImage == I_IMAGECALLBACK &&
6679         (isubitem == 0 || (infoPtr->dwLvExStyle & LVS_EX_SUBITEMIMAGES)))
6680     {
6681         dispInfo.item.mask |= LVIF_IMAGE;
6682         dispInfo.item.iImage = I_IMAGECALLBACK;
6683     }
6684
6685     /* Only items support indentation */
6686     if ((lpLVItem->mask & LVIF_INDENT) && lpItem->iIndent == I_INDENTCALLBACK &&
6687         (isubitem == 0))
6688     {
6689         dispInfo.item.mask |= LVIF_INDENT;
6690         dispInfo.item.iIndent = I_INDENTCALLBACK;
6691     }
6692
6693     /* Apps depend on calling back for text if it is NULL or LPSTR_TEXTCALLBACKW */
6694     if ((lpLVItem->mask & LVIF_TEXT) && !(lpLVItem->mask & LVIF_NORECOMPUTE) &&
6695         !is_text(pItemHdr->pszText))
6696     {
6697         dispInfo.item.mask |= LVIF_TEXT;
6698         dispInfo.item.pszText = lpLVItem->pszText;
6699         dispInfo.item.cchTextMax = lpLVItem->cchTextMax;
6700         if (dispInfo.item.pszText && dispInfo.item.cchTextMax > 0)
6701             *dispInfo.item.pszText = '\0';
6702     }
6703
6704     /* If we don't have all the requested info, query the application */
6705     if (dispInfo.item.mask)
6706     {
6707         dispInfo.item.iItem = lpLVItem->iItem;
6708         dispInfo.item.iSubItem = lpLVItem->iSubItem; /* yes: the original subitem */
6709         dispInfo.item.lParam = lpItem->lParam;
6710         notify_dispinfoT(infoPtr, LVN_GETDISPINFOW, &dispInfo, isW);
6711         TRACE("   getdispinfo(2):item=%s\n", debuglvitem_t(&dispInfo.item, isW));
6712     }
6713
6714     /* we should not store values for subitems */
6715     if (isubitem) dispInfo.item.mask &= ~LVIF_DI_SETITEM;
6716
6717     /* Now, handle the iImage field */
6718     if (dispInfo.item.mask & LVIF_IMAGE)
6719     {
6720         lpLVItem->iImage = dispInfo.item.iImage;
6721         if ((dispInfo.item.mask & LVIF_DI_SETITEM) && pItemHdr->iImage == I_IMAGECALLBACK)
6722             pItemHdr->iImage = dispInfo.item.iImage;
6723     }
6724     else if (lpLVItem->mask & LVIF_IMAGE)
6725     {
6726         if(isubitem == 0 || (infoPtr->dwLvExStyle & LVS_EX_SUBITEMIMAGES))
6727             lpLVItem->iImage = pItemHdr->iImage;
6728         else
6729             lpLVItem->iImage = 0;
6730     }
6731
6732     /* The pszText field */
6733     if (dispInfo.item.mask & LVIF_TEXT)
6734     {
6735         if ((dispInfo.item.mask & LVIF_DI_SETITEM) && pItemHdr->pszText)
6736             textsetptrT(&pItemHdr->pszText, dispInfo.item.pszText, isW);
6737
6738         lpLVItem->pszText = dispInfo.item.pszText;
6739     }
6740     else if (lpLVItem->mask & LVIF_TEXT)
6741     {
6742         /* if LVN_GETDISPINFO's disabled with LVIF_NORECOMPUTE return callback placeholder */
6743         if (isW || !is_text(pItemHdr->pszText)) lpLVItem->pszText = pItemHdr->pszText;
6744         else textcpynT(lpLVItem->pszText, isW, pItemHdr->pszText, TRUE, lpLVItem->cchTextMax);
6745     }
6746
6747     /* Next is the lParam field */
6748     if (dispInfo.item.mask & LVIF_PARAM)
6749     {
6750         lpLVItem->lParam = dispInfo.item.lParam;
6751         if ((dispInfo.item.mask & LVIF_DI_SETITEM))
6752             lpItem->lParam = dispInfo.item.lParam;
6753     }
6754     else if (lpLVItem->mask & LVIF_PARAM)
6755         lpLVItem->lParam = lpItem->lParam;
6756
6757     /* if this is a subitem, we're done */
6758     if (isubitem) return TRUE;
6759
6760     /* ... the state field (this one is different due to uCallbackmask) */
6761     if (lpLVItem->mask & LVIF_STATE)
6762     {
6763         lpLVItem->state = lpItem->state & lpLVItem->stateMask;
6764         if (dispInfo.item.mask & LVIF_STATE)
6765         {
6766             lpLVItem->state &= ~dispInfo.item.stateMask;
6767             lpLVItem->state |= (dispInfo.item.state & dispInfo.item.stateMask);
6768         }
6769         if ( lpLVItem->stateMask & ~infoPtr->uCallbackMask & LVIS_FOCUSED )
6770         {
6771             lpLVItem->state &= ~LVIS_FOCUSED;
6772             if (infoPtr->nFocusedItem == lpLVItem->iItem)
6773                 lpLVItem->state |= LVIS_FOCUSED;
6774         }
6775         if ( lpLVItem->stateMask & ~infoPtr->uCallbackMask & LVIS_SELECTED )
6776         {
6777             lpLVItem->state &= ~LVIS_SELECTED;
6778             if (ranges_contain(infoPtr->selectionRanges, lpLVItem->iItem))
6779                 lpLVItem->state |= LVIS_SELECTED;
6780         }
6781     }
6782
6783     /* and last, but not least, the indent field */
6784     if (dispInfo.item.mask & LVIF_INDENT)
6785     {
6786         lpLVItem->iIndent = dispInfo.item.iIndent;
6787         if ((dispInfo.item.mask & LVIF_DI_SETITEM) && lpItem->iIndent == I_INDENTCALLBACK)
6788             lpItem->iIndent = dispInfo.item.iIndent;
6789     }
6790     else if (lpLVItem->mask & LVIF_INDENT)
6791     {
6792         lpLVItem->iIndent = lpItem->iIndent;
6793     }
6794
6795     return TRUE;
6796 }
6797
6798 /***
6799  * DESCRIPTION:
6800  * Retrieves item attributes.
6801  *
6802  * PARAMETER(S):
6803  * [I] hwnd : window handle
6804  * [IO] lpLVItem : item info
6805  * [I] isW : if TRUE, then lpLVItem is a LPLVITEMW,
6806  *           if FALSE, then lpLVItem is a LPLVITEMA.
6807  *
6808  * NOTE:
6809  *   This is the external 'GetItem' interface -- it properly copies
6810  *   the text in the provided buffer.
6811  *
6812  * RETURN:
6813  *   SUCCESS : TRUE
6814  *   FAILURE : FALSE
6815  */
6816 static BOOL LISTVIEW_GetItemExtT(const LISTVIEW_INFO *infoPtr, LPLVITEMW lpLVItem, BOOL isW)
6817 {
6818     LPWSTR pszText;
6819     BOOL bResult;
6820
6821     if (!lpLVItem || lpLVItem->iItem < 0 || lpLVItem->iItem >= infoPtr->nItemCount)
6822         return FALSE;
6823
6824     pszText = lpLVItem->pszText;
6825     bResult = LISTVIEW_GetItemT(infoPtr, lpLVItem, isW);
6826     if (bResult && (lpLVItem->mask & LVIF_TEXT) && lpLVItem->pszText != pszText)
6827     {
6828         if (lpLVItem->pszText != LPSTR_TEXTCALLBACKW)
6829             textcpynT(pszText, isW, lpLVItem->pszText, isW, lpLVItem->cchTextMax);
6830         else
6831             pszText = LPSTR_TEXTCALLBACKW;
6832     }
6833     lpLVItem->pszText = pszText;
6834
6835     return bResult;
6836 }
6837
6838
6839 /***
6840  * DESCRIPTION:
6841  * Retrieves the position (upper-left) of the listview control item.
6842  * Note that for LVS_ICON style, the upper-left is that of the icon
6843  * and not the bounding box.
6844  *
6845  * PARAMETER(S):
6846  * [I] infoPtr : valid pointer to the listview structure
6847  * [I] nItem : item index
6848  * [O] lpptPosition : coordinate information
6849  *
6850  * RETURN:
6851  *   SUCCESS : TRUE
6852  *   FAILURE : FALSE
6853  */
6854 static BOOL LISTVIEW_GetItemPosition(const LISTVIEW_INFO *infoPtr, INT nItem, LPPOINT lpptPosition)
6855 {
6856     POINT Origin;
6857
6858     TRACE("(nItem=%d, lpptPosition=%p)\n", nItem, lpptPosition);
6859
6860     if (!lpptPosition || nItem < 0 || nItem >= infoPtr->nItemCount) return FALSE;
6861
6862     LISTVIEW_GetOrigin(infoPtr, &Origin);
6863     LISTVIEW_GetItemOrigin(infoPtr, nItem, lpptPosition);
6864
6865     if (infoPtr->uView == LV_VIEW_ICON)
6866     {
6867         lpptPosition->x += (infoPtr->nItemWidth - infoPtr->iconSize.cx) / 2;
6868         lpptPosition->y += ICON_TOP_PADDING;
6869     }
6870     lpptPosition->x += Origin.x;
6871     lpptPosition->y += Origin.y;
6872
6873     TRACE ("  lpptPosition=%s\n", wine_dbgstr_point(lpptPosition));
6874     return TRUE;
6875 }
6876
6877
6878 /***
6879  * DESCRIPTION:
6880  * Retrieves the bounding rectangle for a listview control item.
6881  *
6882  * PARAMETER(S):
6883  * [I] infoPtr : valid pointer to the listview structure
6884  * [I] nItem : item index
6885  * [IO] lprc : bounding rectangle coordinates
6886  *     lprc->left specifies the portion of the item for which the bounding
6887  *     rectangle will be retrieved.
6888  *
6889  *     LVIR_BOUNDS Returns the bounding rectangle of the entire item,
6890  *        including the icon and label.
6891  *         *
6892  *         * For LVS_ICON
6893  *         * Experiment shows that native control returns:
6894  *         *  width = min (48, length of text line)
6895  *         *    .left = position.x - (width - iconsize.cx)/2
6896  *         *    .right = .left + width
6897  *         *  height = #lines of text * ntmHeight + icon height + 8
6898  *         *    .top = position.y - 2
6899  *         *    .bottom = .top + height
6900  *         *  separation between items .y = itemSpacing.cy - height
6901  *         *                           .x = itemSpacing.cx - width
6902  *     LVIR_ICON Returns the bounding rectangle of the icon or small icon.
6903  *         *
6904  *         * For LVS_ICON
6905  *         * Experiment shows that native control returns:
6906  *         *  width = iconSize.cx + 16
6907  *         *    .left = position.x - (width - iconsize.cx)/2
6908  *         *    .right = .left + width
6909  *         *  height = iconSize.cy + 4
6910  *         *    .top = position.y - 2
6911  *         *    .bottom = .top + height
6912  *         *  separation between items .y = itemSpacing.cy - height
6913  *         *                           .x = itemSpacing.cx - width
6914  *     LVIR_LABEL Returns the bounding rectangle of the item text.
6915  *         *
6916  *         * For LVS_ICON
6917  *         * Experiment shows that native control returns:
6918  *         *  width = text length
6919  *         *    .left = position.x - width/2
6920  *         *    .right = .left + width
6921  *         *  height = ntmH * linecount + 2
6922  *         *    .top = position.y + iconSize.cy + 6
6923  *         *    .bottom = .top + height
6924  *         *  separation between items .y = itemSpacing.cy - height
6925  *         *                           .x = itemSpacing.cx - width
6926  *     LVIR_SELECTBOUNDS Returns the union of the LVIR_ICON and LVIR_LABEL
6927  *      rectangles, but excludes columns in report view.
6928  *
6929  * RETURN:
6930  *   SUCCESS : TRUE
6931  *   FAILURE : FALSE
6932  *
6933  * NOTES
6934  *   Note that the bounding rectangle of the label in the LVS_ICON view depends
6935  *   upon whether the window has the focus currently and on whether the item
6936  *   is the one with the focus.  Ensure that the control's record of which
6937  *   item has the focus agrees with the items' records.
6938  */
6939 static BOOL LISTVIEW_GetItemRect(const LISTVIEW_INFO *infoPtr, INT nItem, LPRECT lprc)
6940 {
6941     WCHAR szDispText[DISP_TEXT_SIZE] = { '\0' };
6942     BOOL doLabel = TRUE, oversizedBox = FALSE;
6943     POINT Position, Origin;
6944     LVITEMW lvItem;
6945     LONG mode;
6946
6947     TRACE("(hwnd=%p, nItem=%d, lprc=%p)\n", infoPtr->hwndSelf, nItem, lprc);
6948
6949     if (!lprc || nItem < 0 || nItem >= infoPtr->nItemCount) return FALSE;
6950
6951     LISTVIEW_GetOrigin(infoPtr, &Origin);
6952     LISTVIEW_GetItemOrigin(infoPtr, nItem, &Position);
6953
6954     /* Be smart and try to figure out the minimum we have to do */
6955     if (lprc->left == LVIR_ICON) doLabel = FALSE;
6956     if (infoPtr->uView == LV_VIEW_DETAILS && lprc->left == LVIR_BOUNDS) doLabel = FALSE;
6957     if (infoPtr->uView == LV_VIEW_ICON && lprc->left != LVIR_ICON &&
6958         infoPtr->bFocus && LISTVIEW_GetItemState(infoPtr, nItem, LVIS_FOCUSED))
6959         oversizedBox = TRUE;
6960
6961     /* get what we need from the item before hand, so we make
6962      * only one request. This can speed up things, if data
6963      * is stored on the app side */
6964     lvItem.mask = 0;
6965     if (infoPtr->uView == LV_VIEW_DETAILS) lvItem.mask |= LVIF_INDENT;
6966     if (doLabel) lvItem.mask |= LVIF_TEXT;
6967     lvItem.iItem = nItem;
6968     lvItem.iSubItem = 0;
6969     lvItem.pszText = szDispText;
6970     lvItem.cchTextMax = DISP_TEXT_SIZE;
6971     if (lvItem.mask && !LISTVIEW_GetItemW(infoPtr, &lvItem)) return FALSE;
6972     /* we got the state already up, simulate it here, to avoid a reget */
6973     if (infoPtr->uView == LV_VIEW_ICON && (lprc->left != LVIR_ICON))
6974     {
6975         lvItem.mask |= LVIF_STATE;
6976         lvItem.stateMask = LVIS_FOCUSED;
6977         lvItem.state = (oversizedBox ? LVIS_FOCUSED : 0);
6978     }
6979
6980     if (infoPtr->uView == LV_VIEW_DETAILS && (infoPtr->dwLvExStyle & LVS_EX_FULLROWSELECT) && lprc->left == LVIR_SELECTBOUNDS)
6981         lprc->left = LVIR_BOUNDS;
6982
6983     mode = lprc->left;
6984     switch(lprc->left)
6985     {
6986     case LVIR_ICON:
6987         LISTVIEW_GetItemMetrics(infoPtr, &lvItem, NULL, NULL, lprc, NULL, NULL);
6988         break;
6989
6990     case LVIR_LABEL:
6991         LISTVIEW_GetItemMetrics(infoPtr, &lvItem, NULL, NULL, NULL, NULL, lprc);
6992         break;
6993
6994     case LVIR_BOUNDS:
6995         LISTVIEW_GetItemMetrics(infoPtr, &lvItem, lprc, NULL, NULL, NULL, NULL);
6996         break;
6997
6998     case LVIR_SELECTBOUNDS:
6999         LISTVIEW_GetItemMetrics(infoPtr, &lvItem, NULL, lprc, NULL, NULL, NULL);
7000         break;
7001
7002     default:
7003         WARN("Unknown value: %d\n", lprc->left);
7004         return FALSE;
7005     }
7006
7007     if (infoPtr->uView == LV_VIEW_DETAILS)
7008     {
7009         if (mode != LVIR_BOUNDS)
7010             OffsetRect(lprc, Origin.x + LISTVIEW_GetColumnInfo(infoPtr, 0)->rcHeader.left,
7011                              Position.y + Origin.y);
7012         else
7013             OffsetRect(lprc, Origin.x, Position.y + Origin.y);
7014     }
7015     else
7016         OffsetRect(lprc, Position.x + Origin.x, Position.y + Origin.y);
7017
7018     TRACE(" rect=%s\n", wine_dbgstr_rect(lprc));
7019
7020     return TRUE;
7021 }
7022
7023 /***
7024  * DESCRIPTION:
7025  * Retrieves the spacing between listview control items.
7026  *
7027  * PARAMETER(S):
7028  * [I] infoPtr : valid pointer to the listview structure
7029  * [IO] lprc : rectangle to receive the output
7030  *             on input, lprc->top = nSubItem
7031  *                       lprc->left = LVIR_ICON | LVIR_BOUNDS | LVIR_LABEL
7032  *
7033  * NOTE: for subItem = 0, we should return the bounds of the _entire_ item,
7034  *       not only those of the first column.
7035  *
7036  * RETURN:
7037  *     TRUE: success
7038  *     FALSE: failure
7039  */
7040 static BOOL LISTVIEW_GetSubItemRect(const LISTVIEW_INFO *infoPtr, INT item, LPRECT lprc)
7041 {
7042     RECT rect = { 0, 0, 0, 0 };
7043     POINT origin;
7044     INT y;
7045
7046     if (!lprc) return FALSE;
7047
7048     TRACE("(item=%d, subitem=%d, type=%d)\n", item, lprc->top, lprc->left);
7049     /* Subitem of '0' means item itself, and this works for all control view modes */
7050     if (lprc->top == 0)
7051         return LISTVIEW_GetItemRect(infoPtr, item, lprc);
7052
7053     if (infoPtr->uView != LV_VIEW_DETAILS) return FALSE;
7054
7055     LISTVIEW_GetOrigin(infoPtr, &origin);
7056     /* this works for any item index, no matter if it exists or not */
7057     y = item * infoPtr->nItemHeight + origin.y;
7058
7059     if (infoPtr->hwndHeader && SendMessageW(infoPtr->hwndHeader, HDM_GETITEMRECT, lprc->top, (LPARAM)&rect))
7060     {
7061         rect.top = 0;
7062         rect.bottom = infoPtr->nItemHeight;
7063     }
7064     else
7065     {
7066         /* Native implementation is broken for this case and garbage is left for left and right fields,
7067            we zero them to get predictable output */
7068         lprc->left = lprc->right = lprc->top = 0;
7069         lprc->bottom = infoPtr->nItemHeight;
7070         OffsetRect(lprc, origin.x, y);
7071         TRACE("return rect %s\n", wine_dbgstr_rect(lprc));
7072         return TRUE;
7073     }
7074
7075     switch (lprc->left)
7076     {
7077     case LVIR_ICON:
7078     {
7079         /* it doesn't matter if main item actually has an icon, if imagelist is set icon width is returned */
7080         if (infoPtr->himlSmall)
7081             rect.right = rect.left + infoPtr->iconSize.cx;
7082         else
7083             rect.right = rect.left;
7084
7085         rect.bottom = rect.top + infoPtr->iconSize.cy;
7086         break;
7087     }
7088     case LVIR_LABEL:
7089     case LVIR_BOUNDS:
7090         break;
7091
7092     default:
7093         ERR("Unknown bounds=%d\n", lprc->left);
7094         return FALSE;
7095     }
7096
7097     OffsetRect(&rect, origin.x, y);
7098     *lprc = rect;
7099     TRACE("return rect %s\n", wine_dbgstr_rect(lprc));
7100
7101     return TRUE;
7102 }
7103
7104 /***
7105  * DESCRIPTION:
7106  * Retrieves the spacing between listview control items.
7107  *
7108  * PARAMETER(S):
7109  * [I] infoPtr : valid pointer to the listview structure
7110  * [I] bSmall : flag for small or large icon
7111  *
7112  * RETURN:
7113  * Horizontal + vertical spacing
7114  */
7115 static LONG LISTVIEW_GetItemSpacing(const LISTVIEW_INFO *infoPtr, BOOL bSmall)
7116 {
7117   LONG lResult;
7118
7119   if (!bSmall)
7120   {
7121     lResult = MAKELONG(infoPtr->iconSpacing.cx, infoPtr->iconSpacing.cy);
7122   }
7123   else
7124   {
7125     if (infoPtr->uView == LV_VIEW_ICON)
7126       lResult = MAKELONG(DEFAULT_COLUMN_WIDTH, GetSystemMetrics(SM_CXSMICON)+HEIGHT_PADDING);
7127     else
7128       lResult = MAKELONG(infoPtr->nItemWidth, infoPtr->nItemHeight);
7129   }
7130   return lResult;
7131 }
7132
7133 /***
7134  * DESCRIPTION:
7135  * Retrieves the state of a listview control item.
7136  *
7137  * PARAMETER(S):
7138  * [I] infoPtr : valid pointer to the listview structure
7139  * [I] nItem : item index
7140  * [I] uMask : state mask
7141  *
7142  * RETURN:
7143  * State specified by the mask.
7144  */
7145 static UINT LISTVIEW_GetItemState(const LISTVIEW_INFO *infoPtr, INT nItem, UINT uMask)
7146 {
7147     LVITEMW lvItem;
7148
7149     if (nItem < 0 || nItem >= infoPtr->nItemCount) return 0;
7150
7151     lvItem.iItem = nItem;
7152     lvItem.iSubItem = 0;
7153     lvItem.mask = LVIF_STATE;
7154     lvItem.stateMask = uMask;
7155     if (!LISTVIEW_GetItemW(infoPtr, &lvItem)) return 0;
7156
7157     return lvItem.state & uMask;
7158 }
7159
7160 /***
7161  * DESCRIPTION:
7162  * Retrieves the text of a listview control item or subitem.
7163  *
7164  * PARAMETER(S):
7165  * [I] hwnd : window handle
7166  * [I] nItem : item index
7167  * [IO] lpLVItem : item information
7168  * [I] isW :  TRUE if lpLVItem is Unicode
7169  *
7170  * RETURN:
7171  *   SUCCESS : string length
7172  *   FAILURE : 0
7173  */
7174 static INT LISTVIEW_GetItemTextT(const LISTVIEW_INFO *infoPtr, INT nItem, LPLVITEMW lpLVItem, BOOL isW)
7175 {
7176     if (!lpLVItem || nItem < 0 || nItem >= infoPtr->nItemCount) return 0;
7177
7178     lpLVItem->mask = LVIF_TEXT;
7179     lpLVItem->iItem = nItem;
7180     if (!LISTVIEW_GetItemExtT(infoPtr, lpLVItem, isW)) return 0;
7181
7182     return textlenT(lpLVItem->pszText, isW);
7183 }
7184
7185 /***
7186  * DESCRIPTION:
7187  * Searches for an item based on properties + relationships.
7188  *
7189  * PARAMETER(S):
7190  * [I] infoPtr : valid pointer to the listview structure
7191  * [I] nItem : item index
7192  * [I] uFlags : relationship flag
7193  *
7194  * RETURN:
7195  *   SUCCESS : item index
7196  *   FAILURE : -1
7197  */
7198 static INT LISTVIEW_GetNextItem(const LISTVIEW_INFO *infoPtr, INT nItem, UINT uFlags)
7199 {
7200     UINT uMask = 0;
7201     LVFINDINFOW lvFindInfo;
7202     INT nCountPerColumn;
7203     INT nCountPerRow;
7204     INT i;
7205
7206     TRACE("nItem=%d, uFlags=%x, nItemCount=%d\n", nItem, uFlags, infoPtr->nItemCount);
7207     if (nItem < -1 || nItem >= infoPtr->nItemCount) return -1;
7208
7209     ZeroMemory(&lvFindInfo, sizeof(lvFindInfo));
7210
7211     if (uFlags & LVNI_CUT)
7212       uMask |= LVIS_CUT;
7213
7214     if (uFlags & LVNI_DROPHILITED)
7215       uMask |= LVIS_DROPHILITED;
7216
7217     if (uFlags & LVNI_FOCUSED)
7218       uMask |= LVIS_FOCUSED;
7219
7220     if (uFlags & LVNI_SELECTED)
7221       uMask |= LVIS_SELECTED;
7222
7223     /* if we're asked for the focused item, that's only one,
7224      * so it's worth optimizing */
7225     if (uFlags & LVNI_FOCUSED)
7226     {
7227         if ((LISTVIEW_GetItemState(infoPtr, infoPtr->nFocusedItem, uMask) & uMask) != uMask) return -1;
7228         return (infoPtr->nFocusedItem == nItem) ? -1 : infoPtr->nFocusedItem;
7229     }
7230
7231     if (uFlags & LVNI_ABOVE)
7232     {
7233       if ((infoPtr->uView == LV_VIEW_LIST) || (infoPtr->uView == LV_VIEW_DETAILS))
7234       {
7235         while (nItem >= 0)
7236         {
7237           nItem--;
7238           if ((LISTVIEW_GetItemState(infoPtr, nItem, uMask) & uMask) == uMask)
7239             return nItem;
7240         }
7241       }
7242       else
7243       {
7244         /* Special case for autoarrange - move 'til the top of a list */
7245         if (is_autoarrange(infoPtr))
7246         {
7247           nCountPerRow = LISTVIEW_GetCountPerRow(infoPtr);
7248           while (nItem - nCountPerRow >= 0)
7249           {
7250             nItem -= nCountPerRow;
7251             if ((LISTVIEW_GetItemState(infoPtr, nItem, uMask) & uMask) == uMask)
7252               return nItem;
7253           }
7254           return -1;
7255         }
7256         lvFindInfo.flags = LVFI_NEARESTXY;
7257         lvFindInfo.vkDirection = VK_UP;
7258         LISTVIEW_GetItemPosition(infoPtr, nItem, &lvFindInfo.pt);
7259         while ((nItem = LISTVIEW_FindItemW(infoPtr, nItem, &lvFindInfo)) != -1)
7260         {
7261           if ((LISTVIEW_GetItemState(infoPtr, nItem, uMask) & uMask) == uMask)
7262             return nItem;
7263         }
7264       }
7265     }
7266     else if (uFlags & LVNI_BELOW)
7267     {
7268       if ((infoPtr->uView == LV_VIEW_LIST) || (infoPtr->uView == LV_VIEW_DETAILS))
7269       {
7270         while (nItem < infoPtr->nItemCount)
7271         {
7272           nItem++;
7273           if ((LISTVIEW_GetItemState(infoPtr, nItem, uMask) & uMask) == uMask)
7274             return nItem;
7275         }
7276       }
7277       else
7278       {
7279         /* Special case for autoarrange - move 'til the bottom of a list */
7280         if (is_autoarrange(infoPtr))
7281         {
7282           nCountPerRow = LISTVIEW_GetCountPerRow(infoPtr);
7283           while (nItem + nCountPerRow < infoPtr->nItemCount )
7284           {
7285             nItem += nCountPerRow;
7286             if ((LISTVIEW_GetItemState(infoPtr, nItem, uMask) & uMask) == uMask)
7287               return nItem;
7288           }
7289           return -1;
7290         }
7291         lvFindInfo.flags = LVFI_NEARESTXY;
7292         lvFindInfo.vkDirection = VK_DOWN;
7293         LISTVIEW_GetItemPosition(infoPtr, nItem, &lvFindInfo.pt);
7294         while ((nItem = LISTVIEW_FindItemW(infoPtr, nItem, &lvFindInfo)) != -1)
7295         {
7296           if ((LISTVIEW_GetItemState(infoPtr, nItem, uMask) & uMask) == uMask)
7297             return nItem;
7298         }
7299       }
7300     }
7301     else if (uFlags & LVNI_TOLEFT)
7302     {
7303       if (infoPtr->uView == LV_VIEW_LIST)
7304       {
7305         nCountPerColumn = LISTVIEW_GetCountPerColumn(infoPtr);
7306         while (nItem - nCountPerColumn >= 0)
7307         {
7308           nItem -= nCountPerColumn;
7309           if ((LISTVIEW_GetItemState(infoPtr, nItem, uMask) & uMask) == uMask)
7310             return nItem;
7311         }
7312       }
7313       else if ((infoPtr->uView == LV_VIEW_SMALLICON) || (infoPtr->uView == LV_VIEW_ICON))
7314       {
7315         /* Special case for autoarrange - move 'til the beginning of a row */
7316         if (is_autoarrange(infoPtr))
7317         {
7318           nCountPerRow = LISTVIEW_GetCountPerRow(infoPtr);
7319           while (nItem % nCountPerRow > 0)
7320           {
7321             nItem --;
7322             if ((LISTVIEW_GetItemState(infoPtr, nItem, uMask) & uMask) == uMask)
7323               return nItem;
7324           }
7325           return -1;
7326         }
7327         lvFindInfo.flags = LVFI_NEARESTXY;
7328         lvFindInfo.vkDirection = VK_LEFT;
7329         LISTVIEW_GetItemPosition(infoPtr, nItem, &lvFindInfo.pt);
7330         while ((nItem = LISTVIEW_FindItemW(infoPtr, nItem, &lvFindInfo)) != -1)
7331         {
7332           if ((LISTVIEW_GetItemState(infoPtr, nItem, uMask) & uMask) == uMask)
7333             return nItem;
7334         }
7335       }
7336     }
7337     else if (uFlags & LVNI_TORIGHT)
7338     {
7339       if (infoPtr->uView == LV_VIEW_LIST)
7340       {
7341         nCountPerColumn = LISTVIEW_GetCountPerColumn(infoPtr);
7342         while (nItem + nCountPerColumn < infoPtr->nItemCount)
7343         {
7344           nItem += nCountPerColumn;
7345           if ((LISTVIEW_GetItemState(infoPtr, nItem, uMask) & uMask) == uMask)
7346             return nItem;
7347         }
7348       }
7349       else if ((infoPtr->uView == LV_VIEW_SMALLICON) || (infoPtr->uView == LV_VIEW_ICON))
7350       {
7351         /* Special case for autoarrange - move 'til the end of a row */
7352         if (is_autoarrange(infoPtr))
7353         {
7354           nCountPerRow = LISTVIEW_GetCountPerRow(infoPtr);
7355           while (nItem % nCountPerRow < nCountPerRow - 1 )
7356           {
7357             nItem ++;
7358             if ((LISTVIEW_GetItemState(infoPtr, nItem, uMask) & uMask) == uMask)
7359               return nItem;
7360           }
7361           return -1;
7362         }
7363         lvFindInfo.flags = LVFI_NEARESTXY;
7364         lvFindInfo.vkDirection = VK_RIGHT;
7365         LISTVIEW_GetItemPosition(infoPtr, nItem, &lvFindInfo.pt);
7366         while ((nItem = LISTVIEW_FindItemW(infoPtr, nItem, &lvFindInfo)) != -1)
7367         {
7368           if ((LISTVIEW_GetItemState(infoPtr, nItem, uMask) & uMask) == uMask)
7369             return nItem;
7370         }
7371       }
7372     }
7373     else
7374     {
7375       nItem++;
7376
7377       /* search by index */
7378       for (i = nItem; i < infoPtr->nItemCount; i++)
7379       {
7380         if ((LISTVIEW_GetItemState(infoPtr, i, uMask) & uMask) == uMask)
7381           return i;
7382       }
7383     }
7384
7385     return -1;
7386 }
7387
7388 /* LISTVIEW_GetNumberOfWorkAreas */
7389
7390 /***
7391  * DESCRIPTION:
7392  * Retrieves the origin coordinates when in icon or small icon display mode.
7393  *
7394  * PARAMETER(S):
7395  * [I] infoPtr : valid pointer to the listview structure
7396  * [O] lpptOrigin : coordinate information
7397  *
7398  * RETURN:
7399  *   None.
7400  */
7401 static void LISTVIEW_GetOrigin(const LISTVIEW_INFO *infoPtr, LPPOINT lpptOrigin)
7402 {
7403     INT nHorzPos = 0, nVertPos = 0;
7404     SCROLLINFO scrollInfo;
7405
7406     scrollInfo.cbSize = sizeof(SCROLLINFO);
7407     scrollInfo.fMask = SIF_POS;
7408
7409     if (GetScrollInfo(infoPtr->hwndSelf, SB_HORZ, &scrollInfo))
7410         nHorzPos = scrollInfo.nPos;
7411     if (GetScrollInfo(infoPtr->hwndSelf, SB_VERT, &scrollInfo))
7412         nVertPos = scrollInfo.nPos;
7413
7414     TRACE("nHorzPos=%d, nVertPos=%d\n", nHorzPos, nVertPos);
7415
7416     lpptOrigin->x = infoPtr->rcList.left;
7417     lpptOrigin->y = infoPtr->rcList.top;
7418     if (infoPtr->uView == LV_VIEW_LIST)
7419         nHorzPos *= infoPtr->nItemWidth;
7420     else if (infoPtr->uView == LV_VIEW_DETAILS)
7421         nVertPos *= infoPtr->nItemHeight;
7422
7423     lpptOrigin->x -= nHorzPos;
7424     lpptOrigin->y -= nVertPos;
7425
7426     TRACE(" origin=%s\n", wine_dbgstr_point(lpptOrigin));
7427 }
7428
7429 /***
7430  * DESCRIPTION:
7431  * Retrieves the width of a string.
7432  *
7433  * PARAMETER(S):
7434  * [I] hwnd : window handle
7435  * [I] lpszText : text string to process
7436  * [I] isW : TRUE if lpszText is Unicode, FALSE otherwise
7437  *
7438  * RETURN:
7439  *   SUCCESS : string width (in pixels)
7440  *   FAILURE : zero
7441  */
7442 static INT LISTVIEW_GetStringWidthT(const LISTVIEW_INFO *infoPtr, LPCWSTR lpszText, BOOL isW)
7443 {
7444     SIZE stringSize;
7445
7446     stringSize.cx = 0;
7447     if (is_text(lpszText))
7448     {
7449         HFONT hFont = infoPtr->hFont ? infoPtr->hFont : infoPtr->hDefaultFont;
7450         HDC hdc = GetDC(infoPtr->hwndSelf);
7451         HFONT hOldFont = SelectObject(hdc, hFont);
7452
7453         if (isW)
7454             GetTextExtentPointW(hdc, lpszText, lstrlenW(lpszText), &stringSize);
7455         else
7456             GetTextExtentPointA(hdc, (LPCSTR)lpszText, lstrlenA((LPCSTR)lpszText), &stringSize);
7457         SelectObject(hdc, hOldFont);
7458         ReleaseDC(infoPtr->hwndSelf, hdc);
7459     }
7460     return stringSize.cx;
7461 }
7462
7463 /***
7464  * DESCRIPTION:
7465  * Determines which listview item is located at the specified position.
7466  *
7467  * PARAMETER(S):
7468  * [I] infoPtr : valid pointer to the listview structure
7469  * [IO] lpht : hit test information
7470  * [I] subitem : fill out iSubItem.
7471  * [I] select : return the index only if the hit selects the item
7472  *
7473  * NOTE:
7474  * (mm 20001022): We must not allow iSubItem to be touched, for
7475  * an app might pass only a structure with space up to iItem!
7476  * (MS Office 97 does that for instance in the file open dialog)
7477  *
7478  * RETURN:
7479  *   SUCCESS : item index
7480  *   FAILURE : -1
7481  */
7482 static INT LISTVIEW_HitTest(const LISTVIEW_INFO *infoPtr, LPLVHITTESTINFO lpht, BOOL subitem, BOOL select)
7483 {
7484     WCHAR szDispText[DISP_TEXT_SIZE] = { '\0' };
7485     RECT rcBox, rcBounds, rcState, rcIcon, rcLabel, rcSearch;
7486     POINT Origin, Position, opt;
7487     LVITEMW lvItem;
7488     ITERATOR i;
7489     INT iItem;
7490
7491     TRACE("(pt=%s, subitem=%d, select=%d)\n", wine_dbgstr_point(&lpht->pt), subitem, select);
7492
7493     lpht->flags = 0;
7494     lpht->iItem = -1;
7495     if (subitem) lpht->iSubItem = 0;
7496
7497     LISTVIEW_GetOrigin(infoPtr, &Origin);
7498
7499     /* set whole list relation flags */
7500     if (subitem && infoPtr->uView == LV_VIEW_DETAILS)
7501     {
7502         /* LVM_SUBITEMHITTEST checks left bound of possible client area */
7503         if (infoPtr->rcList.left > lpht->pt.x && Origin.x < lpht->pt.x)
7504             lpht->flags |= LVHT_TOLEFT;
7505
7506         if (lpht->pt.y < infoPtr->rcList.top && lpht->pt.y >= 0)
7507             opt.y = lpht->pt.y + infoPtr->rcList.top;
7508         else
7509             opt.y = lpht->pt.y;
7510
7511         if (infoPtr->rcList.bottom < opt.y)
7512             lpht->flags |= LVHT_BELOW;
7513     }
7514     else
7515     {
7516         if (infoPtr->rcList.left > lpht->pt.x)
7517             lpht->flags |= LVHT_TOLEFT;
7518         else if (infoPtr->rcList.right < lpht->pt.x)
7519             lpht->flags |= LVHT_TORIGHT;
7520
7521         if (infoPtr->rcList.top > lpht->pt.y)
7522             lpht->flags |= LVHT_ABOVE;
7523         else if (infoPtr->rcList.bottom < lpht->pt.y)
7524             lpht->flags |= LVHT_BELOW;
7525     }
7526
7527     /* even if item is invalid try to find subitem */
7528     if (infoPtr->uView == LV_VIEW_DETAILS && subitem)
7529     {
7530         RECT *pRect;
7531         INT j;
7532
7533         opt.x = lpht->pt.x - Origin.x;
7534
7535         lpht->iSubItem = -1;
7536         for (j = 0; j < DPA_GetPtrCount(infoPtr->hdpaColumns); j++)
7537         {
7538             pRect = &LISTVIEW_GetColumnInfo(infoPtr, j)->rcHeader;
7539
7540             if ((opt.x >= pRect->left) && (opt.x < pRect->right))
7541             {
7542                 lpht->iSubItem = j;
7543                 break;
7544             }
7545         }
7546         TRACE("lpht->iSubItem=%d\n", lpht->iSubItem);
7547
7548         /* if we're outside horizontal columns bounds there's nothing to test further */
7549         if (lpht->iSubItem == -1)
7550         {
7551             lpht->iItem = -1;
7552             lpht->flags = LVHT_NOWHERE;
7553             return -1;
7554         }
7555     }
7556
7557     TRACE("lpht->flags=0x%x\n", lpht->flags);
7558     if (lpht->flags) return -1;
7559
7560     lpht->flags |= LVHT_NOWHERE;
7561
7562     /* first deal with the large items */
7563     rcSearch.left = lpht->pt.x;
7564     rcSearch.top = lpht->pt.y;
7565     rcSearch.right = rcSearch.left + 1;
7566     rcSearch.bottom = rcSearch.top + 1;
7567
7568     iterator_frameditems(&i, infoPtr, &rcSearch);
7569     iterator_next(&i); /* go to first item in the sequence */
7570     iItem = i.nItem;
7571     iterator_destroy(&i);
7572
7573     TRACE("lpht->iItem=%d\n", iItem);
7574     if (iItem == -1) return -1;
7575
7576     lvItem.mask = LVIF_STATE | LVIF_TEXT;
7577     if (infoPtr->uView == LV_VIEW_DETAILS) lvItem.mask |= LVIF_INDENT;
7578     lvItem.stateMask = LVIS_STATEIMAGEMASK;
7579     if (infoPtr->uView == LV_VIEW_ICON) lvItem.stateMask |= LVIS_FOCUSED;
7580     lvItem.iItem = iItem;
7581     lvItem.iSubItem = subitem ? lpht->iSubItem : 0;
7582     lvItem.pszText = szDispText;
7583     lvItem.cchTextMax = DISP_TEXT_SIZE;
7584     if (!LISTVIEW_GetItemW(infoPtr, &lvItem)) return -1;
7585     if (!infoPtr->bFocus) lvItem.state &= ~LVIS_FOCUSED;
7586
7587     LISTVIEW_GetItemMetrics(infoPtr, &lvItem, &rcBox, NULL, &rcIcon, &rcState, &rcLabel);
7588     LISTVIEW_GetItemOrigin(infoPtr, iItem, &Position);
7589     opt.x = lpht->pt.x - Position.x - Origin.x;
7590
7591     if (lpht->pt.y < infoPtr->rcList.top && lpht->pt.y >= 0)
7592         opt.y = lpht->pt.y - Position.y - Origin.y + infoPtr->rcList.top;
7593     else
7594         opt.y = lpht->pt.y - Position.y - Origin.y;
7595
7596     if (infoPtr->uView == LV_VIEW_DETAILS)
7597     {
7598         rcBounds = rcBox;
7599         if (infoPtr->dwLvExStyle & LVS_EX_FULLROWSELECT)
7600             opt.x = lpht->pt.x - Origin.x;
7601     }
7602     else
7603     {
7604         UnionRect(&rcBounds, &rcIcon, &rcLabel);
7605         UnionRect(&rcBounds, &rcBounds, &rcState);
7606     }
7607     TRACE("rcBounds=%s\n", wine_dbgstr_rect(&rcBounds));
7608     if (!PtInRect(&rcBounds, opt)) return -1;
7609
7610     if (PtInRect(&rcIcon, opt))
7611         lpht->flags |= LVHT_ONITEMICON;
7612     else if (PtInRect(&rcLabel, opt))
7613         lpht->flags |= LVHT_ONITEMLABEL;
7614     else if (infoPtr->himlState && PtInRect(&rcState, opt))
7615         lpht->flags |= LVHT_ONITEMSTATEICON;
7616     /* special case for LVS_EX_FULLROWSELECT */
7617     if (infoPtr->uView == LV_VIEW_DETAILS && infoPtr->dwLvExStyle & LVS_EX_FULLROWSELECT &&
7618       !(lpht->flags & LVHT_ONITEM))
7619     {
7620         lpht->flags = LVHT_ONITEM | LVHT_ABOVE;
7621     }
7622     if (lpht->flags & LVHT_ONITEM)
7623         lpht->flags &= ~LVHT_NOWHERE;
7624     TRACE("lpht->flags=0x%x\n", lpht->flags);
7625
7626     if (select && !(infoPtr->uView == LV_VIEW_DETAILS &&
7627                     ((infoPtr->dwLvExStyle & LVS_EX_FULLROWSELECT) ||
7628                      (infoPtr->dwStyle & LVS_OWNERDRAWFIXED))))
7629     {
7630         if (infoPtr->uView == LV_VIEW_DETAILS)
7631         {
7632             /* get main item bounds */
7633             lvItem.iSubItem = 0;
7634             LISTVIEW_GetItemMetrics(infoPtr, &lvItem, &rcBox, NULL, &rcIcon, &rcState, &rcLabel);
7635             UnionRect(&rcBounds, &rcIcon, &rcLabel);
7636             UnionRect(&rcBounds, &rcBounds, &rcState);
7637         }
7638         if (!PtInRect(&rcBounds, opt)) iItem = -1;
7639     }
7640     return lpht->iItem = iItem;
7641 }
7642
7643 /***
7644  * DESCRIPTION:
7645  * Inserts a new item in the listview control.
7646  *
7647  * PARAMETER(S):
7648  * [I] infoPtr : valid pointer to the listview structure
7649  * [I] lpLVItem : item information
7650  * [I] isW : TRUE if lpLVItem is Unicode, FALSE if it's ANSI
7651  *
7652  * RETURN:
7653  *   SUCCESS : new item index
7654  *   FAILURE : -1
7655  */
7656 static INT LISTVIEW_InsertItemT(LISTVIEW_INFO *infoPtr, const LVITEMW *lpLVItem, BOOL isW)
7657 {
7658     INT nItem;
7659     HDPA hdpaSubItems;
7660     NMLISTVIEW nmlv;
7661     ITEM_INFO *lpItem;
7662     ITEM_ID *lpID;
7663     BOOL is_sorted, has_changed;
7664     LVITEMW item;
7665     HWND hwndSelf = infoPtr->hwndSelf;
7666
7667     TRACE("(lpLVItem=%s, isW=%d)\n", debuglvitem_t(lpLVItem, isW), isW);
7668
7669     if (infoPtr->dwStyle & LVS_OWNERDATA) return infoPtr->nItemCount++;
7670
7671     /* make sure it's an item, and not a subitem; cannot insert a subitem */
7672     if (!lpLVItem || lpLVItem->iSubItem) return -1;
7673
7674     if (!is_assignable_item(lpLVItem, infoPtr->dwStyle)) return -1;
7675
7676     if (!(lpItem = Alloc(sizeof(ITEM_INFO)))) return -1;
7677
7678     /* insert item in listview control data structure */
7679     if ( !(hdpaSubItems = DPA_Create(8)) ) goto fail;
7680     if ( !DPA_SetPtr(hdpaSubItems, 0, lpItem) ) assert (FALSE);
7681
7682     /* link with id struct */
7683     if (!(lpID = Alloc(sizeof(ITEM_ID)))) goto fail;
7684     lpItem->id = lpID;
7685     lpID->item = hdpaSubItems;
7686     lpID->id = get_next_itemid(infoPtr);
7687     if ( DPA_InsertPtr(infoPtr->hdpaItemIds, infoPtr->nItemCount, lpID) == -1) goto fail;
7688
7689     is_sorted = (infoPtr->dwStyle & (LVS_SORTASCENDING | LVS_SORTDESCENDING)) &&
7690                 !(infoPtr->dwStyle & LVS_OWNERDRAWFIXED) && (LPSTR_TEXTCALLBACKW != lpLVItem->pszText);
7691
7692     if (lpLVItem->iItem < 0 && !is_sorted) return -1;
7693
7694     /* calculate new item index */
7695     if (is_sorted)
7696     {
7697         HDPA hItem;
7698         ITEM_INFO *item_s;
7699         INT i = 0, cmpv;
7700
7701         while (i < infoPtr->nItemCount)
7702         {
7703             hItem  = DPA_GetPtr( infoPtr->hdpaItems, i);
7704             item_s = DPA_GetPtr(hItem, 0);
7705
7706             cmpv = textcmpWT(item_s->hdr.pszText, lpLVItem->pszText, isW);
7707             if (infoPtr->dwStyle & LVS_SORTDESCENDING) cmpv *= -1;
7708
7709             if (cmpv >= 0) break;
7710             i++;
7711         }
7712         nItem = i;
7713     }
7714     else
7715         nItem = min(lpLVItem->iItem, infoPtr->nItemCount);
7716
7717     TRACE(" inserting at %d, sorted=%d, count=%d, iItem=%d\n", nItem, is_sorted, infoPtr->nItemCount, lpLVItem->iItem);
7718     nItem = DPA_InsertPtr( infoPtr->hdpaItems, nItem, hdpaSubItems );
7719     if (nItem == -1) goto fail;
7720     infoPtr->nItemCount++;
7721
7722     /* shift indices first so they don't get tangled */
7723     LISTVIEW_ShiftIndices(infoPtr, nItem, 1);
7724
7725     /* set the item attributes */
7726     if (lpLVItem->mask & (LVIF_GROUPID|LVIF_COLUMNS))
7727     {
7728         /* full size structure expected - _WIN32IE >= 0x560 */
7729         item = *lpLVItem;
7730     }
7731     else if (lpLVItem->mask & LVIF_INDENT)
7732     {
7733         /* indent member expected - _WIN32IE >= 0x300 */
7734         memcpy(&item, lpLVItem, offsetof( LVITEMW, iGroupId ));
7735     }
7736     else
7737     {
7738         /* minimal structure expected */
7739         memcpy(&item, lpLVItem, offsetof( LVITEMW, iIndent ));
7740     }
7741     item.iItem = nItem;
7742     if (infoPtr->dwLvExStyle & LVS_EX_CHECKBOXES)
7743     {
7744         item.mask |= LVIF_STATE;
7745         item.stateMask |= LVIS_STATEIMAGEMASK;
7746         item.state &= ~LVIS_STATEIMAGEMASK;
7747         item.state |= INDEXTOSTATEIMAGEMASK(1);
7748     }
7749     if (!set_main_item(infoPtr, &item, TRUE, isW, &has_changed)) goto undo;
7750
7751     /* make room for the position, if we are in the right mode */
7752     if ((infoPtr->uView == LV_VIEW_SMALLICON) || (infoPtr->uView == LV_VIEW_ICON))
7753     {
7754         if (DPA_InsertPtr(infoPtr->hdpaPosX, nItem, 0) == -1)
7755             goto undo;
7756         if (DPA_InsertPtr(infoPtr->hdpaPosY, nItem, 0) == -1)
7757         {
7758             DPA_DeletePtr(infoPtr->hdpaPosX, nItem);
7759             goto undo;
7760         }
7761     }
7762
7763     /* send LVN_INSERTITEM notification */
7764     ZeroMemory(&nmlv, sizeof(NMLISTVIEW));
7765     nmlv.iItem = nItem;
7766     nmlv.lParam = lpItem->lParam;
7767     notify_listview(infoPtr, LVN_INSERTITEM, &nmlv);
7768     if (!IsWindow(hwndSelf))
7769         return -1;
7770
7771     /* align items (set position of each item) */
7772     if (infoPtr->uView == LV_VIEW_SMALLICON || infoPtr->uView == LV_VIEW_ICON)
7773     {
7774         POINT pt;
7775
7776         if (infoPtr->dwStyle & LVS_ALIGNLEFT)
7777             LISTVIEW_NextIconPosLeft(infoPtr, &pt);
7778         else
7779             LISTVIEW_NextIconPosTop(infoPtr, &pt);
7780
7781         LISTVIEW_MoveIconTo(infoPtr, nItem, &pt, TRUE);
7782     }
7783
7784     /* now is the invalidation fun */
7785     LISTVIEW_ScrollOnInsert(infoPtr, nItem, 1);
7786     return nItem;
7787
7788 undo:
7789     LISTVIEW_ShiftIndices(infoPtr, nItem, -1);
7790     DPA_DeletePtr(infoPtr->hdpaItems, nItem);
7791     infoPtr->nItemCount--;
7792 fail:
7793     DPA_DeletePtr(hdpaSubItems, 0);
7794     DPA_Destroy (hdpaSubItems);
7795     Free (lpItem);
7796     return -1;
7797 }
7798
7799 /***
7800  * DESCRIPTION:
7801  * Checks item visibility.
7802  *
7803  * PARAMETER(S):
7804  * [I] infoPtr : valid pointer to the listview structure
7805  * [I] nFirst : item index to check for
7806  *
7807  * RETURN:
7808  *   Item visible : TRUE
7809  *   Item invisible or failure : FALSE
7810  */
7811 static BOOL LISTVIEW_IsItemVisible(const LISTVIEW_INFO *infoPtr, INT nItem)
7812 {
7813     POINT Origin, Position;
7814     RECT rcItem;
7815     HDC hdc;
7816     BOOL ret;
7817
7818     TRACE("nItem=%d\n", nItem);
7819
7820     if (nItem < 0 || nItem >= DPA_GetPtrCount(infoPtr->hdpaItems)) return FALSE;
7821
7822     LISTVIEW_GetOrigin(infoPtr, &Origin);
7823     LISTVIEW_GetItemOrigin(infoPtr, nItem, &Position);
7824     rcItem.left = Position.x + Origin.x;
7825     rcItem.top  = Position.y + Origin.y;
7826     rcItem.right  = rcItem.left + infoPtr->nItemWidth;
7827     rcItem.bottom = rcItem.top + infoPtr->nItemHeight;
7828
7829     hdc = GetDC(infoPtr->hwndSelf);
7830     if (!hdc) return FALSE;
7831     ret = RectVisible(hdc, &rcItem);
7832     ReleaseDC(infoPtr->hwndSelf, hdc);
7833
7834     return ret;
7835 }
7836
7837 /***
7838  * DESCRIPTION:
7839  * Redraws a range of items.
7840  *
7841  * PARAMETER(S):
7842  * [I] infoPtr : valid pointer to the listview structure
7843  * [I] nFirst : first item
7844  * [I] nLast : last item
7845  *
7846  * RETURN:
7847  *   SUCCESS : TRUE
7848  *   FAILURE : FALSE
7849  */
7850 static BOOL LISTVIEW_RedrawItems(const LISTVIEW_INFO *infoPtr, INT nFirst, INT nLast)
7851 {
7852     INT i;
7853
7854     if (nLast < nFirst || min(nFirst, nLast) < 0 ||
7855         max(nFirst, nLast) >= infoPtr->nItemCount)
7856         return FALSE;
7857
7858     for (i = nFirst; i <= nLast; i++)
7859         LISTVIEW_InvalidateItem(infoPtr, i);
7860
7861     return TRUE;
7862 }
7863
7864 /***
7865  * DESCRIPTION:
7866  * Scroll the content of a listview.
7867  *
7868  * PARAMETER(S):
7869  * [I] infoPtr : valid pointer to the listview structure
7870  * [I] dx : horizontal scroll amount in pixels
7871  * [I] dy : vertical scroll amount in pixels
7872  *
7873  * RETURN:
7874  *   SUCCESS : TRUE
7875  *   FAILURE : FALSE
7876  *
7877  * COMMENTS:
7878  *  If the control is in report view (LV_VIEW_DETAILS) the control can
7879  *  be scrolled only in line increments. "dy" will be rounded to the
7880  *  nearest number of pixels that are a whole line. Ex: if line height
7881  *  is 16 and an 8 is passed, the list will be scrolled by 16. If a 7
7882  *  is passed, then the scroll will be 0.  (per MSDN 7/2002)
7883  *
7884  *  For:  (per experimentation with native control and CSpy ListView)
7885  *     LV_VIEW_ICON       scrolling in any direction is allowed
7886  *     LV_VIEW_SMALLICON  scrolling in any direction is allowed
7887  *     LV_VIEW_LIST       dx=1 = 1 column (horizontal only)
7888  *                           but will only scroll 1 column per message
7889  *                           no matter what the value.
7890  *                        dy must be 0 or FALSE returned.
7891  *     LV_VIEW_DETAILS    dx=1 = 1 pixel
7892  *                        dy=  see above
7893  *
7894  */
7895 static BOOL LISTVIEW_Scroll(LISTVIEW_INFO *infoPtr, INT dx, INT dy)
7896 {
7897     switch(infoPtr->uView) {
7898     case LV_VIEW_DETAILS:
7899         dy += (dy < 0 ? -1 : 1) * infoPtr->nItemHeight/2;
7900         dy /= infoPtr->nItemHeight;
7901         break;
7902     case LV_VIEW_LIST:
7903         if (dy != 0) return FALSE;
7904         break;
7905     default: /* icon */
7906         break;
7907     }
7908
7909     if (dx != 0) LISTVIEW_HScroll(infoPtr, SB_INTERNAL, dx);
7910     if (dy != 0) LISTVIEW_VScroll(infoPtr, SB_INTERNAL, dy);
7911
7912     return TRUE;
7913 }
7914
7915 /***
7916  * DESCRIPTION:
7917  * Sets the background color.
7918  *
7919  * PARAMETER(S):
7920  * [I] infoPtr : valid pointer to the listview structure
7921  * [I] color   : background color
7922  *
7923  * RETURN:
7924  *   SUCCESS : TRUE
7925  *   FAILURE : FALSE
7926  */
7927 static BOOL LISTVIEW_SetBkColor(LISTVIEW_INFO *infoPtr, COLORREF color)
7928 {
7929     TRACE("(color=%x)\n", color);
7930
7931     if(infoPtr->clrBk != color) {
7932         if (infoPtr->clrBk != CLR_NONE) DeleteObject(infoPtr->hBkBrush);
7933         infoPtr->clrBk = color;
7934         if (color == CLR_NONE)
7935             infoPtr->hBkBrush = (HBRUSH)GetClassLongPtrW(infoPtr->hwndSelf, GCLP_HBRBACKGROUND);
7936         else
7937         {
7938             infoPtr->hBkBrush = CreateSolidBrush(color);
7939             infoPtr->dwLvExStyle &= ~LVS_EX_TRANSPARENTBKGND;
7940         }
7941     }
7942
7943     return TRUE;
7944 }
7945
7946 /* LISTVIEW_SetBkImage */
7947
7948 /*** Helper for {Insert,Set}ColumnT *only* */
7949 static void column_fill_hditem(const LISTVIEW_INFO *infoPtr, HDITEMW *lphdi, INT nColumn,
7950                                const LVCOLUMNW *lpColumn, BOOL isW)
7951 {
7952     if (lpColumn->mask & LVCF_FMT)
7953     {
7954         /* format member is valid */
7955         lphdi->mask |= HDI_FORMAT;
7956
7957         /* set text alignment (leftmost column must be left-aligned) */
7958         if (nColumn == 0 || (lpColumn->fmt & LVCFMT_JUSTIFYMASK) == LVCFMT_LEFT)
7959             lphdi->fmt |= HDF_LEFT;
7960         else if ((lpColumn->fmt & LVCFMT_JUSTIFYMASK) == LVCFMT_RIGHT)
7961             lphdi->fmt |= HDF_RIGHT;
7962         else if ((lpColumn->fmt & LVCFMT_JUSTIFYMASK) == LVCFMT_CENTER)
7963             lphdi->fmt |= HDF_CENTER;
7964
7965         if (lpColumn->fmt & LVCFMT_BITMAP_ON_RIGHT)
7966             lphdi->fmt |= HDF_BITMAP_ON_RIGHT;
7967
7968         if (lpColumn->fmt & LVCFMT_COL_HAS_IMAGES)
7969         {
7970             lphdi->fmt |= HDF_IMAGE;
7971             lphdi->iImage = I_IMAGECALLBACK;
7972         }
7973
7974         if (lpColumn->fmt & LVCFMT_FIXED_WIDTH)
7975             lphdi->fmt |= HDF_FIXEDWIDTH;
7976     }
7977
7978     if (lpColumn->mask & LVCF_WIDTH)
7979     {
7980         lphdi->mask |= HDI_WIDTH;
7981         if(lpColumn->cx == LVSCW_AUTOSIZE_USEHEADER)
7982         {
7983             /* make it fill the remainder of the controls width */
7984             RECT rcHeader;
7985             INT item_index;
7986
7987             for(item_index = 0; item_index < (nColumn - 1); item_index++)
7988             {
7989                 LISTVIEW_GetHeaderRect(infoPtr, item_index, &rcHeader);
7990                 lphdi->cxy += rcHeader.right - rcHeader.left;
7991             }
7992
7993             /* retrieve the layout of the header */
7994             GetClientRect(infoPtr->hwndSelf, &rcHeader);
7995             TRACE("start cxy=%d rcHeader=%s\n", lphdi->cxy, wine_dbgstr_rect(&rcHeader));
7996
7997             lphdi->cxy = (rcHeader.right - rcHeader.left) - lphdi->cxy;
7998         }
7999         else
8000             lphdi->cxy = lpColumn->cx;
8001     }
8002
8003     if (lpColumn->mask & LVCF_TEXT)
8004     {
8005         lphdi->mask |= HDI_TEXT | HDI_FORMAT;
8006         lphdi->fmt |= HDF_STRING;
8007         lphdi->pszText = lpColumn->pszText;
8008         lphdi->cchTextMax = textlenT(lpColumn->pszText, isW);
8009     }
8010
8011     if (lpColumn->mask & LVCF_IMAGE)
8012     {
8013         lphdi->mask |= HDI_IMAGE;
8014         lphdi->iImage = lpColumn->iImage;
8015     }
8016
8017     if (lpColumn->mask & LVCF_ORDER)
8018     {
8019         lphdi->mask |= HDI_ORDER;
8020         lphdi->iOrder = lpColumn->iOrder;
8021     }
8022 }
8023
8024
8025 /***
8026  * DESCRIPTION:
8027  * Inserts a new column.
8028  *
8029  * PARAMETER(S):
8030  * [I] infoPtr : valid pointer to the listview structure
8031  * [I] nColumn : column index
8032  * [I] lpColumn : column information
8033  * [I] isW : TRUE if lpColumn is Unicode, FALSE otherwise
8034  *
8035  * RETURN:
8036  *   SUCCESS : new column index
8037  *   FAILURE : -1
8038  */
8039 static INT LISTVIEW_InsertColumnT(LISTVIEW_INFO *infoPtr, INT nColumn,
8040                                   const LVCOLUMNW *lpColumn, BOOL isW)
8041 {
8042     COLUMN_INFO *lpColumnInfo;
8043     INT nNewColumn;
8044     HDITEMW hdi;
8045
8046     TRACE("(nColumn=%d, lpColumn=%s, isW=%d)\n", nColumn, debuglvcolumn_t(lpColumn, isW), isW);
8047
8048     if (!lpColumn || nColumn < 0) return -1;
8049     nColumn = min(nColumn, DPA_GetPtrCount(infoPtr->hdpaColumns));
8050
8051     ZeroMemory(&hdi, sizeof(HDITEMW));
8052     column_fill_hditem(infoPtr, &hdi, nColumn, lpColumn, isW);
8053
8054     /*
8055      * A mask not including LVCF_WIDTH turns into a mask of width, width 10
8056      * (can be seen in SPY) otherwise column never gets added.
8057      */
8058     if (!(lpColumn->mask & LVCF_WIDTH)) {
8059         hdi.mask |= HDI_WIDTH;
8060         hdi.cxy = 10;
8061     }
8062
8063     /*
8064      * when the iSubItem is available Windows copies it to the header lParam. It seems
8065      * to happen only in LVM_INSERTCOLUMN - not in LVM_SETCOLUMN
8066      */
8067     if (lpColumn->mask & LVCF_SUBITEM)
8068     {
8069         hdi.mask |= HDI_LPARAM;
8070         hdi.lParam = lpColumn->iSubItem;
8071     }
8072
8073     /* create header if not present */
8074     LISTVIEW_CreateHeader(infoPtr);
8075     if (!(LVS_NOCOLUMNHEADER & infoPtr->dwStyle) &&
8076          (infoPtr->uView == LV_VIEW_DETAILS) && (WS_VISIBLE & infoPtr->dwStyle))
8077     {
8078         ShowWindow(infoPtr->hwndHeader, SW_SHOWNORMAL);
8079     }
8080
8081     /* insert item in header control */
8082     nNewColumn = SendMessageW(infoPtr->hwndHeader,
8083                               isW ? HDM_INSERTITEMW : HDM_INSERTITEMA,
8084                               nColumn, (LPARAM)&hdi);
8085     if (nNewColumn == -1) return -1;
8086     if (nNewColumn != nColumn) ERR("nColumn=%d, nNewColumn=%d\n", nColumn, nNewColumn);
8087
8088     /* create our own column info */
8089     if (!(lpColumnInfo = Alloc(sizeof(COLUMN_INFO)))) goto fail;
8090     if (DPA_InsertPtr(infoPtr->hdpaColumns, nNewColumn, lpColumnInfo) == -1) goto fail;
8091
8092     if (lpColumn->mask & LVCF_FMT) lpColumnInfo->fmt = lpColumn->fmt;
8093     if (lpColumn->mask & LVCF_MINWIDTH) lpColumnInfo->cxMin = lpColumn->cxMin;
8094     if (!SendMessageW(infoPtr->hwndHeader, HDM_GETITEMRECT, nNewColumn, (LPARAM)&lpColumnInfo->rcHeader))
8095         goto fail;
8096
8097     /* now we have to actually adjust the data */
8098     if (!(infoPtr->dwStyle & LVS_OWNERDATA) && infoPtr->nItemCount > 0)
8099     {
8100         SUBITEM_INFO *lpSubItem;
8101         HDPA hdpaSubItems;
8102         INT nItem, i;
8103         LVITEMW item;
8104         BOOL changed;
8105
8106         item.iSubItem = nNewColumn;
8107         item.mask = LVIF_TEXT | LVIF_IMAGE;
8108         item.iImage = I_IMAGECALLBACK;
8109         item.pszText = LPSTR_TEXTCALLBACKW;
8110
8111         for (nItem = 0; nItem < infoPtr->nItemCount; nItem++)
8112         {
8113             hdpaSubItems = DPA_GetPtr(infoPtr->hdpaItems, nItem);
8114             for (i = 1; i < DPA_GetPtrCount(hdpaSubItems); i++)
8115             {
8116                 lpSubItem = DPA_GetPtr(hdpaSubItems, i);
8117                 if (lpSubItem->iSubItem >= nNewColumn)
8118                     lpSubItem->iSubItem++;
8119             }
8120
8121             /* add new subitem for each item */
8122             item.iItem = nItem;
8123             set_sub_item(infoPtr, &item, isW, &changed);
8124         }
8125     }
8126
8127     /* make space for the new column */
8128     LISTVIEW_ScrollColumns(infoPtr, nNewColumn + 1, lpColumnInfo->rcHeader.right - lpColumnInfo->rcHeader.left);
8129     LISTVIEW_UpdateItemSize(infoPtr);
8130
8131     return nNewColumn;
8132
8133 fail:
8134     if (nNewColumn != -1) SendMessageW(infoPtr->hwndHeader, HDM_DELETEITEM, nNewColumn, 0);
8135     if (lpColumnInfo)
8136     {
8137         DPA_DeletePtr(infoPtr->hdpaColumns, nNewColumn);
8138         Free(lpColumnInfo);
8139     }
8140     return -1;
8141 }
8142
8143 /***
8144  * DESCRIPTION:
8145  * Sets the attributes of a header item.
8146  *
8147  * PARAMETER(S):
8148  * [I] infoPtr : valid pointer to the listview structure
8149  * [I] nColumn : column index
8150  * [I] lpColumn : column attributes
8151  * [I] isW: if TRUE, then lpColumn is a LPLVCOLUMNW, else it is a LPLVCOLUMNA
8152  *
8153  * RETURN:
8154  *   SUCCESS : TRUE
8155  *   FAILURE : FALSE
8156  */
8157 static BOOL LISTVIEW_SetColumnT(const LISTVIEW_INFO *infoPtr, INT nColumn,
8158                                 const LVCOLUMNW *lpColumn, BOOL isW)
8159 {
8160     HDITEMW hdi, hdiget;
8161     BOOL bResult;
8162
8163     TRACE("(nColumn=%d, lpColumn=%s, isW=%d)\n", nColumn, debuglvcolumn_t(lpColumn, isW), isW);
8164
8165     if (!lpColumn || nColumn < 0 || nColumn >= DPA_GetPtrCount(infoPtr->hdpaColumns)) return FALSE;
8166
8167     ZeroMemory(&hdi, sizeof(HDITEMW));
8168     if (lpColumn->mask & LVCF_FMT)
8169     {
8170         hdi.mask |= HDI_FORMAT;
8171         hdiget.mask = HDI_FORMAT;
8172         if (SendMessageW(infoPtr->hwndHeader, HDM_GETITEMW, nColumn, (LPARAM)&hdiget))
8173             hdi.fmt = hdiget.fmt & HDF_STRING;
8174     }
8175     column_fill_hditem(infoPtr, &hdi, nColumn, lpColumn, isW);
8176
8177     /* set header item attributes */
8178     bResult = SendMessageW(infoPtr->hwndHeader, isW ? HDM_SETITEMW : HDM_SETITEMA, nColumn, (LPARAM)&hdi);
8179     if (!bResult) return FALSE;
8180
8181     if (lpColumn->mask & LVCF_FMT)
8182     {
8183         COLUMN_INFO *lpColumnInfo = LISTVIEW_GetColumnInfo(infoPtr, nColumn);
8184         INT oldFmt = lpColumnInfo->fmt;
8185
8186         lpColumnInfo->fmt = lpColumn->fmt;
8187         if ((oldFmt ^ lpColumn->fmt) & (LVCFMT_JUSTIFYMASK | LVCFMT_IMAGE))
8188         {
8189             if (infoPtr->uView == LV_VIEW_DETAILS) LISTVIEW_InvalidateColumn(infoPtr, nColumn);
8190         }
8191     }
8192
8193     if (lpColumn->mask & LVCF_MINWIDTH)
8194         LISTVIEW_GetColumnInfo(infoPtr, nColumn)->cxMin = lpColumn->cxMin;
8195
8196     return TRUE;
8197 }
8198
8199 /***
8200  * DESCRIPTION:
8201  * Sets the column order array
8202  *
8203  * PARAMETERS:
8204  * [I] infoPtr : valid pointer to the listview structure
8205  * [I] iCount : number of elements in column order array
8206  * [I] lpiArray : pointer to column order array
8207  *
8208  * RETURN:
8209  *   SUCCESS : TRUE
8210  *   FAILURE : FALSE
8211  */
8212 static BOOL LISTVIEW_SetColumnOrderArray(LISTVIEW_INFO *infoPtr, INT iCount, const INT *lpiArray)
8213 {
8214     TRACE("iCount %d lpiArray %p\n", iCount, lpiArray);
8215
8216     if (!lpiArray || !IsWindow(infoPtr->hwndHeader)) return FALSE;
8217
8218     infoPtr->colRectsDirty = TRUE;
8219
8220     return SendMessageW(infoPtr->hwndHeader, HDM_SETORDERARRAY, iCount, (LPARAM)lpiArray);
8221 }
8222
8223 /***
8224  * DESCRIPTION:
8225  * Sets the width of a column
8226  *
8227  * PARAMETERS:
8228  * [I] infoPtr : valid pointer to the listview structure
8229  * [I] nColumn : column index
8230  * [I] cx : column width
8231  *
8232  * RETURN:
8233  *   SUCCESS : TRUE
8234  *   FAILURE : FALSE
8235  */
8236 static BOOL LISTVIEW_SetColumnWidth(LISTVIEW_INFO *infoPtr, INT nColumn, INT cx)
8237 {
8238     WCHAR szDispText[DISP_TEXT_SIZE] = { 0 };
8239     INT max_cx = 0;
8240     HDITEMW hdi;
8241
8242     TRACE("(nColumn=%d, cx=%d\n", nColumn, cx);
8243
8244     /* set column width only if in report or list mode */
8245     if (infoPtr->uView != LV_VIEW_DETAILS && infoPtr->uView != LV_VIEW_LIST) return FALSE;
8246
8247     /* take care of invalid cx values */
8248     if(infoPtr->uView == LV_VIEW_DETAILS && cx < -2) cx = LVSCW_AUTOSIZE;
8249     else if (infoPtr->uView == LV_VIEW_LIST && cx < 1) return FALSE;
8250
8251     /* resize all columns if in LV_VIEW_LIST mode */
8252     if(infoPtr->uView == LV_VIEW_LIST)
8253     {
8254         infoPtr->nItemWidth = cx;
8255         LISTVIEW_InvalidateList(infoPtr);
8256         return TRUE;
8257     }
8258
8259     if (nColumn < 0 || nColumn >= DPA_GetPtrCount(infoPtr->hdpaColumns)) return FALSE;
8260
8261     if (cx == LVSCW_AUTOSIZE || (cx == LVSCW_AUTOSIZE_USEHEADER && nColumn < DPA_GetPtrCount(infoPtr->hdpaColumns) -1))
8262     {
8263         INT nLabelWidth;
8264         LVITEMW lvItem;
8265
8266         lvItem.mask = LVIF_TEXT;
8267         lvItem.iItem = 0;
8268         lvItem.iSubItem = nColumn;
8269         lvItem.pszText = szDispText;
8270         lvItem.cchTextMax = DISP_TEXT_SIZE;
8271         for (; lvItem.iItem < infoPtr->nItemCount; lvItem.iItem++)
8272         {
8273             if (!LISTVIEW_GetItemW(infoPtr, &lvItem)) continue;
8274             nLabelWidth = LISTVIEW_GetStringWidthT(infoPtr, lvItem.pszText, TRUE);
8275             if (max_cx < nLabelWidth) max_cx = nLabelWidth;
8276         }
8277         if (infoPtr->himlSmall && (nColumn == 0 || (LISTVIEW_GetColumnInfo(infoPtr, nColumn)->fmt & LVCFMT_IMAGE)))
8278             max_cx += infoPtr->iconSize.cx;
8279         max_cx += TRAILING_LABEL_PADDING;
8280     }
8281
8282     /* autosize based on listview items width */
8283     if(cx == LVSCW_AUTOSIZE)
8284         cx = max_cx;
8285     else if(cx == LVSCW_AUTOSIZE_USEHEADER)
8286     {
8287         /* if iCol is the last column make it fill the remainder of the controls width */
8288         if(nColumn == DPA_GetPtrCount(infoPtr->hdpaColumns) - 1)
8289         {
8290             RECT rcHeader;
8291             POINT Origin;
8292
8293             LISTVIEW_GetOrigin(infoPtr, &Origin);
8294             LISTVIEW_GetHeaderRect(infoPtr, nColumn, &rcHeader);
8295
8296             cx = infoPtr->rcList.right - Origin.x - rcHeader.left;
8297         }
8298         else
8299         {
8300             /* Despite what the MS docs say, if this is not the last
8301                column, then MS resizes the column to the width of the
8302                largest text string in the column, including headers
8303                and items. This is different from LVSCW_AUTOSIZE in that
8304                LVSCW_AUTOSIZE ignores the header string length. */
8305             cx = 0;
8306
8307             /* retrieve header text */
8308             hdi.mask = HDI_TEXT;
8309             hdi.cchTextMax = DISP_TEXT_SIZE;
8310             hdi.pszText = szDispText;
8311             if (SendMessageW(infoPtr->hwndHeader, HDM_GETITEMW, nColumn, (LPARAM)&hdi))
8312             {
8313                 HDC hdc = GetDC(infoPtr->hwndSelf);
8314                 HFONT old_font = SelectObject(hdc, (HFONT)SendMessageW(infoPtr->hwndHeader, WM_GETFONT, 0, 0));
8315                 SIZE size;
8316
8317                 if (GetTextExtentPoint32W(hdc, hdi.pszText, lstrlenW(hdi.pszText), &size))
8318                     cx = size.cx + TRAILING_HEADER_PADDING;
8319                 /* FIXME: Take into account the header image, if one is present */
8320                 SelectObject(hdc, old_font);
8321                 ReleaseDC(infoPtr->hwndSelf, hdc);
8322             }
8323             cx = max (cx, max_cx);
8324         }
8325     }
8326
8327     if (cx < 0) return FALSE;
8328
8329     /* call header to update the column change */
8330     hdi.mask = HDI_WIDTH;
8331     hdi.cxy = max(cx, LISTVIEW_GetColumnInfo(infoPtr, nColumn)->cxMin);
8332     TRACE("hdi.cxy=%d\n", hdi.cxy);
8333     return SendMessageW(infoPtr->hwndHeader, HDM_SETITEMW, nColumn, (LPARAM)&hdi);
8334 }
8335
8336 /***
8337  * Creates the checkbox imagelist.  Helper for LISTVIEW_SetExtendedListViewStyle
8338  *
8339  */
8340 static HIMAGELIST LISTVIEW_CreateCheckBoxIL(const LISTVIEW_INFO *infoPtr)
8341 {
8342     HDC hdc_wnd, hdc;
8343     HBITMAP hbm_im, hbm_mask, hbm_orig;
8344     RECT rc;
8345     HBRUSH hbr_white = GetStockObject(WHITE_BRUSH);
8346     HBRUSH hbr_black = GetStockObject(BLACK_BRUSH);
8347     HIMAGELIST himl;
8348
8349     himl = ImageList_Create(GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON),
8350                             ILC_COLOR | ILC_MASK, 2, 2);
8351     hdc_wnd = GetDC(infoPtr->hwndSelf);
8352     hdc = CreateCompatibleDC(hdc_wnd);
8353     hbm_im = CreateCompatibleBitmap(hdc_wnd, GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON));
8354     hbm_mask = CreateBitmap(GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), 1, 1, NULL);
8355     ReleaseDC(infoPtr->hwndSelf, hdc_wnd);
8356
8357     rc.left = rc.top = 0;
8358     rc.right = GetSystemMetrics(SM_CXSMICON);
8359     rc.bottom = GetSystemMetrics(SM_CYSMICON);
8360
8361     hbm_orig = SelectObject(hdc, hbm_mask);
8362     FillRect(hdc, &rc, hbr_white);
8363     InflateRect(&rc, -2, -2);
8364     FillRect(hdc, &rc, hbr_black);
8365
8366     SelectObject(hdc, hbm_im);
8367     DrawFrameControl(hdc, &rc, DFC_BUTTON, DFCS_BUTTONCHECK | DFCS_MONO);
8368     SelectObject(hdc, hbm_orig);
8369     ImageList_Add(himl, hbm_im, hbm_mask);
8370
8371     SelectObject(hdc, hbm_im);
8372     DrawFrameControl(hdc, &rc, DFC_BUTTON, DFCS_BUTTONCHECK | DFCS_MONO | DFCS_CHECKED);
8373     SelectObject(hdc, hbm_orig);
8374     ImageList_Add(himl, hbm_im, hbm_mask);
8375
8376     DeleteObject(hbm_mask);
8377     DeleteObject(hbm_im);
8378     DeleteDC(hdc);
8379
8380     return himl;
8381 }
8382
8383 /***
8384  * DESCRIPTION:
8385  * Sets the extended listview style.
8386  *
8387  * PARAMETERS:
8388  * [I] infoPtr : valid pointer to the listview structure
8389  * [I] dwMask : mask
8390  * [I] dwStyle : style
8391  *
8392  * RETURN:
8393  *   SUCCESS : previous style
8394  *   FAILURE : 0
8395  */
8396 static DWORD LISTVIEW_SetExtendedListViewStyle(LISTVIEW_INFO *infoPtr, DWORD mask, DWORD ex_style)
8397 {
8398     DWORD old_ex_style = infoPtr->dwLvExStyle;
8399
8400     TRACE("mask=0x%08x, ex_style=0x%08x\n", mask, ex_style);
8401
8402     /* set new style */
8403     if (mask)
8404         infoPtr->dwLvExStyle = (old_ex_style & ~mask) | (ex_style & mask);
8405     else
8406         infoPtr->dwLvExStyle = ex_style;
8407
8408     if((infoPtr->dwLvExStyle ^ old_ex_style) & LVS_EX_CHECKBOXES)
8409     {
8410         HIMAGELIST himl = 0;
8411         if(infoPtr->dwLvExStyle & LVS_EX_CHECKBOXES)
8412         {
8413             LVITEMW item;
8414             item.mask = LVIF_STATE;
8415             item.stateMask = LVIS_STATEIMAGEMASK;
8416             item.state = INDEXTOSTATEIMAGEMASK(1);
8417             LISTVIEW_SetItemState(infoPtr, -1, &item);
8418
8419             himl = LISTVIEW_CreateCheckBoxIL(infoPtr);
8420             if(!(infoPtr->dwStyle & LVS_SHAREIMAGELISTS))
8421                 ImageList_Destroy(infoPtr->himlState);
8422         }
8423         himl = LISTVIEW_SetImageList(infoPtr, LVSIL_STATE, himl);
8424         /*   checkbox list replaces previous custom list or... */
8425         if(((infoPtr->dwLvExStyle & LVS_EX_CHECKBOXES) &&
8426            !(infoPtr->dwStyle & LVS_SHAREIMAGELISTS)) ||
8427             /* ...previous was checkbox list */
8428             (old_ex_style & LVS_EX_CHECKBOXES))
8429             ImageList_Destroy(himl);
8430     }
8431
8432     if((infoPtr->dwLvExStyle ^ old_ex_style) & LVS_EX_HEADERDRAGDROP)
8433     {
8434         DWORD style;
8435
8436         /* if not already created */
8437         LISTVIEW_CreateHeader(infoPtr);
8438
8439         style = GetWindowLongW(infoPtr->hwndHeader, GWL_STYLE);
8440         if (infoPtr->dwLvExStyle & LVS_EX_HEADERDRAGDROP)
8441             style |= HDS_DRAGDROP;
8442         else
8443             style &= ~HDS_DRAGDROP;
8444         SetWindowLongW(infoPtr->hwndHeader, GWL_STYLE, style);
8445     }
8446
8447     /* GRIDLINES adds decoration at top so changes sizes */
8448     if((infoPtr->dwLvExStyle ^ old_ex_style) & LVS_EX_GRIDLINES)
8449     {
8450         LISTVIEW_CreateHeader(infoPtr);
8451         LISTVIEW_UpdateSize(infoPtr);
8452     }
8453
8454     if((infoPtr->dwLvExStyle ^ old_ex_style) & LVS_EX_FULLROWSELECT)
8455     {
8456         LISTVIEW_CreateHeader(infoPtr);
8457     }
8458
8459     if((infoPtr->dwLvExStyle ^ old_ex_style) & LVS_EX_TRANSPARENTBKGND)
8460     {
8461         if (infoPtr->dwLvExStyle & LVS_EX_TRANSPARENTBKGND)
8462             LISTVIEW_SetBkColor(infoPtr, CLR_NONE);
8463     }
8464
8465     if((infoPtr->dwLvExStyle ^ old_ex_style) & LVS_EX_HEADERINALLVIEWS)
8466     {
8467         if (infoPtr->dwLvExStyle & LVS_EX_HEADERINALLVIEWS)
8468             LISTVIEW_CreateHeader(infoPtr);
8469         else
8470             ShowWindow(infoPtr->hwndHeader, SW_HIDE);
8471         LISTVIEW_UpdateSize(infoPtr);
8472         LISTVIEW_UpdateScroll(infoPtr);
8473     }
8474
8475     LISTVIEW_InvalidateList(infoPtr);
8476     return old_ex_style;
8477 }
8478
8479 /***
8480  * DESCRIPTION:
8481  * Sets the new hot cursor used during hot tracking and hover selection.
8482  *
8483  * PARAMETER(S):
8484  * [I] infoPtr : valid pointer to the listview structure
8485  * [I] hCursor : the new hot cursor handle
8486  *
8487  * RETURN:
8488  * Returns the previous hot cursor
8489  */
8490 static HCURSOR LISTVIEW_SetHotCursor(LISTVIEW_INFO *infoPtr, HCURSOR hCursor)
8491 {
8492     HCURSOR oldCursor = infoPtr->hHotCursor;
8493
8494     infoPtr->hHotCursor = hCursor;
8495
8496     return oldCursor;
8497 }
8498
8499
8500 /***
8501  * DESCRIPTION:
8502  * Sets the hot item index.
8503  *
8504  * PARAMETERS:
8505  * [I] infoPtr : valid pointer to the listview structure
8506  * [I] iIndex : index
8507  *
8508  * RETURN:
8509  *   SUCCESS : previous hot item index
8510  *   FAILURE : -1 (no hot item)
8511  */
8512 static INT LISTVIEW_SetHotItem(LISTVIEW_INFO *infoPtr, INT iIndex)
8513 {
8514     INT iOldIndex = infoPtr->nHotItem;
8515
8516     infoPtr->nHotItem = iIndex;
8517
8518     return iOldIndex;
8519 }
8520
8521
8522 /***
8523  * DESCRIPTION:
8524  * Sets the amount of time the cursor must hover over an item before it is selected.
8525  *
8526  * PARAMETER(S):
8527  * [I] infoPtr : valid pointer to the listview structure
8528  * [I] dwHoverTime : hover time, if -1 the hover time is set to the default
8529  *
8530  * RETURN:
8531  * Returns the previous hover time
8532  */
8533 static DWORD LISTVIEW_SetHoverTime(LISTVIEW_INFO *infoPtr, DWORD dwHoverTime)
8534 {
8535     DWORD oldHoverTime = infoPtr->dwHoverTime;
8536
8537     infoPtr->dwHoverTime = dwHoverTime;
8538
8539     return oldHoverTime;
8540 }
8541
8542 /***
8543  * DESCRIPTION:
8544  * Sets spacing for icons of LVS_ICON style.
8545  *
8546  * PARAMETER(S):
8547  * [I] infoPtr : valid pointer to the listview structure
8548  * [I] cx : horizontal spacing (-1 = system spacing, 0 = autosize)
8549  * [I] cy : vertical spacing (-1 = system spacing, 0 = autosize)
8550  *
8551  * RETURN:
8552  *   MAKELONG(oldcx, oldcy)
8553  */
8554 static DWORD LISTVIEW_SetIconSpacing(LISTVIEW_INFO *infoPtr, INT cx, INT cy)
8555 {
8556     DWORD oldspacing = MAKELONG(infoPtr->iconSpacing.cx, infoPtr->iconSpacing.cy);
8557
8558     TRACE("requested=(%d,%d)\n", cx, cy);
8559
8560     /* this is supported only for LVS_ICON style */
8561     if (infoPtr->uView != LV_VIEW_ICON) return oldspacing;
8562
8563     /* set to defaults, if instructed to */
8564     if (cx == -1) cx = GetSystemMetrics(SM_CXICONSPACING);
8565     if (cy == -1) cy = GetSystemMetrics(SM_CYICONSPACING);
8566
8567     /* if 0 then compute width
8568      * FIXME: computed cx and cy is not matching native behaviour */
8569     if (cx == 0) {
8570         cx = GetSystemMetrics(SM_CXICONSPACING);
8571         if (infoPtr->iconSize.cx + ICON_LR_PADDING > cx)
8572             cx = infoPtr->iconSize.cx + ICON_LR_PADDING;
8573     }
8574
8575     /* if 0 then compute height */
8576     if (cy == 0)
8577         cy = infoPtr->iconSize.cy + 2 * infoPtr->ntmHeight +
8578              ICON_BOTTOM_PADDING + ICON_TOP_PADDING + LABEL_VERT_PADDING;
8579
8580
8581     infoPtr->iconSpacing.cx = cx;
8582     infoPtr->iconSpacing.cy = cy;
8583
8584     TRACE("old=(%d,%d), new=(%d,%d), iconSize=(%d,%d), ntmH=%d\n",
8585           LOWORD(oldspacing), HIWORD(oldspacing), cx, cy,
8586           infoPtr->iconSize.cx, infoPtr->iconSize.cy,
8587           infoPtr->ntmHeight);
8588
8589     /* these depend on the iconSpacing */
8590     LISTVIEW_UpdateItemSize(infoPtr);
8591
8592     return oldspacing;
8593 }
8594
8595 static inline void set_icon_size(SIZE *size, HIMAGELIST himl, BOOL small)
8596 {
8597     INT cx, cy;
8598
8599     if (himl && ImageList_GetIconSize(himl, &cx, &cy))
8600     {
8601         size->cx = cx;
8602         size->cy = cy;
8603     }
8604     else
8605     {
8606         size->cx = GetSystemMetrics(small ? SM_CXSMICON : SM_CXICON);
8607         size->cy = GetSystemMetrics(small ? SM_CYSMICON : SM_CYICON);
8608     }
8609 }
8610
8611 /***
8612  * DESCRIPTION:
8613  * Sets image lists.
8614  *
8615  * PARAMETER(S):
8616  * [I] infoPtr : valid pointer to the listview structure
8617  * [I] nType : image list type
8618  * [I] himl : image list handle
8619  *
8620  * RETURN:
8621  *   SUCCESS : old image list
8622  *   FAILURE : NULL
8623  */
8624 static HIMAGELIST LISTVIEW_SetImageList(LISTVIEW_INFO *infoPtr, INT nType, HIMAGELIST himl)
8625 {
8626     INT oldHeight = infoPtr->nItemHeight;
8627     HIMAGELIST himlOld = 0;
8628
8629     TRACE("(nType=%d, himl=%p\n", nType, himl);
8630
8631     switch (nType)
8632     {
8633     case LVSIL_NORMAL:
8634         himlOld = infoPtr->himlNormal;
8635         infoPtr->himlNormal = himl;
8636         if (infoPtr->uView == LV_VIEW_ICON) set_icon_size(&infoPtr->iconSize, himl, FALSE);
8637         LISTVIEW_SetIconSpacing(infoPtr, 0, 0);
8638     break;
8639
8640     case LVSIL_SMALL:
8641         himlOld = infoPtr->himlSmall;
8642         infoPtr->himlSmall = himl;
8643         if (infoPtr->uView != LV_VIEW_ICON) set_icon_size(&infoPtr->iconSize, himl, TRUE);
8644         if (infoPtr->hwndHeader)
8645             SendMessageW(infoPtr->hwndHeader, HDM_SETIMAGELIST, 0, (LPARAM)himl);
8646     break;
8647
8648     case LVSIL_STATE:
8649         himlOld = infoPtr->himlState;
8650         infoPtr->himlState = himl;
8651         set_icon_size(&infoPtr->iconStateSize, himl, TRUE);
8652         ImageList_SetBkColor(infoPtr->himlState, CLR_NONE);
8653     break;
8654
8655     default:
8656         ERR("Unknown icon type=%d\n", nType);
8657         return NULL;
8658     }
8659
8660     infoPtr->nItemHeight = LISTVIEW_CalculateItemHeight(infoPtr);
8661     if (infoPtr->nItemHeight != oldHeight)
8662         LISTVIEW_UpdateScroll(infoPtr);
8663
8664     return himlOld;
8665 }
8666
8667 /***
8668  * DESCRIPTION:
8669  * Preallocates memory (does *not* set the actual count of items !)
8670  *
8671  * PARAMETER(S):
8672  * [I] infoPtr : valid pointer to the listview structure
8673  * [I] nItems : item count (projected number of items to allocate)
8674  * [I] dwFlags : update flags
8675  *
8676  * RETURN:
8677  *   SUCCESS : TRUE
8678  *   FAILURE : FALSE
8679  */
8680 static BOOL LISTVIEW_SetItemCount(LISTVIEW_INFO *infoPtr, INT nItems, DWORD dwFlags)
8681 {
8682     TRACE("(nItems=%d, dwFlags=%x)\n", nItems, dwFlags);
8683
8684     if (infoPtr->dwStyle & LVS_OWNERDATA)
8685     {
8686         INT nOldCount = infoPtr->nItemCount;
8687
8688         if (nItems < nOldCount)
8689         {
8690             RANGE range = { nItems, nOldCount };
8691             ranges_del(infoPtr->selectionRanges, range);
8692             if (infoPtr->nFocusedItem >= nItems)
8693             {
8694                 LISTVIEW_SetItemFocus(infoPtr, -1);
8695                 SetRectEmpty(&infoPtr->rcFocus);
8696             }
8697         }
8698
8699         infoPtr->nItemCount = nItems;
8700         LISTVIEW_UpdateScroll(infoPtr);
8701
8702         /* the flags are valid only in ownerdata report and list modes */
8703         if (infoPtr->uView == LV_VIEW_ICON || infoPtr->uView == LV_VIEW_SMALLICON) dwFlags = 0;
8704
8705         if (!(dwFlags & LVSICF_NOSCROLL) && infoPtr->nFocusedItem != -1)
8706             LISTVIEW_EnsureVisible(infoPtr, infoPtr->nFocusedItem, FALSE);
8707
8708         if (!(dwFlags & LVSICF_NOINVALIDATEALL))
8709             LISTVIEW_InvalidateList(infoPtr);
8710         else
8711         {
8712             INT nFrom, nTo;
8713             POINT Origin;
8714             RECT rcErase;
8715
8716             LISTVIEW_GetOrigin(infoPtr, &Origin);
8717             nFrom = min(nOldCount, nItems);
8718             nTo = max(nOldCount, nItems);
8719
8720             if (infoPtr->uView == LV_VIEW_DETAILS)
8721             {
8722                 rcErase.left = 0;
8723                 rcErase.top = nFrom * infoPtr->nItemHeight;
8724                 rcErase.right = infoPtr->nItemWidth;
8725                 rcErase.bottom = nTo * infoPtr->nItemHeight;
8726                 OffsetRect(&rcErase, Origin.x, Origin.y);
8727                 if (IntersectRect(&rcErase, &rcErase, &infoPtr->rcList))
8728                     LISTVIEW_InvalidateRect(infoPtr, &rcErase);
8729             }
8730             else /* LV_VIEW_LIST */
8731             {
8732                 INT nPerCol = LISTVIEW_GetCountPerColumn(infoPtr);
8733
8734                 rcErase.left = (nFrom / nPerCol) * infoPtr->nItemWidth;
8735                 rcErase.top = (nFrom % nPerCol) * infoPtr->nItemHeight;
8736                 rcErase.right = rcErase.left + infoPtr->nItemWidth;
8737                 rcErase.bottom = nPerCol * infoPtr->nItemHeight;
8738                 OffsetRect(&rcErase, Origin.x, Origin.y);
8739                 if (IntersectRect(&rcErase, &rcErase, &infoPtr->rcList))
8740                     LISTVIEW_InvalidateRect(infoPtr, &rcErase);
8741
8742                 rcErase.left = (nFrom / nPerCol + 1) * infoPtr->nItemWidth;
8743                 rcErase.top = 0;
8744                 rcErase.right = (nTo / nPerCol + 1) * infoPtr->nItemWidth;
8745                 rcErase.bottom = nPerCol * infoPtr->nItemHeight;
8746                 OffsetRect(&rcErase, Origin.x, Origin.y);
8747                 if (IntersectRect(&rcErase, &rcErase, &infoPtr->rcList))
8748                     LISTVIEW_InvalidateRect(infoPtr, &rcErase);
8749             }
8750         }
8751     }
8752     else
8753     {
8754         /* According to MSDN for non-LVS_OWNERDATA this is just
8755          * a performance issue. The control allocates its internal
8756          * data structures for the number of items specified. It
8757          * cuts down on the number of memory allocations. Therefore
8758          * we will just issue a WARN here
8759          */
8760         WARN("for non-ownerdata performance option not implemented.\n");
8761     }
8762
8763     return TRUE;
8764 }
8765
8766 /***
8767  * DESCRIPTION:
8768  * Sets the position of an item.
8769  *
8770  * PARAMETER(S):
8771  * [I] infoPtr : valid pointer to the listview structure
8772  * [I] nItem : item index
8773  * [I] pt : coordinate
8774  *
8775  * RETURN:
8776  *   SUCCESS : TRUE
8777  *   FAILURE : FALSE
8778  */
8779 static BOOL LISTVIEW_SetItemPosition(LISTVIEW_INFO *infoPtr, INT nItem, const POINT *pt)
8780 {
8781     POINT Origin, Pt;
8782
8783     TRACE("(nItem=%d, pt=%s\n", nItem, wine_dbgstr_point(pt));
8784
8785     if (!pt || nItem < 0 || nItem >= infoPtr->nItemCount ||
8786         !(infoPtr->uView == LV_VIEW_ICON || infoPtr->uView == LV_VIEW_SMALLICON)) return FALSE;
8787
8788     Pt = *pt;
8789     LISTVIEW_GetOrigin(infoPtr, &Origin);
8790
8791     /* This point value seems to be an undocumented feature.
8792      * The best guess is that it means either at the origin,
8793      * or at true beginning of the list. I will assume the origin. */
8794     if ((Pt.x == -1) && (Pt.y == -1))
8795         Pt = Origin;
8796
8797     if (infoPtr->uView == LV_VIEW_ICON)
8798     {
8799         Pt.x -= (infoPtr->nItemWidth - infoPtr->iconSize.cx) / 2;
8800         Pt.y -= ICON_TOP_PADDING;
8801     }
8802     Pt.x -= Origin.x;
8803     Pt.y -= Origin.y;
8804
8805     infoPtr->bAutoarrange = FALSE;
8806
8807     return LISTVIEW_MoveIconTo(infoPtr, nItem, &Pt, FALSE);
8808 }
8809
8810 /***
8811  * DESCRIPTION:
8812  * Sets the state of one or many items.
8813  *
8814  * PARAMETER(S):
8815  * [I] infoPtr : valid pointer to the listview structure
8816  * [I] nItem : item index
8817  * [I] item  : item or subitem info
8818  *
8819  * RETURN:
8820  *   SUCCESS : TRUE
8821  *   FAILURE : FALSE
8822  */
8823 static BOOL LISTVIEW_SetItemState(LISTVIEW_INFO *infoPtr, INT nItem, const LVITEMW *item)
8824 {
8825     BOOL ret = TRUE;
8826     LVITEMW lvItem;
8827
8828     if (!item) return FALSE;
8829
8830     lvItem.iItem = nItem;
8831     lvItem.iSubItem = 0;
8832     lvItem.mask = LVIF_STATE;
8833     lvItem.state = item->state;
8834     lvItem.stateMask = item->stateMask;
8835     TRACE("item=%s\n", debuglvitem_t(&lvItem, TRUE));
8836
8837     if (nItem == -1)
8838     {
8839         UINT oldstate = 0;
8840         BOOL notify;
8841
8842         /* select all isn't allowed in LVS_SINGLESEL */
8843         if ((lvItem.state & lvItem.stateMask & LVIS_SELECTED) && (infoPtr->dwStyle & LVS_SINGLESEL))
8844             return FALSE;
8845
8846         /* focus all isn't allowed */
8847         if (lvItem.state & lvItem.stateMask & LVIS_FOCUSED) return FALSE;
8848
8849         notify = infoPtr->bDoChangeNotify;
8850         if (infoPtr->dwStyle & LVS_OWNERDATA)
8851         {
8852             infoPtr->bDoChangeNotify = FALSE;
8853             if (!(lvItem.state & LVIS_SELECTED) && LISTVIEW_GetSelectedCount(infoPtr))
8854                 oldstate |= LVIS_SELECTED;
8855             if (infoPtr->nFocusedItem != -1) oldstate |= LVIS_FOCUSED;
8856         }
8857
8858         /* apply to all items */
8859         for (lvItem.iItem = 0; lvItem.iItem < infoPtr->nItemCount; lvItem.iItem++)
8860             if (!LISTVIEW_SetItemT(infoPtr, &lvItem, TRUE)) ret = FALSE;
8861
8862         if (infoPtr->dwStyle & LVS_OWNERDATA)
8863         {
8864             NMLISTVIEW nmlv;
8865
8866             infoPtr->bDoChangeNotify = notify;
8867
8868             nmlv.iItem = -1;
8869             nmlv.iSubItem = 0;
8870             nmlv.uNewState = lvItem.state & lvItem.stateMask;
8871             nmlv.uOldState = oldstate & lvItem.stateMask;
8872             nmlv.uChanged = LVIF_STATE;
8873             nmlv.ptAction.x = nmlv.ptAction.y = 0;
8874             nmlv.lParam = 0;
8875
8876             notify_listview(infoPtr, LVN_ITEMCHANGED, &nmlv);
8877         }
8878     }
8879     else
8880         ret = LISTVIEW_SetItemT(infoPtr, &lvItem, TRUE);
8881
8882     return ret;
8883 }
8884
8885 /***
8886  * DESCRIPTION:
8887  * Sets the text of an item or subitem.
8888  *
8889  * PARAMETER(S):
8890  * [I] hwnd : window handle
8891  * [I] nItem : item index
8892  * [I] lpLVItem : item or subitem info
8893  * [I] isW : TRUE if input is Unicode
8894  *
8895  * RETURN:
8896  *   SUCCESS : TRUE
8897  *   FAILURE : FALSE
8898  */
8899 static BOOL LISTVIEW_SetItemTextT(LISTVIEW_INFO *infoPtr, INT nItem, const LVITEMW *lpLVItem, BOOL isW)
8900 {
8901     LVITEMW lvItem;
8902
8903     if (!lpLVItem || nItem < 0 || nItem >= infoPtr->nItemCount) return FALSE;
8904     if (infoPtr->dwStyle & LVS_OWNERDATA) return FALSE;
8905
8906     lvItem.iItem = nItem;
8907     lvItem.iSubItem = lpLVItem->iSubItem;
8908     lvItem.mask = LVIF_TEXT;
8909     lvItem.pszText = lpLVItem->pszText;
8910     lvItem.cchTextMax = lpLVItem->cchTextMax;
8911
8912     TRACE("(nItem=%d, lpLVItem=%s, isW=%d)\n", nItem, debuglvitem_t(&lvItem, isW), isW);
8913
8914     return LISTVIEW_SetItemT(infoPtr, &lvItem, isW);
8915 }
8916
8917 /***
8918  * DESCRIPTION:
8919  * Set item index that marks the start of a multiple selection.
8920  *
8921  * PARAMETER(S):
8922  * [I] infoPtr : valid pointer to the listview structure
8923  * [I] nIndex : index
8924  *
8925  * RETURN:
8926  * Index number or -1 if there is no selection mark.
8927  */
8928 static INT LISTVIEW_SetSelectionMark(LISTVIEW_INFO *infoPtr, INT nIndex)
8929 {
8930   INT nOldIndex = infoPtr->nSelectionMark;
8931
8932   TRACE("(nIndex=%d)\n", nIndex);
8933
8934   infoPtr->nSelectionMark = nIndex;
8935
8936   return nOldIndex;
8937 }
8938
8939 /***
8940  * DESCRIPTION:
8941  * Sets the text background color.
8942  *
8943  * PARAMETER(S):
8944  * [I] infoPtr : valid pointer to the listview structure
8945  * [I] color   : text background color
8946  *
8947  * RETURN:
8948  *   SUCCESS : TRUE
8949  *   FAILURE : FALSE
8950  */
8951 static BOOL LISTVIEW_SetTextBkColor(LISTVIEW_INFO *infoPtr, COLORREF color)
8952 {
8953     TRACE("(color=%x)\n", color);
8954
8955     infoPtr->clrTextBk = color;
8956     return TRUE;
8957 }
8958
8959 /***
8960  * DESCRIPTION:
8961  * Sets the text foreground color.
8962  *
8963  * PARAMETER(S):
8964  * [I] infoPtr : valid pointer to the listview structure
8965  * [I] color   : text color
8966  *
8967  * RETURN:
8968  *   SUCCESS : TRUE
8969  *   FAILURE : FALSE
8970  */
8971 static BOOL LISTVIEW_SetTextColor (LISTVIEW_INFO *infoPtr, COLORREF color)
8972 {
8973     TRACE("(color=%x)\n", color);
8974
8975     infoPtr->clrText = color;
8976     return TRUE;
8977 }
8978
8979 /***
8980  * DESCRIPTION:
8981  * Sets new ToolTip window to ListView control.
8982  *
8983  * PARAMETER(S):
8984  * [I] infoPtr        : valid pointer to the listview structure
8985  * [I] hwndNewToolTip : handle to new ToolTip
8986  *
8987  * RETURN:
8988  *   old tool tip
8989  */
8990 static HWND LISTVIEW_SetToolTips( LISTVIEW_INFO *infoPtr, HWND hwndNewToolTip)
8991 {
8992   HWND hwndOldToolTip = infoPtr->hwndToolTip;
8993   infoPtr->hwndToolTip = hwndNewToolTip;
8994   return hwndOldToolTip;
8995 }
8996
8997 /*
8998  * DESCRIPTION:
8999  *   sets the Unicode character format flag for the control
9000  * PARAMETER(S):
9001  *    [I] infoPtr         :valid pointer to the listview structure
9002  *    [I] fUnicode        :true to switch to UNICODE false to switch to ANSI
9003  *
9004  * RETURN:
9005  *    Old Unicode Format
9006  */
9007 static BOOL LISTVIEW_SetUnicodeFormat( LISTVIEW_INFO *infoPtr, BOOL unicode)
9008 {
9009   SHORT rc = infoPtr->notifyFormat;
9010   infoPtr->notifyFormat = (unicode) ? NFR_UNICODE : NFR_ANSI;
9011   return rc == NFR_UNICODE;
9012 }
9013
9014 /*
9015  * DESCRIPTION:
9016  *   sets the control view mode
9017  * PARAMETER(S):
9018  *    [I] infoPtr         :valid pointer to the listview structure
9019  *    [I] nView           :new view mode value
9020  *
9021  * RETURN:
9022  *    SUCCESS:  1
9023  *    FAILURE: -1
9024  */
9025 static INT LISTVIEW_SetView(LISTVIEW_INFO *infoPtr, DWORD nView)
9026 {
9027   SIZE oldIconSize = infoPtr->iconSize;
9028   HIMAGELIST himl;
9029
9030   if (infoPtr->uView == nView) return 1;
9031
9032   if ((INT)nView < 0 || nView > LV_VIEW_MAX) return -1;
9033   if (nView == LV_VIEW_TILE)
9034   {
9035       FIXME("View LV_VIEW_TILE unimplemented\n");
9036       return -1;
9037   }
9038
9039   infoPtr->uView = nView;
9040
9041   SendMessageW(infoPtr->hwndEdit, WM_KILLFOCUS, 0, 0);
9042   ShowWindow(infoPtr->hwndHeader, SW_HIDE);
9043
9044   ShowScrollBar(infoPtr->hwndSelf, SB_BOTH, FALSE);
9045   SetRectEmpty(&infoPtr->rcFocus);
9046
9047   himl = (nView == LV_VIEW_ICON ? infoPtr->himlNormal : infoPtr->himlSmall);
9048   set_icon_size(&infoPtr->iconSize, himl, nView != LV_VIEW_ICON);
9049
9050   switch (nView)
9051   {
9052   case LV_VIEW_ICON:
9053       if ((infoPtr->iconSize.cx != oldIconSize.cx) || (infoPtr->iconSize.cy != oldIconSize.cy))
9054       {
9055             TRACE("icon old size=(%d,%d), new size=(%d,%d)\n",
9056                    oldIconSize.cx, oldIconSize.cy, infoPtr->iconSize.cx, infoPtr->iconSize.cy);
9057             LISTVIEW_SetIconSpacing(infoPtr, 0, 0);
9058       }
9059       LISTVIEW_Arrange(infoPtr, LVA_DEFAULT);
9060       break;
9061   case LV_VIEW_SMALLICON:
9062       LISTVIEW_Arrange(infoPtr, LVA_DEFAULT);
9063       break;
9064   case LV_VIEW_DETAILS:
9065   {
9066       HDLAYOUT hl;
9067       WINDOWPOS wp;
9068
9069       LISTVIEW_CreateHeader( infoPtr );
9070
9071       hl.prc = &infoPtr->rcList;
9072       hl.pwpos = &wp;
9073       SendMessageW(infoPtr->hwndHeader, HDM_LAYOUT, 0, (LPARAM)&hl);
9074       SetWindowPos(infoPtr->hwndHeader, infoPtr->hwndSelf, wp.x, wp.y, wp.cx, wp.cy,
9075                    wp.flags | ((infoPtr->dwStyle & LVS_NOCOLUMNHEADER) ? SWP_HIDEWINDOW : SWP_SHOWWINDOW));
9076       break;
9077   }
9078   case LV_VIEW_LIST:
9079       break;
9080   }
9081
9082   LISTVIEW_UpdateItemSize(infoPtr);
9083   LISTVIEW_UpdateSize(infoPtr);
9084   LISTVIEW_UpdateScroll(infoPtr);
9085   LISTVIEW_InvalidateList(infoPtr);
9086
9087   TRACE("nView=%d\n", nView);
9088
9089   return 1;
9090 }
9091
9092 /* LISTVIEW_SetWorkAreas */
9093
9094 /***
9095  * DESCRIPTION:
9096  * Callback internally used by LISTVIEW_SortItems() in response of LVM_SORTITEMS
9097  *
9098  * PARAMETER(S):
9099  * [I] first : pointer to first ITEM_INFO to compare
9100  * [I] second : pointer to second ITEM_INFO to compare
9101  * [I] lParam : HWND of control
9102  *
9103  * RETURN:
9104  *   if first comes before second : negative
9105  *   if first comes after second : positive
9106  *   if first and second are equivalent : zero
9107  */
9108 static INT WINAPI LISTVIEW_CallBackCompare(LPVOID first, LPVOID second, LPARAM lParam)
9109 {
9110   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)lParam;
9111   ITEM_INFO* lv_first = DPA_GetPtr( first, 0 );
9112   ITEM_INFO* lv_second = DPA_GetPtr( second, 0 );
9113
9114   /* Forward the call to the client defined callback */
9115   return (infoPtr->pfnCompare)( lv_first->lParam , lv_second->lParam, infoPtr->lParamSort );
9116 }
9117
9118 /***
9119  * DESCRIPTION:
9120  * Callback internally used by LISTVIEW_SortItems() in response of LVM_SORTITEMSEX
9121  *
9122  * PARAMETER(S):
9123  * [I] first : pointer to first ITEM_INFO to compare
9124  * [I] second : pointer to second ITEM_INFO to compare
9125  * [I] lParam : HWND of control
9126  *
9127  * RETURN:
9128  *   if first comes before second : negative
9129  *   if first comes after second : positive
9130  *   if first and second are equivalent : zero
9131  */
9132 static INT WINAPI LISTVIEW_CallBackCompareEx(LPVOID first, LPVOID second, LPARAM lParam)
9133 {
9134   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)lParam;
9135   INT first_idx  = DPA_GetPtrIndex( infoPtr->hdpaItems, first  );
9136   INT second_idx = DPA_GetPtrIndex( infoPtr->hdpaItems, second );
9137
9138   /* Forward the call to the client defined callback */
9139   return (infoPtr->pfnCompare)( first_idx, second_idx, infoPtr->lParamSort );
9140 }
9141
9142 /***
9143  * DESCRIPTION:
9144  * Sorts the listview items.
9145  *
9146  * PARAMETER(S):
9147  * [I] infoPtr : valid pointer to the listview structure
9148  * [I] pfnCompare : application-defined value
9149  * [I] lParamSort : pointer to comparison callback
9150  * [I] IsEx : TRUE when LVM_SORTITEMSEX used
9151  *
9152  * RETURN:
9153  *   SUCCESS : TRUE
9154  *   FAILURE : FALSE
9155  */
9156 static BOOL LISTVIEW_SortItems(LISTVIEW_INFO *infoPtr, PFNLVCOMPARE pfnCompare,
9157                                LPARAM lParamSort, BOOL IsEx)
9158 {
9159     HDPA hdpaSubItems;
9160     ITEM_INFO *lpItem;
9161     LPVOID selectionMarkItem = NULL;
9162     LPVOID focusedItem = NULL;
9163     int i;
9164
9165     TRACE("(pfnCompare=%p, lParamSort=%lx)\n", pfnCompare, lParamSort);
9166
9167     if (infoPtr->dwStyle & LVS_OWNERDATA) return FALSE;
9168
9169     if (!pfnCompare) return FALSE;
9170     if (!infoPtr->hdpaItems) return FALSE;
9171
9172     /* if there are 0 or 1 items, there is no need to sort */
9173     if (infoPtr->nItemCount < 2) return TRUE;
9174
9175     /* clear selection */
9176     ranges_clear(infoPtr->selectionRanges);
9177
9178     /* save selection mark and focused item */
9179     if (infoPtr->nSelectionMark >= 0)
9180         selectionMarkItem = DPA_GetPtr(infoPtr->hdpaItems, infoPtr->nSelectionMark);
9181     if (infoPtr->nFocusedItem >= 0)
9182         focusedItem = DPA_GetPtr(infoPtr->hdpaItems, infoPtr->nFocusedItem);
9183
9184     infoPtr->pfnCompare = pfnCompare;
9185     infoPtr->lParamSort = lParamSort;
9186     if (IsEx)
9187         DPA_Sort(infoPtr->hdpaItems, LISTVIEW_CallBackCompareEx, (LPARAM)infoPtr);
9188     else
9189         DPA_Sort(infoPtr->hdpaItems, LISTVIEW_CallBackCompare, (LPARAM)infoPtr);
9190
9191     /* restore selection ranges */
9192     for (i=0; i < infoPtr->nItemCount; i++)
9193     {
9194         hdpaSubItems = DPA_GetPtr(infoPtr->hdpaItems, i);
9195         lpItem = DPA_GetPtr(hdpaSubItems, 0);
9196
9197         if (lpItem->state & LVIS_SELECTED)
9198             ranges_additem(infoPtr->selectionRanges, i);
9199     }
9200     /* restore selection mark and focused item */
9201     infoPtr->nSelectionMark = DPA_GetPtrIndex(infoPtr->hdpaItems, selectionMarkItem);
9202     infoPtr->nFocusedItem   = DPA_GetPtrIndex(infoPtr->hdpaItems, focusedItem);
9203
9204     /* I believe nHotItem should be left alone, see LISTVIEW_ShiftIndices */
9205
9206     /* refresh the display */
9207     LISTVIEW_InvalidateList(infoPtr);
9208     return TRUE;
9209 }
9210
9211 /***
9212  * DESCRIPTION:
9213  * Update theme handle after a theme change.
9214  *
9215  * PARAMETER(S):
9216  * [I] infoPtr : valid pointer to the listview structure
9217  *
9218  * RETURN:
9219  *   SUCCESS : 0
9220  *   FAILURE : something else
9221  */
9222 static LRESULT LISTVIEW_ThemeChanged(const LISTVIEW_INFO *infoPtr)
9223 {
9224     HTHEME theme = GetWindowTheme(infoPtr->hwndSelf);
9225     CloseThemeData(theme);
9226     OpenThemeData(infoPtr->hwndSelf, themeClass);
9227     return 0;
9228 }
9229
9230 /***
9231  * DESCRIPTION:
9232  * Updates an items or rearranges the listview control.
9233  *
9234  * PARAMETER(S):
9235  * [I] infoPtr : valid pointer to the listview structure
9236  * [I] nItem : item index
9237  *
9238  * RETURN:
9239  *   SUCCESS : TRUE
9240  *   FAILURE : FALSE
9241  */
9242 static BOOL LISTVIEW_Update(LISTVIEW_INFO *infoPtr, INT nItem)
9243 {
9244     TRACE("(nItem=%d)\n", nItem);
9245
9246     if (nItem < 0 || nItem >= infoPtr->nItemCount) return FALSE;
9247
9248     /* rearrange with default alignment style */
9249     if (is_autoarrange(infoPtr))
9250         LISTVIEW_Arrange(infoPtr, LVA_DEFAULT);
9251     else
9252         LISTVIEW_InvalidateItem(infoPtr, nItem);
9253
9254     return TRUE;
9255 }
9256
9257 /***
9258  * DESCRIPTION:
9259  * Draw the track line at the place defined in the infoPtr structure.
9260  * The line is drawn with a XOR pen so drawing the line for the second time
9261  * in the same place erases the line.
9262  *
9263  * PARAMETER(S):
9264  * [I] infoPtr : valid pointer to the listview structure
9265  *
9266  * RETURN:
9267  *   SUCCESS : TRUE
9268  *   FAILURE : FALSE
9269  */
9270 static BOOL LISTVIEW_DrawTrackLine(const LISTVIEW_INFO *infoPtr)
9271 {
9272     HDC hdc;
9273
9274     if (infoPtr->xTrackLine == -1)
9275         return FALSE;
9276
9277     if (!(hdc = GetDC(infoPtr->hwndSelf)))
9278         return FALSE;
9279     PatBlt( hdc, infoPtr->xTrackLine, infoPtr->rcList.top,
9280             1, infoPtr->rcList.bottom - infoPtr->rcList.top, DSTINVERT );
9281     ReleaseDC(infoPtr->hwndSelf, hdc);
9282     return TRUE;
9283 }
9284
9285 /***
9286  * DESCRIPTION:
9287  * Called when an edit control should be displayed. This function is called after
9288  * we are sure that there was a single click - not a double click (this is a TIMERPROC).
9289  *
9290  * PARAMETER(S):
9291  * [I] hwnd : Handle to the listview
9292  * [I] uMsg : WM_TIMER (ignored)
9293  * [I] idEvent : The timer ID interpreted as a pointer to a DELAYED_EDIT_ITEM struct
9294  * [I] dwTimer : The elapsed time (ignored)
9295  *
9296  * RETURN:
9297  *   None.
9298  */
9299 static VOID CALLBACK LISTVIEW_DelayedEditItem(HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
9300 {
9301     DELAYED_ITEM_EDIT *editItem = (DELAYED_ITEM_EDIT *)idEvent;
9302     LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongPtrW(hwnd, 0);
9303
9304     KillTimer(hwnd, idEvent);
9305     editItem->fEnabled = FALSE;
9306     /* check if the item is still selected */
9307     if (infoPtr->bFocus && LISTVIEW_GetItemState(infoPtr, editItem->iItem, LVIS_SELECTED))
9308         LISTVIEW_EditLabelT(infoPtr, editItem->iItem, TRUE);
9309 }
9310
9311 /***
9312  * DESCRIPTION:
9313  * Creates the listview control - the WM_NCCREATE phase.
9314  *
9315  * PARAMETER(S):
9316  * [I] hwnd : window handle
9317  * [I] lpcs : the create parameters
9318  *
9319  * RETURN:
9320  *   Success: TRUE
9321  *   Failure: FALSE
9322  */
9323 static LRESULT LISTVIEW_NCCreate(HWND hwnd, const CREATESTRUCTW *lpcs)
9324 {
9325   LISTVIEW_INFO *infoPtr;
9326   LOGFONTW logFont;
9327
9328   TRACE("(lpcs=%p)\n", lpcs);
9329
9330   /* initialize info pointer */
9331   infoPtr = Alloc(sizeof(LISTVIEW_INFO));
9332   if (!infoPtr) return FALSE;
9333
9334   SetWindowLongPtrW(hwnd, 0, (DWORD_PTR)infoPtr);
9335
9336   infoPtr->hwndSelf = hwnd;
9337   infoPtr->dwStyle = lpcs->style;    /* Note: may be changed in WM_CREATE */
9338   map_style_view(infoPtr);
9339   /* determine the type of structures to use */
9340   infoPtr->hwndNotify = lpcs->hwndParent;
9341   /* infoPtr->notifyFormat will be filled in WM_CREATE */
9342
9343   /* initialize color information  */
9344   infoPtr->clrBk = CLR_NONE;
9345   infoPtr->clrText = CLR_DEFAULT;
9346   infoPtr->clrTextBk = CLR_DEFAULT;
9347   LISTVIEW_SetBkColor(infoPtr, comctl32_color.clrWindow);
9348
9349   /* set default values */
9350   infoPtr->nFocusedItem = -1;
9351   infoPtr->nSelectionMark = -1;
9352   infoPtr->nHotItem = -1;
9353   infoPtr->bRedraw = TRUE;
9354   infoPtr->bNoItemMetrics = TRUE;
9355   infoPtr->bDoChangeNotify = TRUE;
9356   infoPtr->iconSpacing.cx = GetSystemMetrics(SM_CXICONSPACING);
9357   infoPtr->iconSpacing.cy = GetSystemMetrics(SM_CYICONSPACING);
9358   infoPtr->nEditLabelItem = -1;
9359   infoPtr->nLButtonDownItem = -1;
9360   infoPtr->dwHoverTime = HOVER_DEFAULT; /* default system hover time */
9361   infoPtr->nMeasureItemHeight = 0;
9362   infoPtr->xTrackLine = -1;  /* no track line */
9363   infoPtr->itemEdit.fEnabled = FALSE;
9364   infoPtr->iVersion = COMCTL32_VERSION;
9365   infoPtr->colRectsDirty = FALSE;
9366
9367   /* get default font (icon title) */
9368   SystemParametersInfoW(SPI_GETICONTITLELOGFONT, 0, &logFont, 0);
9369   infoPtr->hDefaultFont = CreateFontIndirectW(&logFont);
9370   infoPtr->hFont = infoPtr->hDefaultFont;
9371   LISTVIEW_SaveTextMetrics(infoPtr);
9372
9373   /* allocate memory for the data structure */
9374   if (!(infoPtr->selectionRanges = ranges_create(10))) goto fail;
9375   if (!(infoPtr->hdpaItems = DPA_Create(10))) goto fail;
9376   if (!(infoPtr->hdpaItemIds = DPA_Create(10))) goto fail;
9377   if (!(infoPtr->hdpaPosX  = DPA_Create(10))) goto fail;
9378   if (!(infoPtr->hdpaPosY  = DPA_Create(10))) goto fail;
9379   if (!(infoPtr->hdpaColumns = DPA_Create(10))) goto fail;
9380   return TRUE;
9381
9382 fail:
9383     DestroyWindow(infoPtr->hwndHeader);
9384     ranges_destroy(infoPtr->selectionRanges);
9385     DPA_Destroy(infoPtr->hdpaItems);
9386     DPA_Destroy(infoPtr->hdpaItemIds);
9387     DPA_Destroy(infoPtr->hdpaPosX);
9388     DPA_Destroy(infoPtr->hdpaPosY);
9389     DPA_Destroy(infoPtr->hdpaColumns);
9390     Free(infoPtr);
9391     return FALSE;
9392 }
9393
9394 /***
9395  * DESCRIPTION:
9396  * Creates the listview control - the WM_CREATE phase. Most of the data is
9397  * already set up in LISTVIEW_NCCreate
9398  *
9399  * PARAMETER(S):
9400  * [I] hwnd : window handle
9401  * [I] lpcs : the create parameters
9402  *
9403  * RETURN:
9404  *   Success: 0
9405  *   Failure: -1
9406  */
9407 static LRESULT LISTVIEW_Create(HWND hwnd, const CREATESTRUCTW *lpcs)
9408 {
9409   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongPtrW(hwnd, 0);
9410
9411   TRACE("(lpcs=%p, style=0x%08x)\n", lpcs, lpcs->style);
9412
9413   infoPtr->dwStyle = lpcs->style;
9414   map_style_view(infoPtr);
9415
9416   infoPtr->notifyFormat = SendMessageW(infoPtr->hwndNotify, WM_NOTIFYFORMAT,
9417                                        (WPARAM)infoPtr->hwndSelf, NF_QUERY);
9418   /* on error defaulting to ANSI notifications */
9419   if (infoPtr->notifyFormat == 0) infoPtr->notifyFormat = NFR_ANSI;
9420   TRACE("notify format=%d\n", infoPtr->notifyFormat);
9421
9422   if ((infoPtr->uView == LV_VIEW_DETAILS) && (lpcs->style & WS_VISIBLE))
9423   {
9424     if (LISTVIEW_CreateHeader(infoPtr) < 0)  return -1;
9425   }
9426   else
9427     infoPtr->hwndHeader = 0;
9428
9429   /* init item size to avoid division by 0 */
9430   LISTVIEW_UpdateItemSize (infoPtr);
9431   LISTVIEW_UpdateSize (infoPtr);
9432
9433   if (infoPtr->uView == LV_VIEW_DETAILS)
9434   {
9435     if (!(LVS_NOCOLUMNHEADER & lpcs->style) && (WS_VISIBLE & lpcs->style))
9436     {
9437       ShowWindow(infoPtr->hwndHeader, SW_SHOWNORMAL);
9438     }
9439     LISTVIEW_UpdateScroll(infoPtr);
9440     /* send WM_MEASUREITEM notification */
9441     if (infoPtr->dwStyle & LVS_OWNERDRAWFIXED) notify_measureitem(infoPtr);
9442   }
9443
9444   OpenThemeData(hwnd, themeClass);
9445
9446   /* initialize the icon sizes */
9447   set_icon_size(&infoPtr->iconSize, infoPtr->himlNormal, infoPtr->uView != LV_VIEW_ICON);
9448   set_icon_size(&infoPtr->iconStateSize, infoPtr->himlState, TRUE);
9449   return 0;
9450 }
9451
9452 /***
9453  * DESCRIPTION:
9454  * Destroys the listview control.
9455  *
9456  * PARAMETER(S):
9457  * [I] infoPtr : valid pointer to the listview structure
9458  *
9459  * RETURN:
9460  *   Success: 0
9461  *   Failure: -1
9462  */
9463 static LRESULT LISTVIEW_Destroy(LISTVIEW_INFO *infoPtr)
9464 {
9465     HTHEME theme = GetWindowTheme(infoPtr->hwndSelf);
9466     CloseThemeData(theme);
9467
9468     /* delete all items */
9469     LISTVIEW_DeleteAllItems(infoPtr, TRUE);
9470
9471     return 0;
9472 }
9473
9474 /***
9475  * DESCRIPTION:
9476  * Enables the listview control.
9477  *
9478  * PARAMETER(S):
9479  * [I] infoPtr : valid pointer to the listview structure
9480  * [I] bEnable : specifies whether to enable or disable the window
9481  *
9482  * RETURN:
9483  *   SUCCESS : TRUE
9484  *   FAILURE : FALSE
9485  */
9486 static BOOL LISTVIEW_Enable(const LISTVIEW_INFO *infoPtr)
9487 {
9488     if (infoPtr->dwStyle & LVS_OWNERDRAWFIXED)
9489         InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
9490     return TRUE;
9491 }
9492
9493 /***
9494  * DESCRIPTION:
9495  * Erases the background of the listview control.
9496  *
9497  * PARAMETER(S):
9498  * [I] infoPtr : valid pointer to the listview structure
9499  * [I] hdc : device context handle
9500  *
9501  * RETURN:
9502  *   SUCCESS : TRUE
9503  *   FAILURE : FALSE
9504  */
9505 static inline BOOL LISTVIEW_EraseBkgnd(const LISTVIEW_INFO *infoPtr, HDC hdc)
9506 {
9507     RECT rc;
9508
9509     TRACE("(hdc=%p)\n", hdc);
9510
9511     if (!GetClipBox(hdc, &rc)) return FALSE;
9512
9513     if (infoPtr->clrBk == CLR_NONE)
9514     {
9515         if (infoPtr->dwLvExStyle & LVS_EX_TRANSPARENTBKGND)
9516             return SendMessageW(infoPtr->hwndNotify, WM_PRINTCLIENT,
9517                                 (WPARAM)hdc, PRF_ERASEBKGND);
9518         else
9519             return SendMessageW(infoPtr->hwndNotify, WM_ERASEBKGND, (WPARAM)hdc, 0);
9520     }
9521
9522     /* for double buffered controls we need to do this during refresh */
9523     if (infoPtr->dwLvExStyle & LVS_EX_DOUBLEBUFFER) return FALSE;
9524
9525     return LISTVIEW_FillBkgnd(infoPtr, hdc, &rc);
9526 }
9527
9528
9529 /***
9530  * DESCRIPTION:
9531  * Helper function for LISTVIEW_[HV]Scroll *only*.
9532  * Performs vertical/horizontal scrolling by a give amount.
9533  *
9534  * PARAMETER(S):
9535  * [I] infoPtr : valid pointer to the listview structure
9536  * [I] dx : amount of horizontal scroll
9537  * [I] dy : amount of vertical scroll
9538  */
9539 static void scroll_list(LISTVIEW_INFO *infoPtr, INT dx, INT dy)
9540 {
9541     /* now we can scroll the list */
9542     ScrollWindowEx(infoPtr->hwndSelf, dx, dy, &infoPtr->rcList,
9543                    &infoPtr->rcList, 0, 0, SW_ERASE | SW_INVALIDATE);
9544     /* if we have focus, adjust rect */
9545     OffsetRect(&infoPtr->rcFocus, dx, dy);
9546     UpdateWindow(infoPtr->hwndSelf);
9547 }
9548
9549 /***
9550  * DESCRIPTION:
9551  * Performs vertical scrolling.
9552  *
9553  * PARAMETER(S):
9554  * [I] infoPtr : valid pointer to the listview structure
9555  * [I] nScrollCode : scroll code
9556  * [I] nScrollDiff : units to scroll in SB_INTERNAL mode, 0 otherwise
9557  * [I] hScrollWnd  : scrollbar control window handle
9558  *
9559  * RETURN:
9560  * Zero
9561  *
9562  * NOTES:
9563  *   SB_LINEUP/SB_LINEDOWN:
9564  *        for LVS_ICON, LVS_SMALLICON is 37 by experiment
9565  *        for LVS_REPORT is 1 line
9566  *        for LVS_LIST cannot occur
9567  *
9568  */
9569 static LRESULT LISTVIEW_VScroll(LISTVIEW_INFO *infoPtr, INT nScrollCode,
9570                                 INT nScrollDiff)
9571 {
9572     INT nOldScrollPos, nNewScrollPos;
9573     SCROLLINFO scrollInfo;
9574     BOOL is_an_icon;
9575
9576     TRACE("(nScrollCode=%d(%s), nScrollDiff=%d)\n", nScrollCode,
9577         debugscrollcode(nScrollCode), nScrollDiff);
9578
9579     if (infoPtr->hwndEdit) SendMessageW(infoPtr->hwndEdit, WM_KILLFOCUS, 0, 0);
9580
9581     scrollInfo.cbSize = sizeof(SCROLLINFO);
9582     scrollInfo.fMask = SIF_PAGE | SIF_POS | SIF_RANGE | SIF_TRACKPOS;
9583
9584     is_an_icon = ((infoPtr->uView == LV_VIEW_ICON) || (infoPtr->uView == LV_VIEW_SMALLICON));
9585
9586     if (!GetScrollInfo(infoPtr->hwndSelf, SB_VERT, &scrollInfo)) return 1;
9587
9588     nOldScrollPos = scrollInfo.nPos;
9589     switch (nScrollCode)
9590     {
9591     case SB_INTERNAL:
9592         break;
9593
9594     case SB_LINEUP:
9595         nScrollDiff = (is_an_icon) ? -LISTVIEW_SCROLL_ICON_LINE_SIZE : -1;
9596         break;
9597
9598     case SB_LINEDOWN:
9599         nScrollDiff = (is_an_icon) ? LISTVIEW_SCROLL_ICON_LINE_SIZE : 1;
9600         break;
9601
9602     case SB_PAGEUP:
9603         nScrollDiff = -scrollInfo.nPage;
9604         break;
9605
9606     case SB_PAGEDOWN:
9607         nScrollDiff = scrollInfo.nPage;
9608         break;
9609
9610     case SB_THUMBPOSITION:
9611     case SB_THUMBTRACK:
9612         nScrollDiff = scrollInfo.nTrackPos - scrollInfo.nPos;
9613         break;
9614
9615     default:
9616         nScrollDiff = 0;
9617     }
9618
9619     /* quit right away if pos isn't changing */
9620     if (nScrollDiff == 0) return 0;
9621
9622     /* calculate new position, and handle overflows */
9623     nNewScrollPos = scrollInfo.nPos + nScrollDiff;
9624     if (nScrollDiff > 0) {
9625         if (nNewScrollPos < nOldScrollPos ||
9626             nNewScrollPos > scrollInfo.nMax)
9627             nNewScrollPos = scrollInfo.nMax;
9628     } else {
9629         if (nNewScrollPos > nOldScrollPos ||
9630             nNewScrollPos < scrollInfo.nMin)
9631             nNewScrollPos = scrollInfo.nMin;
9632     }
9633
9634     /* set the new position, and reread in case it changed */
9635     scrollInfo.fMask = SIF_POS;
9636     scrollInfo.nPos = nNewScrollPos;
9637     nNewScrollPos = SetScrollInfo(infoPtr->hwndSelf, SB_VERT, &scrollInfo, TRUE);
9638
9639     /* carry on only if it really changed */
9640     if (nNewScrollPos == nOldScrollPos) return 0;
9641
9642     /* now adjust to client coordinates */
9643     nScrollDiff = nOldScrollPos - nNewScrollPos;
9644     if (infoPtr->uView == LV_VIEW_DETAILS) nScrollDiff *= infoPtr->nItemHeight;
9645
9646     /* and scroll the window */
9647     scroll_list(infoPtr, 0, nScrollDiff);
9648
9649     return 0;
9650 }
9651
9652 /***
9653  * DESCRIPTION:
9654  * Performs horizontal scrolling.
9655  *
9656  * PARAMETER(S):
9657  * [I] infoPtr : valid pointer to the listview structure
9658  * [I] nScrollCode : scroll code
9659  * [I] nScrollDiff : units to scroll in SB_INTERNAL mode, 0 otherwise
9660  * [I] hScrollWnd  : scrollbar control window handle
9661  *
9662  * RETURN:
9663  * Zero
9664  *
9665  * NOTES:
9666  *   SB_LINELEFT/SB_LINERIGHT:
9667  *        for LVS_ICON, LVS_SMALLICON  1 pixel
9668  *        for LVS_REPORT is 1 pixel
9669  *        for LVS_LIST  is 1 column --> which is a 1 because the
9670  *                                      scroll is based on columns not pixels
9671  *
9672  */
9673 static LRESULT LISTVIEW_HScroll(LISTVIEW_INFO *infoPtr, INT nScrollCode,
9674                                 INT nScrollDiff)
9675 {
9676     INT nOldScrollPos, nNewScrollPos;
9677     SCROLLINFO scrollInfo;
9678     BOOL is_an_icon;
9679
9680     TRACE("(nScrollCode=%d(%s), nScrollDiff=%d)\n", nScrollCode,
9681         debugscrollcode(nScrollCode), nScrollDiff);
9682
9683     if (infoPtr->hwndEdit) SendMessageW(infoPtr->hwndEdit, WM_KILLFOCUS, 0, 0);
9684
9685     scrollInfo.cbSize = sizeof(SCROLLINFO);
9686     scrollInfo.fMask = SIF_PAGE | SIF_POS | SIF_RANGE | SIF_TRACKPOS;
9687
9688     is_an_icon = ((infoPtr->uView == LV_VIEW_ICON) || (infoPtr->uView == LV_VIEW_SMALLICON));
9689
9690     if (!GetScrollInfo(infoPtr->hwndSelf, SB_HORZ, &scrollInfo)) return 1;
9691
9692     nOldScrollPos = scrollInfo.nPos;
9693
9694     switch (nScrollCode)
9695     {
9696     case SB_INTERNAL:
9697         break;
9698
9699     case SB_LINELEFT:
9700         nScrollDiff = (is_an_icon) ? -LISTVIEW_SCROLL_ICON_LINE_SIZE : -1;
9701         break;
9702
9703     case SB_LINERIGHT:
9704         nScrollDiff = (is_an_icon) ? LISTVIEW_SCROLL_ICON_LINE_SIZE : 1;
9705         break;
9706
9707     case SB_PAGELEFT:
9708         nScrollDiff = -scrollInfo.nPage;
9709         break;
9710
9711     case SB_PAGERIGHT:
9712         nScrollDiff = scrollInfo.nPage;
9713         break;
9714
9715     case SB_THUMBPOSITION:
9716     case SB_THUMBTRACK:
9717         nScrollDiff = scrollInfo.nTrackPos - scrollInfo.nPos;
9718         break;
9719
9720     default:
9721         nScrollDiff = 0;
9722     }
9723
9724     /* quit right away if pos isn't changing */
9725     if (nScrollDiff == 0) return 0;
9726
9727     /* calculate new position, and handle overflows */
9728     nNewScrollPos = scrollInfo.nPos + nScrollDiff;
9729     if (nScrollDiff > 0) {
9730         if (nNewScrollPos < nOldScrollPos ||
9731             nNewScrollPos > scrollInfo.nMax)
9732             nNewScrollPos = scrollInfo.nMax;
9733     } else {
9734         if (nNewScrollPos > nOldScrollPos ||
9735             nNewScrollPos < scrollInfo.nMin)
9736             nNewScrollPos = scrollInfo.nMin;
9737     }
9738
9739     /* set the new position, and reread in case it changed */
9740     scrollInfo.fMask = SIF_POS;
9741     scrollInfo.nPos = nNewScrollPos;
9742     nNewScrollPos = SetScrollInfo(infoPtr->hwndSelf, SB_HORZ, &scrollInfo, TRUE);
9743
9744     /* carry on only if it really changed */
9745     if (nNewScrollPos == nOldScrollPos) return 0;
9746
9747     if (infoPtr->hwndHeader) LISTVIEW_UpdateHeaderSize(infoPtr, nNewScrollPos);
9748
9749     /* now adjust to client coordinates */
9750     nScrollDiff = nOldScrollPos - nNewScrollPos;
9751     if (infoPtr->uView == LV_VIEW_LIST) nScrollDiff *= infoPtr->nItemWidth;
9752
9753     /* and scroll the window */
9754     scroll_list(infoPtr, nScrollDiff, 0);
9755
9756     return 0;
9757 }
9758
9759 static LRESULT LISTVIEW_MouseWheel(LISTVIEW_INFO *infoPtr, INT wheelDelta)
9760 {
9761     INT gcWheelDelta = 0;
9762     INT pulScrollLines = 3;
9763
9764     TRACE("(wheelDelta=%d)\n", wheelDelta);
9765
9766     SystemParametersInfoW(SPI_GETWHEELSCROLLLINES,0, &pulScrollLines, 0);
9767     gcWheelDelta -= wheelDelta;
9768
9769     switch(infoPtr->uView)
9770     {
9771     case LV_VIEW_ICON:
9772     case LV_VIEW_SMALLICON:
9773        /*
9774         *  listview should be scrolled by a multiple of 37 dependently on its dimension or its visible item number
9775         *  should be fixed in the future.
9776         */
9777         LISTVIEW_VScroll(infoPtr, SB_INTERNAL, (gcWheelDelta < 0) ?
9778                 -LISTVIEW_SCROLL_ICON_LINE_SIZE : LISTVIEW_SCROLL_ICON_LINE_SIZE);
9779         break;
9780
9781     case LV_VIEW_DETAILS:
9782         if (abs(gcWheelDelta) >= WHEEL_DELTA && pulScrollLines)
9783         {
9784             int cLineScroll = min(LISTVIEW_GetCountPerColumn(infoPtr), pulScrollLines);
9785             cLineScroll *= (gcWheelDelta / WHEEL_DELTA);
9786             LISTVIEW_VScroll(infoPtr, SB_INTERNAL, cLineScroll);
9787         }
9788         break;
9789
9790     case LV_VIEW_LIST:
9791         LISTVIEW_HScroll(infoPtr, (gcWheelDelta < 0) ? SB_LINELEFT : SB_LINERIGHT, 0);
9792         break;
9793     }
9794     return 0;
9795 }
9796
9797 /***
9798  * DESCRIPTION:
9799  * ???
9800  *
9801  * PARAMETER(S):
9802  * [I] infoPtr : valid pointer to the listview structure
9803  * [I] nVirtualKey : virtual key
9804  * [I] lKeyData : key data
9805  *
9806  * RETURN:
9807  * Zero
9808  */
9809 static LRESULT LISTVIEW_KeyDown(LISTVIEW_INFO *infoPtr, INT nVirtualKey, LONG lKeyData)
9810 {
9811   HWND hwndSelf = infoPtr->hwndSelf;
9812   INT nItem = -1;
9813   NMLVKEYDOWN nmKeyDown;
9814
9815   TRACE("(nVirtualKey=%d, lKeyData=%d)\n", nVirtualKey, lKeyData);
9816
9817   /* send LVN_KEYDOWN notification */
9818   nmKeyDown.wVKey = nVirtualKey;
9819   nmKeyDown.flags = 0;
9820   notify_hdr(infoPtr, LVN_KEYDOWN, &nmKeyDown.hdr);
9821   if (!IsWindow(hwndSelf))
9822     return 0;
9823
9824   switch (nVirtualKey)
9825   {
9826   case VK_SPACE:
9827     nItem = infoPtr->nFocusedItem;
9828     if (infoPtr->dwLvExStyle & LVS_EX_CHECKBOXES)
9829         toggle_checkbox_state(infoPtr, infoPtr->nFocusedItem);
9830     break;
9831
9832   case VK_RETURN:
9833     if ((infoPtr->nItemCount > 0) && (infoPtr->nFocusedItem != -1))
9834     {
9835         if (!notify(infoPtr, NM_RETURN)) return 0;
9836         if (!notify(infoPtr, LVN_ITEMACTIVATE)) return 0;
9837     }
9838     break;
9839
9840   case VK_HOME:
9841     if (infoPtr->nItemCount > 0)
9842       nItem = 0;
9843     break;
9844
9845   case VK_END:
9846     if (infoPtr->nItemCount > 0)
9847       nItem = infoPtr->nItemCount - 1;
9848     break;
9849
9850   case VK_LEFT:
9851     nItem = LISTVIEW_GetNextItem(infoPtr, infoPtr->nFocusedItem, LVNI_TOLEFT);
9852     break;
9853
9854   case VK_UP:
9855     nItem = LISTVIEW_GetNextItem(infoPtr, infoPtr->nFocusedItem, LVNI_ABOVE);
9856     break;
9857
9858   case VK_RIGHT:
9859     nItem = LISTVIEW_GetNextItem(infoPtr, infoPtr->nFocusedItem, LVNI_TORIGHT);
9860     break;
9861
9862   case VK_DOWN:
9863     nItem = LISTVIEW_GetNextItem(infoPtr, infoPtr->nFocusedItem, LVNI_BELOW);
9864     break;
9865
9866   case VK_PRIOR:
9867     if (infoPtr->uView == LV_VIEW_DETAILS)
9868     {
9869       INT topidx = LISTVIEW_GetTopIndex(infoPtr);
9870       if (infoPtr->nFocusedItem == topidx)
9871         nItem = topidx - LISTVIEW_GetCountPerColumn(infoPtr) + 1;
9872       else
9873         nItem = topidx;
9874     }
9875     else
9876       nItem = infoPtr->nFocusedItem - LISTVIEW_GetCountPerColumn(infoPtr)
9877                                     * LISTVIEW_GetCountPerRow(infoPtr);
9878     if(nItem < 0) nItem = 0;
9879     break;
9880
9881   case VK_NEXT:
9882     if (infoPtr->uView == LV_VIEW_DETAILS)
9883     {
9884       INT topidx = LISTVIEW_GetTopIndex(infoPtr);
9885       INT cnt = LISTVIEW_GetCountPerColumn(infoPtr);
9886       if (infoPtr->nFocusedItem == topidx + cnt - 1)
9887         nItem = infoPtr->nFocusedItem + cnt - 1;
9888       else
9889         nItem = topidx + cnt - 1;
9890     }
9891     else
9892       nItem = infoPtr->nFocusedItem + LISTVIEW_GetCountPerColumn(infoPtr)
9893                                     * LISTVIEW_GetCountPerRow(infoPtr);
9894     if(nItem >= infoPtr->nItemCount) nItem = infoPtr->nItemCount - 1;
9895     break;
9896   }
9897
9898   if ((nItem != -1) && (nItem != infoPtr->nFocusedItem || nVirtualKey == VK_SPACE))
9899       LISTVIEW_KeySelection(infoPtr, nItem, nVirtualKey == VK_SPACE);
9900
9901   return 0;
9902 }
9903
9904 /***
9905  * DESCRIPTION:
9906  * Kills the focus.
9907  *
9908  * PARAMETER(S):
9909  * [I] infoPtr : valid pointer to the listview structure
9910  *
9911  * RETURN:
9912  * Zero
9913  */
9914 static LRESULT LISTVIEW_KillFocus(LISTVIEW_INFO *infoPtr)
9915 {
9916     TRACE("()\n");
9917
9918     /* if we did not have the focus, there's nothing to do */
9919     if (!infoPtr->bFocus) return 0;
9920
9921     /* send NM_KILLFOCUS notification */
9922     if (!notify(infoPtr, NM_KILLFOCUS)) return 0;
9923
9924     /* if we have a focus rectangle, get rid of it */
9925     LISTVIEW_ShowFocusRect(infoPtr, FALSE);
9926
9927     /* if have a marquee selection, stop it */
9928     if (infoPtr->bMarqueeSelect)
9929     {
9930         /* Remove the marquee rectangle and release our mouse capture */
9931         LISTVIEW_InvalidateRect(infoPtr, &infoPtr->marqueeRect);
9932         ReleaseCapture();
9933
9934         SetRect(&infoPtr->marqueeRect, 0, 0, 0, 0);
9935
9936         infoPtr->bMarqueeSelect = FALSE;
9937         infoPtr->bScrolling = FALSE;
9938         KillTimer(infoPtr->hwndSelf, (UINT_PTR) infoPtr);
9939     }
9940
9941     /* set window focus flag */
9942     infoPtr->bFocus = FALSE;
9943
9944     /* invalidate the selected items before resetting focus flag */
9945     LISTVIEW_InvalidateSelectedItems(infoPtr);
9946
9947     return 0;
9948 }
9949
9950 /***
9951  * DESCRIPTION:
9952  * Processes double click messages (left mouse button).
9953  *
9954  * PARAMETER(S):
9955  * [I] infoPtr : valid pointer to the listview structure
9956  * [I] wKey : key flag
9957  * [I] x,y : mouse coordinate
9958  *
9959  * RETURN:
9960  * Zero
9961  */
9962 static LRESULT LISTVIEW_LButtonDblClk(LISTVIEW_INFO *infoPtr, WORD wKey, INT x, INT y)
9963 {
9964     LVHITTESTINFO htInfo;
9965
9966     TRACE("(key=%hu, X=%u, Y=%u)\n", wKey, x, y);
9967
9968     /* Cancel the item edition if any */
9969     if (infoPtr->itemEdit.fEnabled)
9970     {
9971       KillTimer(infoPtr->hwndSelf, (UINT_PTR)&infoPtr->itemEdit);
9972       infoPtr->itemEdit.fEnabled = FALSE;
9973     }
9974
9975     /* send NM_RELEASEDCAPTURE notification */
9976     if (!notify(infoPtr, NM_RELEASEDCAPTURE)) return 0;
9977
9978     htInfo.pt.x = x;
9979     htInfo.pt.y = y;
9980
9981     /* send NM_DBLCLK notification */
9982     LISTVIEW_HitTest(infoPtr, &htInfo, TRUE, FALSE);
9983     if (!notify_click(infoPtr, NM_DBLCLK, &htInfo)) return 0;
9984
9985     /* To send the LVN_ITEMACTIVATE, it must be on an Item */
9986     if(htInfo.iItem != -1) notify_itemactivate(infoPtr,&htInfo);
9987
9988     return 0;
9989 }
9990
9991 /***
9992  * DESCRIPTION:
9993  * Processes mouse down messages (left mouse button).
9994  *
9995  * PARAMETERS:
9996  *   infoPtr  [I ] valid pointer to the listview structure
9997  *   wKey     [I ] key flag
9998  *   x,y      [I ] mouse coordinate
9999  *
10000  * RETURN:
10001  *   Zero
10002  */
10003 static LRESULT LISTVIEW_LButtonDown(LISTVIEW_INFO *infoPtr, WORD wKey, INT x, INT y)
10004 {
10005   LVHITTESTINFO lvHitTestInfo;
10006   static BOOL bGroupSelect = TRUE;
10007   POINT pt = { x, y };
10008   INT nItem;
10009
10010   TRACE("(key=%hu, X=%u, Y=%u)\n", wKey, x, y);
10011
10012   /* send NM_RELEASEDCAPTURE notification */
10013   if (!notify(infoPtr, NM_RELEASEDCAPTURE)) return 0;
10014
10015   /* set left button down flag and record the click position */
10016   infoPtr->bLButtonDown = TRUE;
10017   infoPtr->ptClickPos = pt;
10018   infoPtr->bDragging = FALSE;
10019   infoPtr->bMarqueeSelect = FALSE;
10020   infoPtr->bScrolling = FALSE;
10021
10022   lvHitTestInfo.pt.x = x;
10023   lvHitTestInfo.pt.y = y;
10024
10025   nItem = LISTVIEW_HitTest(infoPtr, &lvHitTestInfo, TRUE, TRUE);
10026   TRACE("at %s, nItem=%d\n", wine_dbgstr_point(&pt), nItem);
10027   if ((nItem >= 0) && (nItem < infoPtr->nItemCount))
10028   {
10029     if ((infoPtr->dwLvExStyle & LVS_EX_CHECKBOXES) && (lvHitTestInfo.flags & LVHT_ONITEMSTATEICON))
10030     {
10031         toggle_checkbox_state(infoPtr, nItem);
10032         return 0;
10033     }
10034
10035     if (infoPtr->dwStyle & LVS_SINGLESEL)
10036     {
10037       if (LISTVIEW_GetItemState(infoPtr, nItem, LVIS_SELECTED))
10038         infoPtr->nEditLabelItem = nItem;
10039       else
10040         LISTVIEW_SetSelection(infoPtr, nItem);
10041     }
10042     else
10043     {
10044       if ((wKey & MK_CONTROL) && (wKey & MK_SHIFT))
10045       {
10046         if (bGroupSelect)
10047         {
10048           if (!LISTVIEW_AddGroupSelection(infoPtr, nItem)) return 0;
10049           LISTVIEW_SetItemFocus(infoPtr, nItem);
10050           infoPtr->nSelectionMark = nItem;
10051         }
10052         else
10053         {
10054           LVITEMW item;
10055
10056           item.state = LVIS_SELECTED | LVIS_FOCUSED;
10057           item.stateMask = LVIS_SELECTED | LVIS_FOCUSED;
10058
10059           LISTVIEW_SetItemState(infoPtr,nItem,&item);
10060           infoPtr->nSelectionMark = nItem;
10061         }
10062       }
10063       else if (wKey & MK_CONTROL)
10064       {
10065         LVITEMW item;
10066
10067         bGroupSelect = (LISTVIEW_GetItemState(infoPtr, nItem, LVIS_SELECTED) == 0);
10068
10069         item.state = (bGroupSelect ? LVIS_SELECTED : 0) | LVIS_FOCUSED;
10070         item.stateMask = LVIS_SELECTED | LVIS_FOCUSED;
10071         LISTVIEW_SetItemState(infoPtr, nItem, &item);
10072         infoPtr->nSelectionMark = nItem;
10073       }
10074       else  if (wKey & MK_SHIFT)
10075       {
10076         LISTVIEW_SetGroupSelection(infoPtr, nItem);
10077       }
10078       else
10079       {
10080         if (LISTVIEW_GetItemState(infoPtr, nItem, LVIS_SELECTED))
10081         {
10082           infoPtr->nEditLabelItem = nItem;
10083           infoPtr->nLButtonDownItem = nItem;
10084
10085           LISTVIEW_SetItemFocus(infoPtr, nItem);
10086         }
10087         else
10088           /* set selection (clears other pre-existing selections) */
10089           LISTVIEW_SetSelection(infoPtr, nItem);
10090       }
10091     }
10092
10093     if (infoPtr->dwLvExStyle & LVS_EX_ONECLICKACTIVATE)
10094         if(lvHitTestInfo.iItem != -1) notify_itemactivate(infoPtr,&lvHitTestInfo);
10095   }
10096   else
10097   {
10098     if (!infoPtr->bFocus)
10099         SetFocus(infoPtr->hwndSelf);
10100
10101     /* remove all selections */
10102     if (!(wKey & MK_CONTROL) && !(wKey & MK_SHIFT))
10103         LISTVIEW_DeselectAll(infoPtr);
10104     ReleaseCapture();
10105   }
10106
10107   return 0;
10108 }
10109
10110 /***
10111  * DESCRIPTION:
10112  * Processes mouse up messages (left mouse button).
10113  *
10114  * PARAMETERS:
10115  *   infoPtr [I ] valid pointer to the listview structure
10116  *   wKey    [I ] key flag
10117  *   x,y     [I ] mouse coordinate
10118  *
10119  * RETURN:
10120  *   Zero
10121  */
10122 static LRESULT LISTVIEW_LButtonUp(LISTVIEW_INFO *infoPtr, WORD wKey, INT x, INT y)
10123 {
10124     LVHITTESTINFO lvHitTestInfo;
10125
10126     TRACE("(key=%hu, X=%u, Y=%u)\n", wKey, x, y);
10127
10128     if (!infoPtr->bLButtonDown) return 0;
10129
10130     lvHitTestInfo.pt.x = x;
10131     lvHitTestInfo.pt.y = y;
10132
10133     /* send NM_CLICK notification */
10134     LISTVIEW_HitTest(infoPtr, &lvHitTestInfo, TRUE, FALSE);
10135     if (!notify_click(infoPtr, NM_CLICK, &lvHitTestInfo)) return 0;
10136
10137     /* set left button flag */
10138     infoPtr->bLButtonDown = FALSE;
10139
10140     /* set a single selection, reset others */
10141     if(lvHitTestInfo.iItem == infoPtr->nLButtonDownItem && lvHitTestInfo.iItem != -1)
10142         LISTVIEW_SetSelection(infoPtr, infoPtr->nLButtonDownItem);
10143     infoPtr->nLButtonDownItem = -1;
10144
10145     if (infoPtr->bDragging || infoPtr->bMarqueeSelect)
10146     {
10147         /* Remove the marquee rectangle and release our mouse capture */
10148         if (infoPtr->bMarqueeSelect)
10149         {
10150             LISTVIEW_InvalidateRect(infoPtr, &infoPtr->marqueeDrawRect);
10151             ReleaseCapture();
10152         }
10153
10154         SetRect(&infoPtr->marqueeRect, 0, 0, 0, 0);
10155         SetRect(&infoPtr->marqueeDrawRect, 0, 0, 0, 0);
10156
10157         infoPtr->bDragging = FALSE;
10158         infoPtr->bMarqueeSelect = FALSE;
10159         infoPtr->bScrolling = FALSE;
10160
10161         KillTimer(infoPtr->hwndSelf, (UINT_PTR) infoPtr);
10162         return 0;
10163     }
10164
10165     /* if we clicked on a selected item, edit the label */
10166     if(lvHitTestInfo.iItem == infoPtr->nEditLabelItem && (lvHitTestInfo.flags & LVHT_ONITEMLABEL))
10167     {
10168         /* we want to make sure the user doesn't want to do a double click. So we will
10169          * delay the edit. WM_LBUTTONDBLCLICK will cancel the timer
10170          */
10171         infoPtr->itemEdit.fEnabled = TRUE;
10172         infoPtr->itemEdit.iItem = lvHitTestInfo.iItem;
10173         SetTimer(infoPtr->hwndSelf,
10174             (UINT_PTR)&infoPtr->itemEdit,
10175             GetDoubleClickTime(),
10176             LISTVIEW_DelayedEditItem);
10177     }
10178
10179     if (!infoPtr->bFocus)
10180         SetFocus(infoPtr->hwndSelf);
10181
10182     return 0;
10183 }
10184
10185 /***
10186  * DESCRIPTION:
10187  * Destroys the listview control (called after WM_DESTROY).
10188  *
10189  * PARAMETER(S):
10190  * [I] infoPtr : valid pointer to the listview structure
10191  *
10192  * RETURN:
10193  * Zero
10194  */
10195 static LRESULT LISTVIEW_NCDestroy(LISTVIEW_INFO *infoPtr)
10196 {
10197   INT i;
10198
10199   TRACE("()\n");
10200
10201   /* destroy data structure */
10202   DPA_Destroy(infoPtr->hdpaItems);
10203   DPA_Destroy(infoPtr->hdpaItemIds);
10204   DPA_Destroy(infoPtr->hdpaPosX);
10205   DPA_Destroy(infoPtr->hdpaPosY);
10206   /* columns */
10207   for (i = 0; i < DPA_GetPtrCount(infoPtr->hdpaColumns); i++)
10208       Free(DPA_GetPtr(infoPtr->hdpaColumns, i));
10209   DPA_Destroy(infoPtr->hdpaColumns);
10210   ranges_destroy(infoPtr->selectionRanges);
10211
10212   /* destroy image lists */
10213   if (!(infoPtr->dwStyle & LVS_SHAREIMAGELISTS))
10214   {
10215       ImageList_Destroy(infoPtr->himlNormal);
10216       ImageList_Destroy(infoPtr->himlSmall);
10217       ImageList_Destroy(infoPtr->himlState);
10218   }
10219
10220   /* destroy font, bkgnd brush */
10221   infoPtr->hFont = 0;
10222   if (infoPtr->hDefaultFont) DeleteObject(infoPtr->hDefaultFont);
10223   if (infoPtr->clrBk != CLR_NONE) DeleteObject(infoPtr->hBkBrush);
10224
10225   SetWindowLongPtrW(infoPtr->hwndSelf, 0, 0);
10226
10227   /* free listview info pointer*/
10228   Free(infoPtr);
10229
10230   return 0;
10231 }
10232
10233 /***
10234  * DESCRIPTION:
10235  * Handles notifications.
10236  *
10237  * PARAMETER(S):
10238  * [I] infoPtr : valid pointer to the listview structure
10239  * [I] lpnmhdr : notification information
10240  *
10241  * RETURN:
10242  * Zero
10243  */
10244 static LRESULT LISTVIEW_Notify(LISTVIEW_INFO *infoPtr, NMHDR *lpnmhdr)
10245 {
10246     NMHEADERW *lpnmh;
10247
10248     TRACE("(lpnmhdr=%p)\n", lpnmhdr);
10249
10250     if (!lpnmhdr || lpnmhdr->hwndFrom != infoPtr->hwndHeader) return 0;
10251
10252     /* remember: HDN_LAST < HDN_FIRST */
10253     if (lpnmhdr->code > HDN_FIRST || lpnmhdr->code < HDN_LAST) return 0;
10254     lpnmh = (NMHEADERW *)lpnmhdr;
10255
10256     if (lpnmh->iItem < 0 || lpnmh->iItem >= DPA_GetPtrCount(infoPtr->hdpaColumns)) return 0;
10257
10258     switch (lpnmhdr->code)
10259     {
10260         case HDN_TRACKW:
10261         case HDN_TRACKA:
10262         {
10263             COLUMN_INFO *lpColumnInfo;
10264             POINT ptOrigin;
10265             INT x;
10266
10267             if (!lpnmh->pitem || !(lpnmh->pitem->mask & HDI_WIDTH))
10268                 break;
10269
10270             /* remove the old line (if any) */
10271             LISTVIEW_DrawTrackLine(infoPtr);
10272
10273             /* compute & draw the new line */
10274             lpColumnInfo = LISTVIEW_GetColumnInfo(infoPtr, lpnmh->iItem);
10275             x = lpColumnInfo->rcHeader.left + lpnmh->pitem->cxy;
10276             LISTVIEW_GetOrigin(infoPtr, &ptOrigin);
10277             infoPtr->xTrackLine = x + ptOrigin.x;
10278             LISTVIEW_DrawTrackLine(infoPtr);
10279             return notify_forward_header(infoPtr, lpnmh);
10280         }
10281
10282         case HDN_ENDTRACKA:
10283         case HDN_ENDTRACKW:
10284             /* remove the track line (if any) */
10285             LISTVIEW_DrawTrackLine(infoPtr);
10286             infoPtr->xTrackLine = -1;
10287             return notify_forward_header(infoPtr, lpnmh);
10288
10289         case HDN_BEGINDRAG:
10290             if ((infoPtr->dwLvExStyle & LVS_EX_HEADERDRAGDROP) == 0) return 1;
10291             return notify_forward_header(infoPtr, lpnmh);
10292
10293         case HDN_ENDDRAG:
10294             infoPtr->colRectsDirty = TRUE;
10295             LISTVIEW_InvalidateList(infoPtr);
10296             return notify_forward_header(infoPtr, lpnmh);
10297
10298         case HDN_ITEMCHANGEDW:
10299         case HDN_ITEMCHANGEDA:
10300         {
10301             COLUMN_INFO *lpColumnInfo;
10302             HDITEMW hdi;
10303             INT dx, cxy;
10304
10305             if (!lpnmh->pitem || !(lpnmh->pitem->mask & HDI_WIDTH))
10306             {
10307                 hdi.mask = HDI_WIDTH;
10308                 if (!SendMessageW(infoPtr->hwndHeader, HDM_GETITEMW, lpnmh->iItem, (LPARAM)&hdi)) return 0;
10309                 cxy = hdi.cxy;
10310             }
10311             else
10312                 cxy = lpnmh->pitem->cxy;
10313
10314             /* determine how much we change since the last know position */
10315             lpColumnInfo = LISTVIEW_GetColumnInfo(infoPtr, lpnmh->iItem);
10316             dx = cxy - (lpColumnInfo->rcHeader.right - lpColumnInfo->rcHeader.left);
10317             if (dx != 0)
10318             {
10319                 lpColumnInfo->rcHeader.right += dx;
10320
10321                 hdi.mask = HDI_ORDER;
10322                 SendMessageW(infoPtr->hwndHeader, HDM_GETITEMW, lpnmh->iItem, (LPARAM)&hdi);
10323
10324                 /* not the rightmost one */
10325                 if (hdi.iOrder + 1 < DPA_GetPtrCount(infoPtr->hdpaColumns))
10326                 {
10327                     INT nIndex = SendMessageW(infoPtr->hwndHeader, HDM_ORDERTOINDEX,
10328                                               hdi.iOrder + 1, 0);
10329                     LISTVIEW_ScrollColumns(infoPtr, nIndex, dx);
10330                 }
10331                 else
10332                 {
10333                     /* only needs to update the scrolls */
10334                     infoPtr->nItemWidth += dx;
10335                     LISTVIEW_UpdateScroll(infoPtr);
10336                 }
10337                 LISTVIEW_UpdateItemSize(infoPtr);
10338                 if (infoPtr->uView == LV_VIEW_DETAILS && is_redrawing(infoPtr))
10339                 {
10340                     POINT ptOrigin;
10341                     RECT rcCol = lpColumnInfo->rcHeader;
10342
10343                     LISTVIEW_GetOrigin(infoPtr, &ptOrigin);
10344                     OffsetRect(&rcCol, ptOrigin.x, 0);
10345
10346                     rcCol.top = infoPtr->rcList.top;
10347                     rcCol.bottom = infoPtr->rcList.bottom;
10348
10349                     /* resizing left-aligned columns leaves most of the left side untouched */
10350                     if ((lpColumnInfo->fmt & LVCFMT_JUSTIFYMASK) == LVCFMT_LEFT)
10351                     {
10352                         INT nMaxDirty = infoPtr->nEllipsisWidth + infoPtr->ntmMaxCharWidth;
10353                         if (dx > 0)
10354                             nMaxDirty += dx;
10355                         rcCol.left = max (rcCol.left, rcCol.right - nMaxDirty);
10356                     }
10357
10358                     /* when shrinking the last column clear the now unused field */
10359                     if (hdi.iOrder == DPA_GetPtrCount(infoPtr->hdpaColumns) - 1)
10360                     {
10361                         RECT right;
10362
10363                         rcCol.right -= dx;
10364
10365                         /* deal with right from rightmost column area */
10366                         right.left = rcCol.right;
10367                         right.top  = rcCol.top;
10368                         right.bottom = rcCol.bottom;
10369                         right.right = infoPtr->rcList.right;
10370
10371                         LISTVIEW_InvalidateRect(infoPtr, &right);
10372                     }
10373
10374                     LISTVIEW_InvalidateRect(infoPtr, &rcCol);
10375                 }
10376             }
10377             break;
10378         }
10379
10380         case HDN_ITEMCLICKW:
10381         case HDN_ITEMCLICKA:
10382         {
10383             /* Handle sorting by Header Column */
10384             NMLISTVIEW nmlv;
10385
10386             ZeroMemory(&nmlv, sizeof(NMLISTVIEW));
10387             nmlv.iItem = -1;
10388             nmlv.iSubItem = lpnmh->iItem;
10389             notify_listview(infoPtr, LVN_COLUMNCLICK, &nmlv);
10390             return notify_forward_header(infoPtr, lpnmh);
10391         }
10392
10393         case HDN_DIVIDERDBLCLICKW:
10394         case HDN_DIVIDERDBLCLICKA:
10395             /* FIXME: for LVS_EX_HEADERINALLVIEWS and not LV_VIEW_DETAILS
10396                       we should use LVSCW_AUTOSIZE_USEHEADER, helper rework or
10397                       split needed for that */
10398             LISTVIEW_SetColumnWidth(infoPtr, lpnmh->iItem, LVSCW_AUTOSIZE);
10399             return notify_forward_header(infoPtr, lpnmh);
10400     }
10401     return 0;
10402 }
10403
10404 /***
10405  * DESCRIPTION:
10406  * Paint non-client area of control.
10407  *
10408  * PARAMETER(S):
10409  * [I] infoPtr : valid pointer to the listview structureof the sender
10410  * [I] region : update region
10411  *
10412  * RETURN:
10413  *  TRUE  - frame was painted
10414  *  FALSE - call default window proc
10415  */
10416 static BOOL LISTVIEW_NCPaint(const LISTVIEW_INFO *infoPtr, HRGN region)
10417 {
10418     HTHEME theme = GetWindowTheme (infoPtr->hwndSelf);
10419     HDC dc;
10420     RECT r;
10421     HRGN cliprgn;
10422     int cxEdge = GetSystemMetrics (SM_CXEDGE),
10423         cyEdge = GetSystemMetrics (SM_CYEDGE);
10424
10425     if (!theme)
10426        return DefWindowProcW (infoPtr->hwndSelf, WM_NCPAINT, (WPARAM)region, 0);
10427
10428     GetWindowRect(infoPtr->hwndSelf, &r);
10429
10430     cliprgn = CreateRectRgn (r.left + cxEdge, r.top + cyEdge,
10431         r.right - cxEdge, r.bottom - cyEdge);
10432     if (region != (HRGN)1)
10433         CombineRgn (cliprgn, cliprgn, region, RGN_AND);
10434     OffsetRect(&r, -r.left, -r.top);
10435
10436     dc = GetDCEx(infoPtr->hwndSelf, region, DCX_WINDOW|DCX_INTERSECTRGN);
10437     OffsetRect(&r, -r.left, -r.top);
10438
10439     if (IsThemeBackgroundPartiallyTransparent (theme, 0, 0))
10440         DrawThemeParentBackground(infoPtr->hwndSelf, dc, &r);
10441     DrawThemeBackground (theme, dc, 0, 0, &r, 0);
10442     ReleaseDC(infoPtr->hwndSelf, dc);
10443
10444     /* Call default proc to get the scrollbars etc. painted */
10445     DefWindowProcW (infoPtr->hwndSelf, WM_NCPAINT, (WPARAM)cliprgn, 0);
10446
10447     return FALSE;
10448 }
10449
10450 /***
10451  * DESCRIPTION:
10452  * Determines the type of structure to use.
10453  *
10454  * PARAMETER(S):
10455  * [I] infoPtr : valid pointer to the listview structureof the sender
10456  * [I] hwndFrom : listview window handle
10457  * [I] nCommand : command specifying the nature of the WM_NOTIFYFORMAT
10458  *
10459  * RETURN:
10460  * Zero
10461  */
10462 static LRESULT LISTVIEW_NotifyFormat(LISTVIEW_INFO *infoPtr, HWND hwndFrom, INT nCommand)
10463 {
10464     TRACE("(hwndFrom=%p, nCommand=%d)\n", hwndFrom, nCommand);
10465
10466     if (nCommand == NF_REQUERY)
10467         infoPtr->notifyFormat = SendMessageW(infoPtr->hwndNotify, WM_NOTIFYFORMAT, (WPARAM)infoPtr->hwndSelf, NF_QUERY);
10468
10469     return infoPtr->notifyFormat;
10470 }
10471
10472 /***
10473  * DESCRIPTION:
10474  * Paints/Repaints the listview control. Internal use.
10475  *
10476  * PARAMETER(S):
10477  * [I] infoPtr : valid pointer to the listview structure
10478  * [I] hdc : device context handle
10479  *
10480  * RETURN:
10481  * Zero
10482  */
10483 static LRESULT LISTVIEW_Paint(LISTVIEW_INFO *infoPtr, HDC hdc)
10484 {
10485     TRACE("(hdc=%p)\n", hdc);
10486
10487     if (infoPtr->bNoItemMetrics && infoPtr->nItemCount)
10488     {
10489         infoPtr->bNoItemMetrics = FALSE;
10490         LISTVIEW_UpdateItemSize(infoPtr);
10491         if (infoPtr->uView == LV_VIEW_ICON || infoPtr->uView == LV_VIEW_SMALLICON)
10492             LISTVIEW_Arrange(infoPtr, LVA_DEFAULT);
10493         LISTVIEW_UpdateScroll(infoPtr);
10494     }
10495
10496     if (infoPtr->hwndHeader)  UpdateWindow(infoPtr->hwndHeader);
10497
10498     if (hdc)
10499         LISTVIEW_Refresh(infoPtr, hdc, NULL);
10500     else
10501     {
10502         PAINTSTRUCT ps;
10503
10504         hdc = BeginPaint(infoPtr->hwndSelf, &ps);
10505         if (!hdc) return 1;
10506         LISTVIEW_Refresh(infoPtr, hdc, ps.fErase ? &ps.rcPaint : NULL);
10507         EndPaint(infoPtr->hwndSelf, &ps);
10508     }
10509
10510     return 0;
10511 }
10512
10513 /***
10514  * DESCRIPTION:
10515  * Paints/Repaints the listview control, WM_PAINT handler.
10516  *
10517  * PARAMETER(S):
10518  * [I] infoPtr : valid pointer to the listview structure
10519  * [I] hdc : device context handle
10520  *
10521  * RETURN:
10522  * Zero
10523  */
10524 static inline LRESULT LISTVIEW_WMPaint(LISTVIEW_INFO *infoPtr, HDC hdc)
10525 {
10526     TRACE("(hdc=%p)\n", hdc);
10527
10528     if (!is_redrawing(infoPtr))
10529         return DefWindowProcW (infoPtr->hwndSelf, WM_PAINT, (WPARAM)hdc, 0);
10530
10531     return LISTVIEW_Paint(infoPtr, hdc);
10532 }
10533
10534 /***
10535  * DESCRIPTION:
10536  * Paints/Repaints the listview control.
10537  *
10538  * PARAMETER(S):
10539  * [I] infoPtr : valid pointer to the listview structure
10540  * [I] hdc : device context handle
10541  * [I] options : drawing options
10542  *
10543  * RETURN:
10544  * Zero
10545  */
10546 static LRESULT LISTVIEW_PrintClient(LISTVIEW_INFO *infoPtr, HDC hdc, DWORD options)
10547 {
10548     FIXME("Partial Stub: (hdc=%p options=0x%08x)\n", hdc, options);
10549
10550     if ((options & PRF_CHECKVISIBLE) && !IsWindowVisible(infoPtr->hwndSelf))
10551         return 0;
10552
10553     if (options & PRF_ERASEBKGND)
10554         LISTVIEW_EraseBkgnd(infoPtr, hdc);
10555
10556     if (options & PRF_CLIENT)
10557         LISTVIEW_Paint(infoPtr, hdc);
10558
10559     return 0;
10560 }
10561
10562
10563 /***
10564  * DESCRIPTION:
10565  * Processes double click messages (right mouse button).
10566  *
10567  * PARAMETER(S):
10568  * [I] infoPtr : valid pointer to the listview structure
10569  * [I] wKey : key flag
10570  * [I] x,y : mouse coordinate
10571  *
10572  * RETURN:
10573  * Zero
10574  */
10575 static LRESULT LISTVIEW_RButtonDblClk(const LISTVIEW_INFO *infoPtr, WORD wKey, INT x, INT y)
10576 {
10577     LVHITTESTINFO lvHitTestInfo;
10578
10579     TRACE("(key=%hu,X=%u,Y=%u)\n", wKey, x, y);
10580
10581     /* send NM_RELEASEDCAPTURE notification */
10582     if (!notify(infoPtr, NM_RELEASEDCAPTURE)) return 0;
10583
10584     /* send NM_RDBLCLK notification */
10585     lvHitTestInfo.pt.x = x;
10586     lvHitTestInfo.pt.y = y;
10587     LISTVIEW_HitTest(infoPtr, &lvHitTestInfo, TRUE, FALSE);
10588     notify_click(infoPtr, NM_RDBLCLK, &lvHitTestInfo);
10589
10590     return 0;
10591 }
10592
10593 /***
10594  * DESCRIPTION:
10595  * Processes mouse down messages (right mouse button).
10596  *
10597  * PARAMETER(S):
10598  * [I] infoPtr : valid pointer to the listview structure
10599  * [I] wKey : key flag
10600  * [I] x,y : mouse coordinate
10601  *
10602  * RETURN:
10603  * Zero
10604  */
10605 static LRESULT LISTVIEW_RButtonDown(LISTVIEW_INFO *infoPtr, WORD wKey, INT x, INT y)
10606 {
10607     LVHITTESTINFO lvHitTestInfo;
10608     INT nItem;
10609
10610     TRACE("(key=%hu,X=%u,Y=%u)\n", wKey, x, y);
10611
10612     /* send NM_RELEASEDCAPTURE notification */
10613     if (!notify(infoPtr, NM_RELEASEDCAPTURE)) return 0;
10614
10615     /* make sure the listview control window has the focus */
10616     if (!infoPtr->bFocus) SetFocus(infoPtr->hwndSelf);
10617
10618     /* set right button down flag */
10619     infoPtr->bRButtonDown = TRUE;
10620
10621     /* determine the index of the selected item */
10622     lvHitTestInfo.pt.x = x;
10623     lvHitTestInfo.pt.y = y;
10624     nItem = LISTVIEW_HitTest(infoPtr, &lvHitTestInfo, TRUE, TRUE);
10625
10626     if ((nItem >= 0) && (nItem < infoPtr->nItemCount))
10627     {
10628         LISTVIEW_SetItemFocus(infoPtr, nItem);
10629         if (!((wKey & MK_SHIFT) || (wKey & MK_CONTROL)) &&
10630             !LISTVIEW_GetItemState(infoPtr, nItem, LVIS_SELECTED))
10631             LISTVIEW_SetSelection(infoPtr, nItem);
10632     }
10633     else
10634     {
10635         LISTVIEW_DeselectAll(infoPtr);
10636     }
10637
10638     return 0;
10639 }
10640
10641 /***
10642  * DESCRIPTION:
10643  * Processes mouse up messages (right mouse button).
10644  *
10645  * PARAMETER(S):
10646  * [I] infoPtr : valid pointer to the listview structure
10647  * [I] wKey : key flag
10648  * [I] x,y : mouse coordinate
10649  *
10650  * RETURN:
10651  * Zero
10652  */
10653 static LRESULT LISTVIEW_RButtonUp(LISTVIEW_INFO *infoPtr, WORD wKey, INT x, INT y)
10654 {
10655     LVHITTESTINFO lvHitTestInfo;
10656     POINT pt;
10657
10658     TRACE("(key=%hu,X=%u,Y=%u)\n", wKey, x, y);
10659
10660     if (!infoPtr->bRButtonDown) return 0;
10661
10662     /* set button flag */
10663     infoPtr->bRButtonDown = FALSE;
10664
10665     /* Send NM_RCLICK notification */
10666     lvHitTestInfo.pt.x = x;
10667     lvHitTestInfo.pt.y = y;
10668     LISTVIEW_HitTest(infoPtr, &lvHitTestInfo, TRUE, FALSE);
10669     if (!notify_click(infoPtr, NM_RCLICK, &lvHitTestInfo)) return 0;
10670
10671     /* Change to screen coordinate for WM_CONTEXTMENU */
10672     pt = lvHitTestInfo.pt;
10673     ClientToScreen(infoPtr->hwndSelf, &pt);
10674
10675     /* Send a WM_CONTEXTMENU message in response to the RBUTTONUP */
10676     SendMessageW(infoPtr->hwndSelf, WM_CONTEXTMENU,
10677                  (WPARAM)infoPtr->hwndSelf, MAKELPARAM(pt.x, pt.y));
10678
10679     return 0;
10680 }
10681
10682
10683 /***
10684  * DESCRIPTION:
10685  * Sets the cursor.
10686  *
10687  * PARAMETER(S):
10688  * [I] infoPtr : valid pointer to the listview structure
10689  * [I] hwnd : window handle of window containing the cursor
10690  * [I] nHittest : hit-test code
10691  * [I] wMouseMsg : ideintifier of the mouse message
10692  *
10693  * RETURN:
10694  * TRUE if cursor is set
10695  * FALSE otherwise
10696  */
10697 static BOOL LISTVIEW_SetCursor(const LISTVIEW_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
10698 {
10699     LVHITTESTINFO lvHitTestInfo;
10700
10701     if (!LISTVIEW_IsHotTracking(infoPtr)) goto forward;
10702
10703     if (!infoPtr->hHotCursor) goto forward;
10704
10705     GetCursorPos(&lvHitTestInfo.pt);
10706     if (LISTVIEW_HitTest(infoPtr, &lvHitTestInfo, FALSE, FALSE) < 0) goto forward;
10707
10708     SetCursor(infoPtr->hHotCursor);
10709
10710     return TRUE;
10711
10712 forward:
10713
10714     return DefWindowProcW(infoPtr->hwndSelf, WM_SETCURSOR, wParam, lParam);
10715 }
10716
10717 /***
10718  * DESCRIPTION:
10719  * Sets the focus.
10720  *
10721  * PARAMETER(S):
10722  * [I] infoPtr : valid pointer to the listview structure
10723  * [I] hwndLoseFocus : handle of previously focused window
10724  *
10725  * RETURN:
10726  * Zero
10727  */
10728 static LRESULT LISTVIEW_SetFocus(LISTVIEW_INFO *infoPtr, HWND hwndLoseFocus)
10729 {
10730     TRACE("(hwndLoseFocus=%p)\n", hwndLoseFocus);
10731
10732     /* if we have the focus already, there's nothing to do */
10733     if (infoPtr->bFocus) return 0;
10734
10735     /* send NM_SETFOCUS notification */
10736     if (!notify(infoPtr, NM_SETFOCUS)) return 0;
10737
10738     /* set window focus flag */
10739     infoPtr->bFocus = TRUE;
10740
10741     /* put the focus rect back on */
10742     LISTVIEW_ShowFocusRect(infoPtr, TRUE);
10743
10744     /* redraw all visible selected items */
10745     LISTVIEW_InvalidateSelectedItems(infoPtr);
10746
10747     return 0;
10748 }
10749
10750 /***
10751  * DESCRIPTION:
10752  * Sets the font.
10753  *
10754  * PARAMETER(S):
10755  * [I] infoPtr : valid pointer to the listview structure
10756  * [I] fRedraw : font handle
10757  * [I] fRedraw : redraw flag
10758  *
10759  * RETURN:
10760  * Zero
10761  */
10762 static LRESULT LISTVIEW_SetFont(LISTVIEW_INFO *infoPtr, HFONT hFont, WORD fRedraw)
10763 {
10764     HFONT oldFont = infoPtr->hFont;
10765     INT oldHeight = infoPtr->nItemHeight;
10766
10767     TRACE("(hfont=%p,redraw=%hu)\n", hFont, fRedraw);
10768
10769     infoPtr->hFont = hFont ? hFont : infoPtr->hDefaultFont;
10770     if (infoPtr->hFont == oldFont) return 0;
10771
10772     LISTVIEW_SaveTextMetrics(infoPtr);
10773
10774     infoPtr->nItemHeight = LISTVIEW_CalculateItemHeight(infoPtr);
10775
10776     if (infoPtr->uView == LV_VIEW_DETAILS)
10777     {
10778         SendMessageW(infoPtr->hwndHeader, WM_SETFONT, (WPARAM)hFont, MAKELPARAM(fRedraw, 0));
10779         LISTVIEW_UpdateSize(infoPtr);
10780         LISTVIEW_UpdateScroll(infoPtr);
10781     }
10782     else if (infoPtr->nItemHeight != oldHeight)
10783         LISTVIEW_UpdateScroll(infoPtr);
10784
10785     if (fRedraw) LISTVIEW_InvalidateList(infoPtr);
10786
10787     return 0;
10788 }
10789
10790 /***
10791  * DESCRIPTION:
10792  * Message handling for WM_SETREDRAW.
10793  * For the Listview, it invalidates the entire window (the doc specifies otherwise)
10794  *
10795  * PARAMETER(S):
10796  * [I] infoPtr : valid pointer to the listview structure
10797  * [I] bRedraw: state of redraw flag
10798  *
10799  * RETURN:
10800  * DefWinProc return value
10801  */
10802 static LRESULT LISTVIEW_SetRedraw(LISTVIEW_INFO *infoPtr, BOOL bRedraw)
10803 {
10804     TRACE("infoPtr->bRedraw=%d, bRedraw=%d\n", infoPtr->bRedraw, bRedraw);
10805
10806     /* we cannot use straight equality here because _any_ non-zero value is TRUE */
10807     if ((infoPtr->bRedraw && bRedraw) || (!infoPtr->bRedraw && !bRedraw)) return 0;
10808
10809     infoPtr->bRedraw = bRedraw;
10810
10811     if(!bRedraw) return 0;
10812
10813     if (is_autoarrange(infoPtr))
10814         LISTVIEW_Arrange(infoPtr, LVA_DEFAULT);
10815     LISTVIEW_UpdateScroll(infoPtr);
10816
10817     /* despite what the WM_SETREDRAW docs says, apps expect us
10818      * to invalidate the listview here... stupid! */
10819     LISTVIEW_InvalidateList(infoPtr);
10820
10821     return 0;
10822 }
10823
10824 /***
10825  * DESCRIPTION:
10826  * Resizes the listview control. This function processes WM_SIZE
10827  * messages.  At this time, the width and height are not used.
10828  *
10829  * PARAMETER(S):
10830  * [I] infoPtr : valid pointer to the listview structure
10831  * [I] Width : new width
10832  * [I] Height : new height
10833  *
10834  * RETURN:
10835  * Zero
10836  */
10837 static LRESULT LISTVIEW_Size(LISTVIEW_INFO *infoPtr, int Width, int Height)
10838 {
10839     RECT rcOld = infoPtr->rcList;
10840
10841     TRACE("(width=%d, height=%d)\n", Width, Height);
10842
10843     LISTVIEW_UpdateSize(infoPtr);
10844     if (EqualRect(&rcOld, &infoPtr->rcList)) return 0;
10845
10846     /* do not bother with display related stuff if we're not redrawing */
10847     if (!is_redrawing(infoPtr)) return 0;
10848
10849     if (is_autoarrange(infoPtr))
10850         LISTVIEW_Arrange(infoPtr, LVA_DEFAULT);
10851
10852     LISTVIEW_UpdateScroll(infoPtr);
10853
10854     /* refresh all only for lists whose height changed significantly */
10855     if ((infoPtr->uView == LV_VIEW_LIST) &&
10856         (rcOld.bottom - rcOld.top) / infoPtr->nItemHeight !=
10857         (infoPtr->rcList.bottom - infoPtr->rcList.top) / infoPtr->nItemHeight)
10858         LISTVIEW_InvalidateList(infoPtr);
10859
10860   return 0;
10861 }
10862
10863 /***
10864  * DESCRIPTION:
10865  * Sets the size information.
10866  *
10867  * PARAMETER(S):
10868  * [I] infoPtr : valid pointer to the listview structure
10869  *
10870  * RETURN:
10871  *  None
10872  */
10873 static void LISTVIEW_UpdateSize(LISTVIEW_INFO *infoPtr)
10874 {
10875     TRACE("uView=%d, rcList(old)=%s\n", infoPtr->uView, wine_dbgstr_rect(&infoPtr->rcList));
10876
10877     GetClientRect(infoPtr->hwndSelf, &infoPtr->rcList);
10878
10879     if (infoPtr->uView == LV_VIEW_LIST)
10880     {
10881         /* Apparently the "LIST" style is supposed to have the same
10882          * number of items in a column even if there is no scroll bar.
10883          * Since if a scroll bar already exists then the bottom is already
10884          * reduced, only reduce if the scroll bar does not currently exist.
10885          * The "2" is there to mimic the native control. I think it may be
10886          * related to either padding or edges.  (GLA 7/2002)
10887          */
10888         if (!(GetWindowLongW(infoPtr->hwndSelf, GWL_STYLE) & WS_HSCROLL))
10889             infoPtr->rcList.bottom -= GetSystemMetrics(SM_CYHSCROLL);
10890         infoPtr->rcList.bottom = max (infoPtr->rcList.bottom - 2, 0);
10891     }
10892
10893     /* if control created invisible header isn't created */
10894     if (infoPtr->hwndHeader)
10895     {
10896         HDLAYOUT hl;
10897         WINDOWPOS wp;
10898
10899         hl.prc = &infoPtr->rcList;
10900         hl.pwpos = &wp;
10901         SendMessageW( infoPtr->hwndHeader, HDM_LAYOUT, 0, (LPARAM)&hl );
10902         TRACE("  wp.flags=0x%08x, wp=%d,%d (%dx%d)\n", wp.flags, wp.x, wp.y, wp.cx, wp.cy);
10903
10904         if (LISTVIEW_IsHeaderEnabled(infoPtr))
10905             wp.flags |= SWP_SHOWWINDOW;
10906         else
10907         {
10908             wp.flags |= SWP_HIDEWINDOW;
10909             wp.cy = 0;
10910         }
10911
10912         SetWindowPos(wp.hwnd, wp.hwndInsertAfter, wp.x, wp.y, wp.cx, wp.cy, wp.flags);
10913         TRACE("  after SWP wp=%d,%d (%dx%d)\n", wp.x, wp.y, wp.cx, wp.cy);
10914
10915         infoPtr->rcList.top = max(wp.cy, 0);
10916     }
10917     /* extra padding for grid */
10918     if (infoPtr->uView == LV_VIEW_DETAILS && infoPtr->dwLvExStyle & LVS_EX_GRIDLINES)
10919         infoPtr->rcList.top += 2;
10920
10921     TRACE("  rcList=%s\n", wine_dbgstr_rect(&infoPtr->rcList));
10922 }
10923
10924 /***
10925  * DESCRIPTION:
10926  * Processes WM_STYLECHANGED messages.
10927  *
10928  * PARAMETER(S):
10929  * [I] infoPtr : valid pointer to the listview structure
10930  * [I] wStyleType : window style type (normal or extended)
10931  * [I] lpss : window style information
10932  *
10933  * RETURN:
10934  * Zero
10935  */
10936 static INT LISTVIEW_StyleChanged(LISTVIEW_INFO *infoPtr, WPARAM wStyleType,
10937                                  const STYLESTRUCT *lpss)
10938 {
10939     UINT uNewView = lpss->styleNew & LVS_TYPEMASK;
10940     UINT uOldView = lpss->styleOld & LVS_TYPEMASK;
10941     UINT style;
10942
10943     TRACE("(styletype=%lx, styleOld=0x%08x, styleNew=0x%08x)\n",
10944           wStyleType, lpss->styleOld, lpss->styleNew);
10945
10946     if (wStyleType != GWL_STYLE) return 0;
10947
10948     infoPtr->dwStyle = lpss->styleNew;
10949     map_style_view(infoPtr);
10950
10951     if (((lpss->styleOld & WS_HSCROLL) != 0)&&
10952         ((lpss->styleNew & WS_HSCROLL) == 0))
10953        ShowScrollBar(infoPtr->hwndSelf, SB_HORZ, FALSE);
10954
10955     if (((lpss->styleOld & WS_VSCROLL) != 0)&&
10956         ((lpss->styleNew & WS_VSCROLL) == 0))
10957        ShowScrollBar(infoPtr->hwndSelf, SB_VERT, FALSE);
10958
10959     if (uNewView != uOldView)
10960     {
10961         SIZE oldIconSize = infoPtr->iconSize;
10962         HIMAGELIST himl;
10963
10964         SendMessageW(infoPtr->hwndEdit, WM_KILLFOCUS, 0, 0);
10965         ShowWindow(infoPtr->hwndHeader, SW_HIDE);
10966
10967         ShowScrollBar(infoPtr->hwndSelf, SB_BOTH, FALSE);
10968         SetRectEmpty(&infoPtr->rcFocus);
10969
10970         himl = (uNewView == LVS_ICON ? infoPtr->himlNormal : infoPtr->himlSmall);
10971         set_icon_size(&infoPtr->iconSize, himl, uNewView != LVS_ICON);
10972
10973         if (uNewView == LVS_ICON)
10974         {
10975             if ((infoPtr->iconSize.cx != oldIconSize.cx) || (infoPtr->iconSize.cy != oldIconSize.cy))
10976             {
10977                 TRACE("icon old size=(%d,%d), new size=(%d,%d)\n",
10978                       oldIconSize.cx, oldIconSize.cy, infoPtr->iconSize.cx, infoPtr->iconSize.cy);
10979                 LISTVIEW_SetIconSpacing(infoPtr, 0, 0);
10980             }
10981         }
10982         else if (uNewView == LVS_REPORT)
10983         {
10984             HDLAYOUT hl;
10985             WINDOWPOS wp;
10986
10987             LISTVIEW_CreateHeader( infoPtr );
10988
10989             hl.prc = &infoPtr->rcList;
10990             hl.pwpos = &wp;
10991             SendMessageW( infoPtr->hwndHeader, HDM_LAYOUT, 0, (LPARAM)&hl );
10992             SetWindowPos(infoPtr->hwndHeader, infoPtr->hwndSelf, wp.x, wp.y, wp.cx, wp.cy,
10993                     wp.flags | ((infoPtr->dwStyle & LVS_NOCOLUMNHEADER)
10994                         ? SWP_HIDEWINDOW : SWP_SHOWWINDOW));
10995         }
10996
10997         LISTVIEW_UpdateItemSize(infoPtr);
10998     }
10999
11000     if (uNewView == LVS_REPORT || infoPtr->dwLvExStyle & LVS_EX_HEADERINALLVIEWS)
11001     {
11002         if ((lpss->styleOld ^ lpss->styleNew) & LVS_NOCOLUMNHEADER)
11003         {
11004             if (lpss->styleNew & LVS_NOCOLUMNHEADER)
11005             {
11006                 /* Turn off the header control */
11007                 style = GetWindowLongW(infoPtr->hwndHeader, GWL_STYLE);
11008                 TRACE("Hide header control, was 0x%08x\n", style);
11009                 SetWindowLongW(infoPtr->hwndHeader, GWL_STYLE, style | HDS_HIDDEN);
11010             } else {
11011                 /* Turn on the header control */
11012                 if ((style = GetWindowLongW(infoPtr->hwndHeader, GWL_STYLE)) & HDS_HIDDEN)
11013                 {
11014                     TRACE("Show header control, was 0x%08x\n", style);
11015                     SetWindowLongW(infoPtr->hwndHeader, GWL_STYLE, (style & ~HDS_HIDDEN) | WS_VISIBLE);
11016                 }
11017             }
11018         }
11019     }
11020
11021     if ( (uNewView == LVS_ICON || uNewView == LVS_SMALLICON) &&
11022          (uNewView != uOldView || ((lpss->styleNew ^ lpss->styleOld) & LVS_ALIGNMASK)) )
11023          LISTVIEW_Arrange(infoPtr, LVA_DEFAULT);
11024
11025     /* update the size of the client area */
11026     LISTVIEW_UpdateSize(infoPtr);
11027
11028     /* add scrollbars if needed */
11029     LISTVIEW_UpdateScroll(infoPtr);
11030
11031     /* invalidate client area + erase background */
11032     LISTVIEW_InvalidateList(infoPtr);
11033
11034     return 0;
11035 }
11036
11037 /***
11038  * DESCRIPTION:
11039  * Processes WM_STYLECHANGING messages.
11040  *
11041  * PARAMETER(S):
11042  * [I] wStyleType : window style type (normal or extended)
11043  * [I0] lpss : window style information
11044  *
11045  * RETURN:
11046  * Zero
11047  */
11048 static INT LISTVIEW_StyleChanging(WPARAM wStyleType,
11049                                   STYLESTRUCT *lpss)
11050 {
11051     TRACE("(styletype=%lx, styleOld=0x%08x, styleNew=0x%08x)\n",
11052           wStyleType, lpss->styleOld, lpss->styleNew);
11053
11054     /* don't forward LVS_OWNERDATA only if not already set to */
11055     if ((lpss->styleNew ^ lpss->styleOld) & LVS_OWNERDATA)
11056     {
11057         if (lpss->styleOld & LVS_OWNERDATA)
11058             lpss->styleNew |= LVS_OWNERDATA;
11059         else
11060             lpss->styleNew &= ~LVS_OWNERDATA;
11061     }
11062
11063     return 0;
11064 }
11065
11066 /***
11067  * DESCRIPTION:
11068  * Processes WM_SHOWWINDOW messages.
11069  *
11070  * PARAMETER(S):
11071  * [I] infoPtr : valid pointer to the listview structure
11072  * [I] bShown  : window is being shown (FALSE when hidden)
11073  * [I] iStatus : window show status
11074  *
11075  * RETURN:
11076  * Zero
11077  */
11078 static LRESULT LISTVIEW_ShowWindow(LISTVIEW_INFO *infoPtr, WPARAM bShown, LPARAM iStatus)
11079 {
11080   /* header delayed creation */
11081   if ((infoPtr->uView == LV_VIEW_DETAILS) && bShown)
11082   {
11083     LISTVIEW_CreateHeader(infoPtr);
11084
11085     if (!(LVS_NOCOLUMNHEADER & infoPtr->dwStyle))
11086       ShowWindow(infoPtr->hwndHeader, SW_SHOWNORMAL);
11087   }
11088
11089   return DefWindowProcW(infoPtr->hwndSelf, WM_SHOWWINDOW, bShown, iStatus);
11090 }
11091
11092 /***
11093  * DESCRIPTION:
11094  * Processes CCM_GETVERSION messages.
11095  *
11096  * PARAMETER(S):
11097  * [I] infoPtr : valid pointer to the listview structure
11098  *
11099  * RETURN:
11100  * Current version
11101  */
11102 static inline LRESULT LISTVIEW_GetVersion(const LISTVIEW_INFO *infoPtr)
11103 {
11104   return infoPtr->iVersion;
11105 }
11106
11107 /***
11108  * DESCRIPTION:
11109  * Processes CCM_SETVERSION messages.
11110  *
11111  * PARAMETER(S):
11112  * [I] infoPtr  : valid pointer to the listview structure
11113  * [I] iVersion : version to be set
11114  *
11115  * RETURN:
11116  * -1 when requested version is greater than DLL version;
11117  * previous version otherwise
11118  */
11119 static LRESULT LISTVIEW_SetVersion(LISTVIEW_INFO *infoPtr, DWORD iVersion)
11120 {
11121   INT iOldVersion = infoPtr->iVersion;
11122
11123   if (iVersion > COMCTL32_VERSION)
11124     return -1;
11125
11126   infoPtr->iVersion = iVersion;
11127
11128   TRACE("new version %d\n", iVersion);
11129
11130   return iOldVersion;
11131 }
11132
11133 /***
11134  * DESCRIPTION:
11135  * Window procedure of the listview control.
11136  *
11137  */
11138 static LRESULT WINAPI
11139 LISTVIEW_WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
11140 {
11141   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongPtrW(hwnd, 0);
11142
11143   TRACE("(hwnd=%p uMsg=%x wParam=%lx lParam=%lx)\n", hwnd, uMsg, wParam, lParam);
11144
11145   if (!infoPtr && (uMsg != WM_NCCREATE))
11146     return DefWindowProcW(hwnd, uMsg, wParam, lParam);
11147
11148   switch (uMsg)
11149   {
11150   case LVM_APPROXIMATEVIEWRECT:
11151     return LISTVIEW_ApproximateViewRect(infoPtr, (INT)wParam,
11152                                         LOWORD(lParam), HIWORD(lParam));
11153   case LVM_ARRANGE:
11154     return LISTVIEW_Arrange(infoPtr, (INT)wParam);
11155
11156   case LVM_CANCELEDITLABEL:
11157     return LISTVIEW_CancelEditLabel(infoPtr);
11158
11159   case LVM_CREATEDRAGIMAGE:
11160     return (LRESULT)LISTVIEW_CreateDragImage(infoPtr, (INT)wParam, (LPPOINT)lParam);
11161
11162   case LVM_DELETEALLITEMS:
11163     return LISTVIEW_DeleteAllItems(infoPtr, FALSE);
11164
11165   case LVM_DELETECOLUMN:
11166     return LISTVIEW_DeleteColumn(infoPtr, (INT)wParam);
11167
11168   case LVM_DELETEITEM:
11169     return LISTVIEW_DeleteItem(infoPtr, (INT)wParam);
11170
11171   case LVM_EDITLABELA:
11172   case LVM_EDITLABELW:
11173     return (LRESULT)LISTVIEW_EditLabelT(infoPtr, (INT)wParam,
11174                                         uMsg == LVM_EDITLABELW);
11175   /* case LVM_ENABLEGROUPVIEW: */
11176
11177   case LVM_ENSUREVISIBLE:
11178     return LISTVIEW_EnsureVisible(infoPtr, (INT)wParam, (BOOL)lParam);
11179
11180   case LVM_FINDITEMW:
11181     return LISTVIEW_FindItemW(infoPtr, (INT)wParam, (LPLVFINDINFOW)lParam);
11182
11183   case LVM_FINDITEMA:
11184     return LISTVIEW_FindItemA(infoPtr, (INT)wParam, (LPLVFINDINFOA)lParam);
11185
11186   case LVM_GETBKCOLOR:
11187     return infoPtr->clrBk;
11188
11189   /* case LVM_GETBKIMAGE: */
11190
11191   case LVM_GETCALLBACKMASK:
11192     return infoPtr->uCallbackMask;
11193
11194   case LVM_GETCOLUMNA:
11195   case LVM_GETCOLUMNW:
11196     return LISTVIEW_GetColumnT(infoPtr, (INT)wParam, (LPLVCOLUMNW)lParam,
11197                                uMsg == LVM_GETCOLUMNW);
11198
11199   case LVM_GETCOLUMNORDERARRAY:
11200     return LISTVIEW_GetColumnOrderArray(infoPtr, (INT)wParam, (LPINT)lParam);
11201
11202   case LVM_GETCOLUMNWIDTH:
11203     return LISTVIEW_GetColumnWidth(infoPtr, (INT)wParam);
11204
11205   case LVM_GETCOUNTPERPAGE:
11206     return LISTVIEW_GetCountPerPage(infoPtr);
11207
11208   case LVM_GETEDITCONTROL:
11209     return (LRESULT)infoPtr->hwndEdit;
11210
11211   case LVM_GETEXTENDEDLISTVIEWSTYLE:
11212     return infoPtr->dwLvExStyle;
11213
11214   /* case LVM_GETGROUPINFO: */
11215
11216   /* case LVM_GETGROUPMETRICS: */
11217
11218   case LVM_GETHEADER:
11219     return (LRESULT)infoPtr->hwndHeader;
11220
11221   case LVM_GETHOTCURSOR:
11222     return (LRESULT)infoPtr->hHotCursor;
11223
11224   case LVM_GETHOTITEM:
11225     return infoPtr->nHotItem;
11226
11227   case LVM_GETHOVERTIME:
11228     return infoPtr->dwHoverTime;
11229
11230   case LVM_GETIMAGELIST:
11231     return (LRESULT)LISTVIEW_GetImageList(infoPtr, (INT)wParam);
11232
11233   /* case LVM_GETINSERTMARK: */
11234
11235   /* case LVM_GETINSERTMARKCOLOR: */
11236
11237   /* case LVM_GETINSERTMARKRECT: */
11238
11239   case LVM_GETISEARCHSTRINGA:
11240   case LVM_GETISEARCHSTRINGW:
11241     FIXME("LVM_GETISEARCHSTRING: unimplemented\n");
11242     return FALSE;
11243
11244   case LVM_GETITEMA:
11245   case LVM_GETITEMW:
11246     return LISTVIEW_GetItemExtT(infoPtr, (LPLVITEMW)lParam, uMsg == LVM_GETITEMW);
11247
11248   case LVM_GETITEMCOUNT:
11249     return infoPtr->nItemCount;
11250
11251   case LVM_GETITEMPOSITION:
11252     return LISTVIEW_GetItemPosition(infoPtr, (INT)wParam, (LPPOINT)lParam);
11253
11254   case LVM_GETITEMRECT:
11255     return LISTVIEW_GetItemRect(infoPtr, (INT)wParam, (LPRECT)lParam);
11256
11257   case LVM_GETITEMSPACING:
11258     return LISTVIEW_GetItemSpacing(infoPtr, (BOOL)wParam);
11259
11260   case LVM_GETITEMSTATE:
11261     return LISTVIEW_GetItemState(infoPtr, (INT)wParam, (UINT)lParam);
11262
11263   case LVM_GETITEMTEXTA:
11264   case LVM_GETITEMTEXTW:
11265     return LISTVIEW_GetItemTextT(infoPtr, (INT)wParam, (LPLVITEMW)lParam,
11266                                  uMsg == LVM_GETITEMTEXTW);
11267
11268   case LVM_GETNEXTITEM:
11269     return LISTVIEW_GetNextItem(infoPtr, (INT)wParam, LOWORD(lParam));
11270
11271   case LVM_GETNUMBEROFWORKAREAS:
11272     FIXME("LVM_GETNUMBEROFWORKAREAS: unimplemented\n");
11273     return 1;
11274
11275   case LVM_GETORIGIN:
11276     if (!lParam) return FALSE;
11277     if (infoPtr->uView == LV_VIEW_DETAILS ||
11278         infoPtr->uView == LV_VIEW_LIST) return FALSE;
11279     LISTVIEW_GetOrigin(infoPtr, (LPPOINT)lParam);
11280     return TRUE;
11281
11282   /* case LVM_GETOUTLINECOLOR: */
11283
11284   /* case LVM_GETSELECTEDCOLUMN: */
11285
11286   case LVM_GETSELECTEDCOUNT:
11287     return LISTVIEW_GetSelectedCount(infoPtr);
11288
11289   case LVM_GETSELECTIONMARK:
11290     return infoPtr->nSelectionMark;
11291
11292   case LVM_GETSTRINGWIDTHA:
11293   case LVM_GETSTRINGWIDTHW:
11294     return LISTVIEW_GetStringWidthT(infoPtr, (LPCWSTR)lParam,
11295                                     uMsg == LVM_GETSTRINGWIDTHW);
11296
11297   case LVM_GETSUBITEMRECT:
11298     return LISTVIEW_GetSubItemRect(infoPtr, (UINT)wParam, (LPRECT)lParam);
11299
11300   case LVM_GETTEXTBKCOLOR:
11301     return infoPtr->clrTextBk;
11302
11303   case LVM_GETTEXTCOLOR:
11304     return infoPtr->clrText;
11305
11306   /* case LVM_GETTILEINFO: */
11307
11308   /* case LVM_GETTILEVIEWINFO: */
11309
11310   case LVM_GETTOOLTIPS:
11311     if( !infoPtr->hwndToolTip )
11312         infoPtr->hwndToolTip = COMCTL32_CreateToolTip( hwnd );
11313     return (LRESULT)infoPtr->hwndToolTip;
11314
11315   case LVM_GETTOPINDEX:
11316     return LISTVIEW_GetTopIndex(infoPtr);
11317
11318   case LVM_GETUNICODEFORMAT:
11319     return (infoPtr->notifyFormat == NFR_UNICODE);
11320
11321   case LVM_GETVIEW:
11322     return infoPtr->uView;
11323
11324   case LVM_GETVIEWRECT:
11325     return LISTVIEW_GetViewRect(infoPtr, (LPRECT)lParam);
11326
11327   case LVM_GETWORKAREAS:
11328     FIXME("LVM_GETWORKAREAS: unimplemented\n");
11329     return FALSE;
11330
11331   /* case LVM_HASGROUP: */
11332
11333   case LVM_HITTEST:
11334     return LISTVIEW_HitTest(infoPtr, (LPLVHITTESTINFO)lParam, FALSE, TRUE);
11335
11336   case LVM_INSERTCOLUMNA:
11337   case LVM_INSERTCOLUMNW:
11338     return LISTVIEW_InsertColumnT(infoPtr, (INT)wParam, (LPLVCOLUMNW)lParam,
11339                                   uMsg == LVM_INSERTCOLUMNW);
11340
11341   /* case LVM_INSERTGROUP: */
11342
11343   /* case LVM_INSERTGROUPSORTED: */
11344
11345   case LVM_INSERTITEMA:
11346   case LVM_INSERTITEMW:
11347     return LISTVIEW_InsertItemT(infoPtr, (LPLVITEMW)lParam, uMsg == LVM_INSERTITEMW);
11348
11349   /* case LVM_INSERTMARKHITTEST: */
11350
11351   /* case LVM_ISGROUPVIEWENABLED: */
11352
11353   case LVM_ISITEMVISIBLE:
11354     return LISTVIEW_IsItemVisible(infoPtr, (INT)wParam);
11355
11356   case LVM_MAPIDTOINDEX:
11357     return LISTVIEW_MapIdToIndex(infoPtr, (UINT)wParam);
11358
11359   case LVM_MAPINDEXTOID:
11360     return LISTVIEW_MapIndexToId(infoPtr, (INT)wParam);
11361
11362   /* case LVM_MOVEGROUP: */
11363
11364   /* case LVM_MOVEITEMTOGROUP: */
11365
11366   case LVM_REDRAWITEMS:
11367     return LISTVIEW_RedrawItems(infoPtr, (INT)wParam, (INT)lParam);
11368
11369   /* case LVM_REMOVEALLGROUPS: */
11370
11371   /* case LVM_REMOVEGROUP: */
11372
11373   case LVM_SCROLL:
11374     return LISTVIEW_Scroll(infoPtr, (INT)wParam, (INT)lParam);
11375
11376   case LVM_SETBKCOLOR:
11377     return LISTVIEW_SetBkColor(infoPtr, (COLORREF)lParam);
11378
11379   /* case LVM_SETBKIMAGE: */
11380
11381   case LVM_SETCALLBACKMASK:
11382     infoPtr->uCallbackMask = (UINT)wParam;
11383     return TRUE;
11384
11385   case LVM_SETCOLUMNA:
11386   case LVM_SETCOLUMNW:
11387     return LISTVIEW_SetColumnT(infoPtr, (INT)wParam, (LPLVCOLUMNW)lParam,
11388                                uMsg == LVM_SETCOLUMNW);
11389
11390   case LVM_SETCOLUMNORDERARRAY:
11391     return LISTVIEW_SetColumnOrderArray(infoPtr, (INT)wParam, (LPINT)lParam);
11392
11393   case LVM_SETCOLUMNWIDTH:
11394     return LISTVIEW_SetColumnWidth(infoPtr, (INT)wParam, (short)LOWORD(lParam));
11395
11396   case LVM_SETEXTENDEDLISTVIEWSTYLE:
11397     return LISTVIEW_SetExtendedListViewStyle(infoPtr, (DWORD)wParam, (DWORD)lParam);
11398
11399   /* case LVM_SETGROUPINFO: */
11400
11401   /* case LVM_SETGROUPMETRICS: */
11402
11403   case LVM_SETHOTCURSOR:
11404     return (LRESULT)LISTVIEW_SetHotCursor(infoPtr, (HCURSOR)lParam);
11405
11406   case LVM_SETHOTITEM:
11407     return LISTVIEW_SetHotItem(infoPtr, (INT)wParam);
11408
11409   case LVM_SETHOVERTIME:
11410     return LISTVIEW_SetHoverTime(infoPtr, (DWORD)lParam);
11411
11412   case LVM_SETICONSPACING:
11413     return LISTVIEW_SetIconSpacing(infoPtr, (short)LOWORD(lParam), (short)HIWORD(lParam));
11414
11415   case LVM_SETIMAGELIST:
11416     return (LRESULT)LISTVIEW_SetImageList(infoPtr, (INT)wParam, (HIMAGELIST)lParam);
11417
11418   /* case LVM_SETINFOTIP: */
11419
11420   /* case LVM_SETINSERTMARK: */
11421
11422   /* case LVM_SETINSERTMARKCOLOR: */
11423
11424   case LVM_SETITEMA:
11425   case LVM_SETITEMW:
11426     {
11427         if (infoPtr->dwStyle & LVS_OWNERDATA) return FALSE;
11428         return LISTVIEW_SetItemT(infoPtr, (LPLVITEMW)lParam, (uMsg == LVM_SETITEMW));
11429     }
11430
11431   case LVM_SETITEMCOUNT:
11432     return LISTVIEW_SetItemCount(infoPtr, (INT)wParam, (DWORD)lParam);
11433
11434   case LVM_SETITEMPOSITION:
11435     {
11436         POINT pt;
11437         pt.x = (short)LOWORD(lParam);
11438         pt.y = (short)HIWORD(lParam);
11439         return LISTVIEW_SetItemPosition(infoPtr, (INT)wParam, &pt);
11440     }
11441
11442   case LVM_SETITEMPOSITION32:
11443     return LISTVIEW_SetItemPosition(infoPtr, (INT)wParam, (POINT*)lParam);
11444
11445   case LVM_SETITEMSTATE:
11446     return LISTVIEW_SetItemState(infoPtr, (INT)wParam, (LPLVITEMW)lParam);
11447
11448   case LVM_SETITEMTEXTA:
11449   case LVM_SETITEMTEXTW:
11450     return LISTVIEW_SetItemTextT(infoPtr, (INT)wParam, (LPLVITEMW)lParam,
11451                                  uMsg == LVM_SETITEMTEXTW);
11452
11453   /* case LVM_SETOUTLINECOLOR: */
11454
11455   /* case LVM_SETSELECTEDCOLUMN: */
11456
11457   case LVM_SETSELECTIONMARK:
11458     return LISTVIEW_SetSelectionMark(infoPtr, (INT)lParam);
11459
11460   case LVM_SETTEXTBKCOLOR:
11461     return LISTVIEW_SetTextBkColor(infoPtr, (COLORREF)lParam);
11462
11463   case LVM_SETTEXTCOLOR:
11464     return LISTVIEW_SetTextColor(infoPtr, (COLORREF)lParam);
11465
11466   /* case LVM_SETTILEINFO: */
11467
11468   /* case LVM_SETTILEVIEWINFO: */
11469
11470   /* case LVM_SETTILEWIDTH: */
11471
11472   case LVM_SETTOOLTIPS:
11473     return (LRESULT)LISTVIEW_SetToolTips(infoPtr, (HWND)lParam);
11474
11475   case LVM_SETUNICODEFORMAT:
11476     return LISTVIEW_SetUnicodeFormat(infoPtr, wParam);
11477
11478   case LVM_SETVIEW:
11479     return LISTVIEW_SetView(infoPtr, wParam);
11480
11481   /* case LVM_SETWORKAREAS: */
11482
11483   /* case LVM_SORTGROUPS: */
11484
11485   case LVM_SORTITEMS:
11486   case LVM_SORTITEMSEX:
11487     return LISTVIEW_SortItems(infoPtr, (PFNLVCOMPARE)lParam, wParam,
11488                               uMsg == LVM_SORTITEMSEX);
11489   case LVM_SUBITEMHITTEST:
11490     return LISTVIEW_HitTest(infoPtr, (LPLVHITTESTINFO)lParam, TRUE, FALSE);
11491
11492   case LVM_UPDATE:
11493     return LISTVIEW_Update(infoPtr, (INT)wParam);
11494
11495   case CCM_GETVERSION:
11496     return LISTVIEW_GetVersion(infoPtr);
11497
11498   case CCM_SETVERSION:
11499     return LISTVIEW_SetVersion(infoPtr, wParam);
11500
11501   case WM_CHAR:
11502     return LISTVIEW_ProcessLetterKeys( infoPtr, wParam, lParam );
11503
11504   case WM_COMMAND:
11505     return LISTVIEW_Command(infoPtr, wParam, lParam);
11506
11507   case WM_NCCREATE:
11508     return LISTVIEW_NCCreate(hwnd, (LPCREATESTRUCTW)lParam);
11509
11510   case WM_CREATE:
11511     return LISTVIEW_Create(hwnd, (LPCREATESTRUCTW)lParam);
11512
11513   case WM_DESTROY:
11514     return LISTVIEW_Destroy(infoPtr);
11515
11516   case WM_ENABLE:
11517     return LISTVIEW_Enable(infoPtr);
11518
11519   case WM_ERASEBKGND:
11520     return LISTVIEW_EraseBkgnd(infoPtr, (HDC)wParam);
11521
11522   case WM_GETDLGCODE:
11523     return DLGC_WANTCHARS | DLGC_WANTARROWS;
11524
11525   case WM_GETFONT:
11526     return (LRESULT)infoPtr->hFont;
11527
11528   case WM_HSCROLL:
11529     return LISTVIEW_HScroll(infoPtr, (INT)LOWORD(wParam), 0);
11530
11531   case WM_KEYDOWN:
11532     return LISTVIEW_KeyDown(infoPtr, (INT)wParam, (LONG)lParam);
11533
11534   case WM_KILLFOCUS:
11535     return LISTVIEW_KillFocus(infoPtr);
11536
11537   case WM_LBUTTONDBLCLK:
11538     return LISTVIEW_LButtonDblClk(infoPtr, (WORD)wParam, (SHORT)LOWORD(lParam), (SHORT)HIWORD(lParam));
11539
11540   case WM_LBUTTONDOWN:
11541     return LISTVIEW_LButtonDown(infoPtr, (WORD)wParam, (SHORT)LOWORD(lParam), (SHORT)HIWORD(lParam));
11542
11543   case WM_LBUTTONUP:
11544     return LISTVIEW_LButtonUp(infoPtr, (WORD)wParam, (SHORT)LOWORD(lParam), (SHORT)HIWORD(lParam));
11545
11546   case WM_MOUSEMOVE:
11547     return LISTVIEW_MouseMove (infoPtr, (WORD)wParam, (SHORT)LOWORD(lParam), (SHORT)HIWORD(lParam));
11548
11549   case WM_MOUSEHOVER:
11550     return LISTVIEW_MouseHover(infoPtr, (SHORT)LOWORD(lParam), (SHORT)HIWORD(lParam));
11551
11552   case WM_NCDESTROY:
11553     return LISTVIEW_NCDestroy(infoPtr);
11554
11555   case WM_NCPAINT:
11556     return LISTVIEW_NCPaint(infoPtr, (HRGN)wParam);
11557
11558   case WM_NOTIFY:
11559     return LISTVIEW_Notify(infoPtr, (LPNMHDR)lParam);
11560
11561   case WM_NOTIFYFORMAT:
11562     return LISTVIEW_NotifyFormat(infoPtr, (HWND)wParam, (INT)lParam);
11563
11564   case WM_PRINTCLIENT:
11565     return LISTVIEW_PrintClient(infoPtr, (HDC)wParam, (DWORD)lParam);
11566
11567   case WM_PAINT:
11568     return LISTVIEW_WMPaint(infoPtr, (HDC)wParam);
11569
11570   case WM_RBUTTONDBLCLK:
11571     return LISTVIEW_RButtonDblClk(infoPtr, (WORD)wParam, (SHORT)LOWORD(lParam), (SHORT)HIWORD(lParam));
11572
11573   case WM_RBUTTONDOWN:
11574     return LISTVIEW_RButtonDown(infoPtr, (WORD)wParam, (SHORT)LOWORD(lParam), (SHORT)HIWORD(lParam));
11575
11576   case WM_RBUTTONUP:
11577     return LISTVIEW_RButtonUp(infoPtr, (WORD)wParam, (SHORT)LOWORD(lParam), (SHORT)HIWORD(lParam));
11578
11579   case WM_SETCURSOR:
11580     return LISTVIEW_SetCursor(infoPtr, wParam, lParam);
11581
11582   case WM_SETFOCUS:
11583     return LISTVIEW_SetFocus(infoPtr, (HWND)wParam);
11584
11585   case WM_SETFONT:
11586     return LISTVIEW_SetFont(infoPtr, (HFONT)wParam, (WORD)lParam);
11587
11588   case WM_SETREDRAW:
11589     return LISTVIEW_SetRedraw(infoPtr, (BOOL)wParam);
11590
11591   case WM_SHOWWINDOW:
11592     return LISTVIEW_ShowWindow(infoPtr, wParam, lParam);
11593
11594   case WM_STYLECHANGED:
11595     return LISTVIEW_StyleChanged(infoPtr, wParam, (LPSTYLESTRUCT)lParam);
11596
11597   case WM_STYLECHANGING:
11598     return LISTVIEW_StyleChanging(wParam, (LPSTYLESTRUCT)lParam);
11599
11600   case WM_SYSCOLORCHANGE:
11601     COMCTL32_RefreshSysColors();
11602     return 0;
11603
11604 /*      case WM_TIMER: */
11605   case WM_THEMECHANGED:
11606     return LISTVIEW_ThemeChanged(infoPtr);
11607
11608   case WM_VSCROLL:
11609     return LISTVIEW_VScroll(infoPtr, (INT)LOWORD(wParam), 0);
11610
11611   case WM_MOUSEWHEEL:
11612       if (wParam & (MK_SHIFT | MK_CONTROL))
11613           return DefWindowProcW(hwnd, uMsg, wParam, lParam);
11614       return LISTVIEW_MouseWheel(infoPtr, (short int)HIWORD(wParam));
11615
11616   case WM_WINDOWPOSCHANGED:
11617       if (!(((WINDOWPOS *)lParam)->flags & SWP_NOSIZE))
11618       {
11619           SetWindowPos(infoPtr->hwndSelf, 0, 0, 0, 0, 0, SWP_FRAMECHANGED | SWP_NOACTIVATE |
11620                        SWP_NOZORDER | SWP_NOMOVE | SWP_NOSIZE);
11621
11622           if ((infoPtr->dwStyle & LVS_OWNERDRAWFIXED) && (infoPtr->uView == LV_VIEW_DETAILS))
11623           {
11624               if (notify_measureitem(infoPtr)) LISTVIEW_InvalidateList(infoPtr);
11625           }
11626           LISTVIEW_Size(infoPtr, ((WINDOWPOS *)lParam)->cx, ((WINDOWPOS *)lParam)->cy);
11627       }
11628       return DefWindowProcW(hwnd, uMsg, wParam, lParam);
11629
11630 /*      case WM_WININICHANGE: */
11631
11632   default:
11633     if ((uMsg >= WM_USER) && (uMsg < WM_APP) && !COMCTL32_IsReflectedMessage(uMsg))
11634       ERR("unknown msg %04x wp=%08lx lp=%08lx\n", uMsg, wParam, lParam);
11635
11636     return DefWindowProcW(hwnd, uMsg, wParam, lParam);
11637   }
11638
11639 }
11640
11641 /***
11642  * DESCRIPTION:
11643  * Registers the window class.
11644  *
11645  * PARAMETER(S):
11646  * None
11647  *
11648  * RETURN:
11649  * None
11650  */
11651 void LISTVIEW_Register(void)
11652 {
11653     WNDCLASSW wndClass;
11654
11655     ZeroMemory(&wndClass, sizeof(WNDCLASSW));
11656     wndClass.style = CS_GLOBALCLASS | CS_DBLCLKS;
11657     wndClass.lpfnWndProc = LISTVIEW_WindowProc;
11658     wndClass.cbClsExtra = 0;
11659     wndClass.cbWndExtra = sizeof(LISTVIEW_INFO *);
11660     wndClass.hCursor = LoadCursorW(0, (LPWSTR)IDC_ARROW);
11661     wndClass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
11662     wndClass.lpszClassName = WC_LISTVIEWW;
11663     RegisterClassW(&wndClass);
11664 }
11665
11666 /***
11667  * DESCRIPTION:
11668  * Unregisters the window class.
11669  *
11670  * PARAMETER(S):
11671  * None
11672  *
11673  * RETURN:
11674  * None
11675  */
11676 void LISTVIEW_Unregister(void)
11677 {
11678     UnregisterClassW(WC_LISTVIEWW, NULL);
11679 }
11680
11681 /***
11682  * DESCRIPTION:
11683  * Handle any WM_COMMAND messages
11684  *
11685  * PARAMETER(S):
11686  * [I] infoPtr : valid pointer to the listview structure
11687  * [I] wParam : the first message parameter
11688  * [I] lParam : the second message parameter
11689  *
11690  * RETURN:
11691  *   Zero.
11692  */
11693 static LRESULT LISTVIEW_Command(LISTVIEW_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
11694 {
11695
11696     TRACE("(%p %x %x %lx)\n", infoPtr, HIWORD(wParam), LOWORD(wParam), lParam);
11697
11698     if (!infoPtr->hwndEdit) return 0;
11699
11700     switch (HIWORD(wParam))
11701     {
11702         case EN_UPDATE:
11703         {
11704             /*
11705              * Adjust the edit window size
11706              */
11707             WCHAR buffer[1024];
11708             HDC           hdc = GetDC(infoPtr->hwndEdit);
11709             HFONT         hFont, hOldFont = 0;
11710             RECT          rect;
11711             SIZE          sz;
11712
11713             if (!infoPtr->hwndEdit || !hdc) return 0;
11714             GetWindowTextW(infoPtr->hwndEdit, buffer, sizeof(buffer)/sizeof(buffer[0]));
11715             GetWindowRect(infoPtr->hwndEdit, &rect);
11716
11717             /* Select font to get the right dimension of the string */
11718             hFont = (HFONT)SendMessageW(infoPtr->hwndEdit, WM_GETFONT, 0, 0);
11719             if (hFont)
11720             {
11721                 hOldFont = SelectObject(hdc, hFont);
11722             }
11723
11724             if (GetTextExtentPoint32W(hdc, buffer, lstrlenW(buffer), &sz))
11725             {
11726                 TEXTMETRICW textMetric;
11727
11728                 /* Add Extra spacing for the next character */
11729                 GetTextMetricsW(hdc, &textMetric);
11730                 sz.cx += (textMetric.tmMaxCharWidth * 2);
11731
11732                 SetWindowPos(infoPtr->hwndEdit, NULL, 0, 0, sz.cx,
11733                     rect.bottom - rect.top, SWP_DRAWFRAME | SWP_NOMOVE | SWP_NOZORDER);
11734             }
11735             if (hFont)
11736                 SelectObject(hdc, hOldFont);
11737
11738             ReleaseDC(infoPtr->hwndEdit, hdc);
11739
11740             break;
11741         }
11742         case EN_KILLFOCUS:
11743         {
11744             LISTVIEW_CancelEditLabel(infoPtr);
11745             break;
11746         }
11747
11748         default:
11749           return SendMessageW (infoPtr->hwndNotify, WM_COMMAND, wParam, lParam);
11750     }
11751
11752     return 0;
11753 }