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