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

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