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 Nikolay Sivov
11 * This library is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Lesser General Public
13 * License as published by the Free Software Foundation; either
14 * version 2.1 of the License, or (at your option) any later version.
16 * This library is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Lesser General Public License for more details.
21 * You should have received a copy of the GNU Lesser General Public
22 * License along with this library; if not, write to the Free Software
23 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
27 * This code was audited for completeness against the documented features
28 * of Comctl32.dll version 6.0 on May. 20, 2005, by James Hawkins.
30 * Unless otherwise noted, we believe this code to be complete, as per
31 * the specification mentioned above.
32 * If you discover missing features, or bugs, please note them below.
36 * Default Message Processing
37 * -- WM_CREATE: create the icon and small icon image lists at this point only if
38 * the LVS_SHAREIMAGELISTS style is not specified.
39 * -- WM_WINDOWPOSCHANGED: arrange the list items if the current view is icon
40 * or small icon and the LVS_AUTOARRANGE style is specified.
45 * -- Hot item handling, mouse hovering
46 * -- Workareas support
51 * -- Expand large item in ICON mode when the cursor is flying over the icon or text.
52 * -- Support CustomDraw options for _WIN32_IE >= 0x560 (see NMLVCUSTOMDRAW docs).
53 * -- LVA_SNAPTOGRID not implemented
54 * -- LISTVIEW_ApproximateViewRect partially implemented
55 * -- LISTVIEW_SetColumnWidth ignores header images & bitmap
56 * -- LISTVIEW_SetIconSpacing is incomplete
57 * -- LISTVIEW_StyleChanged doesn't handle some changes too well
60 * -- LISTVIEW_GetNextItem needs to be rewritten. It is currently
61 * linear in the number of items in the list, and this is
62 * unacceptable for large lists.
63 * -- if list is sorted by item text LISTVIEW_InsertItemT could use
64 * binary search to calculate item index (e.g. DPA_Search()).
65 * This requires sorted state to be reliably tracked in item modifiers.
66 * -- we should keep an ordered array of coordinates in iconic mode
67 * this would allow to frame items (iterator_frameditems),
68 * and find nearest item (LVFI_NEARESTXY) a lot more efficiently
75 * -- LVIS_ACTIVATING (not currently supported by comctl32.dll version 6.0)
82 * -- LVS_NOSCROLL (see Q137520)
86 * -- LVS_EX_BORDERSELECT
90 * -- LVS_EX_MULTIWORKAREAS
92 * -- LVS_EX_SIMPLESELECT
93 * -- LVS_EX_TWOCLICKACTIVATE
94 * -- LVS_EX_UNDERLINECOLD
95 * -- LVS_EX_UNDERLINEHOT
98 * -- LVN_BEGINSCROLL, LVN_ENDSCROLL
101 * -- LVN_MARQUEEBEGIN
107 * -- LVM_ENABLEGROUPVIEW
108 * -- LVM_GETBKIMAGE, LVM_SETBKIMAGE
109 * -- LVM_GETGROUPINFO, LVM_SETGROUPINFO
110 * -- LVM_GETGROUPMETRICS, LVM_SETGROUPMETRICS
111 * -- LVM_GETINSERTMARK, LVM_SETINSERTMARK
112 * -- LVM_GETINSERTMARKCOLOR, LVM_SETINSERTMARKCOLOR
113 * -- LVM_GETINSERTMARKRECT
114 * -- LVM_GETNUMBEROFWORKAREAS
115 * -- LVM_GETOUTLINECOLOR, LVM_SETOUTLINECOLOR
116 * -- LVM_GETSELECTEDCOLUMN, LVM_SETSELECTEDCOLUMN
117 * -- LVM_GETISEARCHSTRINGW, LVM_GETISEARCHSTRINGA
118 * -- LVM_GETTILEINFO, LVM_SETTILEINFO
119 * -- LVM_GETTILEVIEWINFO, LVM_SETTILEVIEWINFO
120 * -- LVM_GETWORKAREAS, LVM_SETWORKAREAS
121 * -- LVM_HASGROUP, LVM_INSERTGROUP, LVM_REMOVEGROUP, LVM_REMOVEALLGROUPS
122 * -- LVM_INSERTGROUPSORTED
123 * -- LVM_INSERTMARKHITTEST
124 * -- LVM_ISGROUPVIEWENABLED
126 * -- LVM_MOVEITEMTOGROUP
128 * -- LVM_SETTILEWIDTH
132 * -- ListView_GetHoverTime, ListView_SetHoverTime
133 * -- ListView_GetISearchString
134 * -- ListView_GetNumberOfWorkAreas
135 * -- ListView_GetWorkAreas, ListView_SetWorkAreas
140 * Known differences in message stream from native control (not known if
141 * these differences cause problems):
142 * LVM_INSERTITEM issues LVM_SETITEMSTATE and LVM_SETITEM in certain cases.
143 * LVM_SETITEM does not always issue LVN_ITEMCHANGING/LVN_ITEMCHANGED.
144 * WM_CREATE does not issue WM_QUERYUISTATE and associated registry
145 * processing for "USEDOUBLECLICKTIME".
149 #include "wine/port.h"
164 #include "commctrl.h"
165 #include "comctl32.h"
168 #include "wine/debug.h"
169 #include "wine/unicode.h"
171 WINE_DEFAULT_DEBUG_CHANNEL(listview
);
173 /* make sure you set this to 0 for production use! */
174 #define DEBUG_RANGES 1
176 typedef struct tagCOLUMN_INFO
178 RECT rcHeader
; /* tracks the header's rectangle */
179 int fmt
; /* same as LVCOLUMN.fmt */
182 typedef struct tagITEMHDR
186 } ITEMHDR
, *LPITEMHDR
;
188 typedef struct tagSUBITEM_INFO
194 typedef struct tagITEM_ID ITEM_ID
;
196 typedef struct tagITEM_INFO
207 UINT id
; /* item id */
208 HDPA item
; /* link to item data */
211 typedef struct tagRANGE
217 typedef struct tagRANGES
222 typedef struct tagITERATOR
231 typedef struct tagDELAYED_ITEM_EDIT
237 typedef struct tagLISTVIEW_INFO
244 HIMAGELIST himlNormal
;
245 HIMAGELIST himlSmall
;
246 HIMAGELIST himlState
;
250 POINT ptClickPos
; /* point where the user clicked */
251 BOOL bNoItemMetrics
; /* flags if item metrics are not yet computed */
254 RANGES selectionRanges
;
259 RECT rcList
; /* This rectangle is really the window
260 * client rectangle possibly reduced by the
261 * horizontal scroll bar and/or header - see
262 * LISTVIEW_UpdateSize. This rectangle offset
263 * by the LISTVIEW_GetOrigin value is in
264 * client coordinates */
273 INT ntmHeight
; /* Some cached metrics of the font used */
274 INT ntmMaxCharWidth
; /* by the listview to draw items */
276 BOOL bRedraw
; /* Turns on/off repaints & invalidations */
277 BOOL bAutoarrange
; /* Autoarrange flag when NOT in LVS_AUTOARRANGE */
279 BOOL bDoChangeNotify
; /* send change notification messages? */
282 DWORD dwStyle
; /* the cached window GWL_STYLE */
283 DWORD dwLvExStyle
; /* extended listview style */
284 DWORD uView
; /* current view available through LVM_[G,S]ETVIEW */
285 INT nItemCount
; /* the number of items in the list */
286 HDPA hdpaItems
; /* array ITEM_INFO pointers */
287 HDPA hdpaItemIds
; /* array of ITEM_ID pointers */
288 HDPA hdpaPosX
; /* maintains the (X, Y) coordinates of the */
289 HDPA hdpaPosY
; /* items in LVS_ICON, and LVS_SMALLICON modes */
290 HDPA hdpaColumns
; /* array of COLUMN_INFO pointers */
291 BOOL colRectsDirty
; /* trigger column rectangles requery from header */
292 POINT currIconPos
; /* this is the position next icon will be placed */
293 PFNLVCOMPARE pfnCompare
;
298 INT nLButtonDownItem
; /* tracks item to reset multiselection on WM_LBUTTONUP */
302 DWORD cditemmode
; /* Keep the custom draw flags for an item/row */
304 DWORD lastKeyPressTimestamp
;
306 INT nSearchParamLength
;
307 WCHAR szSearchParam
[ MAX_PATH
];
309 INT nMeasureItemHeight
;
310 INT xTrackLine
; /* The x coefficient of the track line or -1 if none */
311 DELAYED_ITEM_EDIT itemEdit
; /* Pointer to this structure will be the timer ID */
313 DWORD iVersion
; /* CCM_[G,S]ETVERSION */
319 /* How many we debug buffer to allocate */
320 #define DEBUG_BUFFERS 20
321 /* The size of a single debug buffer */
322 #define DEBUG_BUFFER_SIZE 256
324 /* Internal interface to LISTVIEW_HScroll and LISTVIEW_VScroll */
325 #define SB_INTERNAL -1
327 /* maximum size of a label */
328 #define DISP_TEXT_SIZE 512
330 /* padding for items in list and small icon display modes */
331 #define WIDTH_PADDING 12
333 /* padding for items in list, report and small icon display modes */
334 #define HEIGHT_PADDING 1
336 /* offset of items in report display mode */
337 #define REPORT_MARGINX 2
339 /* padding for icon in large icon display mode
340 * ICON_TOP_PADDING_NOTHITABLE - space between top of box and area
341 * that HITTEST will see.
342 * ICON_TOP_PADDING_HITABLE - spacing between above and icon.
343 * ICON_TOP_PADDING - sum of the two above.
344 * ICON_BOTTOM_PADDING - between bottom of icon and top of text
345 * LABEL_HOR_PADDING - between text and sides of box
346 * LABEL_VERT_PADDING - between bottom of text and end of box
348 * ICON_LR_PADDING - additional width above icon size.
349 * ICON_LR_HALF - half of the above value
351 #define ICON_TOP_PADDING_NOTHITABLE 2
352 #define ICON_TOP_PADDING_HITABLE 2
353 #define ICON_TOP_PADDING (ICON_TOP_PADDING_NOTHITABLE + ICON_TOP_PADDING_HITABLE)
354 #define ICON_BOTTOM_PADDING 4
355 #define LABEL_HOR_PADDING 5
356 #define LABEL_VERT_PADDING 7
357 #define ICON_LR_PADDING 16
358 #define ICON_LR_HALF (ICON_LR_PADDING/2)
360 /* default label width for items in list and small icon display modes */
361 #define DEFAULT_LABEL_WIDTH 40
362 /* maximum select rectangle width for empty text item in LV_VIEW_DETAILS */
363 #define MAX_EMPTYTEXT_SELECT_WIDTH 80
365 /* default column width for items in list display mode */
366 #define DEFAULT_COLUMN_WIDTH 128
368 /* Size of "line" scroll for V & H scrolls */
369 #define LISTVIEW_SCROLL_ICON_LINE_SIZE 37
371 /* Padding between image and label */
372 #define IMAGE_PADDING 2
374 /* Padding behind the label */
375 #define TRAILING_LABEL_PADDING 12
376 #define TRAILING_HEADER_PADDING 11
378 /* Border for the icon caption */
379 #define CAPTION_BORDER 2
381 /* Standard DrawText flags */
382 #define LV_ML_DT_FLAGS (DT_TOP | DT_NOPREFIX | DT_EDITCONTROL | DT_CENTER | DT_WORDBREAK | DT_WORD_ELLIPSIS | DT_END_ELLIPSIS)
383 #define LV_FL_DT_FLAGS (DT_TOP | DT_NOPREFIX | DT_EDITCONTROL | DT_CENTER | DT_WORDBREAK | DT_NOCLIP)
384 #define LV_SL_DT_FLAGS (DT_VCENTER | DT_NOPREFIX | DT_EDITCONTROL | DT_SINGLELINE | DT_WORD_ELLIPSIS | DT_END_ELLIPSIS)
386 /* Image index from state */
387 #define STATEIMAGEINDEX(x) (((x) & LVIS_STATEIMAGEMASK) >> 12)
389 /* The time in milliseconds to reset the search in the list */
390 #define KEY_DELAY 450
392 /* Dump the LISTVIEW_INFO structure to the debug channel */
393 #define LISTVIEW_DUMP(iP) do { \
394 TRACE("hwndSelf=%p, clrBk=0x%06x, clrText=0x%06x, clrTextBk=0x%06x, ItemHeight=%d, ItemWidth=%d, Style=0x%08x\n", \
395 iP->hwndSelf, iP->clrBk, iP->clrText, iP->clrTextBk, \
396 iP->nItemHeight, iP->nItemWidth, iP->dwStyle); \
397 TRACE("hwndSelf=%p, himlNor=%p, himlSml=%p, himlState=%p, Focused=%d, Hot=%d, exStyle=0x%08x, Focus=%d\n", \
398 iP->hwndSelf, iP->himlNormal, iP->himlSmall, iP->himlState, \
399 iP->nFocusedItem, iP->nHotItem, iP->dwLvExStyle, iP->bFocus ); \
400 TRACE("hwndSelf=%p, ntmH=%d, icSz.cx=%d, icSz.cy=%d, icSp.cx=%d, icSp.cy=%d, notifyFmt=%d\n", \
401 iP->hwndSelf, iP->ntmHeight, iP->iconSize.cx, iP->iconSize.cy, \
402 iP->iconSpacing.cx, iP->iconSpacing.cy, iP->notifyFormat); \
403 TRACE("hwndSelf=%p, rcList=%s\n", iP->hwndSelf, wine_dbgstr_rect(&iP->rcList)); \
406 static const WCHAR themeClass
[] = {'L','i','s','t','V','i','e','w',0};
409 * forward declarations
411 static BOOL
LISTVIEW_GetItemT(const LISTVIEW_INFO
*, LPLVITEMW
, BOOL
);
412 static void LISTVIEW_GetItemBox(const LISTVIEW_INFO
*, INT
, LPRECT
);
413 static void LISTVIEW_GetItemOrigin(const LISTVIEW_INFO
*, INT
, LPPOINT
);
414 static BOOL
LISTVIEW_GetItemPosition(const LISTVIEW_INFO
*, INT
, LPPOINT
);
415 static BOOL
LISTVIEW_GetItemRect(const LISTVIEW_INFO
*, INT
, LPRECT
);
416 static INT
LISTVIEW_GetLabelWidth(const LISTVIEW_INFO
*, INT
);
417 static void LISTVIEW_GetOrigin(const LISTVIEW_INFO
*, LPPOINT
);
418 static BOOL
LISTVIEW_GetViewRect(const LISTVIEW_INFO
*, LPRECT
);
419 static void LISTVIEW_UpdateSize(LISTVIEW_INFO
*);
420 static LRESULT
LISTVIEW_Command(LISTVIEW_INFO
*, WPARAM
, LPARAM
);
421 static INT
LISTVIEW_GetStringWidthT(const LISTVIEW_INFO
*, LPCWSTR
, BOOL
);
422 static BOOL
LISTVIEW_KeySelection(LISTVIEW_INFO
*, INT
, BOOL
);
423 static UINT
LISTVIEW_GetItemState(const LISTVIEW_INFO
*, INT
, UINT
);
424 static BOOL
LISTVIEW_SetItemState(LISTVIEW_INFO
*, INT
, const LVITEMW
*);
425 static LRESULT
LISTVIEW_VScroll(LISTVIEW_INFO
*, INT
, INT
, HWND
);
426 static LRESULT
LISTVIEW_HScroll(LISTVIEW_INFO
*, INT
, INT
, HWND
);
427 static BOOL
LISTVIEW_EnsureVisible(LISTVIEW_INFO
*, INT
, BOOL
);
428 static HWND
CreateEditLabelT(LISTVIEW_INFO
*, LPCWSTR
, DWORD
, BOOL
);
429 static HIMAGELIST
LISTVIEW_SetImageList(LISTVIEW_INFO
*, INT
, HIMAGELIST
);
430 static INT
LISTVIEW_HitTest(const LISTVIEW_INFO
*, LPLVHITTESTINFO
, BOOL
, BOOL
);
431 static BOOL
LISTVIEW_EndEditLabelT(LISTVIEW_INFO
*, BOOL
, BOOL
);
433 /******** Text handling functions *************************************/
435 /* A text pointer is either NULL, LPSTR_TEXTCALLBACK, or points to a
436 * text string. The string may be ANSI or Unicode, in which case
437 * the boolean isW tells us the type of the string.
439 * The name of the function tell what type of strings it expects:
440 * W: Unicode, T: ANSI/Unicode - function of isW
443 static inline BOOL
is_textW(LPCWSTR text
)
445 return text
!= NULL
&& text
!= LPSTR_TEXTCALLBACKW
;
448 static inline BOOL
is_textT(LPCWSTR text
, BOOL isW
)
450 /* we can ignore isW since LPSTR_TEXTCALLBACKW == LPSTR_TEXTCALLBACKA */
451 return is_textW(text
);
454 static inline int textlenT(LPCWSTR text
, BOOL isW
)
456 return !is_textT(text
, isW
) ? 0 :
457 isW
? lstrlenW(text
) : lstrlenA((LPCSTR
)text
);
460 static inline void textcpynT(LPWSTR dest
, BOOL isDestW
, LPCWSTR src
, BOOL isSrcW
, INT max
)
463 if (isSrcW
) lstrcpynW(dest
, src
, max
);
464 else MultiByteToWideChar(CP_ACP
, 0, (LPCSTR
)src
, -1, dest
, max
);
466 if (isSrcW
) WideCharToMultiByte(CP_ACP
, 0, src
, -1, (LPSTR
)dest
, max
, NULL
, NULL
);
467 else lstrcpynA((LPSTR
)dest
, (LPCSTR
)src
, max
);
470 static inline LPWSTR
textdupTtoW(LPCWSTR text
, BOOL isW
)
472 LPWSTR wstr
= (LPWSTR
)text
;
474 if (!isW
&& is_textT(text
, isW
))
476 INT len
= MultiByteToWideChar(CP_ACP
, 0, (LPCSTR
)text
, -1, NULL
, 0);
477 wstr
= Alloc(len
* sizeof(WCHAR
));
478 if (wstr
) MultiByteToWideChar(CP_ACP
, 0, (LPCSTR
)text
, -1, wstr
, len
);
480 TRACE(" wstr=%s\n", text
== LPSTR_TEXTCALLBACKW
? "(callback)" : debugstr_w(wstr
));
484 static inline void textfreeT(LPWSTR wstr
, BOOL isW
)
486 if (!isW
&& is_textT(wstr
, isW
)) Free (wstr
);
490 * dest is a pointer to a Unicode string
491 * src is a pointer to a string (Unicode if isW, ANSI if !isW)
493 static BOOL
textsetptrT(LPWSTR
*dest
, LPCWSTR src
, BOOL isW
)
497 if (src
== LPSTR_TEXTCALLBACKW
)
499 if (is_textW(*dest
)) Free(*dest
);
500 *dest
= LPSTR_TEXTCALLBACKW
;
504 LPWSTR pszText
= textdupTtoW(src
, isW
);
505 if (*dest
== LPSTR_TEXTCALLBACKW
) *dest
= NULL
;
506 bResult
= Str_SetPtrW(dest
, pszText
);
507 textfreeT(pszText
, isW
);
513 * compares a Unicode to a Unicode/ANSI text string
515 static inline int textcmpWT(LPCWSTR aw
, LPCWSTR bt
, BOOL isW
)
517 if (!aw
) return bt
? -1 : 0;
518 if (!bt
) return aw
? 1 : 0;
519 if (aw
== LPSTR_TEXTCALLBACKW
)
520 return bt
== LPSTR_TEXTCALLBACKW
? 1 : -1;
521 if (bt
!= LPSTR_TEXTCALLBACKW
)
523 LPWSTR bw
= textdupTtoW(bt
, isW
);
524 int r
= bw
? lstrcmpW(aw
, bw
) : 1;
532 static inline int lstrncmpiW(LPCWSTR s1
, LPCWSTR s2
, int n
)
536 n
= min(min(n
, lstrlenW(s1
)), lstrlenW(s2
));
537 res
= CompareStringW(LOCALE_USER_DEFAULT
, NORM_IGNORECASE
, s1
, n
, s2
, n
);
538 return res
? res
- sizeof(WCHAR
) : res
;
541 /******** Debugging functions *****************************************/
543 static inline LPCSTR
debugtext_t(LPCWSTR text
, BOOL isW
)
545 if (text
== LPSTR_TEXTCALLBACKW
) return "(callback)";
546 return isW
? debugstr_w(text
) : debugstr_a((LPCSTR
)text
);
549 static inline LPCSTR
debugtext_tn(LPCWSTR text
, BOOL isW
, INT n
)
551 if (text
== LPSTR_TEXTCALLBACKW
) return "(callback)";
552 n
= min(textlenT(text
, isW
), n
);
553 return isW
? debugstr_wn(text
, n
) : debugstr_an((LPCSTR
)text
, n
);
556 static char* debug_getbuf(void)
558 static int index
= 0;
559 static char buffers
[DEBUG_BUFFERS
][DEBUG_BUFFER_SIZE
];
560 return buffers
[index
++ % DEBUG_BUFFERS
];
563 static inline const char* debugrange(const RANGE
*lprng
)
565 if (!lprng
) return "(null)";
566 return wine_dbg_sprintf("[%d, %d]", lprng
->lower
, lprng
->upper
);
569 static const char* debugscrollinfo(const SCROLLINFO
*pScrollInfo
)
571 char* buf
= debug_getbuf(), *text
= buf
;
572 int len
, size
= DEBUG_BUFFER_SIZE
;
574 if (pScrollInfo
== NULL
) return "(null)";
575 len
= snprintf(buf
, size
, "{cbSize=%d, ", pScrollInfo
->cbSize
);
576 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
577 if (pScrollInfo
->fMask
& SIF_RANGE
)
578 len
= snprintf(buf
, size
, "nMin=%d, nMax=%d, ", pScrollInfo
->nMin
, pScrollInfo
->nMax
);
580 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
581 if (pScrollInfo
->fMask
& SIF_PAGE
)
582 len
= snprintf(buf
, size
, "nPage=%u, ", pScrollInfo
->nPage
);
584 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
585 if (pScrollInfo
->fMask
& SIF_POS
)
586 len
= snprintf(buf
, size
, "nPos=%d, ", pScrollInfo
->nPos
);
588 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
589 if (pScrollInfo
->fMask
& SIF_TRACKPOS
)
590 len
= snprintf(buf
, size
, "nTrackPos=%d, ", pScrollInfo
->nTrackPos
);
592 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
595 buf
= text
+ strlen(text
);
597 if (buf
- text
> 2) { buf
[-2] = '}'; buf
[-1] = 0; }
601 static const char* debugnmlistview(const NMLISTVIEW
*plvnm
)
603 if (!plvnm
) return "(null)";
604 return wine_dbg_sprintf("iItem=%d, iSubItem=%d, uNewState=0x%x,"
605 " uOldState=0x%x, uChanged=0x%x, ptAction=%s, lParam=%ld",
606 plvnm
->iItem
, plvnm
->iSubItem
, plvnm
->uNewState
, plvnm
->uOldState
,
607 plvnm
->uChanged
, wine_dbgstr_point(&plvnm
->ptAction
), plvnm
->lParam
);
610 static const char* debuglvitem_t(const LVITEMW
*lpLVItem
, BOOL isW
)
612 char* buf
= debug_getbuf(), *text
= buf
;
613 int len
, size
= DEBUG_BUFFER_SIZE
;
615 if (lpLVItem
== NULL
) return "(null)";
616 len
= snprintf(buf
, size
, "{iItem=%d, iSubItem=%d, ", lpLVItem
->iItem
, lpLVItem
->iSubItem
);
617 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
618 if (lpLVItem
->mask
& LVIF_STATE
)
619 len
= snprintf(buf
, size
, "state=%x, stateMask=%x, ", lpLVItem
->state
, lpLVItem
->stateMask
);
621 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
622 if (lpLVItem
->mask
& LVIF_TEXT
)
623 len
= snprintf(buf
, size
, "pszText=%s, cchTextMax=%d, ", debugtext_tn(lpLVItem
->pszText
, isW
, 80), lpLVItem
->cchTextMax
);
625 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
626 if (lpLVItem
->mask
& LVIF_IMAGE
)
627 len
= snprintf(buf
, size
, "iImage=%d, ", lpLVItem
->iImage
);
629 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
630 if (lpLVItem
->mask
& LVIF_PARAM
)
631 len
= snprintf(buf
, size
, "lParam=%lx, ", lpLVItem
->lParam
);
633 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
634 if (lpLVItem
->mask
& LVIF_INDENT
)
635 len
= snprintf(buf
, size
, "iIndent=%d, ", lpLVItem
->iIndent
);
637 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
640 buf
= text
+ strlen(text
);
642 if (buf
- text
> 2) { buf
[-2] = '}'; buf
[-1] = 0; }
646 static const char* debuglvcolumn_t(const LVCOLUMNW
*lpColumn
, BOOL isW
)
648 char* buf
= debug_getbuf(), *text
= buf
;
649 int len
, size
= DEBUG_BUFFER_SIZE
;
651 if (lpColumn
== NULL
) return "(null)";
652 len
= snprintf(buf
, size
, "{");
653 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
654 if (lpColumn
->mask
& LVCF_SUBITEM
)
655 len
= snprintf(buf
, size
, "iSubItem=%d, ", lpColumn
->iSubItem
);
657 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
658 if (lpColumn
->mask
& LVCF_FMT
)
659 len
= snprintf(buf
, size
, "fmt=%x, ", lpColumn
->fmt
);
661 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
662 if (lpColumn
->mask
& LVCF_WIDTH
)
663 len
= snprintf(buf
, size
, "cx=%d, ", lpColumn
->cx
);
665 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
666 if (lpColumn
->mask
& LVCF_TEXT
)
667 len
= snprintf(buf
, size
, "pszText=%s, cchTextMax=%d, ", debugtext_tn(lpColumn
->pszText
, isW
, 80), lpColumn
->cchTextMax
);
669 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
670 if (lpColumn
->mask
& LVCF_IMAGE
)
671 len
= snprintf(buf
, size
, "iImage=%d, ", lpColumn
->iImage
);
673 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
674 if (lpColumn
->mask
& LVCF_ORDER
)
675 len
= snprintf(buf
, size
, "iOrder=%d, ", lpColumn
->iOrder
);
677 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
680 buf
= text
+ strlen(text
);
682 if (buf
- text
> 2) { buf
[-2] = '}'; buf
[-1] = 0; }
686 static const char* debuglvhittestinfo(const LVHITTESTINFO
*lpht
)
688 if (!lpht
) return "(null)";
690 return wine_dbg_sprintf("{pt=%s, flags=0x%x, iItem=%d, iSubItem=%d}",
691 wine_dbgstr_point(&lpht
->pt
), lpht
->flags
, lpht
->iItem
, lpht
->iSubItem
);
694 /* Return the corresponding text for a given scroll value */
695 static inline LPCSTR
debugscrollcode(int nScrollCode
)
699 case SB_LINELEFT
: return "SB_LINELEFT";
700 case SB_LINERIGHT
: return "SB_LINERIGHT";
701 case SB_PAGELEFT
: return "SB_PAGELEFT";
702 case SB_PAGERIGHT
: return "SB_PAGERIGHT";
703 case SB_THUMBPOSITION
: return "SB_THUMBPOSITION";
704 case SB_THUMBTRACK
: return "SB_THUMBTRACK";
705 case SB_ENDSCROLL
: return "SB_ENDSCROLL";
706 case SB_INTERNAL
: return "SB_INTERNAL";
707 default: return "unknown";
712 /******** Notification functions ************************************/
714 static int get_ansi_notification(UINT unicodeNotificationCode
)
716 switch (unicodeNotificationCode
)
718 case LVN_BEGINLABELEDITW
: return LVN_BEGINLABELEDITA
;
719 case LVN_ENDLABELEDITW
: return LVN_ENDLABELEDITA
;
720 case LVN_GETDISPINFOW
: return LVN_GETDISPINFOA
;
721 case LVN_SETDISPINFOW
: return LVN_SETDISPINFOA
;
722 case LVN_ODFINDITEMW
: return LVN_ODFINDITEMA
;
723 case LVN_GETINFOTIPW
: return LVN_GETINFOTIPA
;
724 /* header forwards */
725 case HDN_TRACKW
: return HDN_TRACKA
;
726 case HDN_ENDTRACKW
: return HDN_ENDTRACKA
;
727 case HDN_BEGINDRAG
: return HDN_BEGINDRAG
;
728 case HDN_ENDDRAG
: return HDN_ENDDRAG
;
729 case HDN_ITEMCHANGINGW
: return HDN_ITEMCHANGINGA
;
730 case HDN_ITEMCHANGEDW
: return HDN_ITEMCHANGEDA
;
731 case HDN_ITEMCLICKW
: return HDN_ITEMCLICKA
;
732 case HDN_DIVIDERDBLCLICKW
: return HDN_DIVIDERDBLCLICKA
;
734 ERR("unknown notification %x\n", unicodeNotificationCode
);
739 /* forwards header notifications to listview parent */
740 static LRESULT
notify_forward_header(const LISTVIEW_INFO
*infoPtr
, const NMHEADERW
*lpnmh
)
744 HD_TEXTFILTERA textfilter
;
745 LPSTR text
= NULL
, filter
= NULL
;
748 /* on unicode format exit earlier */
749 if (infoPtr
->notifyFormat
== NFR_UNICODE
)
750 return SendMessageW(infoPtr
->hwndNotify
, WM_NOTIFY
,
751 (WPARAM
)lpnmh
->hdr
.idFrom
, (LPARAM
)lpnmh
);
753 /* header always supplies unicode notifications,
754 all we have to do is to convert strings to ANSI */
755 nmhA
= *(NMHEADERA
*)lpnmh
;
758 hditema
= *(HDITEMA
*)lpnmh
->pitem
;
759 nmhA
.pitem
= &hditema
;
760 /* convert item text */
761 if (lpnmh
->pitem
->mask
& HDI_TEXT
)
763 hditema
.pszText
= NULL
;
764 Str_SetPtrWtoA(&hditema
.pszText
, lpnmh
->pitem
->pszText
);
765 text
= hditema
.pszText
;
767 /* convert filter text */
768 if ((lpnmh
->pitem
->mask
& HDI_FILTER
) && (lpnmh
->pitem
->type
== HDFT_ISSTRING
) &&
769 lpnmh
->pitem
->pvFilter
)
771 hditema
.pvFilter
= &textfilter
;
772 textfilter
= *(HD_TEXTFILTERA
*)(lpnmh
->pitem
->pvFilter
);
773 textfilter
.pszText
= NULL
;
774 Str_SetPtrWtoA(&textfilter
.pszText
, ((HD_TEXTFILTERW
*)lpnmh
->pitem
->pvFilter
)->pszText
);
775 filter
= textfilter
.pszText
;
778 nmhA
.hdr
.code
= get_ansi_notification(lpnmh
->hdr
.code
);
780 ret
= SendMessageW(infoPtr
->hwndNotify
, WM_NOTIFY
,
781 (WPARAM
)nmhA
.hdr
.idFrom
, (LPARAM
)&nmhA
);
790 static LRESULT
notify_hdr(const LISTVIEW_INFO
*infoPtr
, INT code
, LPNMHDR pnmh
)
794 TRACE("(code=%d)\n", code
);
796 pnmh
->hwndFrom
= infoPtr
->hwndSelf
;
797 pnmh
->idFrom
= GetWindowLongPtrW(infoPtr
->hwndSelf
, GWLP_ID
);
799 result
= SendMessageW(infoPtr
->hwndNotify
, WM_NOTIFY
, pnmh
->idFrom
, (LPARAM
)pnmh
);
801 TRACE(" <= %ld\n", result
);
806 static inline BOOL
notify(const LISTVIEW_INFO
*infoPtr
, INT code
)
809 HWND hwnd
= infoPtr
->hwndSelf
;
810 notify_hdr(infoPtr
, code
, &nmh
);
811 return IsWindow(hwnd
);
814 static inline void notify_itemactivate(const LISTVIEW_INFO
*infoPtr
, const LVHITTESTINFO
*htInfo
)
825 item
.mask
= LVIF_PARAM
|LVIF_STATE
;
826 item
.iItem
= htInfo
->iItem
;
828 if (LISTVIEW_GetItemT(infoPtr
, &item
, TRUE
)) {
829 nmia
.lParam
= item
.lParam
;
830 nmia
.uOldState
= item
.state
;
831 nmia
.uNewState
= item
.state
| LVIS_ACTIVATING
;
832 nmia
.uChanged
= LVIF_STATE
;
835 nmia
.iItem
= htInfo
->iItem
;
836 nmia
.iSubItem
= htInfo
->iSubItem
;
837 nmia
.ptAction
= htInfo
->pt
;
839 if (GetKeyState(VK_SHIFT
) & 0x8000) nmia
.uKeyFlags
|= LVKF_SHIFT
;
840 if (GetKeyState(VK_CONTROL
) & 0x8000) nmia
.uKeyFlags
|= LVKF_CONTROL
;
841 if (GetKeyState(VK_MENU
) & 0x8000) nmia
.uKeyFlags
|= LVKF_ALT
;
843 notify_hdr(infoPtr
, LVN_ITEMACTIVATE
, (LPNMHDR
)&nmia
);
846 static inline LRESULT
notify_listview(const LISTVIEW_INFO
*infoPtr
, INT code
, LPNMLISTVIEW plvnm
)
848 TRACE("(code=%d, plvnm=%s)\n", code
, debugnmlistview(plvnm
));
849 return notify_hdr(infoPtr
, code
, (LPNMHDR
)plvnm
);
852 static BOOL
notify_click(const LISTVIEW_INFO
*infoPtr
, INT code
, const LVHITTESTINFO
*lvht
)
856 HWND hwnd
= infoPtr
->hwndSelf
;
858 TRACE("code=%d, lvht=%s\n", code
, debuglvhittestinfo(lvht
));
859 ZeroMemory(&nmia
, sizeof(nmia
));
860 nmia
.iItem
= lvht
->iItem
;
861 nmia
.iSubItem
= lvht
->iSubItem
;
862 nmia
.ptAction
= lvht
->pt
;
863 item
.mask
= LVIF_PARAM
;
864 item
.iItem
= lvht
->iItem
;
866 if (LISTVIEW_GetItemT(infoPtr
, &item
, TRUE
)) nmia
.lParam
= item
.lParam
;
867 notify_hdr(infoPtr
, code
, (LPNMHDR
)&nmia
);
868 return IsWindow(hwnd
);
871 static BOOL
notify_deleteitem(const LISTVIEW_INFO
*infoPtr
, INT nItem
)
875 HWND hwnd
= infoPtr
->hwndSelf
;
877 ZeroMemory(&nmlv
, sizeof (NMLISTVIEW
));
879 item
.mask
= LVIF_PARAM
;
882 if (LISTVIEW_GetItemT(infoPtr
, &item
, TRUE
)) nmlv
.lParam
= item
.lParam
;
883 notify_listview(infoPtr
, LVN_DELETEITEM
, &nmlv
);
884 return IsWindow(hwnd
);
888 Send notification. depends on dispinfoW having same
889 structure as dispinfoA.
890 infoPtr : listview struct
891 notificationCode : *Unicode* notification code
892 pdi : dispinfo structure (can be unicode or ansi)
893 isW : TRUE if dispinfo is Unicode
895 static BOOL
notify_dispinfoT(const LISTVIEW_INFO
*infoPtr
, UINT notificationCode
, LPNMLVDISPINFOW pdi
, BOOL isW
)
897 BOOL bResult
= FALSE
;
898 BOOL convertToAnsi
= FALSE
, convertToUnicode
= FALSE
;
899 INT cchTempBufMax
= 0, savCchTextMax
= 0;
901 LPWSTR pszTempBuf
= NULL
, savPszText
= NULL
;
903 if ((pdi
->item
.mask
& LVIF_TEXT
) && is_textT(pdi
->item
.pszText
, isW
))
905 convertToAnsi
= (isW
&& infoPtr
->notifyFormat
== NFR_ANSI
);
906 convertToUnicode
= (!isW
&& infoPtr
->notifyFormat
== NFR_UNICODE
);
909 if (convertToAnsi
|| convertToUnicode
)
911 if (notificationCode
!= LVN_GETDISPINFOW
)
913 cchTempBufMax
= convertToUnicode
?
914 MultiByteToWideChar(CP_ACP
, 0, (LPCSTR
)pdi
->item
.pszText
, -1, NULL
, 0):
915 WideCharToMultiByte(CP_ACP
, 0, pdi
->item
.pszText
, -1, NULL
, 0, NULL
, NULL
);
919 cchTempBufMax
= pdi
->item
.cchTextMax
;
920 *pdi
->item
.pszText
= 0; /* make sure we don't process garbage */
923 pszTempBuf
= Alloc( (convertToUnicode
? sizeof(WCHAR
) : sizeof(CHAR
)) * cchTempBufMax
);
924 if (!pszTempBuf
) return FALSE
;
926 if (convertToUnicode
)
927 MultiByteToWideChar(CP_ACP
, 0, (LPCSTR
)pdi
->item
.pszText
, -1,
928 pszTempBuf
, cchTempBufMax
);
930 WideCharToMultiByte(CP_ACP
, 0, pdi
->item
.pszText
, -1, (LPSTR
) pszTempBuf
,
931 cchTempBufMax
, NULL
, NULL
);
933 savCchTextMax
= pdi
->item
.cchTextMax
;
934 savPszText
= pdi
->item
.pszText
;
935 pdi
->item
.pszText
= pszTempBuf
;
936 pdi
->item
.cchTextMax
= cchTempBufMax
;
939 if (infoPtr
->notifyFormat
== NFR_ANSI
)
940 realNotifCode
= get_ansi_notification(notificationCode
);
942 realNotifCode
= notificationCode
;
943 TRACE(" pdi->item=%s\n", debuglvitem_t(&pdi
->item
, infoPtr
->notifyFormat
!= NFR_ANSI
));
944 bResult
= notify_hdr(infoPtr
, realNotifCode
, &pdi
->hdr
);
946 if (convertToUnicode
|| convertToAnsi
)
948 if (convertToUnicode
) /* note : pointer can be changed by app ! */
949 WideCharToMultiByte(CP_ACP
, 0, pdi
->item
.pszText
, -1, (LPSTR
) savPszText
,
950 savCchTextMax
, NULL
, NULL
);
952 MultiByteToWideChar(CP_ACP
, 0, (LPSTR
) pdi
->item
.pszText
, -1,
953 savPszText
, savCchTextMax
);
954 pdi
->item
.pszText
= savPszText
; /* restores our buffer */
955 pdi
->item
.cchTextMax
= savCchTextMax
;
961 static void customdraw_fill(NMLVCUSTOMDRAW
*lpnmlvcd
, const LISTVIEW_INFO
*infoPtr
, HDC hdc
,
962 const RECT
*rcBounds
, const LVITEMW
*lplvItem
)
964 ZeroMemory(lpnmlvcd
, sizeof(NMLVCUSTOMDRAW
));
965 lpnmlvcd
->nmcd
.hdc
= hdc
;
966 lpnmlvcd
->nmcd
.rc
= *rcBounds
;
967 lpnmlvcd
->clrTextBk
= infoPtr
->clrTextBk
;
968 lpnmlvcd
->clrText
= infoPtr
->clrText
;
969 if (!lplvItem
) return;
970 lpnmlvcd
->nmcd
.dwItemSpec
= lplvItem
->iItem
+ 1;
971 lpnmlvcd
->iSubItem
= lplvItem
->iSubItem
;
972 if (lplvItem
->state
& LVIS_SELECTED
) lpnmlvcd
->nmcd
.uItemState
|= CDIS_SELECTED
;
973 if (lplvItem
->state
& LVIS_FOCUSED
) lpnmlvcd
->nmcd
.uItemState
|= CDIS_FOCUS
;
974 if (lplvItem
->iItem
== infoPtr
->nHotItem
) lpnmlvcd
->nmcd
.uItemState
|= CDIS_HOT
;
975 lpnmlvcd
->nmcd
.lItemlParam
= lplvItem
->lParam
;
978 static inline DWORD
notify_customdraw (const LISTVIEW_INFO
*infoPtr
, DWORD dwDrawStage
, NMLVCUSTOMDRAW
*lpnmlvcd
)
980 BOOL isForItem
= (lpnmlvcd
->nmcd
.dwItemSpec
!= 0);
983 lpnmlvcd
->nmcd
.dwDrawStage
= dwDrawStage
;
984 if (isForItem
) lpnmlvcd
->nmcd
.dwDrawStage
|= CDDS_ITEM
;
985 if (lpnmlvcd
->iSubItem
) lpnmlvcd
->nmcd
.dwDrawStage
|= CDDS_SUBITEM
;
986 if (isForItem
) lpnmlvcd
->nmcd
.dwItemSpec
--;
987 result
= notify_hdr(infoPtr
, NM_CUSTOMDRAW
, &lpnmlvcd
->nmcd
.hdr
);
988 if (isForItem
) lpnmlvcd
->nmcd
.dwItemSpec
++;
992 static void prepaint_setup (const LISTVIEW_INFO
*infoPtr
, HDC hdc
, NMLVCUSTOMDRAW
*lpnmlvcd
, BOOL SubItem
)
994 if (lpnmlvcd
->clrTextBk
== CLR_DEFAULT
)
995 lpnmlvcd
->clrTextBk
= comctl32_color
.clrWindow
;
996 if (lpnmlvcd
->clrText
== CLR_DEFAULT
)
997 lpnmlvcd
->clrText
= comctl32_color
.clrWindowText
;
999 /* apparently, for selected items, we have to override the returned values */
1002 if (lpnmlvcd
->nmcd
.uItemState
& CDIS_SELECTED
)
1004 if (infoPtr
->bFocus
)
1006 lpnmlvcd
->clrTextBk
= comctl32_color
.clrHighlight
;
1007 lpnmlvcd
->clrText
= comctl32_color
.clrHighlightText
;
1009 else if (infoPtr
->dwStyle
& LVS_SHOWSELALWAYS
)
1011 lpnmlvcd
->clrTextBk
= comctl32_color
.clr3dFace
;
1012 lpnmlvcd
->clrText
= comctl32_color
.clrBtnText
;
1017 /* Set the text attributes */
1018 if (lpnmlvcd
->clrTextBk
!= CLR_NONE
)
1020 SetBkMode(hdc
, OPAQUE
);
1021 SetBkColor(hdc
,lpnmlvcd
->clrTextBk
);
1024 SetBkMode(hdc
, TRANSPARENT
);
1025 SetTextColor(hdc
, lpnmlvcd
->clrText
);
1028 static inline DWORD
notify_postpaint (const LISTVIEW_INFO
*infoPtr
, NMLVCUSTOMDRAW
*lpnmlvcd
)
1030 return notify_customdraw(infoPtr
, CDDS_POSTPAINT
, lpnmlvcd
);
1033 /* returns TRUE when repaint needed, FALSE otherwise */
1034 static BOOL
notify_measureitem(LISTVIEW_INFO
*infoPtr
)
1036 MEASUREITEMSTRUCT mis
;
1037 mis
.CtlType
= ODT_LISTVIEW
;
1038 mis
.CtlID
= GetWindowLongPtrW(infoPtr
->hwndSelf
, GWLP_ID
);
1042 mis
.itemHeight
= infoPtr
->nItemHeight
;
1043 SendMessageW(infoPtr
->hwndNotify
, WM_MEASUREITEM
, mis
.CtlID
, (LPARAM
)&mis
);
1044 if (infoPtr
->nItemHeight
!= max(mis
.itemHeight
, 1))
1046 infoPtr
->nMeasureItemHeight
= infoPtr
->nItemHeight
= max(mis
.itemHeight
, 1);
1052 /******** Item iterator functions **********************************/
1054 static RANGES
ranges_create(int count
);
1055 static void ranges_destroy(RANGES ranges
);
1056 static BOOL
ranges_add(RANGES ranges
, RANGE range
);
1057 static BOOL
ranges_del(RANGES ranges
, RANGE range
);
1058 static void ranges_dump(RANGES ranges
);
1060 static inline BOOL
ranges_additem(RANGES ranges
, INT nItem
)
1062 RANGE range
= { nItem
, nItem
+ 1 };
1064 return ranges_add(ranges
, range
);
1067 static inline BOOL
ranges_delitem(RANGES ranges
, INT nItem
)
1069 RANGE range
= { nItem
, nItem
+ 1 };
1071 return ranges_del(ranges
, range
);
1075 * ITERATOR DOCUMENTATION
1077 * The iterator functions allow for easy, and convenient iteration
1078 * over items of interest in the list. Typically, you create a
1079 * iterator, use it, and destroy it, as such:
1082 * iterator_xxxitems(&i, ...);
1083 * while (iterator_{prev,next}(&i)
1085 * //code which uses i.nItem
1087 * iterator_destroy(&i);
1089 * where xxx is either: framed, or visible.
1090 * Note that it is important that the code destroys the iterator
1091 * after it's done with it, as the creation of the iterator may
1092 * allocate memory, which thus needs to be freed.
1094 * You can iterate both forwards, and backwards through the list,
1095 * by using iterator_next or iterator_prev respectively.
1097 * Lower numbered items are draw on top of higher number items in
1098 * LVS_ICON, and LVS_SMALLICON (which are the only modes where
1099 * items may overlap). So, to test items, you should use
1101 * which lists the items top to bottom (in Z-order).
1102 * For drawing items, you should use
1104 * which lists the items bottom to top (in Z-order).
1105 * If you keep iterating over the items after the end-of-items
1106 * marker (-1) is returned, the iterator will start from the
1107 * beginning. Typically, you don't need to test for -1,
1108 * because iterator_{next,prev} will return TRUE if more items
1109 * are to be iterated over, or FALSE otherwise.
1111 * Note: the iterator is defined to be bidirectional. That is,
1112 * any number of prev followed by any number of next, or
1113 * five versa, should leave the iterator at the same item:
1114 * prev * n, next * n = next * n, prev * n
1116 * The iterator has a notion of an out-of-order, special item,
1117 * which sits at the start of the list. This is used in
1118 * LVS_ICON, and LVS_SMALLICON mode to handle the focused item,
1119 * which needs to be first, as it may overlap other items.
1121 * The code is a bit messy because we have:
1122 * - a special item to deal with
1123 * - simple range, or composite range
1125 * If you find bugs, or want to add features, please make sure you
1126 * always check/modify *both* iterator_prev, and iterator_next.
1130 * This function iterates through the items in increasing order,
1131 * but prefixed by the special item, then -1. That is:
1132 * special, 1, 2, 3, ..., n, -1.
1133 * Each item is listed only once.
1135 static inline BOOL
iterator_next(ITERATOR
* i
)
1139 i
->nItem
= i
->nSpecial
;
1140 if (i
->nItem
!= -1) return TRUE
;
1142 if (i
->nItem
== i
->nSpecial
)
1144 if (i
->ranges
) i
->index
= 0;
1150 if (i
->nItem
== i
->nSpecial
) i
->nItem
++;
1151 if (i
->nItem
< i
->range
.upper
) return TRUE
;
1156 if (i
->index
< DPA_GetPtrCount(i
->ranges
->hdpa
))
1157 i
->range
= *(RANGE
*)DPA_GetPtr(i
->ranges
->hdpa
, i
->index
++);
1160 else if (i
->nItem
>= i
->range
.upper
) goto end
;
1162 i
->nItem
= i
->range
.lower
;
1163 if (i
->nItem
>= 0) goto testitem
;
1170 * This function iterates through the items in decreasing order,
1171 * followed by the special item, then -1. That is:
1172 * n, n-1, ..., 3, 2, 1, special, -1.
1173 * Each item is listed only once.
1175 static inline BOOL
iterator_prev(ITERATOR
* i
)
1182 if (i
->ranges
) i
->index
= DPA_GetPtrCount(i
->ranges
->hdpa
);
1185 if (i
->nItem
== i
->nSpecial
)
1193 if (i
->nItem
== i
->nSpecial
) i
->nItem
--;
1194 if (i
->nItem
>= i
->range
.lower
) return TRUE
;
1200 i
->range
= *(RANGE
*)DPA_GetPtr(i
->ranges
->hdpa
, --i
->index
);
1203 else if (!start
&& i
->nItem
< i
->range
.lower
) goto end
;
1205 i
->nItem
= i
->range
.upper
;
1206 if (i
->nItem
> 0) goto testitem
;
1208 return (i
->nItem
= i
->nSpecial
) != -1;
1211 static RANGE
iterator_range(const ITERATOR
*i
)
1215 if (!i
->ranges
) return i
->range
;
1217 if (DPA_GetPtrCount(i
->ranges
->hdpa
) > 0)
1219 range
.lower
= (*(RANGE
*)DPA_GetPtr(i
->ranges
->hdpa
, 0)).lower
;
1220 range
.upper
= (*(RANGE
*)DPA_GetPtr(i
->ranges
->hdpa
, DPA_GetPtrCount(i
->ranges
->hdpa
) - 1)).upper
;
1222 else range
.lower
= range
.upper
= 0;
1228 * Releases resources associated with this ierator.
1230 static inline void iterator_destroy(const ITERATOR
*i
)
1232 ranges_destroy(i
->ranges
);
1236 * Create an empty iterator.
1238 static inline BOOL
iterator_empty(ITERATOR
* i
)
1240 ZeroMemory(i
, sizeof(*i
));
1241 i
->nItem
= i
->nSpecial
= i
->range
.lower
= i
->range
.upper
= -1;
1246 * Create an iterator over a range.
1248 static inline BOOL
iterator_rangeitems(ITERATOR
* i
, RANGE range
)
1256 * Create an iterator over a bunch of ranges.
1257 * Please note that the iterator will take ownership of the ranges,
1258 * and will free them upon destruction.
1260 static inline BOOL
iterator_rangesitems(ITERATOR
* i
, RANGES ranges
)
1268 * Creates an iterator over the items which intersect lprc.
1270 static BOOL
iterator_frameditems(ITERATOR
* i
, const LISTVIEW_INFO
* infoPtr
, const RECT
*lprc
)
1272 RECT frame
= *lprc
, rcItem
, rcTemp
;
1275 /* in case we fail, we want to return an empty iterator */
1276 if (!iterator_empty(i
)) return FALSE
;
1278 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
1280 TRACE("(lprc=%s)\n", wine_dbgstr_rect(lprc
));
1281 OffsetRect(&frame
, -Origin
.x
, -Origin
.y
);
1283 if (infoPtr
->uView
== LV_VIEW_ICON
|| infoPtr
->uView
== LV_VIEW_SMALLICON
)
1287 if (infoPtr
->uView
== LV_VIEW_ICON
&& infoPtr
->nFocusedItem
!= -1)
1289 LISTVIEW_GetItemBox(infoPtr
, infoPtr
->nFocusedItem
, &rcItem
);
1290 if (IntersectRect(&rcTemp
, &rcItem
, lprc
))
1291 i
->nSpecial
= infoPtr
->nFocusedItem
;
1293 if (!(iterator_rangesitems(i
, ranges_create(50)))) return FALSE
;
1294 /* to do better here, we need to have PosX, and PosY sorted */
1295 TRACE("building icon ranges:\n");
1296 for (nItem
= 0; nItem
< infoPtr
->nItemCount
; nItem
++)
1298 rcItem
.left
= (LONG_PTR
)DPA_GetPtr(infoPtr
->hdpaPosX
, nItem
);
1299 rcItem
.top
= (LONG_PTR
)DPA_GetPtr(infoPtr
->hdpaPosY
, nItem
);
1300 rcItem
.right
= rcItem
.left
+ infoPtr
->nItemWidth
;
1301 rcItem
.bottom
= rcItem
.top
+ infoPtr
->nItemHeight
;
1302 if (IntersectRect(&rcTemp
, &rcItem
, &frame
))
1303 ranges_additem(i
->ranges
, nItem
);
1307 else if (infoPtr
->uView
== LV_VIEW_DETAILS
)
1311 if (frame
.left
>= infoPtr
->nItemWidth
) return TRUE
;
1312 if (frame
.top
>= infoPtr
->nItemHeight
* infoPtr
->nItemCount
) return TRUE
;
1314 range
.lower
= max(frame
.top
/ infoPtr
->nItemHeight
, 0);
1315 range
.upper
= min((frame
.bottom
- 1) / infoPtr
->nItemHeight
, infoPtr
->nItemCount
- 1) + 1;
1316 if (range
.upper
<= range
.lower
) return TRUE
;
1317 if (!iterator_rangeitems(i
, range
)) return FALSE
;
1318 TRACE(" report=%s\n", debugrange(&i
->range
));
1322 INT nPerCol
= max((infoPtr
->rcList
.bottom
- infoPtr
->rcList
.top
) / infoPtr
->nItemHeight
, 1);
1323 INT nFirstRow
= max(frame
.top
/ infoPtr
->nItemHeight
, 0);
1324 INT nLastRow
= min((frame
.bottom
- 1) / infoPtr
->nItemHeight
, nPerCol
- 1);
1331 if (infoPtr
->nItemWidth
)
1333 nFirstCol
= max(frame
.left
/ infoPtr
->nItemWidth
, 0);
1334 nLastCol
= min((frame
.right
- 1) / infoPtr
->nItemWidth
, (infoPtr
->nItemCount
+ nPerCol
- 1) / nPerCol
);
1338 nFirstCol
= max(frame
.left
, 0);
1339 nLastCol
= min(frame
.right
- 1, (infoPtr
->nItemCount
+ nPerCol
- 1) / nPerCol
);
1342 lower
= nFirstCol
* nPerCol
+ nFirstRow
;
1344 TRACE("nPerCol=%d, nFirstRow=%d, nLastRow=%d, nFirstCol=%d, nLastCol=%d, lower=%d\n",
1345 nPerCol
, nFirstRow
, nLastRow
, nFirstCol
, nLastCol
, lower
);
1347 if (nLastCol
< nFirstCol
|| nLastRow
< nFirstRow
) return TRUE
;
1349 if (!(iterator_rangesitems(i
, ranges_create(nLastCol
- nFirstCol
+ 1)))) return FALSE
;
1350 TRACE("building list ranges:\n");
1351 for (nCol
= nFirstCol
; nCol
<= nLastCol
; nCol
++)
1353 item_range
.lower
= nCol
* nPerCol
+ nFirstRow
;
1354 if(item_range
.lower
>= infoPtr
->nItemCount
) break;
1355 item_range
.upper
= min(nCol
* nPerCol
+ nLastRow
+ 1, infoPtr
->nItemCount
);
1356 TRACE(" list=%s\n", debugrange(&item_range
));
1357 ranges_add(i
->ranges
, item_range
);
1365 * Creates an iterator over the items which intersect the visible region of hdc.
1367 static BOOL
iterator_visibleitems(ITERATOR
*i
, const LISTVIEW_INFO
*infoPtr
, HDC hdc
)
1369 POINT Origin
, Position
;
1370 RECT rcItem
, rcClip
;
1373 rgntype
= GetClipBox(hdc
, &rcClip
);
1374 if (rgntype
== NULLREGION
) return iterator_empty(i
);
1375 if (!iterator_frameditems(i
, infoPtr
, &rcClip
)) return FALSE
;
1376 if (rgntype
== SIMPLEREGION
) return TRUE
;
1378 /* first deal with the special item */
1379 if (i
->nSpecial
!= -1)
1381 LISTVIEW_GetItemBox(infoPtr
, i
->nSpecial
, &rcItem
);
1382 if (!RectVisible(hdc
, &rcItem
)) i
->nSpecial
= -1;
1385 /* if we can't deal with the region, we'll just go with the simple range */
1386 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
1387 TRACE("building visible range:\n");
1388 if (!i
->ranges
&& i
->range
.lower
< i
->range
.upper
)
1390 if (!(i
->ranges
= ranges_create(50))) return TRUE
;
1391 if (!ranges_add(i
->ranges
, i
->range
))
1393 ranges_destroy(i
->ranges
);
1399 /* now delete the invisible items from the list */
1400 while(iterator_next(i
))
1402 LISTVIEW_GetItemOrigin(infoPtr
, i
->nItem
, &Position
);
1403 rcItem
.left
= (infoPtr
->uView
== LV_VIEW_DETAILS
) ? Origin
.x
: Position
.x
+ Origin
.x
;
1404 rcItem
.top
= Position
.y
+ Origin
.y
;
1405 rcItem
.right
= rcItem
.left
+ infoPtr
->nItemWidth
;
1406 rcItem
.bottom
= rcItem
.top
+ infoPtr
->nItemHeight
;
1407 if (!RectVisible(hdc
, &rcItem
))
1408 ranges_delitem(i
->ranges
, i
->nItem
);
1410 /* the iterator should restart on the next iterator_next */
1416 /******** Misc helper functions ************************************/
1418 static inline LRESULT
CallWindowProcT(WNDPROC proc
, HWND hwnd
, UINT uMsg
,
1419 WPARAM wParam
, LPARAM lParam
, BOOL isW
)
1421 if (isW
) return CallWindowProcW(proc
, hwnd
, uMsg
, wParam
, lParam
);
1422 else return CallWindowProcA(proc
, hwnd
, uMsg
, wParam
, lParam
);
1425 static inline BOOL
is_autoarrange(const LISTVIEW_INFO
*infoPtr
)
1427 return ((infoPtr
->dwStyle
& LVS_AUTOARRANGE
) || infoPtr
->bAutoarrange
) &&
1428 (infoPtr
->uView
== LV_VIEW_ICON
|| infoPtr
->uView
== LV_VIEW_SMALLICON
);
1431 static void toggle_checkbox_state(LISTVIEW_INFO
*infoPtr
, INT nItem
)
1433 DWORD state
= STATEIMAGEINDEX(LISTVIEW_GetItemState(infoPtr
, nItem
, LVIS_STATEIMAGEMASK
));
1434 if(state
== 1 || state
== 2)
1438 lvitem
.state
= INDEXTOSTATEIMAGEMASK(state
);
1439 lvitem
.stateMask
= LVIS_STATEIMAGEMASK
;
1440 LISTVIEW_SetItemState(infoPtr
, nItem
, &lvitem
);
1444 /* this should be called after window style got updated,
1445 it used to reset view state to match current window style */
1446 static inline void map_style_view(LISTVIEW_INFO
*infoPtr
)
1448 switch (infoPtr
->dwStyle
& LVS_TYPEMASK
)
1451 infoPtr
->uView
= LV_VIEW_ICON
;
1454 infoPtr
->uView
= LV_VIEW_DETAILS
;
1457 infoPtr
->uView
= LV_VIEW_SMALLICON
;
1460 infoPtr
->uView
= LV_VIEW_LIST
;
1464 /* computes next item id value */
1465 static DWORD
get_next_itemid(const LISTVIEW_INFO
*infoPtr
)
1467 INT count
= DPA_GetPtrCount(infoPtr
->hdpaItemIds
);
1471 ITEM_ID
*lpID
= DPA_GetPtr(infoPtr
->hdpaItemIds
, count
- 1);
1472 return lpID
->id
+ 1;
1477 /******** Internal API functions ************************************/
1479 static inline COLUMN_INFO
* LISTVIEW_GetColumnInfo(const LISTVIEW_INFO
*infoPtr
, INT nSubItem
)
1481 static COLUMN_INFO mainItem
;
1483 if (nSubItem
== 0 && DPA_GetPtrCount(infoPtr
->hdpaColumns
) == 0) return &mainItem
;
1484 assert (nSubItem
>= 0 && nSubItem
< DPA_GetPtrCount(infoPtr
->hdpaColumns
));
1486 /* update cached column rectangles */
1487 if (infoPtr
->colRectsDirty
)
1490 LISTVIEW_INFO
*Ptr
= (LISTVIEW_INFO
*)infoPtr
;
1493 for (i
= 0; i
< DPA_GetPtrCount(infoPtr
->hdpaColumns
); i
++) {
1494 info
= DPA_GetPtr(infoPtr
->hdpaColumns
, i
);
1495 SendMessageW(infoPtr
->hwndHeader
, HDM_GETITEMRECT
, i
, (LPARAM
)&info
->rcHeader
);
1497 Ptr
->colRectsDirty
= FALSE
;
1500 return DPA_GetPtr(infoPtr
->hdpaColumns
, nSubItem
);
1503 static INT
LISTVIEW_CreateHeader(LISTVIEW_INFO
*infoPtr
)
1505 DWORD dFlags
= WS_CHILD
| HDS_HORZ
| HDS_FULLDRAG
| HDS_DRAGDROP
;
1508 if (infoPtr
->hwndHeader
) return 0;
1510 TRACE("Creating header for list %p\n", infoPtr
->hwndSelf
);
1512 /* setup creation flags */
1513 dFlags
|= (LVS_NOSORTHEADER
& infoPtr
->dwStyle
) ? 0 : HDS_BUTTONS
;
1514 dFlags
|= (LVS_NOCOLUMNHEADER
& infoPtr
->dwStyle
) ? HDS_HIDDEN
: 0;
1516 hInst
= (HINSTANCE
)GetWindowLongPtrW(infoPtr
->hwndSelf
, GWLP_HINSTANCE
);
1519 infoPtr
->hwndHeader
= CreateWindowW(WC_HEADERW
, NULL
, dFlags
,
1520 0, 0, 0, 0, infoPtr
->hwndSelf
, NULL
, hInst
, NULL
);
1521 if (!infoPtr
->hwndHeader
) return -1;
1523 /* set header unicode format */
1524 SendMessageW(infoPtr
->hwndHeader
, HDM_SETUNICODEFORMAT
, TRUE
, 0);
1526 /* set header font */
1527 SendMessageW(infoPtr
->hwndHeader
, WM_SETFONT
, (WPARAM
)infoPtr
->hFont
, (LPARAM
)TRUE
);
1529 LISTVIEW_UpdateSize(infoPtr
);
1534 static inline void LISTVIEW_GetHeaderRect(const LISTVIEW_INFO
*infoPtr
, INT nSubItem
, LPRECT lprc
)
1536 *lprc
= LISTVIEW_GetColumnInfo(infoPtr
, nSubItem
)->rcHeader
;
1539 static inline BOOL
LISTVIEW_GetItemW(const LISTVIEW_INFO
*infoPtr
, LPLVITEMW lpLVItem
)
1541 return LISTVIEW_GetItemT(infoPtr
, lpLVItem
, TRUE
);
1544 /* used to handle collapse main item column case */
1545 static inline BOOL
LISTVIEW_DrawFocusRect(const LISTVIEW_INFO
*infoPtr
, HDC hdc
)
1547 return (infoPtr
->rcFocus
.left
< infoPtr
->rcFocus
.right
) ?
1548 DrawFocusRect(hdc
, &infoPtr
->rcFocus
) : FALSE
;
1551 /* Listview invalidation functions: use _only_ these functions to invalidate */
1553 static inline BOOL
is_redrawing(const LISTVIEW_INFO
*infoPtr
)
1555 return infoPtr
->bRedraw
;
1558 static inline void LISTVIEW_InvalidateRect(const LISTVIEW_INFO
*infoPtr
, const RECT
* rect
)
1560 if(!is_redrawing(infoPtr
)) return;
1561 TRACE(" invalidating rect=%s\n", wine_dbgstr_rect(rect
));
1562 InvalidateRect(infoPtr
->hwndSelf
, rect
, TRUE
);
1565 static inline void LISTVIEW_InvalidateItem(const LISTVIEW_INFO
*infoPtr
, INT nItem
)
1569 if(!is_redrawing(infoPtr
)) return;
1570 LISTVIEW_GetItemBox(infoPtr
, nItem
, &rcBox
);
1571 LISTVIEW_InvalidateRect(infoPtr
, &rcBox
);
1574 static inline void LISTVIEW_InvalidateSubItem(const LISTVIEW_INFO
*infoPtr
, INT nItem
, INT nSubItem
)
1576 POINT Origin
, Position
;
1579 if(!is_redrawing(infoPtr
)) return;
1580 assert (infoPtr
->uView
== LV_VIEW_DETAILS
);
1581 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
1582 LISTVIEW_GetItemOrigin(infoPtr
, nItem
, &Position
);
1583 LISTVIEW_GetHeaderRect(infoPtr
, nSubItem
, &rcBox
);
1585 rcBox
.bottom
= infoPtr
->nItemHeight
;
1586 OffsetRect(&rcBox
, Origin
.x
+ Position
.x
, Origin
.y
+ Position
.y
);
1587 LISTVIEW_InvalidateRect(infoPtr
, &rcBox
);
1590 static inline void LISTVIEW_InvalidateList(const LISTVIEW_INFO
*infoPtr
)
1592 LISTVIEW_InvalidateRect(infoPtr
, NULL
);
1595 static inline void LISTVIEW_InvalidateColumn(const LISTVIEW_INFO
*infoPtr
, INT nColumn
)
1599 if(!is_redrawing(infoPtr
)) return;
1600 LISTVIEW_GetHeaderRect(infoPtr
, nColumn
, &rcCol
);
1601 rcCol
.top
= infoPtr
->rcList
.top
;
1602 rcCol
.bottom
= infoPtr
->rcList
.bottom
;
1603 LISTVIEW_InvalidateRect(infoPtr
, &rcCol
);
1608 * Retrieves the number of items that can fit vertically in the client area.
1611 * [I] infoPtr : valid pointer to the listview structure
1614 * Number of items per row.
1616 static inline INT
LISTVIEW_GetCountPerRow(const LISTVIEW_INFO
*infoPtr
)
1618 INT nListWidth
= infoPtr
->rcList
.right
- infoPtr
->rcList
.left
;
1620 return max(nListWidth
/(infoPtr
->nItemWidth
? infoPtr
->nItemWidth
: 1), 1);
1625 * Retrieves the number of items that can fit horizontally in the client
1629 * [I] infoPtr : valid pointer to the listview structure
1632 * Number of items per column.
1634 static inline INT
LISTVIEW_GetCountPerColumn(const LISTVIEW_INFO
*infoPtr
)
1636 INT nListHeight
= infoPtr
->rcList
.bottom
- infoPtr
->rcList
.top
;
1638 return max(nListHeight
/ infoPtr
->nItemHeight
, 1);
1642 /*************************************************************************
1643 * LISTVIEW_ProcessLetterKeys
1645 * Processes keyboard messages generated by pressing the letter keys
1647 * What this does is perform a case insensitive search from the
1648 * current position with the following quirks:
1649 * - If two chars or more are pressed in quick succession we search
1650 * for the corresponding string (e.g. 'abc').
1651 * - If there is a delay we wipe away the current search string and
1652 * restart with just that char.
1653 * - If the user keeps pressing the same character, whether slowly or
1654 * fast, so that the search string is entirely composed of this
1655 * character ('aaaaa' for instance), then we search for first item
1656 * that starting with that character.
1657 * - If the user types the above character in quick succession, then
1658 * we must also search for the corresponding string ('aaaaa'), and
1659 * go to that string if there is a match.
1662 * [I] hwnd : handle to the window
1663 * [I] charCode : the character code, the actual character
1664 * [I] keyData : key data
1672 * - The current implementation has a list of characters it will
1673 * accept and it ignores everything else. In particular it will
1674 * ignore accentuated characters which seems to match what
1675 * Windows does. But I'm not sure it makes sense to follow
1677 * - We don't sound a beep when the search fails.
1681 * TREEVIEW_ProcessLetterKeys
1683 static INT
LISTVIEW_ProcessLetterKeys(LISTVIEW_INFO
*infoPtr
, WPARAM charCode
, LPARAM keyData
)
1688 WCHAR buffer
[MAX_PATH
];
1689 DWORD lastKeyPressTimestamp
= infoPtr
->lastKeyPressTimestamp
;
1691 /* simple parameter checking */
1692 if (!charCode
|| !keyData
) return 0;
1694 /* only allow the valid WM_CHARs through */
1695 if (!isalnumW(charCode
) &&
1696 charCode
!= '.' && charCode
!= '`' && charCode
!= '!' &&
1697 charCode
!= '@' && charCode
!= '#' && charCode
!= '$' &&
1698 charCode
!= '%' && charCode
!= '^' && charCode
!= '&' &&
1699 charCode
!= '*' && charCode
!= '(' && charCode
!= ')' &&
1700 charCode
!= '-' && charCode
!= '_' && charCode
!= '+' &&
1701 charCode
!= '=' && charCode
!= '\\'&& charCode
!= ']' &&
1702 charCode
!= '}' && charCode
!= '[' && charCode
!= '{' &&
1703 charCode
!= '/' && charCode
!= '?' && charCode
!= '>' &&
1704 charCode
!= '<' && charCode
!= ',' && charCode
!= '~')
1707 /* if there's one item or less, there is no where to go */
1708 if (infoPtr
->nItemCount
<= 1) return 0;
1710 /* update the search parameters */
1711 infoPtr
->lastKeyPressTimestamp
= GetTickCount();
1712 if (infoPtr
->lastKeyPressTimestamp
- lastKeyPressTimestamp
< KEY_DELAY
) {
1713 if (infoPtr
->nSearchParamLength
< MAX_PATH
-1)
1714 infoPtr
->szSearchParam
[infoPtr
->nSearchParamLength
++]=charCode
;
1715 if (infoPtr
->charCode
!= charCode
)
1716 infoPtr
->charCode
= charCode
= 0;
1718 infoPtr
->charCode
=charCode
;
1719 infoPtr
->szSearchParam
[0]=charCode
;
1720 infoPtr
->nSearchParamLength
=1;
1721 /* Redundant with the 1 char string */
1725 /* and search from the current position */
1727 if (infoPtr
->nFocusedItem
>= 0) {
1728 endidx
=infoPtr
->nFocusedItem
;
1730 /* if looking for single character match,
1731 * then we must always move forward
1733 if (infoPtr
->nSearchParamLength
== 1)
1736 endidx
=infoPtr
->nItemCount
;
1740 /* Let application handle this for virtual listview */
1741 if (infoPtr
->dwStyle
& LVS_OWNERDATA
)
1746 ZeroMemory(&lvfi
, sizeof(lvfi
));
1747 lvfi
.flags
= (LVFI_WRAP
| LVFI_PARTIAL
);
1748 infoPtr
->szSearchParam
[infoPtr
->nSearchParamLength
] = '\0';
1749 lvfi
.psz
= infoPtr
->szSearchParam
;
1753 nItem
= notify_hdr(infoPtr
, LVN_ODFINDITEMW
, (LPNMHDR
)&nmlv
.hdr
);
1756 LISTVIEW_KeySelection(infoPtr
, nItem
, FALSE
);
1762 if (idx
== infoPtr
->nItemCount
) {
1763 if (endidx
== infoPtr
->nItemCount
|| endidx
== 0)
1769 item
.mask
= LVIF_TEXT
;
1772 item
.pszText
= buffer
;
1773 item
.cchTextMax
= MAX_PATH
;
1774 if (!LISTVIEW_GetItemW(infoPtr
, &item
)) return 0;
1776 /* check for a match */
1777 if (lstrncmpiW(item
.pszText
,infoPtr
->szSearchParam
,infoPtr
->nSearchParamLength
) == 0) {
1780 } else if ( (charCode
!= 0) && (nItem
== -1) && (nItem
!= infoPtr
->nFocusedItem
) &&
1781 (lstrncmpiW(item
.pszText
,infoPtr
->szSearchParam
,1) == 0) ) {
1782 /* This would work but we must keep looking for a longer match */
1786 } while (idx
!= endidx
);
1789 LISTVIEW_KeySelection(infoPtr
, nItem
, FALSE
);
1794 /*************************************************************************
1795 * LISTVIEW_UpdateHeaderSize [Internal]
1797 * Function to resize the header control
1800 * [I] hwnd : handle to a window
1801 * [I] nNewScrollPos : scroll pos to set
1806 static void LISTVIEW_UpdateHeaderSize(const LISTVIEW_INFO
*infoPtr
, INT nNewScrollPos
)
1811 TRACE("nNewScrollPos=%d\n", nNewScrollPos
);
1813 if (!infoPtr
->hwndHeader
) return;
1815 GetWindowRect(infoPtr
->hwndHeader
, &winRect
);
1816 point
[0].x
= winRect
.left
;
1817 point
[0].y
= winRect
.top
;
1818 point
[1].x
= winRect
.right
;
1819 point
[1].y
= winRect
.bottom
;
1821 MapWindowPoints(HWND_DESKTOP
, infoPtr
->hwndSelf
, point
, 2);
1822 point
[0].x
= -nNewScrollPos
;
1823 point
[1].x
+= nNewScrollPos
;
1825 SetWindowPos(infoPtr
->hwndHeader
,0,
1826 point
[0].x
,point
[0].y
,point
[1].x
,point
[1].y
,
1827 (infoPtr
->dwStyle
& LVS_NOCOLUMNHEADER
) ? SWP_HIDEWINDOW
: SWP_SHOWWINDOW
|
1828 SWP_NOZORDER
| SWP_NOACTIVATE
);
1833 * Update the scrollbars. This functions should be called whenever
1834 * the content, size or view changes.
1837 * [I] infoPtr : valid pointer to the listview structure
1842 static void LISTVIEW_UpdateScroll(const LISTVIEW_INFO
*infoPtr
)
1844 SCROLLINFO horzInfo
, vertInfo
;
1847 if ((infoPtr
->dwStyle
& LVS_NOSCROLL
) || !is_redrawing(infoPtr
)) return;
1849 ZeroMemory(&horzInfo
, sizeof(SCROLLINFO
));
1850 horzInfo
.cbSize
= sizeof(SCROLLINFO
);
1851 horzInfo
.nPage
= infoPtr
->rcList
.right
- infoPtr
->rcList
.left
;
1853 /* for now, we'll set info.nMax to the _count_, and adjust it later */
1854 if (infoPtr
->uView
== LV_VIEW_LIST
)
1856 INT nPerCol
= LISTVIEW_GetCountPerColumn(infoPtr
);
1857 horzInfo
.nMax
= (infoPtr
->nItemCount
+ nPerCol
- 1) / nPerCol
;
1859 /* scroll by at least one column per page */
1860 if(horzInfo
.nPage
< infoPtr
->nItemWidth
)
1861 horzInfo
.nPage
= infoPtr
->nItemWidth
;
1863 if (infoPtr
->nItemWidth
)
1864 horzInfo
.nPage
/= infoPtr
->nItemWidth
;
1866 else if (infoPtr
->uView
== LV_VIEW_DETAILS
)
1868 horzInfo
.nMax
= infoPtr
->nItemWidth
;
1870 else /* LV_VIEW_ICON, or LV_VIEW_SMALLICON */
1874 if (LISTVIEW_GetViewRect(infoPtr
, &rcView
)) horzInfo
.nMax
= rcView
.right
- rcView
.left
;
1877 horzInfo
.fMask
= SIF_RANGE
| SIF_PAGE
;
1878 horzInfo
.nMax
= max(horzInfo
.nMax
- 1, 0);
1879 dx
= GetScrollPos(infoPtr
->hwndSelf
, SB_HORZ
);
1880 dx
-= SetScrollInfo(infoPtr
->hwndSelf
, SB_HORZ
, &horzInfo
, TRUE
);
1881 TRACE("horzInfo=%s\n", debugscrollinfo(&horzInfo
));
1883 /* Setting the horizontal scroll can change the listview size
1884 * (and potentially everything else) so we need to recompute
1885 * everything again for the vertical scroll
1888 ZeroMemory(&vertInfo
, sizeof(SCROLLINFO
));
1889 vertInfo
.cbSize
= sizeof(SCROLLINFO
);
1890 vertInfo
.nPage
= infoPtr
->rcList
.bottom
- infoPtr
->rcList
.top
;
1892 if (infoPtr
->uView
== LV_VIEW_DETAILS
)
1894 vertInfo
.nMax
= infoPtr
->nItemCount
;
1896 /* scroll by at least one page */
1897 if(vertInfo
.nPage
< infoPtr
->nItemHeight
)
1898 vertInfo
.nPage
= infoPtr
->nItemHeight
;
1900 if (infoPtr
->nItemHeight
> 0)
1901 vertInfo
.nPage
/= infoPtr
->nItemHeight
;
1903 else if (infoPtr
->uView
!= LV_VIEW_LIST
) /* LV_VIEW_ICON, or LV_VIEW_SMALLICON */
1907 if (LISTVIEW_GetViewRect(infoPtr
, &rcView
)) vertInfo
.nMax
= rcView
.bottom
- rcView
.top
;
1910 vertInfo
.fMask
= SIF_RANGE
| SIF_PAGE
;
1911 vertInfo
.nMax
= max(vertInfo
.nMax
- 1, 0);
1912 dy
= GetScrollPos(infoPtr
->hwndSelf
, SB_VERT
);
1913 dy
-= SetScrollInfo(infoPtr
->hwndSelf
, SB_VERT
, &vertInfo
, TRUE
);
1914 TRACE("vertInfo=%s\n", debugscrollinfo(&vertInfo
));
1916 /* Change of the range may have changed the scroll pos. If so move the content */
1917 if (dx
!= 0 || dy
!= 0)
1920 listRect
= infoPtr
->rcList
;
1921 ScrollWindowEx(infoPtr
->hwndSelf
, dx
, dy
, &listRect
, &listRect
, 0, 0,
1922 SW_ERASE
| SW_INVALIDATE
);
1925 /* Update the Header Control */
1926 if (infoPtr
->uView
== LV_VIEW_DETAILS
)
1928 horzInfo
.fMask
= SIF_POS
;
1929 GetScrollInfo(infoPtr
->hwndSelf
, SB_HORZ
, &horzInfo
);
1930 LISTVIEW_UpdateHeaderSize(infoPtr
, horzInfo
.nPos
);
1937 * Shows/hides the focus rectangle.
1940 * [I] infoPtr : valid pointer to the listview structure
1941 * [I] fShow : TRUE to show the focus, FALSE to hide it.
1946 static void LISTVIEW_ShowFocusRect(const LISTVIEW_INFO
*infoPtr
, BOOL fShow
)
1950 TRACE("fShow=%d, nItem=%d\n", fShow
, infoPtr
->nFocusedItem
);
1952 if (infoPtr
->nFocusedItem
< 0) return;
1954 /* we need some gymnastics in ICON mode to handle large items */
1955 if (infoPtr
->uView
== LV_VIEW_ICON
)
1959 LISTVIEW_GetItemBox(infoPtr
, infoPtr
->nFocusedItem
, &rcBox
);
1960 if ((rcBox
.bottom
- rcBox
.top
) > infoPtr
->nItemHeight
)
1962 LISTVIEW_InvalidateRect(infoPtr
, &rcBox
);
1967 if (!(hdc
= GetDC(infoPtr
->hwndSelf
))) return;
1969 /* for some reason, owner draw should work only in report mode */
1970 if ((infoPtr
->dwStyle
& LVS_OWNERDRAWFIXED
) && (infoPtr
->uView
== LV_VIEW_DETAILS
))
1975 HFONT hFont
= infoPtr
->hFont
? infoPtr
->hFont
: infoPtr
->hDefaultFont
;
1976 HFONT hOldFont
= SelectObject(hdc
, hFont
);
1978 item
.iItem
= infoPtr
->nFocusedItem
;
1980 item
.mask
= LVIF_PARAM
;
1981 if (!LISTVIEW_GetItemW(infoPtr
, &item
)) goto done
;
1983 ZeroMemory(&dis
, sizeof(dis
));
1984 dis
.CtlType
= ODT_LISTVIEW
;
1985 dis
.CtlID
= (UINT
)GetWindowLongPtrW(infoPtr
->hwndSelf
, GWLP_ID
);
1986 dis
.itemID
= item
.iItem
;
1987 dis
.itemAction
= ODA_FOCUS
;
1988 if (fShow
) dis
.itemState
|= ODS_FOCUS
;
1989 dis
.hwndItem
= infoPtr
->hwndSelf
;
1991 LISTVIEW_GetItemBox(infoPtr
, dis
.itemID
, &dis
.rcItem
);
1992 dis
.itemData
= item
.lParam
;
1994 SendMessageW(infoPtr
->hwndNotify
, WM_DRAWITEM
, dis
.CtlID
, (LPARAM
)&dis
);
1996 SelectObject(hdc
, hOldFont
);
2000 LISTVIEW_DrawFocusRect(infoPtr
, hdc
);
2003 ReleaseDC(infoPtr
->hwndSelf
, hdc
);
2007 * Invalidates all visible selected items.
2009 static void LISTVIEW_InvalidateSelectedItems(const LISTVIEW_INFO
*infoPtr
)
2013 iterator_frameditems(&i
, infoPtr
, &infoPtr
->rcList
);
2014 while(iterator_next(&i
))
2016 if (LISTVIEW_GetItemState(infoPtr
, i
.nItem
, LVIS_SELECTED
))
2017 LISTVIEW_InvalidateItem(infoPtr
, i
.nItem
);
2019 iterator_destroy(&i
);
2024 * DESCRIPTION: [INTERNAL]
2025 * Computes an item's (left,top) corner, relative to rcView.
2026 * That is, the position has NOT been made relative to the Origin.
2027 * This is deliberate, to avoid computing the Origin over, and
2028 * over again, when this function is called in a loop. Instead,
2029 * one can factor the computation of the Origin before the loop,
2030 * and offset the value returned by this function, on every iteration.
2033 * [I] infoPtr : valid pointer to the listview structure
2034 * [I] nItem : item number
2035 * [O] lpptOrig : item top, left corner
2040 static void LISTVIEW_GetItemOrigin(const LISTVIEW_INFO
*infoPtr
, INT nItem
, LPPOINT lpptPosition
)
2042 assert(nItem
>= 0 && nItem
< infoPtr
->nItemCount
);
2044 if ((infoPtr
->uView
== LV_VIEW_SMALLICON
) || (infoPtr
->uView
== LV_VIEW_ICON
))
2046 lpptPosition
->x
= (LONG_PTR
)DPA_GetPtr(infoPtr
->hdpaPosX
, nItem
);
2047 lpptPosition
->y
= (LONG_PTR
)DPA_GetPtr(infoPtr
->hdpaPosY
, nItem
);
2049 else if (infoPtr
->uView
== LV_VIEW_LIST
)
2051 INT nCountPerColumn
= LISTVIEW_GetCountPerColumn(infoPtr
);
2052 lpptPosition
->x
= nItem
/ nCountPerColumn
* infoPtr
->nItemWidth
;
2053 lpptPosition
->y
= nItem
% nCountPerColumn
* infoPtr
->nItemHeight
;
2055 else /* LV_VIEW_DETAILS */
2057 lpptPosition
->x
= REPORT_MARGINX
;
2058 /* item is always at zero indexed column */
2059 if (DPA_GetPtrCount(infoPtr
->hdpaColumns
) > 0)
2060 lpptPosition
->x
+= LISTVIEW_GetColumnInfo(infoPtr
, 0)->rcHeader
.left
;
2061 lpptPosition
->y
= nItem
* infoPtr
->nItemHeight
;
2066 * DESCRIPTION: [INTERNAL]
2067 * Compute the rectangles of an item. This is to localize all
2068 * the computations in one place. If you are not interested in some
2069 * of these values, simply pass in a NULL -- the function is smart
2070 * enough to compute only what's necessary. The function computes
2071 * the standard rectangles (BOUNDS, ICON, LABEL) plus a non-standard
2072 * one, the BOX rectangle. This rectangle is very cheap to compute,
2073 * and is guaranteed to contain all the other rectangles. Computing
2074 * the ICON rect is also cheap, but all the others are potentially
2075 * expensive. This gives an easy and effective optimization when
2076 * searching (like point inclusion, or rectangle intersection):
2077 * first test against the BOX, and if TRUE, test against the desired
2079 * If the function does not have all the necessary information
2080 * to computed the requested rectangles, will crash with a
2081 * failed assertion. This is done so we catch all programming
2082 * errors, given that the function is called only from our code.
2084 * We have the following 'special' meanings for a few fields:
2085 * * If LVIS_FOCUSED is set, we assume the item has the focus
2086 * This is important in ICON mode, where it might get a larger
2087 * then usual rectangle
2089 * Please note that subitem support works only in REPORT mode.
2092 * [I] infoPtr : valid pointer to the listview structure
2093 * [I] lpLVItem : item to compute the measures for
2094 * [O] lprcBox : ptr to Box rectangle
2095 * Same as LVM_GETITEMRECT with LVIR_BOUNDS
2096 * [0] lprcSelectBox : ptr to select box rectangle
2097 * Same as LVM_GETITEMRECT with LVIR_SELECTEDBOUNDS
2098 * [O] lprcIcon : ptr to Icon rectangle
2099 * Same as LVM_GETITEMRECT with LVIR_ICON
2100 * [O] lprcStateIcon: ptr to State Icon rectangle
2101 * [O] lprcLabel : ptr to Label rectangle
2102 * Same as LVM_GETITEMRECT with LVIR_LABEL
2107 static void LISTVIEW_GetItemMetrics(const LISTVIEW_INFO
*infoPtr
, const LVITEMW
*lpLVItem
,
2108 LPRECT lprcBox
, LPRECT lprcSelectBox
,
2109 LPRECT lprcIcon
, LPRECT lprcStateIcon
, LPRECT lprcLabel
)
2111 BOOL doSelectBox
= FALSE
, doIcon
= FALSE
, doLabel
= FALSE
, oversizedBox
= FALSE
;
2112 RECT Box
, SelectBox
, Icon
, Label
;
2113 COLUMN_INFO
*lpColumnInfo
= NULL
;
2114 SIZE labelSize
= { 0, 0 };
2116 TRACE("(lpLVItem=%s)\n", debuglvitem_t(lpLVItem
, TRUE
));
2118 /* Be smart and try to figure out the minimum we have to do */
2119 if (lpLVItem
->iSubItem
) assert(infoPtr
->uView
== LV_VIEW_DETAILS
);
2120 if (infoPtr
->uView
== LV_VIEW_ICON
&& (lprcBox
|| lprcLabel
))
2122 assert((lpLVItem
->mask
& LVIF_STATE
) && (lpLVItem
->stateMask
& LVIS_FOCUSED
));
2123 if (lpLVItem
->state
& LVIS_FOCUSED
) oversizedBox
= doLabel
= TRUE
;
2125 if (lprcSelectBox
) doSelectBox
= TRUE
;
2126 if (lprcLabel
) doLabel
= TRUE
;
2127 if (doLabel
|| lprcIcon
|| lprcStateIcon
) doIcon
= TRUE
;
2134 /************************************************************/
2135 /* compute the box rectangle (it should be cheap to do) */
2136 /************************************************************/
2137 if (lpLVItem
->iSubItem
|| infoPtr
->uView
== LV_VIEW_DETAILS
)
2138 lpColumnInfo
= LISTVIEW_GetColumnInfo(infoPtr
, lpLVItem
->iSubItem
);
2140 if (lpLVItem
->iSubItem
)
2142 Box
= lpColumnInfo
->rcHeader
;
2147 Box
.right
= infoPtr
->nItemWidth
;
2150 Box
.bottom
= infoPtr
->nItemHeight
;
2152 /******************************************************************/
2153 /* compute ICON bounding box (ala LVM_GETITEMRECT) and STATEICON */
2154 /******************************************************************/
2157 LONG state_width
= 0;
2159 if (infoPtr
->himlState
&& lpLVItem
->iSubItem
== 0)
2160 state_width
= infoPtr
->iconStateSize
.cx
;
2162 if (infoPtr
->uView
== LV_VIEW_ICON
)
2164 Icon
.left
= Box
.left
+ state_width
;
2165 if (infoPtr
->himlNormal
)
2166 Icon
.left
+= (infoPtr
->nItemWidth
- infoPtr
->iconSize
.cx
- state_width
) / 2;
2167 Icon
.top
= Box
.top
+ ICON_TOP_PADDING
;
2168 Icon
.right
= Icon
.left
;
2169 Icon
.bottom
= Icon
.top
;
2170 if (infoPtr
->himlNormal
)
2172 Icon
.right
+= infoPtr
->iconSize
.cx
;
2173 Icon
.bottom
+= infoPtr
->iconSize
.cy
;
2176 else /* LV_VIEW_SMALLICON, LV_VIEW_LIST or LV_VIEW_DETAILS */
2178 Icon
.left
= Box
.left
+ state_width
;
2180 if (infoPtr
->uView
== LV_VIEW_DETAILS
&& lpLVItem
->iSubItem
== 0)
2182 /* we need the indent in report mode */
2183 assert(lpLVItem
->mask
& LVIF_INDENT
);
2184 Icon
.left
+= infoPtr
->iconSize
.cx
* lpLVItem
->iIndent
+ REPORT_MARGINX
;
2188 Icon
.right
= Icon
.left
;
2189 if (infoPtr
->himlSmall
&&
2190 (!lpColumnInfo
|| lpLVItem
->iSubItem
== 0 || (lpColumnInfo
->fmt
& LVCFMT_IMAGE
) ||
2191 ((infoPtr
->dwLvExStyle
& LVS_EX_SUBITEMIMAGES
) && lpLVItem
->iImage
!= I_IMAGECALLBACK
)))
2192 Icon
.right
+= infoPtr
->iconSize
.cx
;
2193 Icon
.bottom
= Icon
.top
+ infoPtr
->iconSize
.cy
;
2195 if(lprcIcon
) *lprcIcon
= Icon
;
2196 TRACE(" - icon=%s\n", wine_dbgstr_rect(&Icon
));
2198 /* TODO: is this correct? */
2201 lprcStateIcon
->left
= Icon
.left
- state_width
;
2202 lprcStateIcon
->right
= Icon
.left
;
2203 lprcStateIcon
->top
= Icon
.top
;
2204 lprcStateIcon
->bottom
= lprcStateIcon
->top
+ infoPtr
->iconSize
.cy
;
2205 TRACE(" - state icon=%s\n", wine_dbgstr_rect(lprcStateIcon
));
2208 else Icon
.right
= 0;
2210 /************************************************************/
2211 /* compute LABEL bounding box (ala LVM_GETITEMRECT) */
2212 /************************************************************/
2215 /* calculate how far to the right can the label stretch */
2216 Label
.right
= Box
.right
;
2217 if (infoPtr
->uView
== LV_VIEW_DETAILS
)
2219 if (lpLVItem
->iSubItem
== 0)
2221 /* we need a zero based rect here */
2222 Label
= lpColumnInfo
->rcHeader
;
2223 OffsetRect(&Label
, -Label
.left
, 0);
2227 if (lpLVItem
->iSubItem
|| ((infoPtr
->dwStyle
& LVS_OWNERDRAWFIXED
) && infoPtr
->uView
== LV_VIEW_DETAILS
))
2229 labelSize
.cx
= infoPtr
->nItemWidth
;
2230 labelSize
.cy
= infoPtr
->nItemHeight
;
2234 /* we need the text in non owner draw mode */
2235 assert(lpLVItem
->mask
& LVIF_TEXT
);
2236 if (is_textT(lpLVItem
->pszText
, TRUE
))
2238 HFONT hFont
= infoPtr
->hFont
? infoPtr
->hFont
: infoPtr
->hDefaultFont
;
2239 HDC hdc
= GetDC(infoPtr
->hwndSelf
);
2240 HFONT hOldFont
= SelectObject(hdc
, hFont
);
2244 /* compute rough rectangle where the label will go */
2245 SetRectEmpty(&rcText
);
2246 rcText
.right
= infoPtr
->nItemWidth
- TRAILING_LABEL_PADDING
;
2247 rcText
.bottom
= infoPtr
->nItemHeight
;
2248 if (infoPtr
->uView
== LV_VIEW_ICON
)
2249 rcText
.bottom
-= ICON_TOP_PADDING
+ infoPtr
->iconSize
.cy
+ ICON_BOTTOM_PADDING
;
2251 /* now figure out the flags */
2252 if (infoPtr
->uView
== LV_VIEW_ICON
)
2253 uFormat
= oversizedBox
? LV_FL_DT_FLAGS
: LV_ML_DT_FLAGS
;
2255 uFormat
= LV_SL_DT_FLAGS
;
2257 DrawTextW (hdc
, lpLVItem
->pszText
, -1, &rcText
, uFormat
| DT_CALCRECT
);
2259 if (rcText
.right
!= rcText
.left
)
2260 labelSize
.cx
= min(rcText
.right
- rcText
.left
+ TRAILING_LABEL_PADDING
, infoPtr
->nItemWidth
);
2262 labelSize
.cy
= rcText
.bottom
- rcText
.top
;
2264 SelectObject(hdc
, hOldFont
);
2265 ReleaseDC(infoPtr
->hwndSelf
, hdc
);
2269 if (infoPtr
->uView
== LV_VIEW_ICON
)
2271 Label
.left
= Box
.left
+ (infoPtr
->nItemWidth
- labelSize
.cx
) / 2;
2272 Label
.top
= Box
.top
+ ICON_TOP_PADDING_HITABLE
+
2273 infoPtr
->iconSize
.cy
+ ICON_BOTTOM_PADDING
;
2274 Label
.right
= Label
.left
+ labelSize
.cx
;
2275 Label
.bottom
= Label
.top
+ infoPtr
->nItemHeight
;
2276 if (!oversizedBox
&& labelSize
.cy
> infoPtr
->ntmHeight
)
2278 labelSize
.cy
= min(Box
.bottom
- Label
.top
, labelSize
.cy
);
2279 labelSize
.cy
/= infoPtr
->ntmHeight
;
2280 labelSize
.cy
= max(labelSize
.cy
, 1);
2281 labelSize
.cy
*= infoPtr
->ntmHeight
;
2283 Label
.bottom
= Label
.top
+ labelSize
.cy
+ HEIGHT_PADDING
;
2285 else if (infoPtr
->uView
== LV_VIEW_DETAILS
)
2287 Label
.left
= Icon
.right
;
2288 Label
.top
= Box
.top
;
2289 Label
.right
= lpLVItem
->iSubItem
? lpColumnInfo
->rcHeader
.right
:
2290 lpColumnInfo
->rcHeader
.right
- lpColumnInfo
->rcHeader
.left
;
2291 Label
.bottom
= Label
.top
+ infoPtr
->nItemHeight
;
2293 else /* LV_VIEW_SMALLICON or LV_VIEW_LIST */
2295 Label
.left
= Icon
.right
;
2296 Label
.top
= Box
.top
;
2297 Label
.right
= min(Label
.left
+ labelSize
.cx
, Label
.right
);
2298 Label
.bottom
= Label
.top
+ infoPtr
->nItemHeight
;
2301 if (lprcLabel
) *lprcLabel
= Label
;
2302 TRACE(" - label=%s\n", wine_dbgstr_rect(&Label
));
2305 /************************************************************/
2306 /* compute SELECT bounding box */
2307 /************************************************************/
2310 if (infoPtr
->uView
== LV_VIEW_DETAILS
)
2312 SelectBox
.left
= Icon
.left
;
2313 SelectBox
.top
= Box
.top
;
2314 SelectBox
.bottom
= Box
.bottom
;
2317 SelectBox
.right
= min(Label
.left
+ labelSize
.cx
, Label
.right
);
2319 SelectBox
.right
= min(Label
.left
+ MAX_EMPTYTEXT_SELECT_WIDTH
, Label
.right
);
2323 UnionRect(&SelectBox
, &Icon
, &Label
);
2325 if (lprcSelectBox
) *lprcSelectBox
= SelectBox
;
2326 TRACE(" - select box=%s\n", wine_dbgstr_rect(&SelectBox
));
2329 /* Fix the Box if necessary */
2332 if (oversizedBox
) UnionRect(lprcBox
, &Box
, &Label
);
2333 else *lprcBox
= Box
;
2335 TRACE(" - box=%s\n", wine_dbgstr_rect(&Box
));
2339 * DESCRIPTION: [INTERNAL]
2342 * [I] infoPtr : valid pointer to the listview structure
2343 * [I] nItem : item number
2344 * [O] lprcBox : ptr to Box rectangle
2349 static void LISTVIEW_GetItemBox(const LISTVIEW_INFO
*infoPtr
, INT nItem
, LPRECT lprcBox
)
2351 WCHAR szDispText
[DISP_TEXT_SIZE
] = { '\0' };
2352 POINT Position
, Origin
;
2355 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
2356 LISTVIEW_GetItemOrigin(infoPtr
, nItem
, &Position
);
2358 /* Be smart and try to figure out the minimum we have to do */
2360 if (infoPtr
->uView
== LV_VIEW_ICON
&& infoPtr
->bFocus
&& LISTVIEW_GetItemState(infoPtr
, nItem
, LVIS_FOCUSED
))
2361 lvItem
.mask
|= LVIF_TEXT
;
2362 lvItem
.iItem
= nItem
;
2363 lvItem
.iSubItem
= 0;
2364 lvItem
.pszText
= szDispText
;
2365 lvItem
.cchTextMax
= DISP_TEXT_SIZE
;
2366 if (lvItem
.mask
) LISTVIEW_GetItemW(infoPtr
, &lvItem
);
2367 if (infoPtr
->uView
== LV_VIEW_ICON
)
2369 lvItem
.mask
|= LVIF_STATE
;
2370 lvItem
.stateMask
= LVIS_FOCUSED
;
2371 lvItem
.state
= (lvItem
.mask
& LVIF_TEXT
? LVIS_FOCUSED
: 0);
2373 LISTVIEW_GetItemMetrics(infoPtr
, &lvItem
, lprcBox
, 0, 0, 0, 0);
2375 if (infoPtr
->uView
== LV_VIEW_DETAILS
&& infoPtr
->dwLvExStyle
& LVS_EX_FULLROWSELECT
&&
2376 SendMessageW(infoPtr
->hwndHeader
, HDM_ORDERTOINDEX
, 0, 0))
2378 OffsetRect(lprcBox
, Origin
.x
, Position
.y
+ Origin
.y
);
2381 OffsetRect(lprcBox
, Position
.x
+ Origin
.x
, Position
.y
+ Origin
.y
);
2384 /* LISTVIEW_MapIdToIndex helper */
2385 static INT CALLBACK
MapIdSearchCompare(LPVOID p1
, LPVOID p2
, LPARAM lParam
)
2387 ITEM_ID
*id1
= (ITEM_ID
*)p1
;
2388 ITEM_ID
*id2
= (ITEM_ID
*)p2
;
2390 if (id1
->id
== id2
->id
) return 0;
2392 return (id1
->id
< id2
->id
) ? -1 : 1;
2397 * Returns the item index for id specified.
2400 * [I] infoPtr : valid pointer to the listview structure
2401 * [I] iID : item id to get index for
2404 * Item index, or -1 on failure.
2406 static INT
LISTVIEW_MapIdToIndex(const LISTVIEW_INFO
*infoPtr
, UINT iID
)
2411 TRACE("iID=%d\n", iID
);
2413 if (infoPtr
->dwStyle
& LVS_OWNERDATA
) return -1;
2414 if (infoPtr
->nItemCount
== 0) return -1;
2417 index
= DPA_Search(infoPtr
->hdpaItemIds
, &ID
, -1, &MapIdSearchCompare
, 0, DPAS_SORTED
);
2421 ITEM_ID
*lpID
= DPA_GetPtr(infoPtr
->hdpaItemIds
, index
);
2422 return DPA_GetPtrIndex(infoPtr
->hdpaItems
, lpID
->item
);
2430 * Returns the item id for index given.
2433 * [I] infoPtr : valid pointer to the listview structure
2434 * [I] iItem : item index to get id for
2439 static DWORD
LISTVIEW_MapIndexToId(const LISTVIEW_INFO
*infoPtr
, INT iItem
)
2444 TRACE("iItem=%d\n", iItem
);
2446 if (infoPtr
->dwStyle
& LVS_OWNERDATA
) return -1;
2447 if (iItem
< 0 || iItem
>= infoPtr
->nItemCount
) return -1;
2449 hdpaSubItems
= DPA_GetPtr(infoPtr
->hdpaItems
, iItem
);
2450 lpItem
= DPA_GetPtr(hdpaSubItems
, 0);
2452 return lpItem
->id
->id
;
2457 * Returns the current icon position, and advances it along the top.
2458 * The returned position is not offset by Origin.
2461 * [I] infoPtr : valid pointer to the listview structure
2462 * [O] lpPos : will get the current icon position
2467 static void LISTVIEW_NextIconPosTop(LISTVIEW_INFO
*infoPtr
, LPPOINT lpPos
)
2469 INT nListWidth
= infoPtr
->rcList
.right
- infoPtr
->rcList
.left
;
2471 *lpPos
= infoPtr
->currIconPos
;
2473 infoPtr
->currIconPos
.x
+= infoPtr
->nItemWidth
;
2474 if (infoPtr
->currIconPos
.x
+ infoPtr
->nItemWidth
<= nListWidth
) return;
2476 infoPtr
->currIconPos
.x
= 0;
2477 infoPtr
->currIconPos
.y
+= infoPtr
->nItemHeight
;
2483 * Returns the current icon position, and advances it down the left edge.
2484 * The returned position is not offset by Origin.
2487 * [I] infoPtr : valid pointer to the listview structure
2488 * [O] lpPos : will get the current icon position
2493 static void LISTVIEW_NextIconPosLeft(LISTVIEW_INFO
*infoPtr
, LPPOINT lpPos
)
2495 INT nListHeight
= infoPtr
->rcList
.bottom
- infoPtr
->rcList
.top
;
2497 *lpPos
= infoPtr
->currIconPos
;
2499 infoPtr
->currIconPos
.y
+= infoPtr
->nItemHeight
;
2500 if (infoPtr
->currIconPos
.y
+ infoPtr
->nItemHeight
<= nListHeight
) return;
2502 infoPtr
->currIconPos
.x
+= infoPtr
->nItemWidth
;
2503 infoPtr
->currIconPos
.y
= 0;
2509 * Moves an icon to the specified position.
2510 * It takes care of invalidating the item, etc.
2513 * [I] infoPtr : valid pointer to the listview structure
2514 * [I] nItem : the item to move
2515 * [I] lpPos : the new icon position
2516 * [I] isNew : flags the item as being new
2522 static BOOL
LISTVIEW_MoveIconTo(const LISTVIEW_INFO
*infoPtr
, INT nItem
, const POINT
*lppt
, BOOL isNew
)
2528 old
.x
= (LONG_PTR
)DPA_GetPtr(infoPtr
->hdpaPosX
, nItem
);
2529 old
.y
= (LONG_PTR
)DPA_GetPtr(infoPtr
->hdpaPosY
, nItem
);
2531 if (lppt
->x
== old
.x
&& lppt
->y
== old
.y
) return TRUE
;
2532 LISTVIEW_InvalidateItem(infoPtr
, nItem
);
2535 /* Allocating a POINTER for every item is too resource intensive,
2536 * so we'll keep the (x,y) in different arrays */
2537 if (!DPA_SetPtr(infoPtr
->hdpaPosX
, nItem
, (void *)(LONG_PTR
)lppt
->x
)) return FALSE
;
2538 if (!DPA_SetPtr(infoPtr
->hdpaPosY
, nItem
, (void *)(LONG_PTR
)lppt
->y
)) return FALSE
;
2540 LISTVIEW_InvalidateItem(infoPtr
, nItem
);
2547 * Arranges listview items in icon display mode.
2550 * [I] infoPtr : valid pointer to the listview structure
2551 * [I] nAlignCode : alignment code
2557 static BOOL
LISTVIEW_Arrange(LISTVIEW_INFO
*infoPtr
, INT nAlignCode
)
2559 void (*next_pos
)(LISTVIEW_INFO
*, LPPOINT
);
2563 if (infoPtr
->uView
!= LV_VIEW_ICON
&& infoPtr
->uView
!= LV_VIEW_SMALLICON
) return FALSE
;
2565 TRACE("nAlignCode=%d\n", nAlignCode
);
2567 if (nAlignCode
== LVA_DEFAULT
)
2569 if (infoPtr
->dwStyle
& LVS_ALIGNLEFT
) nAlignCode
= LVA_ALIGNLEFT
;
2570 else nAlignCode
= LVA_ALIGNTOP
;
2575 case LVA_ALIGNLEFT
: next_pos
= LISTVIEW_NextIconPosLeft
; break;
2576 case LVA_ALIGNTOP
: next_pos
= LISTVIEW_NextIconPosTop
; break;
2577 case LVA_SNAPTOGRID
: next_pos
= LISTVIEW_NextIconPosTop
; break; /* FIXME */
2578 default: return FALSE
;
2581 infoPtr
->bAutoarrange
= TRUE
;
2582 infoPtr
->currIconPos
.x
= infoPtr
->currIconPos
.y
= 0;
2583 for (i
= 0; i
< infoPtr
->nItemCount
; i
++)
2585 next_pos(infoPtr
, &pos
);
2586 LISTVIEW_MoveIconTo(infoPtr
, i
, &pos
, FALSE
);
2594 * Retrieves the bounding rectangle of all the items, not offset by Origin.
2595 * For LVS_REPORT always returns empty rectangle.
2598 * [I] infoPtr : valid pointer to the listview structure
2599 * [O] lprcView : bounding rectangle
2605 static void LISTVIEW_GetAreaRect(const LISTVIEW_INFO
*infoPtr
, LPRECT lprcView
)
2609 SetRectEmpty(lprcView
);
2611 switch (infoPtr
->uView
)
2614 case LV_VIEW_SMALLICON
:
2615 for (i
= 0; i
< infoPtr
->nItemCount
; i
++)
2617 x
= (LONG_PTR
)DPA_GetPtr(infoPtr
->hdpaPosX
, i
);
2618 y
= (LONG_PTR
)DPA_GetPtr(infoPtr
->hdpaPosY
, i
);
2619 lprcView
->right
= max(lprcView
->right
, x
);
2620 lprcView
->bottom
= max(lprcView
->bottom
, y
);
2622 if (infoPtr
->nItemCount
> 0)
2624 lprcView
->right
+= infoPtr
->nItemWidth
;
2625 lprcView
->bottom
+= infoPtr
->nItemHeight
;
2630 y
= LISTVIEW_GetCountPerColumn(infoPtr
);
2631 x
= infoPtr
->nItemCount
/ y
;
2632 if (infoPtr
->nItemCount
% y
) x
++;
2633 lprcView
->right
= x
* infoPtr
->nItemWidth
;
2634 lprcView
->bottom
= y
* infoPtr
->nItemHeight
;
2641 * Retrieves the bounding rectangle of all the items.
2644 * [I] infoPtr : valid pointer to the listview structure
2645 * [O] lprcView : bounding rectangle
2651 static BOOL
LISTVIEW_GetViewRect(const LISTVIEW_INFO
*infoPtr
, LPRECT lprcView
)
2655 TRACE("(lprcView=%p)\n", lprcView
);
2657 if (!lprcView
) return FALSE
;
2659 LISTVIEW_GetAreaRect(infoPtr
, lprcView
);
2661 if (infoPtr
->uView
!= LV_VIEW_DETAILS
)
2663 LISTVIEW_GetOrigin(infoPtr
, &ptOrigin
);
2664 OffsetRect(lprcView
, ptOrigin
.x
, ptOrigin
.y
);
2667 TRACE("lprcView=%s\n", wine_dbgstr_rect(lprcView
));
2674 * Retrieves the subitem pointer associated with the subitem index.
2677 * [I] hdpaSubItems : DPA handle for a specific item
2678 * [I] nSubItem : index of subitem
2681 * SUCCESS : subitem pointer
2684 static SUBITEM_INFO
* LISTVIEW_GetSubItemPtr(HDPA hdpaSubItems
, INT nSubItem
)
2686 SUBITEM_INFO
*lpSubItem
;
2689 /* we should binary search here if need be */
2690 for (i
= 1; i
< DPA_GetPtrCount(hdpaSubItems
); i
++)
2692 lpSubItem
= DPA_GetPtr(hdpaSubItems
, i
);
2693 if (lpSubItem
->iSubItem
== nSubItem
)
2703 * Calculates the desired item width.
2706 * [I] infoPtr : valid pointer to the listview structure
2709 * The desired item width.
2711 static INT
LISTVIEW_CalculateItemWidth(const LISTVIEW_INFO
*infoPtr
)
2715 TRACE("uView=%d\n", infoPtr
->uView
);
2717 if (infoPtr
->uView
== LV_VIEW_ICON
)
2718 nItemWidth
= infoPtr
->iconSpacing
.cx
;
2719 else if (infoPtr
->uView
== LV_VIEW_DETAILS
)
2721 if (DPA_GetPtrCount(infoPtr
->hdpaColumns
) > 0)
2726 index
= SendMessageW(infoPtr
->hwndHeader
, HDM_ORDERTOINDEX
,
2727 DPA_GetPtrCount(infoPtr
->hdpaColumns
) - 1, 0);
2729 LISTVIEW_GetHeaderRect(infoPtr
, index
, &rcHeader
);
2730 nItemWidth
= rcHeader
.right
;
2733 else /* LV_VIEW_SMALLICON, or LV_VIEW_LIST */
2737 for (i
= 0; i
< infoPtr
->nItemCount
; i
++)
2738 nItemWidth
= max(LISTVIEW_GetLabelWidth(infoPtr
, i
), nItemWidth
);
2740 if (infoPtr
->himlSmall
) nItemWidth
+= infoPtr
->iconSize
.cx
;
2741 if (infoPtr
->himlState
) nItemWidth
+= infoPtr
->iconStateSize
.cx
;
2743 nItemWidth
= max(DEFAULT_COLUMN_WIDTH
, nItemWidth
+ WIDTH_PADDING
);
2751 * Calculates the desired item height.
2754 * [I] infoPtr : valid pointer to the listview structure
2757 * The desired item height.
2759 static INT
LISTVIEW_CalculateItemHeight(const LISTVIEW_INFO
*infoPtr
)
2763 TRACE("uView=%d\n", infoPtr
->uView
);
2765 if (infoPtr
->uView
== LV_VIEW_ICON
)
2766 nItemHeight
= infoPtr
->iconSpacing
.cy
;
2769 nItemHeight
= infoPtr
->ntmHeight
;
2770 if (infoPtr
->uView
== LV_VIEW_DETAILS
&& infoPtr
->dwLvExStyle
& LVS_EX_GRIDLINES
)
2772 if (infoPtr
->himlState
)
2773 nItemHeight
= max(nItemHeight
, infoPtr
->iconStateSize
.cy
);
2774 if (infoPtr
->himlSmall
)
2775 nItemHeight
= max(nItemHeight
, infoPtr
->iconSize
.cy
);
2776 if (infoPtr
->himlState
|| infoPtr
->himlSmall
)
2777 nItemHeight
+= HEIGHT_PADDING
;
2778 if (infoPtr
->nMeasureItemHeight
> 0)
2779 nItemHeight
= infoPtr
->nMeasureItemHeight
;
2782 return max(nItemHeight
, 1);
2787 * Updates the width, and height of an item.
2790 * [I] infoPtr : valid pointer to the listview structure
2795 static inline void LISTVIEW_UpdateItemSize(LISTVIEW_INFO
*infoPtr
)
2797 infoPtr
->nItemWidth
= LISTVIEW_CalculateItemWidth(infoPtr
);
2798 infoPtr
->nItemHeight
= LISTVIEW_CalculateItemHeight(infoPtr
);
2804 * Retrieves and saves important text metrics info for the current
2808 * [I] infoPtr : valid pointer to the listview structure
2811 static void LISTVIEW_SaveTextMetrics(LISTVIEW_INFO
*infoPtr
)
2813 HDC hdc
= GetDC(infoPtr
->hwndSelf
);
2814 HFONT hFont
= infoPtr
->hFont
? infoPtr
->hFont
: infoPtr
->hDefaultFont
;
2815 HFONT hOldFont
= SelectObject(hdc
, hFont
);
2819 if (GetTextMetricsW(hdc
, &tm
))
2821 infoPtr
->ntmHeight
= tm
.tmHeight
;
2822 infoPtr
->ntmMaxCharWidth
= tm
.tmMaxCharWidth
;
2825 if (GetTextExtentPoint32A(hdc
, "...", 3, &sz
))
2826 infoPtr
->nEllipsisWidth
= sz
.cx
;
2828 SelectObject(hdc
, hOldFont
);
2829 ReleaseDC(infoPtr
->hwndSelf
, hdc
);
2831 TRACE("tmHeight=%d\n", infoPtr
->ntmHeight
);
2836 * A compare function for ranges
2839 * [I] range1 : pointer to range 1;
2840 * [I] range2 : pointer to range 2;
2844 * > 0 : if range 1 > range 2
2845 * < 0 : if range 2 > range 1
2846 * = 0 : if range intersects range 2
2848 static INT CALLBACK
ranges_cmp(LPVOID range1
, LPVOID range2
, LPARAM flags
)
2852 if (((RANGE
*)range1
)->upper
<= ((RANGE
*)range2
)->lower
)
2854 else if (((RANGE
*)range2
)->upper
<= ((RANGE
*)range1
)->lower
)
2859 TRACE("range1=%s, range2=%s, cmp=%d\n", debugrange(range1
), debugrange(range2
), cmp
);
2865 #define ranges_check(ranges, desc) ranges_assert(ranges, desc, __FUNCTION__, __LINE__)
2867 #define ranges_check(ranges, desc) do { } while(0)
2870 static void ranges_assert(RANGES ranges
, LPCSTR desc
, const char *func
, int line
)
2875 TRACE("*** Checking %s:%d:%s ***\n", func
, line
, desc
);
2877 assert (DPA_GetPtrCount(ranges
->hdpa
) >= 0);
2878 ranges_dump(ranges
);
2879 if (DPA_GetPtrCount(ranges
->hdpa
) > 0)
2881 prev
= DPA_GetPtr(ranges
->hdpa
, 0);
2882 assert (prev
->lower
>= 0 && prev
->lower
< prev
->upper
);
2883 for (i
= 1; i
< DPA_GetPtrCount(ranges
->hdpa
); i
++)
2885 curr
= DPA_GetPtr(ranges
->hdpa
, i
);
2886 assert (prev
->upper
<= curr
->lower
);
2887 assert (curr
->lower
< curr
->upper
);
2891 TRACE("--- Done checking---\n");
2894 static RANGES
ranges_create(int count
)
2896 RANGES ranges
= Alloc(sizeof(struct tagRANGES
));
2897 if (!ranges
) return NULL
;
2898 ranges
->hdpa
= DPA_Create(count
);
2899 if (ranges
->hdpa
) return ranges
;
2904 static void ranges_clear(RANGES ranges
)
2908 for(i
= 0; i
< DPA_GetPtrCount(ranges
->hdpa
); i
++)
2909 Free(DPA_GetPtr(ranges
->hdpa
, i
));
2910 DPA_DeleteAllPtrs(ranges
->hdpa
);
2914 static void ranges_destroy(RANGES ranges
)
2916 if (!ranges
) return;
2917 ranges_clear(ranges
);
2918 DPA_Destroy(ranges
->hdpa
);
2922 static RANGES
ranges_clone(RANGES ranges
)
2927 if (!(clone
= ranges_create(DPA_GetPtrCount(ranges
->hdpa
)))) goto fail
;
2929 for (i
= 0; i
< DPA_GetPtrCount(ranges
->hdpa
); i
++)
2931 RANGE
*newrng
= Alloc(sizeof(RANGE
));
2932 if (!newrng
) goto fail
;
2933 *newrng
= *((RANGE
*)DPA_GetPtr(ranges
->hdpa
, i
));
2934 DPA_SetPtr(clone
->hdpa
, i
, newrng
);
2939 TRACE ("clone failed\n");
2940 ranges_destroy(clone
);
2944 static RANGES
ranges_diff(RANGES ranges
, RANGES sub
)
2948 for (i
= 0; i
< DPA_GetPtrCount(sub
->hdpa
); i
++)
2949 ranges_del(ranges
, *((RANGE
*)DPA_GetPtr(sub
->hdpa
, i
)));
2954 static void ranges_dump(RANGES ranges
)
2958 for (i
= 0; i
< DPA_GetPtrCount(ranges
->hdpa
); i
++)
2959 TRACE(" %s\n", debugrange(DPA_GetPtr(ranges
->hdpa
, i
)));
2962 static inline BOOL
ranges_contain(RANGES ranges
, INT nItem
)
2964 RANGE srchrng
= { nItem
, nItem
+ 1 };
2966 TRACE("(nItem=%d)\n", nItem
);
2967 ranges_check(ranges
, "before contain");
2968 return DPA_Search(ranges
->hdpa
, &srchrng
, 0, ranges_cmp
, 0, DPAS_SORTED
) != -1;
2971 static INT
ranges_itemcount(RANGES ranges
)
2975 for (i
= 0; i
< DPA_GetPtrCount(ranges
->hdpa
); i
++)
2977 RANGE
*sel
= DPA_GetPtr(ranges
->hdpa
, i
);
2978 count
+= sel
->upper
- sel
->lower
;
2984 static BOOL
ranges_shift(RANGES ranges
, INT nItem
, INT delta
, INT nUpper
)
2986 RANGE srchrng
= { nItem
, nItem
+ 1 }, *chkrng
;
2989 index
= DPA_Search(ranges
->hdpa
, &srchrng
, 0, ranges_cmp
, 0, DPAS_SORTED
| DPAS_INSERTAFTER
);
2990 if (index
== -1) return TRUE
;
2992 for (; index
< DPA_GetPtrCount(ranges
->hdpa
); index
++)
2994 chkrng
= DPA_GetPtr(ranges
->hdpa
, index
);
2995 if (chkrng
->lower
>= nItem
)
2996 chkrng
->lower
= max(min(chkrng
->lower
+ delta
, nUpper
- 1), 0);
2997 if (chkrng
->upper
> nItem
)
2998 chkrng
->upper
= max(min(chkrng
->upper
+ delta
, nUpper
), 0);
3003 static BOOL
ranges_add(RANGES ranges
, RANGE range
)
3008 TRACE("(%s)\n", debugrange(&range
));
3009 ranges_check(ranges
, "before add");
3011 /* try find overlapping regions first */
3012 srchrgn
.lower
= range
.lower
- 1;
3013 srchrgn
.upper
= range
.upper
+ 1;
3014 index
= DPA_Search(ranges
->hdpa
, &srchrgn
, 0, ranges_cmp
, 0, DPAS_SORTED
);
3020 TRACE("Adding new range\n");
3022 /* create the brand new range to insert */
3023 newrgn
= Alloc(sizeof(RANGE
));
3024 if(!newrgn
) goto fail
;
3027 /* figure out where to insert it */
3028 index
= DPA_Search(ranges
->hdpa
, newrgn
, 0, ranges_cmp
, 0, DPAS_SORTED
| DPAS_INSERTAFTER
);
3029 TRACE("index=%d\n", index
);
3030 if (index
== -1) index
= 0;
3032 /* and get it over with */
3033 if (DPA_InsertPtr(ranges
->hdpa
, index
, newrgn
) == -1)
3041 RANGE
*chkrgn
, *mrgrgn
;
3042 INT fromindex
, mergeindex
;
3044 chkrgn
= DPA_GetPtr(ranges
->hdpa
, index
);
3045 TRACE("Merge with %s @%d\n", debugrange(chkrgn
), index
);
3047 chkrgn
->lower
= min(range
.lower
, chkrgn
->lower
);
3048 chkrgn
->upper
= max(range
.upper
, chkrgn
->upper
);
3050 TRACE("New range %s @%d\n", debugrange(chkrgn
), index
);
3052 /* merge now common ranges */
3054 srchrgn
.lower
= chkrgn
->lower
- 1;
3055 srchrgn
.upper
= chkrgn
->upper
+ 1;
3059 mergeindex
= DPA_Search(ranges
->hdpa
, &srchrgn
, fromindex
, ranges_cmp
, 0, 0);
3060 if (mergeindex
== -1) break;
3061 if (mergeindex
== index
)
3063 fromindex
= index
+ 1;
3067 TRACE("Merge with index %i\n", mergeindex
);
3069 mrgrgn
= DPA_GetPtr(ranges
->hdpa
, mergeindex
);
3070 chkrgn
->lower
= min(chkrgn
->lower
, mrgrgn
->lower
);
3071 chkrgn
->upper
= max(chkrgn
->upper
, mrgrgn
->upper
);
3073 DPA_DeletePtr(ranges
->hdpa
, mergeindex
);
3074 if (mergeindex
< index
) index
--;
3078 ranges_check(ranges
, "after add");
3082 ranges_check(ranges
, "failed add");
3086 static BOOL
ranges_del(RANGES ranges
, RANGE range
)
3091 TRACE("(%s)\n", debugrange(&range
));
3092 ranges_check(ranges
, "before del");
3094 /* we don't use DPAS_SORTED here, since we need *
3095 * to find the first overlapping range */
3096 index
= DPA_Search(ranges
->hdpa
, &range
, 0, ranges_cmp
, 0, 0);
3099 chkrgn
= DPA_GetPtr(ranges
->hdpa
, index
);
3101 TRACE("Matches range %s @%d\n", debugrange(chkrgn
), index
);
3103 /* case 1: Same range */
3104 if ( (chkrgn
->upper
== range
.upper
) &&
3105 (chkrgn
->lower
== range
.lower
) )
3107 DPA_DeletePtr(ranges
->hdpa
, index
);
3110 /* case 2: engulf */
3111 else if ( (chkrgn
->upper
<= range
.upper
) &&
3112 (chkrgn
->lower
>= range
.lower
) )
3114 DPA_DeletePtr(ranges
->hdpa
, index
);
3116 /* case 3: overlap upper */
3117 else if ( (chkrgn
->upper
<= range
.upper
) &&
3118 (chkrgn
->lower
< range
.lower
) )
3120 chkrgn
->upper
= range
.lower
;
3122 /* case 4: overlap lower */
3123 else if ( (chkrgn
->upper
> range
.upper
) &&
3124 (chkrgn
->lower
>= range
.lower
) )
3126 chkrgn
->lower
= range
.upper
;
3129 /* case 5: fully internal */
3132 RANGE tmprgn
= *chkrgn
, *newrgn
;
3134 if (!(newrgn
= Alloc(sizeof(RANGE
)))) goto fail
;
3135 newrgn
->lower
= chkrgn
->lower
;
3136 newrgn
->upper
= range
.lower
;
3137 chkrgn
->lower
= range
.upper
;
3138 if (DPA_InsertPtr(ranges
->hdpa
, index
, newrgn
) == -1)
3147 index
= DPA_Search(ranges
->hdpa
, &range
, index
, ranges_cmp
, 0, 0);
3150 ranges_check(ranges
, "after del");
3154 ranges_check(ranges
, "failed del");
3160 * Removes all selection ranges
3163 * [I] infoPtr : valid pointer to the listview structure
3164 * [I] toSkip : item range to skip removing the selection
3170 static BOOL
LISTVIEW_DeselectAllSkipItems(LISTVIEW_INFO
*infoPtr
, RANGES toSkip
)
3179 lvItem
.stateMask
= LVIS_SELECTED
;
3181 /* need to clone the DPA because callbacks can change it */
3182 if (!(clone
= ranges_clone(infoPtr
->selectionRanges
))) return FALSE
;
3183 iterator_rangesitems(&i
, ranges_diff(clone
, toSkip
));
3184 while(iterator_next(&i
))
3185 LISTVIEW_SetItemState(infoPtr
, i
.nItem
, &lvItem
);
3186 /* note that the iterator destructor will free the cloned range */
3187 iterator_destroy(&i
);
3192 static inline BOOL
LISTVIEW_DeselectAllSkipItem(LISTVIEW_INFO
*infoPtr
, INT nItem
)
3196 if (!(toSkip
= ranges_create(1))) return FALSE
;
3197 if (nItem
!= -1) ranges_additem(toSkip
, nItem
);
3198 LISTVIEW_DeselectAllSkipItems(infoPtr
, toSkip
);
3199 ranges_destroy(toSkip
);
3203 static inline BOOL
LISTVIEW_DeselectAll(LISTVIEW_INFO
*infoPtr
)
3205 return LISTVIEW_DeselectAllSkipItem(infoPtr
, -1);
3210 * Retrieves the number of items that are marked as selected.
3213 * [I] infoPtr : valid pointer to the listview structure
3216 * Number of items selected.
3218 static INT
LISTVIEW_GetSelectedCount(const LISTVIEW_INFO
*infoPtr
)
3220 INT nSelectedCount
= 0;
3222 if (infoPtr
->uCallbackMask
& LVIS_SELECTED
)
3225 for (i
= 0; i
< infoPtr
->nItemCount
; i
++)
3227 if (LISTVIEW_GetItemState(infoPtr
, i
, LVIS_SELECTED
))
3232 nSelectedCount
= ranges_itemcount(infoPtr
->selectionRanges
);
3234 TRACE("nSelectedCount=%d\n", nSelectedCount
);
3235 return nSelectedCount
;
3240 * Manages the item focus.
3243 * [I] infoPtr : valid pointer to the listview structure
3244 * [I] nItem : item index
3247 * TRUE : focused item changed
3248 * FALSE : focused item has NOT changed
3250 static inline BOOL
LISTVIEW_SetItemFocus(LISTVIEW_INFO
*infoPtr
, INT nItem
)
3252 INT oldFocus
= infoPtr
->nFocusedItem
;
3255 if (nItem
== infoPtr
->nFocusedItem
) return FALSE
;
3257 lvItem
.state
= nItem
== -1 ? 0 : LVIS_FOCUSED
;
3258 lvItem
.stateMask
= LVIS_FOCUSED
;
3259 LISTVIEW_SetItemState(infoPtr
, nItem
== -1 ? infoPtr
->nFocusedItem
: nItem
, &lvItem
);
3261 return oldFocus
!= infoPtr
->nFocusedItem
;
3264 /* Helper function for LISTVIEW_ShiftIndices *only* */
3265 static INT
shift_item(const LISTVIEW_INFO
*infoPtr
, INT nShiftItem
, INT nItem
, INT direction
)
3267 if (nShiftItem
< nItem
) return nShiftItem
;
3269 if (nShiftItem
> nItem
) return nShiftItem
+ direction
;
3271 if (direction
> 0) return nShiftItem
+ direction
;
3273 return min(nShiftItem
, infoPtr
->nItemCount
- 1);
3278 * Updates the various indices after an item has been inserted or deleted.
3281 * [I] infoPtr : valid pointer to the listview structure
3282 * [I] nItem : item index
3283 * [I] direction : Direction of shift, +1 or -1.
3288 static void LISTVIEW_ShiftIndices(LISTVIEW_INFO
*infoPtr
, INT nItem
, INT direction
)
3293 /* temporarily disable change notification while shifting items */
3294 bOldChange
= infoPtr
->bDoChangeNotify
;
3295 infoPtr
->bDoChangeNotify
= FALSE
;
3297 TRACE("Shifting %iu, %i steps\n", nItem
, direction
);
3299 ranges_shift(infoPtr
->selectionRanges
, nItem
, direction
, infoPtr
->nItemCount
);
3301 assert(abs(direction
) == 1);
3303 infoPtr
->nSelectionMark
= shift_item(infoPtr
, infoPtr
->nSelectionMark
, nItem
, direction
);
3305 nNewFocus
= shift_item(infoPtr
, infoPtr
->nFocusedItem
, nItem
, direction
);
3306 if (nNewFocus
!= infoPtr
->nFocusedItem
)
3307 LISTVIEW_SetItemFocus(infoPtr
, nNewFocus
);
3309 /* But we are not supposed to modify nHotItem! */
3311 infoPtr
->bDoChangeNotify
= bOldChange
;
3317 * Adds a block of selections.
3320 * [I] infoPtr : valid pointer to the listview structure
3321 * [I] nItem : item index
3324 * Whether the window is still valid.
3326 static BOOL
LISTVIEW_AddGroupSelection(LISTVIEW_INFO
*infoPtr
, INT nItem
)
3328 INT nFirst
= min(infoPtr
->nSelectionMark
, nItem
);
3329 INT nLast
= max(infoPtr
->nSelectionMark
, nItem
);
3330 HWND hwndSelf
= infoPtr
->hwndSelf
;
3331 NMLVODSTATECHANGE nmlv
;
3336 /* Temporarily disable change notification
3337 * If the control is LVS_OWNERDATA, we need to send
3338 * only one LVN_ODSTATECHANGED notification.
3339 * See MSDN documentation for LVN_ITEMCHANGED.
3341 bOldChange
= infoPtr
->bDoChangeNotify
;
3342 if (infoPtr
->dwStyle
& LVS_OWNERDATA
) infoPtr
->bDoChangeNotify
= FALSE
;
3344 if (nFirst
== -1) nFirst
= nItem
;
3346 item
.state
= LVIS_SELECTED
;
3347 item
.stateMask
= LVIS_SELECTED
;
3349 for (i
= nFirst
; i
<= nLast
; i
++)
3350 LISTVIEW_SetItemState(infoPtr
,i
,&item
);
3352 ZeroMemory(&nmlv
, sizeof(nmlv
));
3353 nmlv
.iFrom
= nFirst
;
3356 nmlv
.uOldState
= item
.state
;
3358 notify_hdr(infoPtr
, LVN_ODSTATECHANGED
, (LPNMHDR
)&nmlv
);
3359 if (!IsWindow(hwndSelf
))
3361 infoPtr
->bDoChangeNotify
= bOldChange
;
3368 * Sets a single group selection.
3371 * [I] infoPtr : valid pointer to the listview structure
3372 * [I] nItem : item index
3377 static void LISTVIEW_SetGroupSelection(LISTVIEW_INFO
*infoPtr
, INT nItem
)
3384 if (!(selection
= ranges_create(100))) return;
3386 item
.state
= LVIS_SELECTED
;
3387 item
.stateMask
= LVIS_SELECTED
;
3389 if ((infoPtr
->uView
== LV_VIEW_LIST
) || (infoPtr
->uView
== LV_VIEW_DETAILS
))
3391 if (infoPtr
->nSelectionMark
== -1)
3393 infoPtr
->nSelectionMark
= nItem
;
3394 ranges_additem(selection
, nItem
);
3400 sel
.lower
= min(infoPtr
->nSelectionMark
, nItem
);
3401 sel
.upper
= max(infoPtr
->nSelectionMark
, nItem
) + 1;
3402 ranges_add(selection
, sel
);
3407 RECT rcItem
, rcSel
, rcSelMark
;
3410 rcItem
.left
= LVIR_BOUNDS
;
3411 if (!LISTVIEW_GetItemRect(infoPtr
, nItem
, &rcItem
)) return;
3412 rcSelMark
.left
= LVIR_BOUNDS
;
3413 if (!LISTVIEW_GetItemRect(infoPtr
, infoPtr
->nSelectionMark
, &rcSelMark
)) return;
3414 UnionRect(&rcSel
, &rcItem
, &rcSelMark
);
3415 iterator_frameditems(&i
, infoPtr
, &rcSel
);
3416 while(iterator_next(&i
))
3418 LISTVIEW_GetItemPosition(infoPtr
, i
.nItem
, &ptItem
);
3419 if (PtInRect(&rcSel
, ptItem
)) ranges_additem(selection
, i
.nItem
);
3421 iterator_destroy(&i
);
3424 /* disable per item notifications on LVS_OWNERDATA style
3425 FIXME: single LVN_ODSTATECHANGED should be used */
3426 bOldChange
= infoPtr
->bDoChangeNotify
;
3427 if (infoPtr
->dwStyle
& LVS_OWNERDATA
) infoPtr
->bDoChangeNotify
= FALSE
;
3429 LISTVIEW_DeselectAllSkipItems(infoPtr
, selection
);
3432 iterator_rangesitems(&i
, selection
);
3433 while(iterator_next(&i
))
3434 LISTVIEW_SetItemState(infoPtr
, i
.nItem
, &item
);
3435 /* this will also destroy the selection */
3436 iterator_destroy(&i
);
3438 infoPtr
->bDoChangeNotify
= bOldChange
;
3440 LISTVIEW_SetItemFocus(infoPtr
, nItem
);
3445 * Sets a single selection.
3448 * [I] infoPtr : valid pointer to the listview structure
3449 * [I] nItem : item index
3454 static void LISTVIEW_SetSelection(LISTVIEW_INFO
*infoPtr
, INT nItem
)
3458 TRACE("nItem=%d\n", nItem
);
3460 LISTVIEW_DeselectAllSkipItem(infoPtr
, nItem
);
3462 lvItem
.state
= LVIS_FOCUSED
| LVIS_SELECTED
;
3463 lvItem
.stateMask
= LVIS_FOCUSED
| LVIS_SELECTED
;
3464 LISTVIEW_SetItemState(infoPtr
, nItem
, &lvItem
);
3466 infoPtr
->nSelectionMark
= nItem
;
3471 * Set selection(s) with keyboard.
3474 * [I] infoPtr : valid pointer to the listview structure
3475 * [I] nItem : item index
3476 * [I] space : VK_SPACE code sent
3479 * SUCCESS : TRUE (needs to be repainted)
3480 * FAILURE : FALSE (nothing has changed)
3482 static BOOL
LISTVIEW_KeySelection(LISTVIEW_INFO
*infoPtr
, INT nItem
, BOOL space
)
3484 /* FIXME: pass in the state */
3485 WORD wShift
= HIWORD(GetKeyState(VK_SHIFT
));
3486 WORD wCtrl
= HIWORD(GetKeyState(VK_CONTROL
));
3487 BOOL bResult
= FALSE
;
3489 TRACE("nItem=%d, wShift=%d, wCtrl=%d\n", nItem
, wShift
, wCtrl
);
3490 if ((nItem
>= 0) && (nItem
< infoPtr
->nItemCount
))
3494 if (infoPtr
->dwStyle
& LVS_SINGLESEL
|| (wShift
== 0 && wCtrl
== 0))
3495 LISTVIEW_SetSelection(infoPtr
, nItem
);
3499 LISTVIEW_SetGroupSelection(infoPtr
, nItem
);
3503 lvItem
.state
= ~LISTVIEW_GetItemState(infoPtr
, nItem
, LVIS_SELECTED
);
3504 lvItem
.stateMask
= LVIS_SELECTED
;
3507 LISTVIEW_SetItemState(infoPtr
, nItem
, &lvItem
);
3508 if (lvItem
.state
& LVIS_SELECTED
)
3509 infoPtr
->nSelectionMark
= nItem
;
3511 bResult
= LISTVIEW_SetItemFocus(infoPtr
, nItem
);
3514 LISTVIEW_EnsureVisible(infoPtr
, nItem
, FALSE
);
3517 UpdateWindow(infoPtr
->hwndSelf
); /* update client area */
3521 static BOOL
LISTVIEW_GetItemAtPt(const LISTVIEW_INFO
*infoPtr
, LPLVITEMW lpLVItem
, POINT pt
)
3523 LVHITTESTINFO lvHitTestInfo
;
3525 ZeroMemory(&lvHitTestInfo
, sizeof(lvHitTestInfo
));
3526 lvHitTestInfo
.pt
.x
= pt
.x
;
3527 lvHitTestInfo
.pt
.y
= pt
.y
;
3529 LISTVIEW_HitTest(infoPtr
, &lvHitTestInfo
, TRUE
, FALSE
);
3531 lpLVItem
->mask
= LVIF_PARAM
;
3532 lpLVItem
->iItem
= lvHitTestInfo
.iItem
;
3533 lpLVItem
->iSubItem
= 0;
3535 return LISTVIEW_GetItemT(infoPtr
, lpLVItem
, TRUE
);
3538 static inline BOOL
LISTVIEW_isHotTracking(const LISTVIEW_INFO
*infoPtr
)
3540 return ((infoPtr
->dwLvExStyle
& LVS_EX_TRACKSELECT
) ||
3541 (infoPtr
->dwLvExStyle
& LVS_EX_ONECLICKACTIVATE
) ||
3542 (infoPtr
->dwLvExStyle
& LVS_EX_TWOCLICKACTIVATE
));
3547 * Called when the mouse is being actively tracked and has hovered for a specified
3551 * [I] infoPtr : valid pointer to the listview structure
3552 * [I] fwKeys : key indicator
3553 * [I] x,y : mouse position
3556 * 0 if the message was processed, non-zero if there was an error
3559 * LVS_EX_TRACKSELECT: An item is automatically selected when the cursor remains
3560 * over the item for a certain period of time.
3563 static LRESULT
LISTVIEW_MouseHover(LISTVIEW_INFO
*infoPtr
, WORD fwKeys
, INT x
, INT y
)
3565 if (LISTVIEW_isHotTracking(infoPtr
))
3573 if (LISTVIEW_GetItemAtPt(infoPtr
, &item
, pt
))
3574 LISTVIEW_SetSelection(infoPtr
, item
.iItem
);
3582 * Called whenever WM_MOUSEMOVE is received.
3585 * [I] infoPtr : valid pointer to the listview structure
3586 * [I] fwKeys : key indicator
3587 * [I] x,y : mouse position
3590 * 0 if the message is processed, non-zero if there was an error
3592 static LRESULT
LISTVIEW_MouseMove(LISTVIEW_INFO
*infoPtr
, WORD fwKeys
, INT x
, INT y
)
3594 TRACKMOUSEEVENT trackinfo
;
3596 if (!(fwKeys
& MK_LBUTTON
))
3597 infoPtr
->bLButtonDown
= FALSE
;
3599 if (infoPtr
->bLButtonDown
)
3603 LVHITTESTINFO lvHitTestInfo
;
3604 WORD wDragWidth
= GetSystemMetrics(SM_CXDRAG
);
3605 WORD wDragHeight
= GetSystemMetrics(SM_CYDRAG
);
3607 rect
.left
= infoPtr
->ptClickPos
.x
- wDragWidth
;
3608 rect
.right
= infoPtr
->ptClickPos
.x
+ wDragWidth
;
3609 rect
.top
= infoPtr
->ptClickPos
.y
- wDragHeight
;
3610 rect
.bottom
= infoPtr
->ptClickPos
.y
+ wDragHeight
;
3615 lvHitTestInfo
.pt
= tmp
;
3616 LISTVIEW_HitTest(infoPtr
, &lvHitTestInfo
, TRUE
, TRUE
);
3618 /* reset item marker */
3619 if (infoPtr
->nLButtonDownItem
!= lvHitTestInfo
.iItem
)
3620 infoPtr
->nLButtonDownItem
= -1;
3622 if (!PtInRect(&rect
, tmp
))
3624 /* this path covers the following:
3625 1. WM_LBUTTONDOWN over selected item (sets focus on it)
3626 2. change focus with keys
3627 3. move mouse over item from step 1 selects it and moves focus on it */
3628 if (infoPtr
->nLButtonDownItem
!= -1 &&
3629 !LISTVIEW_GetItemState(infoPtr
, infoPtr
->nLButtonDownItem
, LVIS_SELECTED
))
3633 lvItem
.state
= LVIS_FOCUSED
| LVIS_SELECTED
;
3634 lvItem
.stateMask
= LVIS_FOCUSED
| LVIS_SELECTED
;
3636 LISTVIEW_SetItemState(infoPtr
, infoPtr
->nLButtonDownItem
, &lvItem
);
3637 infoPtr
->nLButtonDownItem
= -1;
3640 if (!infoPtr
->bDragging
)
3644 lvHitTestInfo
.pt
= infoPtr
->ptClickPos
;
3645 LISTVIEW_HitTest(infoPtr
, &lvHitTestInfo
, TRUE
, TRUE
);
3647 ZeroMemory(&nmlv
, sizeof(nmlv
));
3648 nmlv
.iItem
= lvHitTestInfo
.iItem
;
3649 nmlv
.ptAction
= infoPtr
->ptClickPos
;
3651 notify_listview(infoPtr
, LVN_BEGINDRAG
, &nmlv
);
3652 infoPtr
->bDragging
= TRUE
;
3659 /* see if we are supposed to be tracking mouse hovering */
3660 if (LISTVIEW_isHotTracking(infoPtr
)) {
3661 /* fill in the trackinfo struct */
3662 trackinfo
.cbSize
= sizeof(TRACKMOUSEEVENT
);
3663 trackinfo
.dwFlags
= TME_QUERY
;
3664 trackinfo
.hwndTrack
= infoPtr
->hwndSelf
;
3665 trackinfo
.dwHoverTime
= infoPtr
->dwHoverTime
;
3667 /* see if we are already tracking this hwnd */
3668 _TrackMouseEvent(&trackinfo
);
3670 if(!(trackinfo
.dwFlags
& TME_HOVER
)) {
3671 trackinfo
.dwFlags
= TME_HOVER
;
3673 /* call TRACKMOUSEEVENT so we receive WM_MOUSEHOVER messages */
3674 _TrackMouseEvent(&trackinfo
);
3683 * Tests whether the item is assignable to a list with style lStyle
3685 static inline BOOL
is_assignable_item(const LVITEMW
*lpLVItem
, LONG lStyle
)
3687 if ( (lpLVItem
->mask
& LVIF_TEXT
) &&
3688 (lpLVItem
->pszText
== LPSTR_TEXTCALLBACKW
) &&
3689 (lStyle
& (LVS_SORTASCENDING
| LVS_SORTDESCENDING
)) ) return FALSE
;
3697 * Helper for LISTVIEW_SetItemT *only*: sets item attributes.
3700 * [I] infoPtr : valid pointer to the listview structure
3701 * [I] lpLVItem : valid pointer to new item attributes
3702 * [I] isNew : the item being set is being inserted
3703 * [I] isW : TRUE if lpLVItem is Unicode, FALSE if it's ANSI
3704 * [O] bChanged : will be set to TRUE if the item really changed
3710 static BOOL
set_main_item(LISTVIEW_INFO
*infoPtr
, const LVITEMW
*lpLVItem
, BOOL isNew
, BOOL isW
, BOOL
*bChanged
)
3716 /* stateMask is ignored for LVM_INSERTITEM */
3717 UINT stateMask
= isNew
? ~0 : lpLVItem
->stateMask
;
3721 assert(lpLVItem
->iItem
>= 0 && lpLVItem
->iItem
< infoPtr
->nItemCount
);
3723 if (lpLVItem
->mask
== 0) return TRUE
;
3725 if (infoPtr
->dwStyle
& LVS_OWNERDATA
)
3727 /* a virtual listview only stores selection and focus */
3728 if (lpLVItem
->mask
& ~LVIF_STATE
)
3734 HDPA hdpaSubItems
= DPA_GetPtr(infoPtr
->hdpaItems
, lpLVItem
->iItem
);
3735 lpItem
= DPA_GetPtr(hdpaSubItems
, 0);
3739 /* we need to get the lParam and state of the item */
3740 item
.iItem
= lpLVItem
->iItem
;
3741 item
.iSubItem
= lpLVItem
->iSubItem
;
3742 item
.mask
= LVIF_STATE
| LVIF_PARAM
;
3743 item
.stateMask
= (infoPtr
->dwStyle
& LVS_OWNERDATA
) ? LVIS_FOCUSED
| LVIS_SELECTED
: ~0;
3747 if (!isNew
&& !LISTVIEW_GetItemW(infoPtr
, &item
)) return FALSE
;
3749 TRACE("oldState=%x, newState=%x\n", item
.state
, lpLVItem
->state
);
3750 /* determine what fields will change */
3751 if ((lpLVItem
->mask
& LVIF_STATE
) && ((item
.state
^ lpLVItem
->state
) & stateMask
& ~infoPtr
->uCallbackMask
))
3752 uChanged
|= LVIF_STATE
;
3754 if ((lpLVItem
->mask
& LVIF_IMAGE
) && (lpItem
->hdr
.iImage
!= lpLVItem
->iImage
))
3755 uChanged
|= LVIF_IMAGE
;
3757 if ((lpLVItem
->mask
& LVIF_PARAM
) && (lpItem
->lParam
!= lpLVItem
->lParam
))
3758 uChanged
|= LVIF_PARAM
;
3760 if ((lpLVItem
->mask
& LVIF_INDENT
) && (lpItem
->iIndent
!= lpLVItem
->iIndent
))
3761 uChanged
|= LVIF_INDENT
;
3763 if ((lpLVItem
->mask
& LVIF_TEXT
) && textcmpWT(lpItem
->hdr
.pszText
, lpLVItem
->pszText
, isW
))
3764 uChanged
|= LVIF_TEXT
;
3766 TRACE("uChanged=0x%x\n", uChanged
);
3767 if (!uChanged
) return TRUE
;
3770 ZeroMemory(&nmlv
, sizeof(NMLISTVIEW
));
3771 nmlv
.iItem
= lpLVItem
->iItem
;
3772 nmlv
.uNewState
= (item
.state
& ~stateMask
) | (lpLVItem
->state
& stateMask
);
3773 nmlv
.uOldState
= item
.state
;
3774 nmlv
.uChanged
= uChanged
;
3775 nmlv
.lParam
= item
.lParam
;
3777 /* send LVN_ITEMCHANGING notification, if the item is not being inserted */
3778 /* and we are _NOT_ virtual (LVS_OWNERDATA), and change notifications */
3780 if(lpItem
&& !isNew
&& infoPtr
->bDoChangeNotify
)
3782 HWND hwndSelf
= infoPtr
->hwndSelf
;
3784 if (notify_listview(infoPtr
, LVN_ITEMCHANGING
, &nmlv
))
3786 if (!IsWindow(hwndSelf
))
3790 /* copy information */
3791 if (lpLVItem
->mask
& LVIF_TEXT
)
3792 textsetptrT(&lpItem
->hdr
.pszText
, lpLVItem
->pszText
, isW
);
3794 if (lpLVItem
->mask
& LVIF_IMAGE
)
3795 lpItem
->hdr
.iImage
= lpLVItem
->iImage
;
3797 if (lpLVItem
->mask
& LVIF_PARAM
)
3798 lpItem
->lParam
= lpLVItem
->lParam
;
3800 if (lpLVItem
->mask
& LVIF_INDENT
)
3801 lpItem
->iIndent
= lpLVItem
->iIndent
;
3803 if (uChanged
& LVIF_STATE
)
3805 if (lpItem
&& (stateMask
& ~infoPtr
->uCallbackMask
))
3807 lpItem
->state
&= ~stateMask
;
3808 lpItem
->state
|= (lpLVItem
->state
& stateMask
);
3810 if (lpLVItem
->state
& stateMask
& ~infoPtr
->uCallbackMask
& LVIS_SELECTED
)
3812 if (infoPtr
->dwStyle
& LVS_SINGLESEL
) LISTVIEW_DeselectAllSkipItem(infoPtr
, lpLVItem
->iItem
);
3813 ranges_additem(infoPtr
->selectionRanges
, lpLVItem
->iItem
);
3815 else if (stateMask
& LVIS_SELECTED
)
3817 ranges_delitem(infoPtr
->selectionRanges
, lpLVItem
->iItem
);
3819 /* if we are asked to change focus, and we manage it, do it */
3820 if (stateMask
& ~infoPtr
->uCallbackMask
& LVIS_FOCUSED
)
3822 if (lpLVItem
->state
& LVIS_FOCUSED
)
3824 if (infoPtr
->nFocusedItem
!= -1)
3826 /* remove current focus */
3827 item
.mask
= LVIF_STATE
;
3829 item
.stateMask
= LVIS_FOCUSED
;
3831 /* recurse with redrawing an item */
3832 LISTVIEW_SetItemState(infoPtr
, infoPtr
->nFocusedItem
, &item
);
3835 infoPtr
->nFocusedItem
= lpLVItem
->iItem
;
3836 LISTVIEW_EnsureVisible(infoPtr
, lpLVItem
->iItem
, infoPtr
->uView
== LV_VIEW_LIST
);
3838 else if (infoPtr
->nFocusedItem
== lpLVItem
->iItem
)
3840 infoPtr
->nFocusedItem
= -1;
3845 /* if we're inserting the item, we're done */
3846 if (isNew
) return TRUE
;
3848 /* send LVN_ITEMCHANGED notification */
3849 if (lpLVItem
->mask
& LVIF_PARAM
) nmlv
.lParam
= lpLVItem
->lParam
;
3850 if (infoPtr
->bDoChangeNotify
) notify_listview(infoPtr
, LVN_ITEMCHANGED
, &nmlv
);
3857 * Helper for LISTVIEW_{Set,Insert}ItemT *only*: sets subitem attributes.
3860 * [I] infoPtr : valid pointer to the listview structure
3861 * [I] lpLVItem : valid pointer to new subitem attributes
3862 * [I] isW : TRUE if lpLVItem is Unicode, FALSE if it's ANSI
3863 * [O] bChanged : will be set to TRUE if the item really changed
3869 static BOOL
set_sub_item(const LISTVIEW_INFO
*infoPtr
, const LVITEMW
*lpLVItem
, BOOL isW
, BOOL
*bChanged
)
3872 SUBITEM_INFO
*lpSubItem
;
3874 /* we do not support subitems for virtual listviews */
3875 if (infoPtr
->dwStyle
& LVS_OWNERDATA
) return FALSE
;
3877 /* set subitem only if column is present */
3878 if (lpLVItem
->iSubItem
>= DPA_GetPtrCount(infoPtr
->hdpaColumns
)) return FALSE
;
3880 /* First do some sanity checks */
3881 /* The LVIF_STATE flag is valid for subitems, but does not appear to be
3882 particularly useful. We currently do not actually do anything with
3883 the flag on subitems.
3885 if (lpLVItem
->mask
& ~(LVIF_TEXT
| LVIF_IMAGE
| LVIF_STATE
)) return FALSE
;
3886 if (!(lpLVItem
->mask
& (LVIF_TEXT
| LVIF_IMAGE
| LVIF_STATE
))) return TRUE
;
3888 /* get the subitem structure, and create it if not there */
3889 hdpaSubItems
= DPA_GetPtr(infoPtr
->hdpaItems
, lpLVItem
->iItem
);
3890 assert (hdpaSubItems
);
3892 lpSubItem
= LISTVIEW_GetSubItemPtr(hdpaSubItems
, lpLVItem
->iSubItem
);
3895 SUBITEM_INFO
*tmpSubItem
;
3898 lpSubItem
= Alloc(sizeof(SUBITEM_INFO
));
3899 if (!lpSubItem
) return FALSE
;
3900 /* we could binary search here, if need be...*/
3901 for (i
= 1; i
< DPA_GetPtrCount(hdpaSubItems
); i
++)
3903 tmpSubItem
= DPA_GetPtr(hdpaSubItems
, i
);
3904 if (tmpSubItem
->iSubItem
> lpLVItem
->iSubItem
) break;
3906 if (DPA_InsertPtr(hdpaSubItems
, i
, lpSubItem
) == -1)
3911 lpSubItem
->iSubItem
= lpLVItem
->iSubItem
;
3912 lpSubItem
->hdr
.iImage
= I_IMAGECALLBACK
;
3916 if (lpLVItem
->mask
& LVIF_IMAGE
)
3917 if (lpSubItem
->hdr
.iImage
!= lpLVItem
->iImage
)
3919 lpSubItem
->hdr
.iImage
= lpLVItem
->iImage
;
3923 if ((lpLVItem
->mask
& LVIF_TEXT
) && textcmpWT(lpSubItem
->hdr
.pszText
, lpLVItem
->pszText
, isW
))
3925 textsetptrT(&lpSubItem
->hdr
.pszText
, lpLVItem
->pszText
, isW
);
3934 * Sets item attributes.
3937 * [I] infoPtr : valid pointer to the listview structure
3938 * [I] lpLVItem : new item attributes
3939 * [I] isW : TRUE if lpLVItem is Unicode, FALSE if it's ANSI
3945 static BOOL
LISTVIEW_SetItemT(LISTVIEW_INFO
*infoPtr
, LVITEMW
*lpLVItem
, BOOL isW
)
3947 HWND hwndSelf
= infoPtr
->hwndSelf
;
3948 LPWSTR pszText
= NULL
;
3949 BOOL bResult
, bChanged
= FALSE
;
3951 TRACE("(lpLVItem=%s, isW=%d)\n", debuglvitem_t(lpLVItem
, isW
), isW
);
3953 if (!lpLVItem
|| lpLVItem
->iItem
< 0 || lpLVItem
->iItem
>= infoPtr
->nItemCount
)
3956 /* For efficiency, we transform the lpLVItem->pszText to Unicode here */
3957 if ((lpLVItem
->mask
& LVIF_TEXT
) && is_textW(lpLVItem
->pszText
))
3959 pszText
= lpLVItem
->pszText
;
3960 lpLVItem
->pszText
= textdupTtoW(lpLVItem
->pszText
, isW
);
3963 /* actually set the fields */
3964 if (!is_assignable_item(lpLVItem
, infoPtr
->dwStyle
)) return FALSE
;
3966 if (lpLVItem
->iSubItem
)
3967 bResult
= set_sub_item(infoPtr
, lpLVItem
, TRUE
, &bChanged
);
3969 bResult
= set_main_item(infoPtr
, lpLVItem
, FALSE
, TRUE
, &bChanged
);
3970 if (!IsWindow(hwndSelf
))
3973 /* redraw item, if necessary */
3974 if (bChanged
&& !infoPtr
->bIsDrawing
)
3976 /* this little optimization eliminates some nasty flicker */
3977 if ( infoPtr
->uView
== LV_VIEW_DETAILS
&& !(infoPtr
->dwStyle
& LVS_OWNERDRAWFIXED
) &&
3978 !(infoPtr
->dwLvExStyle
& LVS_EX_FULLROWSELECT
) &&
3979 lpLVItem
->iSubItem
> 0 && lpLVItem
->iSubItem
<= DPA_GetPtrCount(infoPtr
->hdpaColumns
) )
3980 LISTVIEW_InvalidateSubItem(infoPtr
, lpLVItem
->iItem
, lpLVItem
->iSubItem
);
3982 LISTVIEW_InvalidateItem(infoPtr
, lpLVItem
->iItem
);
3987 textfreeT(lpLVItem
->pszText
, isW
);
3988 lpLVItem
->pszText
= pszText
;
3996 * Retrieves the index of the item at coordinate (0, 0) of the client area.
3999 * [I] infoPtr : valid pointer to the listview structure
4004 static INT
LISTVIEW_GetTopIndex(const LISTVIEW_INFO
*infoPtr
)
4007 SCROLLINFO scrollInfo
;
4009 scrollInfo
.cbSize
= sizeof(SCROLLINFO
);
4010 scrollInfo
.fMask
= SIF_POS
;
4012 if (infoPtr
->uView
== LV_VIEW_LIST
)
4014 if (GetScrollInfo(infoPtr
->hwndSelf
, SB_HORZ
, &scrollInfo
))
4015 nItem
= scrollInfo
.nPos
* LISTVIEW_GetCountPerColumn(infoPtr
);
4017 else if (infoPtr
->uView
== LV_VIEW_DETAILS
)
4019 if (GetScrollInfo(infoPtr
->hwndSelf
, SB_VERT
, &scrollInfo
))
4020 nItem
= scrollInfo
.nPos
;
4024 if (GetScrollInfo(infoPtr
->hwndSelf
, SB_VERT
, &scrollInfo
))
4025 nItem
= LISTVIEW_GetCountPerRow(infoPtr
) * (scrollInfo
.nPos
/ infoPtr
->nItemHeight
);
4028 TRACE("nItem=%d\n", nItem
);
4036 * Erases the background of the given rectangle
4039 * [I] infoPtr : valid pointer to the listview structure
4040 * [I] hdc : device context handle
4041 * [I] lprcBox : clipping rectangle
4047 static inline BOOL
LISTVIEW_FillBkgnd(const LISTVIEW_INFO
*infoPtr
, HDC hdc
, const RECT
*lprcBox
)
4049 if (!infoPtr
->hBkBrush
) return FALSE
;
4051 TRACE("(hdc=%p, lprcBox=%s, hBkBrush=%p)\n", hdc
, wine_dbgstr_rect(lprcBox
), infoPtr
->hBkBrush
);
4053 return FillRect(hdc
, lprcBox
, infoPtr
->hBkBrush
);
4061 * [I] infoPtr : valid pointer to the listview structure
4062 * [I] hdc : device context handle
4063 * [I] nItem : item index
4064 * [I] nSubItem : subitem index
4065 * [I] pos : item position in client coordinates
4066 * [I] cdmode : custom draw mode
4072 static BOOL
LISTVIEW_DrawItem(LISTVIEW_INFO
*infoPtr
, HDC hdc
, INT nItem
, INT nSubItem
, POINT pos
, DWORD cdmode
)
4075 WCHAR szDispText
[DISP_TEXT_SIZE
] = { '\0' };
4076 static WCHAR szCallback
[] = { '(', 'c', 'a', 'l', 'l', 'b', 'a', 'c', 'k', ')', 0 };
4077 DWORD cdsubitemmode
= CDRF_DODEFAULT
;
4079 RECT rcSelect
, rcBox
, rcIcon
, rcLabel
, rcStateIcon
;
4080 NMLVCUSTOMDRAW nmlvcd
;
4085 TRACE("(hdc=%p, nItem=%d, nSubItem=%d, pos=%s)\n", hdc
, nItem
, nSubItem
, wine_dbgstr_point(&pos
));
4087 /* get information needed for drawing the item */
4088 lvItem
.mask
= LVIF_TEXT
| LVIF_IMAGE
| LVIF_PARAM
;
4089 if (nSubItem
== 0) lvItem
.mask
|= LVIF_STATE
;
4090 if (infoPtr
->uView
== LV_VIEW_DETAILS
) lvItem
.mask
|= LVIF_INDENT
;
4091 lvItem
.stateMask
= LVIS_SELECTED
| LVIS_FOCUSED
| LVIS_STATEIMAGEMASK
;
4092 lvItem
.iItem
= nItem
;
4093 lvItem
.iSubItem
= nSubItem
;
4096 lvItem
.cchTextMax
= DISP_TEXT_SIZE
;
4097 lvItem
.pszText
= szDispText
;
4098 if (!LISTVIEW_GetItemW(infoPtr
, &lvItem
)) return FALSE
;
4099 if (nSubItem
> 0 && (infoPtr
->dwLvExStyle
& LVS_EX_FULLROWSELECT
))
4100 lvItem
.state
= LISTVIEW_GetItemState(infoPtr
, nItem
, LVIS_SELECTED
);
4101 if (lvItem
.pszText
== LPSTR_TEXTCALLBACKW
) lvItem
.pszText
= szCallback
;
4102 TRACE(" lvItem=%s\n", debuglvitem_t(&lvItem
, TRUE
));
4104 /* now check if we need to update the focus rectangle */
4105 lprcFocus
= infoPtr
->bFocus
&& (lvItem
.state
& LVIS_FOCUSED
) ? &infoPtr
->rcFocus
: 0;
4107 if (!lprcFocus
) lvItem
.state
&= ~LVIS_FOCUSED
;
4108 LISTVIEW_GetItemMetrics(infoPtr
, &lvItem
, &rcBox
, &rcSelect
, &rcIcon
, &rcStateIcon
, &rcLabel
);
4109 OffsetRect(&rcBox
, pos
.x
, pos
.y
);
4110 OffsetRect(&rcSelect
, pos
.x
, pos
.y
);
4111 OffsetRect(&rcIcon
, pos
.x
, pos
.y
);
4112 OffsetRect(&rcStateIcon
, pos
.x
, pos
.y
);
4113 OffsetRect(&rcLabel
, pos
.x
, pos
.y
);
4114 TRACE(" rcBox=%s, rcSelect=%s, rcIcon=%s. rcLabel=%s\n",
4115 wine_dbgstr_rect(&rcBox
), wine_dbgstr_rect(&rcSelect
),
4116 wine_dbgstr_rect(&rcIcon
), wine_dbgstr_rect(&rcLabel
));
4118 /* fill in the custom draw structure */
4119 customdraw_fill(&nmlvcd
, infoPtr
, hdc
, &rcBox
, &lvItem
);
4121 hOldFont
= GetCurrentObject(hdc
, OBJ_FONT
);
4122 if (nSubItem
> 0) cdmode
= infoPtr
->cditemmode
;
4123 if (cdmode
& CDRF_SKIPDEFAULT
) goto postpaint
;
4124 if (cdmode
& CDRF_NOTIFYITEMDRAW
)
4125 cdsubitemmode
= notify_customdraw(infoPtr
, CDDS_PREPAINT
, &nmlvcd
);
4126 if (nSubItem
== 0) infoPtr
->cditemmode
= cdsubitemmode
;
4127 if (cdsubitemmode
& CDRF_SKIPDEFAULT
) goto postpaint
;
4128 /* we have to send a CDDS_SUBITEM customdraw explicitly for subitem 0 */
4129 if (nSubItem
== 0 && cdsubitemmode
== CDRF_NOTIFYITEMDRAW
)
4131 cdsubitemmode
= notify_customdraw(infoPtr
, CDDS_SUBITEM
| CDDS_ITEMPREPAINT
, &nmlvcd
);
4132 if (cdsubitemmode
& CDRF_SKIPDEFAULT
) goto postpaint
;
4134 if (nSubItem
== 0 || (cdmode
& CDRF_NOTIFYITEMDRAW
))
4135 prepaint_setup(infoPtr
, hdc
, &nmlvcd
, FALSE
);
4136 else if ((infoPtr
->dwLvExStyle
& LVS_EX_FULLROWSELECT
) == FALSE
)
4137 prepaint_setup(infoPtr
, hdc
, &nmlvcd
, TRUE
);
4139 /* in full row select, subitems, will just use main item's colors */
4140 if (nSubItem
&& infoPtr
->uView
== LV_VIEW_DETAILS
&& (infoPtr
->dwLvExStyle
& LVS_EX_FULLROWSELECT
))
4141 nmlvcd
.clrTextBk
= CLR_NONE
;
4143 /* FIXME: temporary hack */
4144 rcSelect
.left
= rcLabel
.left
;
4146 /* draw the selection background, if we're drawing the main item */
4149 /* in icon mode, the label rect is really what we want to draw the
4151 if (infoPtr
->uView
== LV_VIEW_ICON
)
4154 if (infoPtr
->uView
== LV_VIEW_DETAILS
&& (infoPtr
->dwLvExStyle
& LVS_EX_FULLROWSELECT
))
4156 /* we have to update left focus bound too if item isn't in leftmost column
4157 and reduce right box bound */
4158 if (DPA_GetPtrCount(infoPtr
->hdpaColumns
) > 0)
4162 if ((leftmost
= SendMessageW(infoPtr
->hwndHeader
, HDM_ORDERTOINDEX
, 0, 0)))
4164 INT Originx
= pos
.x
- LISTVIEW_GetColumnInfo(infoPtr
, 0)->rcHeader
.left
;
4165 INT index
= SendMessageW(infoPtr
->hwndHeader
, HDM_ORDERTOINDEX
,
4166 DPA_GetPtrCount(infoPtr
->hdpaColumns
) - 1, 0);
4168 rcBox
.right
= LISTVIEW_GetColumnInfo(infoPtr
, index
)->rcHeader
.right
+ Originx
;
4169 rcSelect
.left
= LISTVIEW_GetColumnInfo(infoPtr
, leftmost
)->rcHeader
.left
+ Originx
;
4173 rcSelect
.right
= rcBox
.right
;
4176 if (nmlvcd
.clrTextBk
!= CLR_NONE
)
4177 ExtTextOutW(hdc
, rcSelect
.left
, rcSelect
.top
, ETO_OPAQUE
, &rcSelect
, NULL
, 0, NULL
);
4178 /* store new focus rectangle */
4179 if (infoPtr
->nFocusedItem
== nItem
) infoPtr
->rcFocus
= rcSelect
;
4183 if (infoPtr
->himlState
&& STATEIMAGEINDEX(lvItem
.state
) && (nSubItem
== 0))
4185 UINT uStateImage
= STATEIMAGEINDEX(lvItem
.state
);
4188 TRACE("uStateImage=%d\n", uStateImage
);
4189 ImageList_Draw(infoPtr
->himlState
, uStateImage
- 1, hdc
,
4190 rcStateIcon
.left
, rcStateIcon
.top
, ILD_NORMAL
);
4195 himl
= (infoPtr
->uView
== LV_VIEW_ICON
? infoPtr
->himlNormal
: infoPtr
->himlSmall
);
4196 if (himl
&& lvItem
.iImage
>= 0 && !IsRectEmpty(&rcIcon
))
4198 TRACE("iImage=%d\n", lvItem
.iImage
);
4199 ImageList_DrawEx(himl
, lvItem
.iImage
, hdc
, rcIcon
.left
, rcIcon
.top
,
4200 rcIcon
.right
- rcIcon
.left
, rcIcon
.bottom
- rcIcon
.top
, infoPtr
->clrBk
, CLR_DEFAULT
,
4201 (lvItem
.state
& LVIS_SELECTED
) && (infoPtr
->bFocus
) ? ILD_SELECTED
: ILD_NORMAL
);
4204 /* Don't bother painting item being edited */
4205 if (infoPtr
->hwndEdit
&& nItem
== infoPtr
->nEditLabelItem
&& nSubItem
== 0) goto postpaint
;
4207 /* figure out the text drawing flags */
4208 uFormat
= (infoPtr
->uView
== LV_VIEW_ICON
? (lprcFocus
? LV_FL_DT_FLAGS
: LV_ML_DT_FLAGS
) : LV_SL_DT_FLAGS
);
4209 if (infoPtr
->uView
== LV_VIEW_ICON
)
4210 uFormat
= (lprcFocus
? LV_FL_DT_FLAGS
: LV_ML_DT_FLAGS
);
4213 switch (LISTVIEW_GetColumnInfo(infoPtr
, nSubItem
)->fmt
& LVCFMT_JUSTIFYMASK
)
4215 case LVCFMT_RIGHT
: uFormat
|= DT_RIGHT
; break;
4216 case LVCFMT_CENTER
: uFormat
|= DT_CENTER
; break;
4217 default: uFormat
|= DT_LEFT
;
4220 if (!(uFormat
& (DT_RIGHT
| DT_CENTER
)))
4222 if (himl
&& lvItem
.iImage
>= 0 && !IsRectEmpty(&rcIcon
)) rcLabel
.left
+= IMAGE_PADDING
;
4223 else rcLabel
.left
+= LABEL_HOR_PADDING
;
4225 else if (uFormat
& DT_RIGHT
) rcLabel
.right
-= LABEL_HOR_PADDING
;
4227 /* for GRIDLINES reduce the bottom so the text formats correctly */
4228 if (infoPtr
->uView
== LV_VIEW_DETAILS
&& infoPtr
->dwLvExStyle
& LVS_EX_GRIDLINES
)
4231 DrawTextW(hdc
, lvItem
.pszText
, -1, &rcLabel
, uFormat
);
4234 if (cdsubitemmode
& CDRF_NOTIFYPOSTPAINT
)
4235 notify_postpaint(infoPtr
, &nmlvcd
);
4236 if (cdsubitemmode
& CDRF_NEWFONT
)
4237 SelectObject(hdc
, hOldFont
);
4243 * Draws listview items when in owner draw mode.
4246 * [I] infoPtr : valid pointer to the listview structure
4247 * [I] hdc : device context handle
4252 static void LISTVIEW_RefreshOwnerDraw(const LISTVIEW_INFO
*infoPtr
, ITERATOR
*i
, HDC hdc
, DWORD cdmode
)
4254 UINT uID
= (UINT
)GetWindowLongPtrW(infoPtr
->hwndSelf
, GWLP_ID
);
4255 DWORD cditemmode
= CDRF_DODEFAULT
;
4256 NMLVCUSTOMDRAW nmlvcd
;
4257 POINT Origin
, Position
;
4263 ZeroMemory(&dis
, sizeof(dis
));
4265 /* Get scroll info once before loop */
4266 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
4268 /* iterate through the invalidated rows */
4269 while(iterator_next(i
))
4271 item
.iItem
= i
->nItem
;
4273 item
.mask
= LVIF_PARAM
| LVIF_STATE
;
4274 item
.stateMask
= LVIS_SELECTED
| LVIS_FOCUSED
;
4275 if (!LISTVIEW_GetItemW(infoPtr
, &item
)) continue;
4277 dis
.CtlType
= ODT_LISTVIEW
;
4279 dis
.itemID
= item
.iItem
;
4280 dis
.itemAction
= ODA_DRAWENTIRE
;
4282 if (item
.state
& LVIS_SELECTED
) dis
.itemState
|= ODS_SELECTED
;
4283 if (infoPtr
->bFocus
&& (item
.state
& LVIS_FOCUSED
)) dis
.itemState
|= ODS_FOCUS
;
4284 dis
.hwndItem
= infoPtr
->hwndSelf
;
4286 LISTVIEW_GetItemOrigin(infoPtr
, dis
.itemID
, &Position
);
4287 dis
.rcItem
.left
= Position
.x
+ Origin
.x
;
4288 dis
.rcItem
.right
= dis
.rcItem
.left
+ infoPtr
->nItemWidth
;
4289 dis
.rcItem
.top
= Position
.y
+ Origin
.y
;
4290 dis
.rcItem
.bottom
= dis
.rcItem
.top
+ infoPtr
->nItemHeight
;
4291 dis
.itemData
= item
.lParam
;
4293 TRACE("item=%s, rcItem=%s\n", debuglvitem_t(&item
, TRUE
), wine_dbgstr_rect(&dis
.rcItem
));
4296 * Even if we do not send the CDRF_NOTIFYITEMDRAW we need to fill the nmlvcd
4297 * structure for the rest. of the paint cycle
4299 customdraw_fill(&nmlvcd
, infoPtr
, hdc
, &dis
.rcItem
, &item
);
4300 if (cdmode
& CDRF_NOTIFYITEMDRAW
)
4301 cditemmode
= notify_customdraw(infoPtr
, CDDS_PREPAINT
, &nmlvcd
);
4303 if (!(cditemmode
& CDRF_SKIPDEFAULT
))
4305 prepaint_setup (infoPtr
, hdc
, &nmlvcd
, FALSE
);
4306 SendMessageW(infoPtr
->hwndNotify
, WM_DRAWITEM
, dis
.CtlID
, (LPARAM
)&dis
);
4309 if (cditemmode
& CDRF_NOTIFYPOSTPAINT
)
4310 notify_postpaint(infoPtr
, &nmlvcd
);
4316 * Draws listview items when in report display mode.
4319 * [I] infoPtr : valid pointer to the listview structure
4320 * [I] hdc : device context handle
4321 * [I] cdmode : custom draw mode
4326 static void LISTVIEW_RefreshReport(LISTVIEW_INFO
*infoPtr
, ITERATOR
*i
, HDC hdc
, DWORD cdmode
)
4329 RECT rcClip
, rcItem
;
4330 POINT Origin
, Position
;
4337 /* figure out what to draw */
4338 rgntype
= GetClipBox(hdc
, &rcClip
);
4339 if (rgntype
== NULLREGION
) return;
4341 /* Get scroll info once before loop */
4342 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
4344 colRanges
= ranges_create(DPA_GetPtrCount(infoPtr
->hdpaColumns
));
4346 /* narrow down the columns we need to paint */
4347 for(col
= 0; col
< DPA_GetPtrCount(infoPtr
->hdpaColumns
); col
++)
4349 index
= SendMessageW(infoPtr
->hwndHeader
, HDM_ORDERTOINDEX
, col
, 0);
4351 LISTVIEW_GetHeaderRect(infoPtr
, index
, &rcItem
);
4352 if ((rcItem
.right
+ Origin
.x
>= rcClip
.left
) && (rcItem
.left
+ Origin
.x
< rcClip
.right
))
4353 ranges_additem(colRanges
, index
);
4355 iterator_rangesitems(&j
, colRanges
);
4357 /* in full row select, we _have_ to draw the main item */
4358 if (infoPtr
->dwLvExStyle
& LVS_EX_FULLROWSELECT
)
4361 /* iterate through the invalidated rows */
4362 while(iterator_next(i
))
4364 LISTVIEW_GetItemOrigin(infoPtr
, i
->nItem
, &Position
);
4365 Position
.y
+= Origin
.y
;
4367 /* iterate through the invalidated columns */
4368 while(iterator_next(&j
))
4370 LISTVIEW_GetHeaderRect(infoPtr
, j
.nItem
, &rcItem
);
4371 Position
.x
= (j
.nItem
== 0) ? rcItem
.left
+ Origin
.x
: Origin
.x
;
4373 if (rgntype
== COMPLEXREGION
&& !((infoPtr
->dwLvExStyle
& LVS_EX_FULLROWSELECT
) && j
.nItem
== 0))
4376 rcItem
.bottom
= infoPtr
->nItemHeight
;
4377 OffsetRect(&rcItem
, Origin
.x
, Position
.y
);
4378 if (!RectVisible(hdc
, &rcItem
)) continue;
4381 LISTVIEW_DrawItem(infoPtr
, hdc
, i
->nItem
, j
.nItem
, Position
, cdmode
);
4384 iterator_destroy(&j
);
4389 * Draws the gridlines if necessary when in report display mode.
4392 * [I] infoPtr : valid pointer to the listview structure
4393 * [I] hdc : device context handle
4398 static void LISTVIEW_RefreshReportGrid(LISTVIEW_INFO
*infoPtr
, HDC hdc
)
4404 RECT rcClip
, rcItem
= {0};
4412 /* figure out what to draw */
4413 rgntype
= GetClipBox(hdc
, &rcClip
);
4414 if (rgntype
== NULLREGION
) return;
4416 /* Get scroll info once before loop */
4417 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
4419 colRanges
= ranges_create(DPA_GetPtrCount(infoPtr
->hdpaColumns
));
4421 /* narrow down the columns we need to paint */
4422 for(col
= 0; col
< DPA_GetPtrCount(infoPtr
->hdpaColumns
); col
++)
4424 index
= SendMessageW(infoPtr
->hwndHeader
, HDM_ORDERTOINDEX
, col
, 0);
4426 LISTVIEW_GetHeaderRect(infoPtr
, index
, &rcItem
);
4427 if ((rcItem
.right
+ Origin
.x
>= rcClip
.left
) && (rcItem
.left
+ Origin
.x
< rcClip
.right
))
4428 ranges_additem(colRanges
, index
);
4431 /* is right most vertical line visible? */
4432 if (DPA_GetPtrCount(infoPtr
->hdpaColumns
) > 0)
4434 index
= SendMessageW(infoPtr
->hwndHeader
, HDM_ORDERTOINDEX
, DPA_GetPtrCount(infoPtr
->hdpaColumns
) - 1, 0);
4435 LISTVIEW_GetHeaderRect(infoPtr
, index
, &rcItem
);
4436 rmost
= (rcItem
.right
+ Origin
.x
< rcClip
.right
);
4439 if ((hPen
= CreatePen( PS_SOLID
, 1, comctl32_color
.clr3dFace
)))
4441 hOldPen
= SelectObject ( hdc
, hPen
);
4443 /* draw the vertical lines for the columns */
4444 iterator_rangesitems(&j
, colRanges
);
4445 while(iterator_next(&j
))
4447 LISTVIEW_GetHeaderRect(infoPtr
, j
.nItem
, &rcItem
);
4448 if (rcItem
.left
== 0) continue; /* skip leftmost column */
4449 rcItem
.left
+= Origin
.x
;
4450 rcItem
.right
+= Origin
.x
;
4451 rcItem
.top
= infoPtr
->rcList
.top
;
4452 rcItem
.bottom
= infoPtr
->rcList
.bottom
;
4453 TRACE("vert col=%d, rcItem=%s\n", j
.nItem
, wine_dbgstr_rect(&rcItem
));
4454 MoveToEx (hdc
, rcItem
.left
, rcItem
.top
, NULL
);
4455 LineTo (hdc
, rcItem
.left
, rcItem
.bottom
);
4457 iterator_destroy(&j
);
4458 /* draw rightmost grid line if visible */
4461 index
= SendMessageW(infoPtr
->hwndHeader
, HDM_ORDERTOINDEX
,
4462 DPA_GetPtrCount(infoPtr
->hdpaColumns
) - 1, 0);
4463 LISTVIEW_GetHeaderRect(infoPtr
, index
, &rcItem
);
4465 rcItem
.right
+= Origin
.x
;
4467 MoveToEx (hdc
, rcItem
.right
, infoPtr
->rcList
.top
, NULL
);
4468 LineTo (hdc
, rcItem
.right
, infoPtr
->rcList
.bottom
);
4471 /* draw the horizontial lines for the rows */
4472 itemheight
= LISTVIEW_CalculateItemHeight(infoPtr
);
4473 rcItem
.left
= infoPtr
->rcList
.left
;
4474 rcItem
.right
= infoPtr
->rcList
.right
;
4475 rcItem
.bottom
= rcItem
.top
= Origin
.y
- 1;
4476 MoveToEx(hdc
, rcItem
.left
, rcItem
.top
, NULL
);
4477 LineTo(hdc
, rcItem
.right
, rcItem
.top
);
4478 for(y
=itemheight
-1+Origin
.y
; y
<=infoPtr
->rcList
.bottom
; y
+=itemheight
)
4480 rcItem
.bottom
= rcItem
.top
= y
;
4481 TRACE("horz rcItem=%s\n", wine_dbgstr_rect(&rcItem
));
4482 MoveToEx (hdc
, rcItem
.left
, rcItem
.top
, NULL
);
4483 LineTo (hdc
, rcItem
.right
, rcItem
.top
);
4486 SelectObject( hdc
, hOldPen
);
4487 DeleteObject( hPen
);
4493 * Draws listview items when in list display mode.
4496 * [I] infoPtr : valid pointer to the listview structure
4497 * [I] hdc : device context handle
4498 * [I] cdmode : custom draw mode
4503 static void LISTVIEW_RefreshList(LISTVIEW_INFO
*infoPtr
, ITERATOR
*i
, HDC hdc
, DWORD cdmode
)
4505 POINT Origin
, Position
;
4507 /* Get scroll info once before loop */
4508 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
4510 while(iterator_prev(i
))
4512 LISTVIEW_GetItemOrigin(infoPtr
, i
->nItem
, &Position
);
4513 Position
.x
+= Origin
.x
;
4514 Position
.y
+= Origin
.y
;
4516 LISTVIEW_DrawItem(infoPtr
, hdc
, i
->nItem
, 0, Position
, cdmode
);
4523 * Draws listview items.
4526 * [I] infoPtr : valid pointer to the listview structure
4527 * [I] hdc : device context handle
4528 * [I] prcErase : rect to be erased before refresh (may be NULL)
4533 static void LISTVIEW_Refresh(LISTVIEW_INFO
*infoPtr
, HDC hdc
, const RECT
*prcErase
)
4535 COLORREF oldTextColor
= 0, oldBkColor
= 0, oldClrTextBk
, oldClrText
;
4536 NMLVCUSTOMDRAW nmlvcd
;
4543 HBITMAP hbmp
= NULL
;
4546 LISTVIEW_DUMP(infoPtr
);
4548 if (infoPtr
->dwLvExStyle
& LVS_EX_DOUBLEBUFFER
) {
4549 TRACE("double buffering\n");
4551 hdc
= CreateCompatibleDC(hdcOrig
);
4553 ERR("Failed to create DC for backbuffer\n");
4556 hbmp
= CreateCompatibleBitmap(hdcOrig
, infoPtr
->rcList
.right
,
4557 infoPtr
->rcList
.bottom
);
4559 ERR("Failed to create bitmap for backbuffer\n");
4564 SelectObject(hdc
, hbmp
);
4565 SelectObject(hdc
, infoPtr
->hFont
);
4567 /* Save dc values we're gonna trash while drawing
4568 * FIXME: Should be done in LISTVIEW_DrawItem() */
4569 hOldFont
= SelectObject(hdc
, infoPtr
->hFont
);
4570 oldBkMode
= GetBkMode(hdc
);
4571 oldBkColor
= GetBkColor(hdc
);
4572 oldTextColor
= GetTextColor(hdc
);
4575 infoPtr
->bIsDrawing
= TRUE
;
4578 LISTVIEW_FillBkgnd(infoPtr
, hdc
, prcErase
);
4579 } else if (infoPtr
->dwLvExStyle
& LVS_EX_DOUBLEBUFFER
) {
4580 /* If no erasing was done (usually because RedrawWindow was called
4581 * with RDW_INVALIDATE only) we need to copy the old contents into
4582 * the backbuffer before continuing. */
4583 BitBlt(hdc
, infoPtr
->rcList
.left
, infoPtr
->rcList
.top
,
4584 infoPtr
->rcList
.right
- infoPtr
->rcList
.left
,
4585 infoPtr
->rcList
.bottom
- infoPtr
->rcList
.top
,
4586 hdcOrig
, infoPtr
->rcList
.left
, infoPtr
->rcList
.top
, SRCCOPY
);
4589 /* FIXME: Shouldn't need to do this */
4590 oldClrTextBk
= infoPtr
->clrTextBk
;
4591 oldClrText
= infoPtr
->clrText
;
4593 infoPtr
->cditemmode
= CDRF_DODEFAULT
;
4595 GetClientRect(infoPtr
->hwndSelf
, &rcClient
);
4596 customdraw_fill(&nmlvcd
, infoPtr
, hdc
, &rcClient
, 0);
4597 cdmode
= notify_customdraw(infoPtr
, CDDS_PREPAINT
, &nmlvcd
);
4598 if (cdmode
& CDRF_SKIPDEFAULT
) goto enddraw
;
4599 prepaint_setup(infoPtr
, hdc
, &nmlvcd
, FALSE
);
4601 /* Use these colors to draw the items */
4602 infoPtr
->clrTextBk
= nmlvcd
.clrTextBk
;
4603 infoPtr
->clrText
= nmlvcd
.clrText
;
4605 /* nothing to draw */
4606 if(infoPtr
->nItemCount
== 0) goto enddraw
;
4608 /* figure out what we need to draw */
4609 iterator_visibleitems(&i
, infoPtr
, hdc
);
4610 range
= iterator_range(&i
);
4612 /* send cache hint notification */
4613 if (infoPtr
->dwStyle
& LVS_OWNERDATA
)
4617 ZeroMemory(&nmlv
, sizeof(NMLVCACHEHINT
));
4618 nmlv
.iFrom
= range
.lower
;
4619 nmlv
.iTo
= range
.upper
- 1;
4620 notify_hdr(infoPtr
, LVN_ODCACHEHINT
, &nmlv
.hdr
);
4623 if ((infoPtr
->dwStyle
& LVS_OWNERDRAWFIXED
) && (infoPtr
->uView
== LV_VIEW_DETAILS
))
4624 LISTVIEW_RefreshOwnerDraw(infoPtr
, &i
, hdc
, cdmode
);
4627 if (infoPtr
->uView
== LV_VIEW_DETAILS
)
4628 LISTVIEW_RefreshReport(infoPtr
, &i
, hdc
, cdmode
);
4629 else /* LV_VIEW_LIST, LV_VIEW_ICON or LV_VIEW_SMALLICON */
4630 LISTVIEW_RefreshList(infoPtr
, &i
, hdc
, cdmode
);
4632 /* if we have a focus rect and it's visible, draw it */
4633 if (infoPtr
->bFocus
&& range
.lower
<= infoPtr
->nFocusedItem
&&
4634 (range
.upper
- 1) >= infoPtr
->nFocusedItem
)
4635 LISTVIEW_DrawFocusRect(infoPtr
, hdc
);
4637 iterator_destroy(&i
);
4640 /* For LVS_EX_GRIDLINES go and draw lines */
4641 /* This includes the case where there were *no* items */
4642 if ((infoPtr
->uView
== LV_VIEW_DETAILS
) && infoPtr
->dwLvExStyle
& LVS_EX_GRIDLINES
)
4643 LISTVIEW_RefreshReportGrid(infoPtr
, hdc
);
4645 if (cdmode
& CDRF_NOTIFYPOSTPAINT
)
4646 notify_postpaint(infoPtr
, &nmlvcd
);
4648 infoPtr
->clrTextBk
= oldClrTextBk
;
4649 infoPtr
->clrText
= oldClrText
;
4652 BitBlt(hdcOrig
, infoPtr
->rcList
.left
, infoPtr
->rcList
.top
,
4653 infoPtr
->rcList
.right
- infoPtr
->rcList
.left
,
4654 infoPtr
->rcList
.bottom
- infoPtr
->rcList
.top
,
4655 hdc
, infoPtr
->rcList
.left
, infoPtr
->rcList
.top
, SRCCOPY
);
4660 SelectObject(hdc
, hOldFont
);
4661 SetBkMode(hdc
, oldBkMode
);
4662 SetBkColor(hdc
, oldBkColor
);
4663 SetTextColor(hdc
, oldTextColor
);
4666 infoPtr
->bIsDrawing
= FALSE
;
4672 * Calculates the approximate width and height of a given number of items.
4675 * [I] infoPtr : valid pointer to the listview structure
4676 * [I] nItemCount : number of items
4677 * [I] wWidth : width
4678 * [I] wHeight : height
4681 * Returns a DWORD. The width in the low word and the height in high word.
4683 static DWORD
LISTVIEW_ApproximateViewRect(const LISTVIEW_INFO
*infoPtr
, INT nItemCount
,
4684 WORD wWidth
, WORD wHeight
)
4686 INT nItemCountPerColumn
= 1;
4687 INT nColumnCount
= 0;
4688 DWORD dwViewRect
= 0;
4690 if (nItemCount
== -1)
4691 nItemCount
= infoPtr
->nItemCount
;
4693 if (infoPtr
->uView
== LV_VIEW_LIST
)
4695 if (wHeight
== 0xFFFF)
4697 /* use current height */
4698 wHeight
= infoPtr
->rcList
.bottom
- infoPtr
->rcList
.top
;
4701 if (wHeight
< infoPtr
->nItemHeight
)
4702 wHeight
= infoPtr
->nItemHeight
;
4706 if (infoPtr
->nItemHeight
> 0)
4708 nItemCountPerColumn
= wHeight
/ infoPtr
->nItemHeight
;
4709 if (nItemCountPerColumn
== 0)
4710 nItemCountPerColumn
= 1;
4712 if (nItemCount
% nItemCountPerColumn
!= 0)
4713 nColumnCount
= nItemCount
/ nItemCountPerColumn
;
4715 nColumnCount
= nItemCount
/ nItemCountPerColumn
+ 1;
4719 /* Microsoft padding magic */
4720 wHeight
= nItemCountPerColumn
* infoPtr
->nItemHeight
+ 2;
4721 wWidth
= nColumnCount
* infoPtr
->nItemWidth
+ 2;
4723 dwViewRect
= MAKELONG(wWidth
, wHeight
);
4725 else if (infoPtr
->uView
== LV_VIEW_DETAILS
)
4729 if (infoPtr
->nItemCount
> 0)
4731 LISTVIEW_GetItemBox(infoPtr
, 0, &rcBox
);
4732 wWidth
= rcBox
.right
- rcBox
.left
;
4733 wHeight
= (rcBox
.bottom
- rcBox
.top
) * nItemCount
;
4737 /* use current height and width */
4738 if (wHeight
== 0xffff)
4739 wHeight
= infoPtr
->rcList
.bottom
- infoPtr
->rcList
.top
;
4740 if (wWidth
== 0xffff)
4741 wWidth
= infoPtr
->rcList
.right
- infoPtr
->rcList
.left
;
4744 dwViewRect
= MAKELONG(wWidth
, wHeight
);
4746 else if (infoPtr
->uView
== LV_VIEW_SMALLICON
)
4747 FIXME("uView == LV_VIEW_SMALLICON: not implemented\n");
4748 else if (infoPtr
->uView
== LV_VIEW_ICON
)
4749 FIXME("uView == LV_VIEW_ICON: not implemented\n");
4756 * Cancel edit label with saving item text.
4759 * [I] infoPtr : valid pointer to the listview structure
4762 * Always returns TRUE.
4764 static LRESULT
LISTVIEW_CancelEditLabel(LISTVIEW_INFO
*infoPtr
)
4766 /* handle value will be lost after LISTVIEW_EndEditLabelT */
4767 HWND edit
= infoPtr
->hwndEdit
;
4769 LISTVIEW_EndEditLabelT(infoPtr
, TRUE
, IsWindowUnicode(infoPtr
->hwndEdit
));
4770 SendMessageW(edit
, WM_CLOSE
, 0, 0);
4777 * Create a drag image list for the specified item.
4780 * [I] infoPtr : valid pointer to the listview structure
4781 * [I] iItem : index of item
4782 * [O] lppt : Upper-left corner of the image
4785 * Returns a handle to the image list if successful, NULL otherwise.
4787 static HIMAGELIST
LISTVIEW_CreateDragImage(LISTVIEW_INFO
*infoPtr
, INT iItem
, LPPOINT lppt
)
4793 HBITMAP hbmp
, hOldbmp
;
4794 HIMAGELIST dragList
= 0;
4795 TRACE("iItem=%d Count=%d\n", iItem
, infoPtr
->nItemCount
);
4797 if (iItem
< 0 || iItem
>= infoPtr
->nItemCount
)
4800 rcItem
.left
= LVIR_BOUNDS
;
4801 if (!LISTVIEW_GetItemRect(infoPtr
, iItem
, &rcItem
))
4804 lppt
->x
= rcItem
.left
;
4805 lppt
->y
= rcItem
.top
;
4807 size
.cx
= rcItem
.right
- rcItem
.left
;
4808 size
.cy
= rcItem
.bottom
- rcItem
.top
;
4810 hdcOrig
= GetDC(infoPtr
->hwndSelf
);
4811 hdc
= CreateCompatibleDC(hdcOrig
);
4812 hbmp
= CreateCompatibleBitmap(hdcOrig
, size
.cx
, size
.cy
);
4813 hOldbmp
= SelectObject(hdc
, hbmp
);
4815 rcItem
.left
= rcItem
.top
= 0;
4816 rcItem
.right
= size
.cx
;
4817 rcItem
.bottom
= size
.cy
;
4818 FillRect(hdc
, &rcItem
, infoPtr
->hBkBrush
);
4821 if (LISTVIEW_DrawItem(infoPtr
, hdc
, iItem
, 0, pos
, infoPtr
->cditemmode
))
4823 dragList
= ImageList_Create(size
.cx
, size
.cy
, ILC_COLOR
, 10, 10);
4824 SelectObject(hdc
, hOldbmp
);
4825 ImageList_Add(dragList
, hbmp
, 0);
4828 SelectObject(hdc
, hOldbmp
);
4832 ReleaseDC(infoPtr
->hwndSelf
, hdcOrig
);
4834 TRACE("ret=%p\n", dragList
);
4842 * Removes all listview items and subitems.
4845 * [I] infoPtr : valid pointer to the listview structure
4851 static BOOL
LISTVIEW_DeleteAllItems(LISTVIEW_INFO
*infoPtr
, BOOL destroy
)
4854 HDPA hdpaSubItems
= NULL
;
4861 /* we do it directly, to avoid notifications */
4862 ranges_clear(infoPtr
->selectionRanges
);
4863 infoPtr
->nSelectionMark
= -1;
4864 infoPtr
->nFocusedItem
= -1;
4865 SetRectEmpty(&infoPtr
->rcFocus
);
4866 /* But we are supposed to leave nHotItem as is! */
4869 /* send LVN_DELETEALLITEMS notification */
4870 ZeroMemory(&nmlv
, sizeof(NMLISTVIEW
));
4872 bSuppress
= notify_listview(infoPtr
, LVN_DELETEALLITEMS
, &nmlv
);
4874 for (i
= infoPtr
->nItemCount
- 1; i
>= 0; i
--)
4876 if (!(infoPtr
->dwStyle
& LVS_OWNERDATA
))
4878 /* send LVN_DELETEITEM notification, if not suppressed
4879 and if it is not a virtual listview */
4880 if (!bSuppress
) notify_deleteitem(infoPtr
, i
);
4881 hdpaSubItems
= DPA_GetPtr(infoPtr
->hdpaItems
, i
);
4882 for (j
= 0; j
< DPA_GetPtrCount(hdpaSubItems
); j
++)
4884 hdrItem
= DPA_GetPtr(hdpaSubItems
, j
);
4885 if (is_textW(hdrItem
->pszText
)) Free(hdrItem
->pszText
);
4888 DPA_Destroy(hdpaSubItems
);
4889 DPA_DeletePtr(infoPtr
->hdpaItems
, i
);
4891 DPA_DeletePtr(infoPtr
->hdpaPosX
, i
);
4892 DPA_DeletePtr(infoPtr
->hdpaPosY
, i
);
4893 infoPtr
->nItemCount
--;
4898 LISTVIEW_Arrange(infoPtr
, LVA_DEFAULT
);
4899 LISTVIEW_UpdateScroll(infoPtr
);
4901 LISTVIEW_InvalidateList(infoPtr
);
4908 * Scrolls, and updates the columns, when a column is changing width.
4911 * [I] infoPtr : valid pointer to the listview structure
4912 * [I] nColumn : column to scroll
4913 * [I] dx : amount of scroll, in pixels
4918 static void LISTVIEW_ScrollColumns(LISTVIEW_INFO
*infoPtr
, INT nColumn
, INT dx
)
4920 COLUMN_INFO
*lpColumnInfo
;
4926 if (nColumn
< 0 || DPA_GetPtrCount(infoPtr
->hdpaColumns
) < 1) return;
4927 lpColumnInfo
= LISTVIEW_GetColumnInfo(infoPtr
, min(nColumn
, DPA_GetPtrCount(infoPtr
->hdpaColumns
) - 1));
4928 rcCol
= lpColumnInfo
->rcHeader
;
4929 if (nColumn
>= DPA_GetPtrCount(infoPtr
->hdpaColumns
))
4930 rcCol
.left
= rcCol
.right
;
4932 /* adjust the other columns */
4933 hdi
.mask
= HDI_ORDER
;
4934 if (SendMessageW(infoPtr
->hwndHeader
, HDM_GETITEMW
, nColumn
, (LPARAM
)&hdi
))
4936 INT nOrder
= hdi
.iOrder
;
4937 for (nCol
= 0; nCol
< DPA_GetPtrCount(infoPtr
->hdpaColumns
); nCol
++)
4939 hdi
.mask
= HDI_ORDER
;
4940 SendMessageW(infoPtr
->hwndHeader
, HDM_GETITEMW
, nCol
, (LPARAM
)&hdi
);
4941 if (hdi
.iOrder
>= nOrder
) {
4942 lpColumnInfo
= LISTVIEW_GetColumnInfo(infoPtr
, nCol
);
4943 lpColumnInfo
->rcHeader
.left
+= dx
;
4944 lpColumnInfo
->rcHeader
.right
+= dx
;
4949 /* do not update screen if not in report mode */
4950 if (!is_redrawing(infoPtr
) || infoPtr
->uView
!= LV_VIEW_DETAILS
) return;
4952 /* Need to reset the item width when inserting a new column */
4953 infoPtr
->nItemWidth
+= dx
;
4955 LISTVIEW_UpdateScroll(infoPtr
);
4956 LISTVIEW_GetOrigin(infoPtr
, &ptOrigin
);
4958 /* scroll to cover the deleted column, and invalidate for redraw */
4959 rcOld
= infoPtr
->rcList
;
4960 rcOld
.left
= ptOrigin
.x
+ rcCol
.left
+ dx
;
4961 ScrollWindowEx(infoPtr
->hwndSelf
, dx
, 0, &rcOld
, &rcOld
, 0, 0, SW_ERASE
| SW_INVALIDATE
);
4966 * Removes a column from the listview control.
4969 * [I] infoPtr : valid pointer to the listview structure
4970 * [I] nColumn : column index
4976 static BOOL
LISTVIEW_DeleteColumn(LISTVIEW_INFO
*infoPtr
, INT nColumn
)
4980 TRACE("nColumn=%d\n", nColumn
);
4982 if (nColumn
< 0 || DPA_GetPtrCount(infoPtr
->hdpaColumns
) == 0
4983 || nColumn
>= DPA_GetPtrCount(infoPtr
->hdpaColumns
)) return FALSE
;
4985 /* While the MSDN specifically says that column zero should not be deleted,
4986 what actually happens is that the column itself is deleted but no items or subitems
4990 LISTVIEW_GetHeaderRect(infoPtr
, nColumn
, &rcCol
);
4992 if (!SendMessageW(infoPtr
->hwndHeader
, HDM_DELETEITEM
, nColumn
, 0))
4995 Free(DPA_GetPtr(infoPtr
->hdpaColumns
, nColumn
));
4996 DPA_DeletePtr(infoPtr
->hdpaColumns
, nColumn
);
4998 if (!(infoPtr
->dwStyle
& LVS_OWNERDATA
) && nColumn
)
5000 SUBITEM_INFO
*lpSubItem
, *lpDelItem
;
5002 INT nItem
, nSubItem
, i
;
5004 for (nItem
= 0; nItem
< infoPtr
->nItemCount
; nItem
++)
5006 hdpaSubItems
= DPA_GetPtr(infoPtr
->hdpaItems
, nItem
);
5009 for (i
= 1; i
< DPA_GetPtrCount(hdpaSubItems
); i
++)
5011 lpSubItem
= DPA_GetPtr(hdpaSubItems
, i
);
5012 if (lpSubItem
->iSubItem
== nColumn
)
5015 lpDelItem
= lpSubItem
;
5017 else if (lpSubItem
->iSubItem
> nColumn
)
5019 lpSubItem
->iSubItem
--;
5023 /* if we found our subitem, zapp it */
5027 if (is_textW(lpDelItem
->hdr
.pszText
))
5028 Free(lpDelItem
->hdr
.pszText
);
5033 /* free dpa memory */
5034 DPA_DeletePtr(hdpaSubItems
, nSubItem
);
5039 /* update the other column info */
5040 LISTVIEW_UpdateItemSize(infoPtr
);
5041 if(DPA_GetPtrCount(infoPtr
->hdpaColumns
) == 0)
5042 LISTVIEW_InvalidateList(infoPtr
);
5044 LISTVIEW_ScrollColumns(infoPtr
, nColumn
, -(rcCol
.right
- rcCol
.left
));
5051 * Invalidates the listview after an item's insertion or deletion.
5054 * [I] infoPtr : valid pointer to the listview structure
5055 * [I] nItem : item index
5056 * [I] dir : -1 if deleting, 1 if inserting
5061 static void LISTVIEW_ScrollOnInsert(LISTVIEW_INFO
*infoPtr
, INT nItem
, INT dir
)
5063 INT nPerCol
, nItemCol
, nItemRow
;
5067 /* if we don't refresh, what's the point of scrolling? */
5068 if (!is_redrawing(infoPtr
)) return;
5070 assert (abs(dir
) == 1);
5072 /* arrange icons if autoarrange is on */
5073 if (is_autoarrange(infoPtr
))
5075 BOOL arrange
= TRUE
;
5076 if (dir
< 0 && nItem
>= infoPtr
->nItemCount
) arrange
= FALSE
;
5077 if (dir
> 0 && nItem
== infoPtr
->nItemCount
- 1) arrange
= FALSE
;
5078 if (arrange
) LISTVIEW_Arrange(infoPtr
, LVA_DEFAULT
);
5081 /* scrollbars need updating */
5082 LISTVIEW_UpdateScroll(infoPtr
);
5084 /* figure out the item's position */
5085 if (infoPtr
->uView
== LV_VIEW_DETAILS
)
5086 nPerCol
= infoPtr
->nItemCount
+ 1;
5087 else if (infoPtr
->uView
== LV_VIEW_LIST
)
5088 nPerCol
= LISTVIEW_GetCountPerColumn(infoPtr
);
5089 else /* LV_VIEW_ICON, or LV_VIEW_SMALLICON */
5092 nItemCol
= nItem
/ nPerCol
;
5093 nItemRow
= nItem
% nPerCol
;
5094 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
5096 /* move the items below up a slot */
5097 rcScroll
.left
= nItemCol
* infoPtr
->nItemWidth
;
5098 rcScroll
.top
= nItemRow
* infoPtr
->nItemHeight
;
5099 rcScroll
.right
= rcScroll
.left
+ infoPtr
->nItemWidth
;
5100 rcScroll
.bottom
= nPerCol
* infoPtr
->nItemHeight
;
5101 OffsetRect(&rcScroll
, Origin
.x
, Origin
.y
);
5102 TRACE("rcScroll=%s, dx=%d\n", wine_dbgstr_rect(&rcScroll
), dir
* infoPtr
->nItemHeight
);
5103 if (IntersectRect(&rcScroll
, &rcScroll
, &infoPtr
->rcList
))
5105 TRACE("Scrolling rcScroll=%s, rcList=%s\n", wine_dbgstr_rect(&rcScroll
), wine_dbgstr_rect(&infoPtr
->rcList
));
5106 ScrollWindowEx(infoPtr
->hwndSelf
, 0, dir
* infoPtr
->nItemHeight
,
5107 &rcScroll
, &rcScroll
, 0, 0, SW_ERASE
| SW_INVALIDATE
);
5110 /* report has only that column, so we're done */
5111 if (infoPtr
->uView
== LV_VIEW_DETAILS
) return;
5113 /* now for LISTs, we have to deal with the columns to the right */
5114 rcScroll
.left
= (nItemCol
+ 1) * infoPtr
->nItemWidth
;
5116 rcScroll
.right
= (infoPtr
->nItemCount
/ nPerCol
+ 1) * infoPtr
->nItemWidth
;
5117 rcScroll
.bottom
= nPerCol
* infoPtr
->nItemHeight
;
5118 OffsetRect(&rcScroll
, Origin
.x
, Origin
.y
);
5119 if (IntersectRect(&rcScroll
, &rcScroll
, &infoPtr
->rcList
))
5120 ScrollWindowEx(infoPtr
->hwndSelf
, 0, dir
* infoPtr
->nItemHeight
,
5121 &rcScroll
, &rcScroll
, 0, 0, SW_ERASE
| SW_INVALIDATE
);
5126 * Removes an item from the listview control.
5129 * [I] infoPtr : valid pointer to the listview structure
5130 * [I] nItem : item index
5136 static BOOL
LISTVIEW_DeleteItem(LISTVIEW_INFO
*infoPtr
, INT nItem
)
5139 const BOOL is_icon
= (infoPtr
->uView
== LV_VIEW_SMALLICON
|| infoPtr
->uView
== LV_VIEW_ICON
);
5141 TRACE("(nItem=%d)\n", nItem
);
5143 if (nItem
< 0 || nItem
>= infoPtr
->nItemCount
) return FALSE
;
5145 /* remove selection, and focus */
5147 item
.stateMask
= LVIS_SELECTED
| LVIS_FOCUSED
;
5148 LISTVIEW_SetItemState(infoPtr
, nItem
, &item
);
5150 /* send LVN_DELETEITEM notification. */
5151 if (!notify_deleteitem(infoPtr
, nItem
)) return FALSE
;
5153 /* we need to do this here, because we'll be deleting stuff */
5155 LISTVIEW_InvalidateItem(infoPtr
, nItem
);
5157 if (!(infoPtr
->dwStyle
& LVS_OWNERDATA
))
5165 hdpaSubItems
= DPA_DeletePtr(infoPtr
->hdpaItems
, nItem
);
5166 lpItem
= DPA_GetPtr(hdpaSubItems
, 0);
5168 /* free id struct */
5169 i
= DPA_GetPtrIndex(infoPtr
->hdpaItemIds
, lpItem
->id
);
5170 lpID
= DPA_GetPtr(infoPtr
->hdpaItemIds
, i
);
5171 DPA_DeletePtr(infoPtr
->hdpaItemIds
, i
);
5173 for (i
= 0; i
< DPA_GetPtrCount(hdpaSubItems
); i
++)
5175 hdrItem
= DPA_GetPtr(hdpaSubItems
, i
);
5176 if (is_textW(hdrItem
->pszText
)) Free(hdrItem
->pszText
);
5179 DPA_Destroy(hdpaSubItems
);
5184 DPA_DeletePtr(infoPtr
->hdpaPosX
, nItem
);
5185 DPA_DeletePtr(infoPtr
->hdpaPosY
, nItem
);
5188 infoPtr
->nItemCount
--;
5189 LISTVIEW_ShiftIndices(infoPtr
, nItem
, -1);
5191 /* now is the invalidation fun */
5193 LISTVIEW_ScrollOnInsert(infoPtr
, nItem
, -1);
5200 * Callback implementation for editlabel control
5203 * [I] infoPtr : valid pointer to the listview structure
5204 * [I] storeText : store edit box text as item text
5205 * [I] isW : TRUE if psxText is Unicode, FALSE if it's ANSI
5211 static BOOL
LISTVIEW_EndEditLabelT(LISTVIEW_INFO
*infoPtr
, BOOL storeText
, BOOL isW
)
5213 HWND hwndSelf
= infoPtr
->hwndSelf
;
5214 NMLVDISPINFOW dispInfo
;
5215 INT editedItem
= infoPtr
->nEditLabelItem
;
5217 WCHAR
*pszText
= NULL
;
5222 DWORD len
= isW
? GetWindowTextLengthW(infoPtr
->hwndEdit
) : GetWindowTextLengthA(infoPtr
->hwndEdit
);
5226 if ((pszText
= Alloc((len
+1) * (isW
? sizeof(WCHAR
) : sizeof(CHAR
)))))
5228 if (isW
) GetWindowTextW(infoPtr
->hwndEdit
, pszText
, len
+1);
5229 else GetWindowTextA(infoPtr
->hwndEdit
, (CHAR
*)pszText
, len
+1);
5234 TRACE("(pszText=%s, isW=%d)\n", debugtext_t(pszText
, isW
), isW
);
5236 infoPtr
->nEditLabelItem
= -1;
5237 infoPtr
->hwndEdit
= 0;
5239 ZeroMemory(&dispInfo
, sizeof(dispInfo
));
5240 dispInfo
.item
.mask
= LVIF_PARAM
| LVIF_STATE
| LVIF_TEXT
;
5241 dispInfo
.item
.iItem
= editedItem
;
5242 dispInfo
.item
.iSubItem
= 0;
5243 dispInfo
.item
.stateMask
= ~0;
5244 if (!LISTVIEW_GetItemW(infoPtr
, &dispInfo
.item
))
5251 bSame
= (lstrcmpW(dispInfo
.item
.pszText
, pszText
) == 0);
5254 LPWSTR tmp
= textdupTtoW(pszText
, FALSE
);
5255 bSame
= (lstrcmpW(dispInfo
.item
.pszText
, tmp
) == 0);
5256 textfreeT(tmp
, FALSE
);
5264 /* add the text from the edit in */
5265 dispInfo
.item
.mask
|= LVIF_TEXT
;
5266 dispInfo
.item
.pszText
= pszText
;
5267 dispInfo
.item
.cchTextMax
= textlenT(pszText
, isW
);
5269 /* Do we need to update the Item Text */
5270 if (!notify_dispinfoT(infoPtr
, LVN_ENDLABELEDITW
, &dispInfo
, isW
))
5275 if (!IsWindow(hwndSelf
))
5280 if (!pszText
) return TRUE
;
5282 if (!(infoPtr
->dwStyle
& LVS_OWNERDATA
))
5284 HDPA hdpaSubItems
= DPA_GetPtr(infoPtr
->hdpaItems
, editedItem
);
5285 ITEM_INFO
* lpItem
= DPA_GetPtr(hdpaSubItems
, 0);
5286 if (lpItem
&& lpItem
->hdr
.pszText
== LPSTR_TEXTCALLBACKW
)
5288 LISTVIEW_InvalidateItem(infoPtr
, editedItem
);
5294 ZeroMemory(&dispInfo
, sizeof(dispInfo
));
5295 dispInfo
.item
.mask
= LVIF_TEXT
;
5296 dispInfo
.item
.iItem
= editedItem
;
5297 dispInfo
.item
.iSubItem
= 0;
5298 dispInfo
.item
.pszText
= pszText
;
5299 dispInfo
.item
.cchTextMax
= textlenT(pszText
, isW
);
5300 res
= LISTVIEW_SetItemT(infoPtr
, &dispInfo
.item
, isW
);
5310 * Begin in place editing of specified list view item
5313 * [I] infoPtr : valid pointer to the listview structure
5314 * [I] nItem : item index
5315 * [I] isW : TRUE if it's a Unicode req, FALSE if ASCII
5321 static HWND
LISTVIEW_EditLabelT(LISTVIEW_INFO
*infoPtr
, INT nItem
, BOOL isW
)
5323 WCHAR szDispText
[DISP_TEXT_SIZE
] = { 0 };
5324 NMLVDISPINFOW dispInfo
;
5327 HWND hwndSelf
= infoPtr
->hwndSelf
;
5329 HFONT hOldFont
= NULL
;
5330 TEXTMETRICW textMetric
;
5332 TRACE("(nItem=%d, isW=%d)\n", nItem
, isW
);
5334 if (~infoPtr
->dwStyle
& LVS_EDITLABELS
) return 0;
5336 /* Is the EditBox still there, if so remove it */
5337 if(infoPtr
->hwndEdit
!= 0)
5339 SetFocus(infoPtr
->hwndSelf
);
5340 infoPtr
->hwndEdit
= 0;
5343 if (nItem
< 0 || nItem
>= infoPtr
->nItemCount
) return 0;
5345 infoPtr
->nEditLabelItem
= nItem
;
5347 LISTVIEW_SetSelection(infoPtr
, nItem
);
5348 LISTVIEW_SetItemFocus(infoPtr
, nItem
);
5349 LISTVIEW_InvalidateItem(infoPtr
, nItem
);
5351 rect
.left
= LVIR_LABEL
;
5352 if (!LISTVIEW_GetItemRect(infoPtr
, nItem
, &rect
)) return 0;
5354 ZeroMemory(&dispInfo
, sizeof(dispInfo
));
5355 dispInfo
.item
.mask
= LVIF_PARAM
| LVIF_STATE
| LVIF_TEXT
;
5356 dispInfo
.item
.iItem
= nItem
;
5357 dispInfo
.item
.iSubItem
= 0;
5358 dispInfo
.item
.stateMask
= ~0;
5359 dispInfo
.item
.pszText
= szDispText
;
5360 dispInfo
.item
.cchTextMax
= DISP_TEXT_SIZE
;
5361 if (!LISTVIEW_GetItemT(infoPtr
, &dispInfo
.item
, isW
)) return 0;
5363 infoPtr
->hwndEdit
= CreateEditLabelT(infoPtr
, dispInfo
.item
.pszText
, WS_VISIBLE
, isW
);
5364 if (!infoPtr
->hwndEdit
) return 0;
5366 if (notify_dispinfoT(infoPtr
, LVN_BEGINLABELEDITW
, &dispInfo
, isW
))
5368 if (!IsWindow(hwndSelf
))
5370 SendMessageW(infoPtr
->hwndEdit
, WM_CLOSE
, 0, 0);
5371 infoPtr
->hwndEdit
= 0;
5375 /* Now position and display edit box */
5376 hdc
= GetDC(infoPtr
->hwndSelf
);
5378 /* Select the font to get appropriate metric dimensions */
5379 if(infoPtr
->hFont
!= 0)
5380 hOldFont
= SelectObject(hdc
, infoPtr
->hFont
);
5382 /* Get String Length in pixels */
5383 GetTextExtentPoint32W(hdc
, dispInfo
.item
.pszText
, lstrlenW(dispInfo
.item
.pszText
), &sz
);
5385 /* Add Extra spacing for the next character */
5386 GetTextMetricsW(hdc
, &textMetric
);
5387 sz
.cx
+= (textMetric
.tmMaxCharWidth
* 2);
5389 if(infoPtr
->hFont
!= 0)
5390 SelectObject(hdc
, hOldFont
);
5392 ReleaseDC(infoPtr
->hwndSelf
, hdc
);
5394 MoveWindow(infoPtr
->hwndEdit
, rect
.left
- 2, rect
.top
- 1, sz
.cx
,
5395 rect
.bottom
- rect
.top
+ 2, FALSE
);
5396 ShowWindow(infoPtr
->hwndEdit
, SW_NORMAL
);
5397 SetFocus(infoPtr
->hwndEdit
);
5398 SendMessageW(infoPtr
->hwndEdit
, EM_SETSEL
, 0, -1);
5399 return infoPtr
->hwndEdit
;
5405 * Ensures the specified item is visible, scrolling into view if necessary.
5408 * [I] infoPtr : valid pointer to the listview structure
5409 * [I] nItem : item index
5410 * [I] bPartial : partially or entirely visible
5416 static BOOL
LISTVIEW_EnsureVisible(LISTVIEW_INFO
*infoPtr
, INT nItem
, BOOL bPartial
)
5418 INT nScrollPosHeight
= 0;
5419 INT nScrollPosWidth
= 0;
5420 INT nHorzAdjust
= 0;
5421 INT nVertAdjust
= 0;
5424 RECT rcItem
, rcTemp
;
5426 rcItem
.left
= LVIR_BOUNDS
;
5427 if (!LISTVIEW_GetItemRect(infoPtr
, nItem
, &rcItem
)) return FALSE
;
5429 if (bPartial
&& IntersectRect(&rcTemp
, &infoPtr
->rcList
, &rcItem
)) return TRUE
;
5431 if (rcItem
.left
< infoPtr
->rcList
.left
|| rcItem
.right
> infoPtr
->rcList
.right
)
5433 /* scroll left/right, but in LV_VIEW_DETAILS mode */
5434 if (infoPtr
->uView
== LV_VIEW_LIST
)
5435 nScrollPosWidth
= infoPtr
->nItemWidth
;
5436 else if ((infoPtr
->uView
== LV_VIEW_SMALLICON
) || (infoPtr
->uView
== LV_VIEW_ICON
))
5437 nScrollPosWidth
= 1;
5439 if (rcItem
.left
< infoPtr
->rcList
.left
)
5442 if (infoPtr
->uView
!= LV_VIEW_DETAILS
) nHorzDiff
= rcItem
.left
- infoPtr
->rcList
.left
;
5447 if (infoPtr
->uView
!= LV_VIEW_DETAILS
) nHorzDiff
= rcItem
.right
- infoPtr
->rcList
.right
;
5451 if (rcItem
.top
< infoPtr
->rcList
.top
|| rcItem
.bottom
> infoPtr
->rcList
.bottom
)
5453 /* scroll up/down, but not in LVS_LIST mode */
5454 if (infoPtr
->uView
== LV_VIEW_DETAILS
)
5455 nScrollPosHeight
= infoPtr
->nItemHeight
;
5456 else if ((infoPtr
->uView
== LV_VIEW_ICON
) || (infoPtr
->uView
== LV_VIEW_SMALLICON
))
5457 nScrollPosHeight
= 1;
5459 if (rcItem
.top
< infoPtr
->rcList
.top
)
5462 if (infoPtr
->uView
!= LV_VIEW_LIST
) nVertDiff
= rcItem
.top
- infoPtr
->rcList
.top
;
5467 if (infoPtr
->uView
!= LV_VIEW_LIST
) nVertDiff
= rcItem
.bottom
- infoPtr
->rcList
.bottom
;
5471 if (!nScrollPosWidth
&& !nScrollPosHeight
) return TRUE
;
5473 if (nScrollPosWidth
)
5475 INT diff
= nHorzDiff
/ nScrollPosWidth
;
5476 if (nHorzDiff
% nScrollPosWidth
) diff
+= nHorzAdjust
;
5477 LISTVIEW_HScroll(infoPtr
, SB_INTERNAL
, diff
, 0);
5480 if (nScrollPosHeight
)
5482 INT diff
= nVertDiff
/ nScrollPosHeight
;
5483 if (nVertDiff
% nScrollPosHeight
) diff
+= nVertAdjust
;
5484 LISTVIEW_VScroll(infoPtr
, SB_INTERNAL
, diff
, 0);
5492 * Searches for an item with specific characteristics.
5495 * [I] hwnd : window handle
5496 * [I] nStart : base item index
5497 * [I] lpFindInfo : item information to look for
5500 * SUCCESS : index of item
5503 static INT
LISTVIEW_FindItemW(const LISTVIEW_INFO
*infoPtr
, INT nStart
,
5504 const LVFINDINFOW
*lpFindInfo
)
5506 WCHAR szDispText
[DISP_TEXT_SIZE
] = { '\0' };
5507 BOOL bWrap
= FALSE
, bNearest
= FALSE
;
5508 INT nItem
= nStart
+ 1, nLast
= infoPtr
->nItemCount
, nNearestItem
= -1;
5509 ULONG xdist
, ydist
, dist
, mindist
= 0x7fffffff;
5510 POINT Position
, Destination
;
5513 /* Search in virtual listviews should be done by application, not by
5514 listview control, so we just send LVN_ODFINDITEMW and return the result */
5515 if (infoPtr
->dwStyle
& LVS_OWNERDATA
)
5519 nmlv
.iStart
= nStart
;
5520 nmlv
.lvfi
= *lpFindInfo
;
5521 return notify_hdr(infoPtr
, LVN_ODFINDITEMW
, (LPNMHDR
)&nmlv
.hdr
);
5524 if (!lpFindInfo
|| nItem
< 0) return -1;
5527 if (lpFindInfo
->flags
& (LVFI_STRING
| LVFI_PARTIAL
))
5529 lvItem
.mask
|= LVIF_TEXT
;
5530 lvItem
.pszText
= szDispText
;
5531 lvItem
.cchTextMax
= DISP_TEXT_SIZE
;
5534 if (lpFindInfo
->flags
& LVFI_WRAP
)
5537 if ((lpFindInfo
->flags
& LVFI_NEARESTXY
) &&
5538 (infoPtr
->uView
== LV_VIEW_ICON
|| infoPtr
->uView
== LV_VIEW_SMALLICON
))
5543 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
5544 Destination
.x
= lpFindInfo
->pt
.x
- Origin
.x
;
5545 Destination
.y
= lpFindInfo
->pt
.y
- Origin
.y
;
5546 switch(lpFindInfo
->vkDirection
)
5548 case VK_DOWN
: Destination
.y
+= infoPtr
->nItemHeight
; break;
5549 case VK_UP
: Destination
.y
-= infoPtr
->nItemHeight
; break;
5550 case VK_RIGHT
: Destination
.x
+= infoPtr
->nItemWidth
; break;
5551 case VK_LEFT
: Destination
.x
-= infoPtr
->nItemWidth
; break;
5552 case VK_HOME
: Destination
.x
= Destination
.y
= 0; break;
5553 case VK_NEXT
: Destination
.y
+= infoPtr
->rcList
.bottom
- infoPtr
->rcList
.top
; break;
5554 case VK_PRIOR
: Destination
.y
-= infoPtr
->rcList
.bottom
- infoPtr
->rcList
.top
; break;
5556 LISTVIEW_GetAreaRect(infoPtr
, &rcArea
);
5557 Destination
.x
= rcArea
.right
;
5558 Destination
.y
= rcArea
.bottom
;
5560 default: ERR("Unknown vkDirection=%d\n", lpFindInfo
->vkDirection
);
5564 else Destination
.x
= Destination
.y
= 0;
5566 /* if LVFI_PARAM is specified, all other flags are ignored */
5567 if (lpFindInfo
->flags
& LVFI_PARAM
)
5569 lvItem
.mask
|= LVIF_PARAM
;
5571 lvItem
.mask
&= ~LVIF_TEXT
;
5575 for (; nItem
< nLast
; nItem
++)
5577 lvItem
.iItem
= nItem
;
5578 lvItem
.iSubItem
= 0;
5579 if (!LISTVIEW_GetItemW(infoPtr
, &lvItem
)) continue;
5581 if (lvItem
.mask
& LVIF_PARAM
)
5583 if (lpFindInfo
->lParam
== lvItem
.lParam
)
5589 if (lvItem
.mask
& LVIF_TEXT
)
5591 if (lpFindInfo
->flags
& LVFI_PARTIAL
)
5593 if (strstrW(lvItem
.pszText
, lpFindInfo
->psz
) == NULL
) continue;
5597 if (lstrcmpW(lvItem
.pszText
, lpFindInfo
->psz
) != 0) continue;
5601 if (!bNearest
) return nItem
;
5603 /* This is very inefficient. To do a good job here,
5604 * we need a sorted array of (x,y) item positions */
5605 LISTVIEW_GetItemOrigin(infoPtr
, nItem
, &Position
);
5607 /* compute the distance^2 to the destination */
5608 xdist
= Destination
.x
- Position
.x
;
5609 ydist
= Destination
.y
- Position
.y
;
5610 dist
= xdist
* xdist
+ ydist
* ydist
;
5612 /* remember the distance, and item if it's closer */
5616 nNearestItem
= nItem
;
5623 nLast
= min(nStart
+ 1, infoPtr
->nItemCount
);
5628 return nNearestItem
;
5633 * Searches for an item with specific characteristics.
5636 * [I] hwnd : window handle
5637 * [I] nStart : base item index
5638 * [I] lpFindInfo : item information to look for
5641 * SUCCESS : index of item
5644 static INT
LISTVIEW_FindItemA(const LISTVIEW_INFO
*infoPtr
, INT nStart
,
5645 const LVFINDINFOA
*lpFindInfo
)
5647 BOOL hasText
= lpFindInfo
->flags
& (LVFI_STRING
| LVFI_PARTIAL
);
5652 memcpy(&fiw
, lpFindInfo
, sizeof(fiw
));
5653 if (hasText
) fiw
.psz
= strW
= textdupTtoW((LPCWSTR
)lpFindInfo
->psz
, FALSE
);
5654 res
= LISTVIEW_FindItemW(infoPtr
, nStart
, &fiw
);
5655 textfreeT(strW
, FALSE
);
5661 * Retrieves the background image of the listview control.
5664 * [I] infoPtr : valid pointer to the listview structure
5665 * [O] lpBkImage : background image attributes
5671 /* static BOOL LISTVIEW_GetBkImage(const LISTVIEW_INFO *infoPtr, LPLVBKIMAGE lpBkImage) */
5673 /* FIXME (listview, "empty stub!\n"); */
5679 * Retrieves column attributes.
5682 * [I] infoPtr : valid pointer to the listview structure
5683 * [I] nColumn : column index
5684 * [IO] lpColumn : column information
5685 * [I] isW : if TRUE, then lpColumn is a LPLVCOLUMNW
5686 * otherwise it is in fact a LPLVCOLUMNA
5692 static BOOL
LISTVIEW_GetColumnT(const LISTVIEW_INFO
*infoPtr
, INT nColumn
, LPLVCOLUMNW lpColumn
, BOOL isW
)
5694 COLUMN_INFO
*lpColumnInfo
;
5697 if (!lpColumn
|| nColumn
< 0 || nColumn
>= DPA_GetPtrCount(infoPtr
->hdpaColumns
)) return FALSE
;
5698 lpColumnInfo
= LISTVIEW_GetColumnInfo(infoPtr
, nColumn
);
5700 /* initialize memory */
5701 ZeroMemory(&hdi
, sizeof(hdi
));
5703 if (lpColumn
->mask
& LVCF_TEXT
)
5705 hdi
.mask
|= HDI_TEXT
;
5706 hdi
.pszText
= lpColumn
->pszText
;
5707 hdi
.cchTextMax
= lpColumn
->cchTextMax
;
5710 if (lpColumn
->mask
& LVCF_IMAGE
)
5711 hdi
.mask
|= HDI_IMAGE
;
5713 if (lpColumn
->mask
& LVCF_ORDER
)
5714 hdi
.mask
|= HDI_ORDER
;
5716 if (lpColumn
->mask
& LVCF_SUBITEM
)
5717 hdi
.mask
|= HDI_LPARAM
;
5719 if (!SendMessageW(infoPtr
->hwndHeader
, isW
? HDM_GETITEMW
: HDM_GETITEMA
, nColumn
, (LPARAM
)&hdi
)) return FALSE
;
5721 if (lpColumn
->mask
& LVCF_FMT
)
5722 lpColumn
->fmt
= lpColumnInfo
->fmt
;
5724 if (lpColumn
->mask
& LVCF_WIDTH
)
5725 lpColumn
->cx
= lpColumnInfo
->rcHeader
.right
- lpColumnInfo
->rcHeader
.left
;
5727 if (lpColumn
->mask
& LVCF_IMAGE
)
5728 lpColumn
->iImage
= hdi
.iImage
;
5730 if (lpColumn
->mask
& LVCF_ORDER
)
5731 lpColumn
->iOrder
= hdi
.iOrder
;
5733 if (lpColumn
->mask
& LVCF_SUBITEM
)
5734 lpColumn
->iSubItem
= hdi
.lParam
;
5740 static BOOL
LISTVIEW_GetColumnOrderArray(const LISTVIEW_INFO
*infoPtr
, INT iCount
, LPINT lpiArray
)
5742 TRACE("iCount=%d, lpiArray=%p\n", iCount
, lpiArray
);
5747 return SendMessageW(infoPtr
->hwndHeader
, HDM_GETORDERARRAY
, iCount
, (LPARAM
)lpiArray
);
5752 * Retrieves the column width.
5755 * [I] infoPtr : valid pointer to the listview structure
5756 * [I] int : column index
5759 * SUCCESS : column width
5762 static INT
LISTVIEW_GetColumnWidth(const LISTVIEW_INFO
*infoPtr
, INT nColumn
)
5764 INT nColumnWidth
= 0;
5767 TRACE("nColumn=%d\n", nColumn
);
5769 /* we have a 'column' in LIST and REPORT mode only */
5770 switch(infoPtr
->uView
)
5773 nColumnWidth
= infoPtr
->nItemWidth
;
5775 case LV_VIEW_DETAILS
:
5776 /* We are not using LISTVIEW_GetHeaderRect as this data is updated only after a HDN_ITEMCHANGED.
5777 * There is an application that subclasses the listview, calls LVM_GETCOLUMNWIDTH in the
5778 * HDN_ITEMCHANGED handler and goes into infinite recursion if it receives old data.
5780 * TODO: should we do the same in LVM_GETCOLUMN?
5782 hdItem
.mask
= HDI_WIDTH
;
5783 if (!SendMessageW(infoPtr
->hwndHeader
, HDM_GETITEMW
, nColumn
, (LPARAM
)&hdItem
))
5785 WARN("(%p): HDM_GETITEMW failed for item %d\n", infoPtr
->hwndSelf
, nColumn
);
5788 nColumnWidth
= hdItem
.cxy
;
5792 TRACE("nColumnWidth=%d\n", nColumnWidth
);
5793 return nColumnWidth
;
5798 * In list or report display mode, retrieves the number of items that can fit
5799 * vertically in the visible area. In icon or small icon display mode,
5800 * retrieves the total number of visible items.
5803 * [I] infoPtr : valid pointer to the listview structure
5806 * Number of fully visible items.
5808 static INT
LISTVIEW_GetCountPerPage(const LISTVIEW_INFO
*infoPtr
)
5810 switch (infoPtr
->uView
)
5813 case LV_VIEW_SMALLICON
:
5814 return infoPtr
->nItemCount
;
5815 case LV_VIEW_DETAILS
:
5816 return LISTVIEW_GetCountPerColumn(infoPtr
);
5818 return LISTVIEW_GetCountPerRow(infoPtr
) * LISTVIEW_GetCountPerColumn(infoPtr
);
5826 * Retrieves an image list handle.
5829 * [I] infoPtr : valid pointer to the listview structure
5830 * [I] nImageList : image list identifier
5833 * SUCCESS : image list handle
5836 static HIMAGELIST
LISTVIEW_GetImageList(const LISTVIEW_INFO
*infoPtr
, INT nImageList
)
5840 case LVSIL_NORMAL
: return infoPtr
->himlNormal
;
5841 case LVSIL_SMALL
: return infoPtr
->himlSmall
;
5842 case LVSIL_STATE
: return infoPtr
->himlState
;
5847 /* LISTVIEW_GetISearchString */
5851 * Retrieves item attributes.
5854 * [I] hwnd : window handle
5855 * [IO] lpLVItem : item info
5856 * [I] isW : if TRUE, then lpLVItem is a LPLVITEMW,
5857 * if FALSE, then lpLVItem is a LPLVITEMA.
5860 * This is the internal 'GetItem' interface -- it tries to
5861 * be smart and avoid text copies, if possible, by modifying
5862 * lpLVItem->pszText to point to the text string. Please note
5863 * that this is not always possible (e.g. OWNERDATA), so on
5864 * entry you *must* supply valid values for pszText, and cchTextMax.
5865 * The only difference to the documented interface is that upon
5866 * return, you should use *only* the lpLVItem->pszText, rather than
5867 * the buffer pointer you provided on input. Most code already does
5868 * that, so it's not a problem.
5869 * For the two cases when the text must be copied (that is,
5870 * for LVM_GETITEM, and LVM_GETITEMTEXT), use LISTVIEW_GetItemExtT.
5876 static BOOL
LISTVIEW_GetItemT(const LISTVIEW_INFO
*infoPtr
, LPLVITEMW lpLVItem
, BOOL isW
)
5878 ITEMHDR callbackHdr
= { LPSTR_TEXTCALLBACKW
, I_IMAGECALLBACK
};
5879 NMLVDISPINFOW dispInfo
;
5885 TRACE("(lpLVItem=%s, isW=%d)\n", debuglvitem_t(lpLVItem
, isW
), isW
);
5887 if (!lpLVItem
|| lpLVItem
->iItem
< 0 || lpLVItem
->iItem
>= infoPtr
->nItemCount
)
5890 if (lpLVItem
->mask
== 0) return TRUE
;
5892 /* make a local copy */
5893 isubitem
= lpLVItem
->iSubItem
;
5895 /* a quick optimization if all we're asked is the focus state
5896 * these queries are worth optimising since they are common,
5897 * and can be answered in constant time, without the heavy accesses */
5898 if ( (lpLVItem
->mask
== LVIF_STATE
) && (lpLVItem
->stateMask
== LVIS_FOCUSED
) &&
5899 !(infoPtr
->uCallbackMask
& LVIS_FOCUSED
) )
5901 lpLVItem
->state
= 0;
5902 if (infoPtr
->nFocusedItem
== lpLVItem
->iItem
)
5903 lpLVItem
->state
|= LVIS_FOCUSED
;
5907 ZeroMemory(&dispInfo
, sizeof(dispInfo
));
5909 /* if the app stores all the data, handle it separately */
5910 if (infoPtr
->dwStyle
& LVS_OWNERDATA
)
5912 dispInfo
.item
.state
= 0;
5914 /* apparently, we should not callback for lParam in LVS_OWNERDATA */
5915 if ((lpLVItem
->mask
& ~(LVIF_STATE
| LVIF_PARAM
)) ||
5916 ((lpLVItem
->mask
& LVIF_STATE
) && (infoPtr
->uCallbackMask
& lpLVItem
->stateMask
)))
5918 UINT mask
= lpLVItem
->mask
;
5920 /* NOTE: copy only fields which we _know_ are initialized, some apps
5921 * depend on the uninitialized fields being 0 */
5922 dispInfo
.item
.mask
= lpLVItem
->mask
& ~LVIF_PARAM
;
5923 dispInfo
.item
.iItem
= lpLVItem
->iItem
;
5924 dispInfo
.item
.iSubItem
= isubitem
;
5925 if (lpLVItem
->mask
& LVIF_TEXT
)
5927 if (lpLVItem
->mask
& LVIF_NORECOMPUTE
)
5929 dispInfo
.item
.mask
&= ~(LVIF_TEXT
| LVIF_NORECOMPUTE
);
5932 dispInfo
.item
.pszText
= lpLVItem
->pszText
;
5933 dispInfo
.item
.cchTextMax
= lpLVItem
->cchTextMax
;
5936 if (lpLVItem
->mask
& LVIF_STATE
)
5937 dispInfo
.item
.stateMask
= lpLVItem
->stateMask
& infoPtr
->uCallbackMask
;
5938 /* could be zeroed on LVIF_NORECOMPUTE case */
5939 if (dispInfo
.item
.mask
!= 0)
5941 notify_dispinfoT(infoPtr
, LVN_GETDISPINFOW
, &dispInfo
, isW
);
5942 dispInfo
.item
.stateMask
= lpLVItem
->stateMask
;
5943 if (lpLVItem
->mask
& (LVIF_GROUPID
|LVIF_COLUMNS
))
5945 /* full size structure expected - _WIN32IE >= 0x560 */
5946 *lpLVItem
= dispInfo
.item
;
5948 else if (lpLVItem
->mask
& LVIF_INDENT
)
5950 /* indent member expected - _WIN32IE >= 0x300 */
5951 memcpy(lpLVItem
, &dispInfo
.item
, offsetof( LVITEMW
, iGroupId
));
5955 /* minimal structure expected */
5956 memcpy(lpLVItem
, &dispInfo
.item
, offsetof( LVITEMW
, iIndent
));
5958 lpLVItem
->mask
= mask
;
5959 TRACE(" getdispinfo(1):lpLVItem=%s\n", debuglvitem_t(lpLVItem
, isW
));
5963 /* make sure lParam is zeroed out */
5964 if (lpLVItem
->mask
& LVIF_PARAM
) lpLVItem
->lParam
= 0;
5966 /* callback marked pointer required here */
5967 if ((lpLVItem
->mask
& LVIF_TEXT
) && (lpLVItem
->mask
& LVIF_NORECOMPUTE
))
5968 lpLVItem
->pszText
= LPSTR_TEXTCALLBACKW
;
5970 /* we store only a little state, so if we're not asked, we're done */
5971 if (!(lpLVItem
->mask
& LVIF_STATE
) || isubitem
) return TRUE
;
5973 /* if focus is handled by us, report it */
5974 if ( lpLVItem
->stateMask
& ~infoPtr
->uCallbackMask
& LVIS_FOCUSED
)
5976 lpLVItem
->state
&= ~LVIS_FOCUSED
;
5977 if (infoPtr
->nFocusedItem
== lpLVItem
->iItem
)
5978 lpLVItem
->state
|= LVIS_FOCUSED
;
5981 /* and do the same for selection, if we handle it */
5982 if ( lpLVItem
->stateMask
& ~infoPtr
->uCallbackMask
& LVIS_SELECTED
)
5984 lpLVItem
->state
&= ~LVIS_SELECTED
;
5985 if (ranges_contain(infoPtr
->selectionRanges
, lpLVItem
->iItem
))
5986 lpLVItem
->state
|= LVIS_SELECTED
;
5992 /* find the item and subitem structures before we proceed */
5993 hdpaSubItems
= DPA_GetPtr(infoPtr
->hdpaItems
, lpLVItem
->iItem
);
5994 lpItem
= DPA_GetPtr(hdpaSubItems
, 0);
5999 SUBITEM_INFO
*lpSubItem
= LISTVIEW_GetSubItemPtr(hdpaSubItems
, isubitem
);
6000 pItemHdr
= lpSubItem
? &lpSubItem
->hdr
: &callbackHdr
;
6003 WARN(" iSubItem invalid (%08x), ignored.\n", isubitem
);
6008 pItemHdr
= &lpItem
->hdr
;
6010 /* Do we need to query the state from the app? */
6011 if ((lpLVItem
->mask
& LVIF_STATE
) && infoPtr
->uCallbackMask
&& isubitem
== 0)
6013 dispInfo
.item
.mask
|= LVIF_STATE
;
6014 dispInfo
.item
.stateMask
= infoPtr
->uCallbackMask
;
6017 /* Do we need to enquire about the image? */
6018 if ((lpLVItem
->mask
& LVIF_IMAGE
) && pItemHdr
->iImage
== I_IMAGECALLBACK
&&
6019 (isubitem
== 0 || (infoPtr
->dwLvExStyle
& LVS_EX_SUBITEMIMAGES
)))
6021 dispInfo
.item
.mask
|= LVIF_IMAGE
;
6022 dispInfo
.item
.iImage
= I_IMAGECALLBACK
;
6025 /* Only items support indentation */
6026 if ((lpLVItem
->mask
& LVIF_INDENT
) && lpItem
->iIndent
== I_INDENTCALLBACK
&&
6029 dispInfo
.item
.mask
|= LVIF_INDENT
;
6030 dispInfo
.item
.iIndent
= I_INDENTCALLBACK
;
6033 /* Apps depend on calling back for text if it is NULL or LPSTR_TEXTCALLBACKW */
6034 if ((lpLVItem
->mask
& LVIF_TEXT
) && !(lpLVItem
->mask
& LVIF_NORECOMPUTE
) &&
6035 !is_textW(pItemHdr
->pszText
))
6037 dispInfo
.item
.mask
|= LVIF_TEXT
;
6038 dispInfo
.item
.pszText
= lpLVItem
->pszText
;
6039 dispInfo
.item
.cchTextMax
= lpLVItem
->cchTextMax
;
6040 if (dispInfo
.item
.pszText
&& dispInfo
.item
.cchTextMax
> 0)
6041 *dispInfo
.item
.pszText
= '\0';
6044 /* If we don't have all the requested info, query the application */
6045 if (dispInfo
.item
.mask
!= 0)
6047 dispInfo
.item
.iItem
= lpLVItem
->iItem
;
6048 dispInfo
.item
.iSubItem
= lpLVItem
->iSubItem
; /* yes: the original subitem */
6049 dispInfo
.item
.lParam
= lpItem
->lParam
;
6050 notify_dispinfoT(infoPtr
, LVN_GETDISPINFOW
, &dispInfo
, isW
);
6051 TRACE(" getdispinfo(2):item=%s\n", debuglvitem_t(&dispInfo
.item
, isW
));
6054 /* we should not store values for subitems */
6055 if (isubitem
) dispInfo
.item
.mask
&= ~LVIF_DI_SETITEM
;
6057 /* Now, handle the iImage field */
6058 if (dispInfo
.item
.mask
& LVIF_IMAGE
)
6060 lpLVItem
->iImage
= dispInfo
.item
.iImage
;
6061 if ((dispInfo
.item
.mask
& LVIF_DI_SETITEM
) && pItemHdr
->iImage
== I_IMAGECALLBACK
)
6062 pItemHdr
->iImage
= dispInfo
.item
.iImage
;
6064 else if (lpLVItem
->mask
& LVIF_IMAGE
)
6066 if(isubitem
== 0 || (infoPtr
->dwLvExStyle
& LVS_EX_SUBITEMIMAGES
))
6067 lpLVItem
->iImage
= pItemHdr
->iImage
;
6069 lpLVItem
->iImage
= 0;
6072 /* The pszText field */
6073 if (dispInfo
.item
.mask
& LVIF_TEXT
)
6075 if ((dispInfo
.item
.mask
& LVIF_DI_SETITEM
) && pItemHdr
->pszText
)
6076 textsetptrT(&pItemHdr
->pszText
, dispInfo
.item
.pszText
, isW
);
6078 lpLVItem
->pszText
= dispInfo
.item
.pszText
;
6080 else if (lpLVItem
->mask
& LVIF_TEXT
)
6082 /* if LVN_GETDISPINFO's disabled with LVIF_NORECOMPUTE return callback placeholder */
6083 if (isW
|| !is_textW(pItemHdr
->pszText
)) lpLVItem
->pszText
= pItemHdr
->pszText
;
6084 else textcpynT(lpLVItem
->pszText
, isW
, pItemHdr
->pszText
, TRUE
, lpLVItem
->cchTextMax
);
6087 /* Next is the lParam field */
6088 if (dispInfo
.item
.mask
& LVIF_PARAM
)
6090 lpLVItem
->lParam
= dispInfo
.item
.lParam
;
6091 if ((dispInfo
.item
.mask
& LVIF_DI_SETITEM
))
6092 lpItem
->lParam
= dispInfo
.item
.lParam
;
6094 else if (lpLVItem
->mask
& LVIF_PARAM
)
6095 lpLVItem
->lParam
= lpItem
->lParam
;
6097 /* if this is a subitem, we're done */
6098 if (isubitem
) return TRUE
;
6100 /* ... the state field (this one is different due to uCallbackmask) */
6101 if (lpLVItem
->mask
& LVIF_STATE
)
6103 lpLVItem
->state
= lpItem
->state
& lpLVItem
->stateMask
;
6104 if (dispInfo
.item
.mask
& LVIF_STATE
)
6106 lpLVItem
->state
&= ~dispInfo
.item
.stateMask
;
6107 lpLVItem
->state
|= (dispInfo
.item
.state
& dispInfo
.item
.stateMask
);
6109 if ( lpLVItem
->stateMask
& ~infoPtr
->uCallbackMask
& LVIS_FOCUSED
)
6111 lpLVItem
->state
&= ~LVIS_FOCUSED
;
6112 if (infoPtr
->nFocusedItem
== lpLVItem
->iItem
)
6113 lpLVItem
->state
|= LVIS_FOCUSED
;
6115 if ( lpLVItem
->stateMask
& ~infoPtr
->uCallbackMask
& LVIS_SELECTED
)
6117 lpLVItem
->state
&= ~LVIS_SELECTED
;
6118 if (ranges_contain(infoPtr
->selectionRanges
, lpLVItem
->iItem
))
6119 lpLVItem
->state
|= LVIS_SELECTED
;
6123 /* and last, but not least, the indent field */
6124 if (dispInfo
.item
.mask
& LVIF_INDENT
)
6126 lpLVItem
->iIndent
= dispInfo
.item
.iIndent
;
6127 if ((dispInfo
.item
.mask
& LVIF_DI_SETITEM
) && lpItem
->iIndent
== I_INDENTCALLBACK
)
6128 lpItem
->iIndent
= dispInfo
.item
.iIndent
;
6130 else if (lpLVItem
->mask
& LVIF_INDENT
)
6132 lpLVItem
->iIndent
= lpItem
->iIndent
;
6140 * Retrieves item attributes.
6143 * [I] hwnd : window handle
6144 * [IO] lpLVItem : item info
6145 * [I] isW : if TRUE, then lpLVItem is a LPLVITEMW,
6146 * if FALSE, then lpLVItem is a LPLVITEMA.
6149 * This is the external 'GetItem' interface -- it properly copies
6150 * the text in the provided buffer.
6156 static BOOL
LISTVIEW_GetItemExtT(const LISTVIEW_INFO
*infoPtr
, LPLVITEMW lpLVItem
, BOOL isW
)
6161 if (!lpLVItem
|| lpLVItem
->iItem
< 0 || lpLVItem
->iItem
>= infoPtr
->nItemCount
)
6164 pszText
= lpLVItem
->pszText
;
6165 bResult
= LISTVIEW_GetItemT(infoPtr
, lpLVItem
, isW
);
6166 if (bResult
&& lpLVItem
->pszText
!= pszText
)
6168 if (lpLVItem
->pszText
!= LPSTR_TEXTCALLBACKW
)
6169 textcpynT(pszText
, isW
, lpLVItem
->pszText
, isW
, lpLVItem
->cchTextMax
);
6171 pszText
= LPSTR_TEXTCALLBACKW
;
6173 lpLVItem
->pszText
= pszText
;
6181 * Retrieves the position (upper-left) of the listview control item.
6182 * Note that for LVS_ICON style, the upper-left is that of the icon
6183 * and not the bounding box.
6186 * [I] infoPtr : valid pointer to the listview structure
6187 * [I] nItem : item index
6188 * [O] lpptPosition : coordinate information
6194 static BOOL
LISTVIEW_GetItemPosition(const LISTVIEW_INFO
*infoPtr
, INT nItem
, LPPOINT lpptPosition
)
6198 TRACE("(nItem=%d, lpptPosition=%p)\n", nItem
, lpptPosition
);
6200 if (!lpptPosition
|| nItem
< 0 || nItem
>= infoPtr
->nItemCount
) return FALSE
;
6202 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
6203 LISTVIEW_GetItemOrigin(infoPtr
, nItem
, lpptPosition
);
6205 if (infoPtr
->uView
== LV_VIEW_ICON
)
6207 lpptPosition
->x
+= (infoPtr
->nItemWidth
- infoPtr
->iconSize
.cx
) / 2;
6208 lpptPosition
->y
+= ICON_TOP_PADDING
;
6210 lpptPosition
->x
+= Origin
.x
;
6211 lpptPosition
->y
+= Origin
.y
;
6213 TRACE (" lpptPosition=%s\n", wine_dbgstr_point(lpptPosition
));
6220 * Retrieves the bounding rectangle for a listview control item.
6223 * [I] infoPtr : valid pointer to the listview structure
6224 * [I] nItem : item index
6225 * [IO] lprc : bounding rectangle coordinates
6226 * lprc->left specifies the portion of the item for which the bounding
6227 * rectangle will be retrieved.
6229 * LVIR_BOUNDS Returns the bounding rectangle of the entire item,
6230 * including the icon and label.
6233 * * Experiment shows that native control returns:
6234 * * width = min (48, length of text line)
6235 * * .left = position.x - (width - iconsize.cx)/2
6236 * * .right = .left + width
6237 * * height = #lines of text * ntmHeight + icon height + 8
6238 * * .top = position.y - 2
6239 * * .bottom = .top + height
6240 * * separation between items .y = itemSpacing.cy - height
6241 * * .x = itemSpacing.cx - width
6242 * LVIR_ICON Returns the bounding rectangle of the icon or small icon.
6245 * * Experiment shows that native control returns:
6246 * * width = iconSize.cx + 16
6247 * * .left = position.x - (width - iconsize.cx)/2
6248 * * .right = .left + width
6249 * * height = iconSize.cy + 4
6250 * * .top = position.y - 2
6251 * * .bottom = .top + height
6252 * * separation between items .y = itemSpacing.cy - height
6253 * * .x = itemSpacing.cx - width
6254 * LVIR_LABEL Returns the bounding rectangle of the item text.
6257 * * Experiment shows that native control returns:
6258 * * width = text length
6259 * * .left = position.x - width/2
6260 * * .right = .left + width
6261 * * height = ntmH * linecount + 2
6262 * * .top = position.y + iconSize.cy + 6
6263 * * .bottom = .top + height
6264 * * separation between items .y = itemSpacing.cy - height
6265 * * .x = itemSpacing.cx - width
6266 * LVIR_SELECTBOUNDS Returns the union of the LVIR_ICON and LVIR_LABEL
6267 * rectangles, but excludes columns in report view.
6274 * Note that the bounding rectangle of the label in the LVS_ICON view depends
6275 * upon whether the window has the focus currently and on whether the item
6276 * is the one with the focus. Ensure that the control's record of which
6277 * item has the focus agrees with the items' records.
6279 static BOOL
LISTVIEW_GetItemRect(const LISTVIEW_INFO
*infoPtr
, INT nItem
, LPRECT lprc
)
6281 WCHAR szDispText
[DISP_TEXT_SIZE
] = { '\0' };
6282 BOOL doLabel
= TRUE
, oversizedBox
= FALSE
;
6283 POINT Position
, Origin
;
6287 TRACE("(hwnd=%p, nItem=%d, lprc=%p)\n", infoPtr
->hwndSelf
, nItem
, lprc
);
6289 if (!lprc
|| nItem
< 0 || nItem
>= infoPtr
->nItemCount
) return FALSE
;
6291 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
6292 LISTVIEW_GetItemOrigin(infoPtr
, nItem
, &Position
);
6294 /* Be smart and try to figure out the minimum we have to do */
6295 if (lprc
->left
== LVIR_ICON
) doLabel
= FALSE
;
6296 if (infoPtr
->uView
== LV_VIEW_DETAILS
&& lprc
->left
== LVIR_BOUNDS
) doLabel
= FALSE
;
6297 if (infoPtr
->uView
== LV_VIEW_ICON
&& lprc
->left
!= LVIR_ICON
&&
6298 infoPtr
->bFocus
&& LISTVIEW_GetItemState(infoPtr
, nItem
, LVIS_FOCUSED
))
6299 oversizedBox
= TRUE
;
6301 /* get what we need from the item before hand, so we make
6302 * only one request. This can speed up things, if data
6303 * is stored on the app side */
6305 if (infoPtr
->uView
== LV_VIEW_DETAILS
) lvItem
.mask
|= LVIF_INDENT
;
6306 if (doLabel
) lvItem
.mask
|= LVIF_TEXT
;
6307 lvItem
.iItem
= nItem
;
6308 lvItem
.iSubItem
= 0;
6309 lvItem
.pszText
= szDispText
;
6310 lvItem
.cchTextMax
= DISP_TEXT_SIZE
;
6311 if (lvItem
.mask
&& !LISTVIEW_GetItemW(infoPtr
, &lvItem
)) return FALSE
;
6312 /* we got the state already up, simulate it here, to avoid a reget */
6313 if (infoPtr
->uView
== LV_VIEW_ICON
&& (lprc
->left
!= LVIR_ICON
))
6315 lvItem
.mask
|= LVIF_STATE
;
6316 lvItem
.stateMask
= LVIS_FOCUSED
;
6317 lvItem
.state
= (oversizedBox
? LVIS_FOCUSED
: 0);
6320 if (infoPtr
->uView
== LV_VIEW_DETAILS
&& (infoPtr
->dwLvExStyle
& LVS_EX_FULLROWSELECT
) && lprc
->left
== LVIR_SELECTBOUNDS
)
6321 lprc
->left
= LVIR_BOUNDS
;
6327 LISTVIEW_GetItemMetrics(infoPtr
, &lvItem
, NULL
, NULL
, lprc
, NULL
, NULL
);
6331 LISTVIEW_GetItemMetrics(infoPtr
, &lvItem
, NULL
, NULL
, NULL
, NULL
, lprc
);
6335 LISTVIEW_GetItemMetrics(infoPtr
, &lvItem
, lprc
, NULL
, NULL
, NULL
, NULL
);
6338 case LVIR_SELECTBOUNDS
:
6339 LISTVIEW_GetItemMetrics(infoPtr
, &lvItem
, NULL
, lprc
, NULL
, NULL
, NULL
);
6343 WARN("Unknown value: %d\n", lprc
->left
);
6347 if (infoPtr
->uView
== LV_VIEW_DETAILS
)
6349 if (mode
!= LVIR_BOUNDS
)
6350 OffsetRect(lprc
, Origin
.x
+ LISTVIEW_GetColumnInfo(infoPtr
, 0)->rcHeader
.left
,
6351 Position
.y
+ Origin
.y
);
6353 OffsetRect(lprc
, Origin
.x
, Position
.y
+ Origin
.y
);
6356 OffsetRect(lprc
, Position
.x
+ Origin
.x
, Position
.y
+ Origin
.y
);
6358 TRACE(" rect=%s\n", wine_dbgstr_rect(lprc
));
6365 * Retrieves the spacing between listview control items.
6368 * [I] infoPtr : valid pointer to the listview structure
6369 * [IO] lprc : rectangle to receive the output
6370 * on input, lprc->top = nSubItem
6371 * lprc->left = LVIR_ICON | LVIR_BOUNDS | LVIR_LABEL
6373 * NOTE: for subItem = 0, we should return the bounds of the _entire_ item,
6374 * not only those of the first column.
6375 * Fortunately, LISTVIEW_GetItemMetrics does the right thing.
6381 static BOOL
LISTVIEW_GetSubItemRect(const LISTVIEW_INFO
*infoPtr
, INT nItem
, LPRECT lprc
)
6387 if (!lprc
) return FALSE
;
6389 nColumn
= lprc
->top
;
6391 TRACE("(nItem=%d, nSubItem=%d)\n", nItem
, lprc
->top
);
6392 /* On WinNT, a subitem of '0' calls LISTVIEW_GetItemRect */
6394 return LISTVIEW_GetItemRect(infoPtr
, nItem
, lprc
);
6396 if (infoPtr
->uView
!= LV_VIEW_DETAILS
) return FALSE
;
6398 /* special case for header items */
6401 if (lprc
->left
!= LVIR_BOUNDS
)
6403 FIXME("Only LVIR_BOUNDS is implemented for header, got %d\n", lprc
->left
);
6407 if (infoPtr
->hwndHeader
)
6408 return SendMessageW(infoPtr
->hwndHeader
, HDM_GETITEMRECT
, lprc
->top
, (LPARAM
)lprc
);
6411 memset(lprc
, 0, sizeof(RECT
));
6416 if (!LISTVIEW_GetItemPosition(infoPtr
, nItem
, &Position
)) return FALSE
;
6418 if (nColumn
< 0 || nColumn
>= DPA_GetPtrCount(infoPtr
->hdpaColumns
)) return FALSE
;
6421 lvItem
.iItem
= nItem
;
6422 lvItem
.iSubItem
= nColumn
;
6424 if (lvItem
.mask
&& !LISTVIEW_GetItemW(infoPtr
, &lvItem
)) return FALSE
;
6428 LISTVIEW_GetItemMetrics(infoPtr
, &lvItem
, NULL
, NULL
, lprc
, NULL
, NULL
);
6433 LISTVIEW_GetItemMetrics(infoPtr
, &lvItem
, lprc
, NULL
, NULL
, NULL
, NULL
);
6437 ERR("Unknown bounds=%d\n", lprc
->left
);
6441 OffsetRect(lprc
, 0, Position
.y
);
6448 * Retrieves the width of a label.
6451 * [I] infoPtr : valid pointer to the listview structure
6454 * SUCCESS : string width (in pixels)
6457 static INT
LISTVIEW_GetLabelWidth(const LISTVIEW_INFO
*infoPtr
, INT nItem
)
6459 WCHAR szDispText
[DISP_TEXT_SIZE
] = { '\0' };
6462 TRACE("(nItem=%d)\n", nItem
);
6464 lvItem
.mask
= LVIF_TEXT
;
6465 lvItem
.iItem
= nItem
;
6466 lvItem
.iSubItem
= 0;
6467 lvItem
.pszText
= szDispText
;
6468 lvItem
.cchTextMax
= DISP_TEXT_SIZE
;
6469 if (!LISTVIEW_GetItemW(infoPtr
, &lvItem
)) return 0;
6471 return LISTVIEW_GetStringWidthT(infoPtr
, lvItem
.pszText
, TRUE
);
6476 * Retrieves the spacing between listview control items.
6479 * [I] infoPtr : valid pointer to the listview structure
6480 * [I] bSmall : flag for small or large icon
6483 * Horizontal + vertical spacing
6485 static LONG
LISTVIEW_GetItemSpacing(const LISTVIEW_INFO
*infoPtr
, BOOL bSmall
)
6491 lResult
= MAKELONG(infoPtr
->iconSpacing
.cx
, infoPtr
->iconSpacing
.cy
);
6495 if (infoPtr
->uView
== LV_VIEW_ICON
)
6496 lResult
= MAKELONG(DEFAULT_COLUMN_WIDTH
, GetSystemMetrics(SM_CXSMICON
)+HEIGHT_PADDING
);
6498 lResult
= MAKELONG(infoPtr
->nItemWidth
, infoPtr
->nItemHeight
);
6505 * Retrieves the state of a listview control item.
6508 * [I] infoPtr : valid pointer to the listview structure
6509 * [I] nItem : item index
6510 * [I] uMask : state mask
6513 * State specified by the mask.
6515 static UINT
LISTVIEW_GetItemState(const LISTVIEW_INFO
*infoPtr
, INT nItem
, UINT uMask
)
6519 if (nItem
< 0 || nItem
>= infoPtr
->nItemCount
) return 0;
6521 lvItem
.iItem
= nItem
;
6522 lvItem
.iSubItem
= 0;
6523 lvItem
.mask
= LVIF_STATE
;
6524 lvItem
.stateMask
= uMask
;
6525 if (!LISTVIEW_GetItemW(infoPtr
, &lvItem
)) return 0;
6527 return lvItem
.state
& uMask
;
6532 * Retrieves the text of a listview control item or subitem.
6535 * [I] hwnd : window handle
6536 * [I] nItem : item index
6537 * [IO] lpLVItem : item information
6538 * [I] isW : TRUE if lpLVItem is Unicode
6541 * SUCCESS : string length
6544 static INT
LISTVIEW_GetItemTextT(const LISTVIEW_INFO
*infoPtr
, INT nItem
, LPLVITEMW lpLVItem
, BOOL isW
)
6546 if (!lpLVItem
|| nItem
< 0 || nItem
>= infoPtr
->nItemCount
) return 0;
6548 lpLVItem
->mask
= LVIF_TEXT
;
6549 lpLVItem
->iItem
= nItem
;
6550 if (!LISTVIEW_GetItemExtT(infoPtr
, lpLVItem
, isW
)) return 0;
6552 return textlenT(lpLVItem
->pszText
, isW
);
6557 * Searches for an item based on properties + relationships.
6560 * [I] infoPtr : valid pointer to the listview structure
6561 * [I] nItem : item index
6562 * [I] uFlags : relationship flag
6565 * SUCCESS : item index
6568 static INT
LISTVIEW_GetNextItem(const LISTVIEW_INFO
*infoPtr
, INT nItem
, UINT uFlags
)
6571 LVFINDINFOW lvFindInfo
;
6572 INT nCountPerColumn
;
6576 TRACE("nItem=%d, uFlags=%x, nItemCount=%d\n", nItem
, uFlags
, infoPtr
->nItemCount
);
6577 if (nItem
< -1 || nItem
>= infoPtr
->nItemCount
) return -1;
6579 ZeroMemory(&lvFindInfo
, sizeof(lvFindInfo
));
6581 if (uFlags
& LVNI_CUT
)
6584 if (uFlags
& LVNI_DROPHILITED
)
6585 uMask
|= LVIS_DROPHILITED
;
6587 if (uFlags
& LVNI_FOCUSED
)
6588 uMask
|= LVIS_FOCUSED
;
6590 if (uFlags
& LVNI_SELECTED
)
6591 uMask
|= LVIS_SELECTED
;
6593 /* if we're asked for the focused item, that's only one,
6594 * so it's worth optimizing */
6595 if (uFlags
& LVNI_FOCUSED
)
6597 if ((LISTVIEW_GetItemState(infoPtr
, infoPtr
->nFocusedItem
, uMask
) & uMask
) != uMask
) return -1;
6598 return (infoPtr
->nFocusedItem
== nItem
) ? -1 : infoPtr
->nFocusedItem
;
6601 if (uFlags
& LVNI_ABOVE
)
6603 if ((infoPtr
->uView
== LV_VIEW_LIST
) || (infoPtr
->uView
== LV_VIEW_DETAILS
))
6608 if ((LISTVIEW_GetItemState(infoPtr
, nItem
, uMask
) & uMask
) == uMask
)
6614 /* Special case for autoarrange - move 'til the top of a list */
6615 if (is_autoarrange(infoPtr
))
6617 nCountPerRow
= LISTVIEW_GetCountPerRow(infoPtr
);
6618 while (nItem
- nCountPerRow
>= 0)
6620 nItem
-= nCountPerRow
;
6621 if ((LISTVIEW_GetItemState(infoPtr
, nItem
, uMask
) & uMask
) == uMask
)
6626 lvFindInfo
.flags
= LVFI_NEARESTXY
;
6627 lvFindInfo
.vkDirection
= VK_UP
;
6628 LISTVIEW_GetItemPosition(infoPtr
, nItem
, &lvFindInfo
.pt
);
6629 while ((nItem
= LISTVIEW_FindItemW(infoPtr
, nItem
, &lvFindInfo
)) != -1)
6631 if ((LISTVIEW_GetItemState(infoPtr
, nItem
, uMask
) & uMask
) == uMask
)
6636 else if (uFlags
& LVNI_BELOW
)
6638 if ((infoPtr
->uView
== LV_VIEW_LIST
) || (infoPtr
->uView
== LV_VIEW_DETAILS
))
6640 while (nItem
< infoPtr
->nItemCount
)
6643 if ((LISTVIEW_GetItemState(infoPtr
, nItem
, uMask
) & uMask
) == uMask
)
6649 /* Special case for autoarrange - move 'til the bottom of a list */
6650 if (is_autoarrange(infoPtr
))
6652 nCountPerRow
= LISTVIEW_GetCountPerRow(infoPtr
);
6653 while (nItem
+ nCountPerRow
< infoPtr
->nItemCount
)
6655 nItem
+= nCountPerRow
;
6656 if ((LISTVIEW_GetItemState(infoPtr
, nItem
, uMask
) & uMask
) == uMask
)
6661 lvFindInfo
.flags
= LVFI_NEARESTXY
;
6662 lvFindInfo
.vkDirection
= VK_DOWN
;
6663 LISTVIEW_GetItemPosition(infoPtr
, nItem
, &lvFindInfo
.pt
);
6664 while ((nItem
= LISTVIEW_FindItemW(infoPtr
, nItem
, &lvFindInfo
)) != -1)
6666 if ((LISTVIEW_GetItemState(infoPtr
, nItem
, uMask
) & uMask
) == uMask
)
6671 else if (uFlags
& LVNI_TOLEFT
)
6673 if (infoPtr
->uView
== LV_VIEW_LIST
)
6675 nCountPerColumn
= LISTVIEW_GetCountPerColumn(infoPtr
);
6676 while (nItem
- nCountPerColumn
>= 0)
6678 nItem
-= nCountPerColumn
;
6679 if ((LISTVIEW_GetItemState(infoPtr
, nItem
, uMask
) & uMask
) == uMask
)
6683 else if ((infoPtr
->uView
== LV_VIEW_SMALLICON
) || (infoPtr
->uView
== LV_VIEW_ICON
))
6685 /* Special case for autoarrange - move 'til the beginning of a row */
6686 if (is_autoarrange(infoPtr
))
6688 nCountPerRow
= LISTVIEW_GetCountPerRow(infoPtr
);
6689 while (nItem
% nCountPerRow
> 0)
6692 if ((LISTVIEW_GetItemState(infoPtr
, nItem
, uMask
) & uMask
) == uMask
)
6697 lvFindInfo
.flags
= LVFI_NEARESTXY
;
6698 lvFindInfo
.vkDirection
= VK_LEFT
;
6699 LISTVIEW_GetItemPosition(infoPtr
, nItem
, &lvFindInfo
.pt
);
6700 while ((nItem
= LISTVIEW_FindItemW(infoPtr
, nItem
, &lvFindInfo
)) != -1)
6702 if ((LISTVIEW_GetItemState(infoPtr
, nItem
, uMask
) & uMask
) == uMask
)
6707 else if (uFlags
& LVNI_TORIGHT
)
6709 if (infoPtr
->uView
== LV_VIEW_LIST
)
6711 nCountPerColumn
= LISTVIEW_GetCountPerColumn(infoPtr
);
6712 while (nItem
+ nCountPerColumn
< infoPtr
->nItemCount
)
6714 nItem
+= nCountPerColumn
;
6715 if ((LISTVIEW_GetItemState(infoPtr
, nItem
, uMask
) & uMask
) == uMask
)
6719 else if ((infoPtr
->uView
== LV_VIEW_SMALLICON
) || (infoPtr
->uView
== LV_VIEW_ICON
))
6721 /* Special case for autoarrange - move 'til the end of a row */
6722 if (is_autoarrange(infoPtr
))
6724 nCountPerRow
= LISTVIEW_GetCountPerRow(infoPtr
);
6725 while (nItem
% nCountPerRow
< nCountPerRow
- 1 )
6728 if ((LISTVIEW_GetItemState(infoPtr
, nItem
, uMask
) & uMask
) == uMask
)
6733 lvFindInfo
.flags
= LVFI_NEARESTXY
;
6734 lvFindInfo
.vkDirection
= VK_RIGHT
;
6735 LISTVIEW_GetItemPosition(infoPtr
, nItem
, &lvFindInfo
.pt
);
6736 while ((nItem
= LISTVIEW_FindItemW(infoPtr
, nItem
, &lvFindInfo
)) != -1)
6738 if ((LISTVIEW_GetItemState(infoPtr
, nItem
, uMask
) & uMask
) == uMask
)
6747 /* search by index */
6748 for (i
= nItem
; i
< infoPtr
->nItemCount
; i
++)
6750 if ((LISTVIEW_GetItemState(infoPtr
, i
, uMask
) & uMask
) == uMask
)
6758 /* LISTVIEW_GetNumberOfWorkAreas */
6762 * Retrieves the origin coordinates when in icon or small icon display mode.
6765 * [I] infoPtr : valid pointer to the listview structure
6766 * [O] lpptOrigin : coordinate information
6771 static void LISTVIEW_GetOrigin(const LISTVIEW_INFO
*infoPtr
, LPPOINT lpptOrigin
)
6773 INT nHorzPos
= 0, nVertPos
= 0;
6774 SCROLLINFO scrollInfo
;
6776 scrollInfo
.cbSize
= sizeof(SCROLLINFO
);
6777 scrollInfo
.fMask
= SIF_POS
;
6779 if (GetScrollInfo(infoPtr
->hwndSelf
, SB_HORZ
, &scrollInfo
))
6780 nHorzPos
= scrollInfo
.nPos
;
6781 if (GetScrollInfo(infoPtr
->hwndSelf
, SB_VERT
, &scrollInfo
))
6782 nVertPos
= scrollInfo
.nPos
;
6784 TRACE("nHorzPos=%d, nVertPos=%d\n", nHorzPos
, nVertPos
);
6786 lpptOrigin
->x
= infoPtr
->rcList
.left
;
6787 lpptOrigin
->y
= infoPtr
->rcList
.top
;
6788 if (infoPtr
->uView
== LV_VIEW_LIST
)
6789 nHorzPos
*= infoPtr
->nItemWidth
;
6790 else if (infoPtr
->uView
== LV_VIEW_DETAILS
)
6791 nVertPos
*= infoPtr
->nItemHeight
;
6793 lpptOrigin
->x
-= nHorzPos
;
6794 lpptOrigin
->y
-= nVertPos
;
6796 TRACE(" origin=%s\n", wine_dbgstr_point(lpptOrigin
));
6801 * Retrieves the width of a string.
6804 * [I] hwnd : window handle
6805 * [I] lpszText : text string to process
6806 * [I] isW : TRUE if lpszText is Unicode, FALSE otherwise
6809 * SUCCESS : string width (in pixels)
6812 static INT
LISTVIEW_GetStringWidthT(const LISTVIEW_INFO
*infoPtr
, LPCWSTR lpszText
, BOOL isW
)
6817 if (is_textT(lpszText
, isW
))
6819 HFONT hFont
= infoPtr
->hFont
? infoPtr
->hFont
: infoPtr
->hDefaultFont
;
6820 HDC hdc
= GetDC(infoPtr
->hwndSelf
);
6821 HFONT hOldFont
= SelectObject(hdc
, hFont
);
6824 GetTextExtentPointW(hdc
, lpszText
, lstrlenW(lpszText
), &stringSize
);
6826 GetTextExtentPointA(hdc
, (LPCSTR
)lpszText
, lstrlenA((LPCSTR
)lpszText
), &stringSize
);
6827 SelectObject(hdc
, hOldFont
);
6828 ReleaseDC(infoPtr
->hwndSelf
, hdc
);
6830 return stringSize
.cx
;
6835 * Determines which listview item is located at the specified position.
6838 * [I] infoPtr : valid pointer to the listview structure
6839 * [IO] lpht : hit test information
6840 * [I] subitem : fill out iSubItem.
6841 * [I] select : return the index only if the hit selects the item
6844 * (mm 20001022): We must not allow iSubItem to be touched, for
6845 * an app might pass only a structure with space up to iItem!
6846 * (MS Office 97 does that for instance in the file open dialog)
6849 * SUCCESS : item index
6852 static INT
LISTVIEW_HitTest(const LISTVIEW_INFO
*infoPtr
, LPLVHITTESTINFO lpht
, BOOL subitem
, BOOL select
)
6854 WCHAR szDispText
[DISP_TEXT_SIZE
] = { '\0' };
6855 RECT rcBox
, rcBounds
, rcState
, rcIcon
, rcLabel
, rcSearch
;
6856 POINT Origin
, Position
, opt
;
6861 TRACE("(pt=%s, subitem=%d, select=%d)\n", wine_dbgstr_point(&lpht
->pt
), subitem
, select
);
6865 if (subitem
) lpht
->iSubItem
= 0;
6867 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
6869 /* set whole list relation flags */
6870 if (subitem
&& infoPtr
->uView
== LV_VIEW_DETAILS
)
6872 /* LVM_SUBITEMHITTEST checks left bound of possible client area */
6873 if (infoPtr
->rcList
.left
> lpht
->pt
.x
&& Origin
.x
< lpht
->pt
.x
)
6874 lpht
->flags
|= LVHT_TOLEFT
;
6876 if (lpht
->pt
.y
< infoPtr
->rcList
.top
&& lpht
->pt
.y
>= 0)
6877 opt
.y
= lpht
->pt
.y
+ infoPtr
->rcList
.top
;
6881 if (infoPtr
->rcList
.bottom
< opt
.y
)
6882 lpht
->flags
|= LVHT_BELOW
;
6886 if (infoPtr
->rcList
.left
> lpht
->pt
.x
)
6887 lpht
->flags
|= LVHT_TOLEFT
;
6888 else if (infoPtr
->rcList
.right
< lpht
->pt
.x
)
6889 lpht
->flags
|= LVHT_TORIGHT
;
6891 if (infoPtr
->rcList
.top
> lpht
->pt
.y
)
6892 lpht
->flags
|= LVHT_ABOVE
;
6893 else if (infoPtr
->rcList
.bottom
< lpht
->pt
.y
)
6894 lpht
->flags
|= LVHT_BELOW
;
6897 /* even if item is invalid try to find subitem */
6898 if (infoPtr
->uView
== LV_VIEW_DETAILS
&& subitem
)
6903 opt
.x
= lpht
->pt
.x
- Origin
.x
;
6905 lpht
->iSubItem
= -1;
6906 for (j
= 0; j
< DPA_GetPtrCount(infoPtr
->hdpaColumns
); j
++)
6908 pRect
= &LISTVIEW_GetColumnInfo(infoPtr
, j
)->rcHeader
;
6910 if ((opt
.x
>= pRect
->left
) && (opt
.x
< pRect
->right
))
6916 TRACE("lpht->iSubItem=%d\n", lpht
->iSubItem
);
6919 TRACE("lpht->flags=0x%x\n", lpht
->flags
);
6920 if (lpht
->flags
) return -1;
6922 lpht
->flags
|= LVHT_NOWHERE
;
6924 /* first deal with the large items */
6925 rcSearch
.left
= lpht
->pt
.x
;
6926 rcSearch
.top
= lpht
->pt
.y
;
6927 rcSearch
.right
= rcSearch
.left
+ 1;
6928 rcSearch
.bottom
= rcSearch
.top
+ 1;
6930 iterator_frameditems(&i
, infoPtr
, &rcSearch
);
6931 iterator_next(&i
); /* go to first item in the sequence */
6933 iterator_destroy(&i
);
6935 TRACE("lpht->iItem=%d\n", iItem
);
6936 if (iItem
== -1) return -1;
6938 lvItem
.mask
= LVIF_STATE
| LVIF_TEXT
;
6939 if (infoPtr
->uView
== LV_VIEW_DETAILS
) lvItem
.mask
|= LVIF_INDENT
;
6940 lvItem
.stateMask
= LVIS_STATEIMAGEMASK
;
6941 if (infoPtr
->uView
== LV_VIEW_ICON
) lvItem
.stateMask
|= LVIS_FOCUSED
;
6942 lvItem
.iItem
= iItem
;
6943 lvItem
.iSubItem
= subitem
? lpht
->iSubItem
: 0;
6944 lvItem
.pszText
= szDispText
;
6945 lvItem
.cchTextMax
= DISP_TEXT_SIZE
;
6946 if (!LISTVIEW_GetItemW(infoPtr
, &lvItem
)) return -1;
6947 if (!infoPtr
->bFocus
) lvItem
.state
&= ~LVIS_FOCUSED
;
6949 LISTVIEW_GetItemMetrics(infoPtr
, &lvItem
, &rcBox
, NULL
, &rcIcon
, &rcState
, &rcLabel
);
6950 LISTVIEW_GetItemOrigin(infoPtr
, iItem
, &Position
);
6951 opt
.x
= lpht
->pt
.x
- Position
.x
- Origin
.x
;
6953 if (lpht
->pt
.y
< infoPtr
->rcList
.top
&& lpht
->pt
.y
>= 0)
6954 opt
.y
= lpht
->pt
.y
- Position
.y
- Origin
.y
+ infoPtr
->rcList
.top
;
6956 opt
.y
= lpht
->pt
.y
- Position
.y
- Origin
.y
;
6958 if (infoPtr
->uView
== LV_VIEW_DETAILS
)
6961 if (infoPtr
->dwLvExStyle
& LVS_EX_FULLROWSELECT
)
6962 opt
.x
= lpht
->pt
.x
- Origin
.x
;
6966 UnionRect(&rcBounds
, &rcIcon
, &rcLabel
);
6967 UnionRect(&rcBounds
, &rcBounds
, &rcState
);
6969 TRACE("rcBounds=%s\n", wine_dbgstr_rect(&rcBounds
));
6970 if (!PtInRect(&rcBounds
, opt
)) return -1;
6972 if (PtInRect(&rcIcon
, opt
))
6973 lpht
->flags
|= LVHT_ONITEMICON
;
6974 else if (PtInRect(&rcLabel
, opt
))
6975 lpht
->flags
|= LVHT_ONITEMLABEL
;
6976 else if (infoPtr
->himlState
&& PtInRect(&rcState
, opt
))
6977 lpht
->flags
|= LVHT_ONITEMSTATEICON
;
6978 /* special case for LVS_EX_FULLROWSELECT */
6979 if (infoPtr
->uView
== LV_VIEW_DETAILS
&& infoPtr
->dwLvExStyle
& LVS_EX_FULLROWSELECT
&&
6980 !(lpht
->flags
& LVHT_ONITEM
))
6982 lpht
->flags
= LVHT_ONITEM
| LVHT_ABOVE
;
6984 if (lpht
->flags
& LVHT_ONITEM
)
6985 lpht
->flags
&= ~LVHT_NOWHERE
;
6986 TRACE("lpht->flags=0x%x\n", lpht
->flags
);
6988 if (select
&& !(infoPtr
->uView
== LV_VIEW_DETAILS
&&
6989 ((infoPtr
->dwLvExStyle
& LVS_EX_FULLROWSELECT
) ||
6990 (infoPtr
->dwStyle
& LVS_OWNERDRAWFIXED
))))
6992 if (infoPtr
->uView
== LV_VIEW_DETAILS
)
6994 /* get main item bounds */
6995 lvItem
.iSubItem
= 0;
6996 LISTVIEW_GetItemMetrics(infoPtr
, &lvItem
, &rcBox
, NULL
, &rcIcon
, &rcState
, &rcLabel
);
6997 UnionRect(&rcBounds
, &rcIcon
, &rcLabel
);
6998 UnionRect(&rcBounds
, &rcBounds
, &rcState
);
7000 if (!PtInRect(&rcBounds
, opt
)) iItem
= -1;
7002 return lpht
->iItem
= iItem
;
7007 * Inserts a new item in the listview control.
7010 * [I] infoPtr : valid pointer to the listview structure
7011 * [I] lpLVItem : item information
7012 * [I] isW : TRUE if lpLVItem is Unicode, FALSE if it's ANSI
7015 * SUCCESS : new item index
7018 static INT
LISTVIEW_InsertItemT(LISTVIEW_INFO
*infoPtr
, const LVITEMW
*lpLVItem
, BOOL isW
)
7025 BOOL is_sorted
, has_changed
;
7027 HWND hwndSelf
= infoPtr
->hwndSelf
;
7029 TRACE("(lpLVItem=%s, isW=%d)\n", debuglvitem_t(lpLVItem
, isW
), isW
);
7031 if (infoPtr
->dwStyle
& LVS_OWNERDATA
) return infoPtr
->nItemCount
++;
7033 /* make sure it's an item, and not a subitem; cannot insert a subitem */
7034 if (!lpLVItem
|| lpLVItem
->iSubItem
) return -1;
7036 if (!is_assignable_item(lpLVItem
, infoPtr
->dwStyle
)) return -1;
7038 if (!(lpItem
= Alloc(sizeof(ITEM_INFO
)))) return -1;
7040 /* insert item in listview control data structure */
7041 if ( !(hdpaSubItems
= DPA_Create(8)) ) goto fail
;
7042 if ( !DPA_SetPtr(hdpaSubItems
, 0, lpItem
) ) assert (FALSE
);
7044 /* link with id struct */
7045 if (!(lpID
= Alloc(sizeof(ITEM_ID
)))) goto fail
;
7047 lpID
->item
= hdpaSubItems
;
7048 lpID
->id
= get_next_itemid(infoPtr
);
7049 if ( DPA_InsertPtr(infoPtr
->hdpaItemIds
, infoPtr
->nItemCount
, lpID
) == -1) goto fail
;
7051 is_sorted
= (infoPtr
->dwStyle
& (LVS_SORTASCENDING
| LVS_SORTDESCENDING
)) &&
7052 !(infoPtr
->dwStyle
& LVS_OWNERDRAWFIXED
) && (LPSTR_TEXTCALLBACKW
!= lpLVItem
->pszText
);
7054 if (lpLVItem
->iItem
< 0 && !is_sorted
) return -1;
7056 /* calculate new item index */
7063 while (i
< infoPtr
->nItemCount
)
7065 hItem
= DPA_GetPtr( infoPtr
->hdpaItems
, i
);
7066 item_s
= (ITEM_INFO
*)DPA_GetPtr(hItem
, 0);
7068 cmpv
= textcmpWT(item_s
->hdr
.pszText
, lpLVItem
->pszText
, TRUE
);
7069 if (infoPtr
->dwStyle
& LVS_SORTDESCENDING
) cmpv
*= -1;
7071 if (cmpv
>= 0) break;
7077 nItem
= min(lpLVItem
->iItem
, infoPtr
->nItemCount
);
7079 TRACE(" inserting at %d, sorted=%d, count=%d, iItem=%d\n", nItem
, is_sorted
, infoPtr
->nItemCount
, lpLVItem
->iItem
);
7080 nItem
= DPA_InsertPtr( infoPtr
->hdpaItems
, nItem
, hdpaSubItems
);
7081 if (nItem
== -1) goto fail
;
7082 infoPtr
->nItemCount
++;
7084 /* shift indices first so they don't get tangled */
7085 LISTVIEW_ShiftIndices(infoPtr
, nItem
, 1);
7087 /* set the item attributes */
7088 if (lpLVItem
->mask
& (LVIF_GROUPID
|LVIF_COLUMNS
))
7090 /* full size structure expected - _WIN32IE >= 0x560 */
7093 else if (lpLVItem
->mask
& LVIF_INDENT
)
7095 /* indent member expected - _WIN32IE >= 0x300 */
7096 memcpy(&item
, lpLVItem
, offsetof( LVITEMW
, iGroupId
));
7100 /* minimal structure expected */
7101 memcpy(&item
, lpLVItem
, offsetof( LVITEMW
, iIndent
));
7104 if (infoPtr
->dwLvExStyle
& LVS_EX_CHECKBOXES
)
7106 item
.mask
|= LVIF_STATE
;
7107 item
.stateMask
|= LVIS_STATEIMAGEMASK
;
7108 item
.state
&= ~LVIS_STATEIMAGEMASK
;
7109 item
.state
|= INDEXTOSTATEIMAGEMASK(1);
7111 if (!set_main_item(infoPtr
, &item
, TRUE
, isW
, &has_changed
)) goto undo
;
7113 /* make room for the position, if we are in the right mode */
7114 if ((infoPtr
->uView
== LV_VIEW_SMALLICON
) || (infoPtr
->uView
== LV_VIEW_ICON
))
7116 if (DPA_InsertPtr(infoPtr
->hdpaPosX
, nItem
, 0) == -1)
7118 if (DPA_InsertPtr(infoPtr
->hdpaPosY
, nItem
, 0) == -1)
7120 DPA_DeletePtr(infoPtr
->hdpaPosX
, nItem
);
7125 /* send LVN_INSERTITEM notification */
7126 ZeroMemory(&nmlv
, sizeof(NMLISTVIEW
));
7128 nmlv
.lParam
= lpItem
->lParam
;
7129 notify_listview(infoPtr
, LVN_INSERTITEM
, &nmlv
);
7130 if (!IsWindow(hwndSelf
))
7133 /* align items (set position of each item) */
7134 if (infoPtr
->uView
== LV_VIEW_SMALLICON
|| infoPtr
->uView
== LV_VIEW_ICON
)
7138 if (infoPtr
->dwStyle
& LVS_ALIGNLEFT
)
7139 LISTVIEW_NextIconPosLeft(infoPtr
, &pt
);
7141 LISTVIEW_NextIconPosTop(infoPtr
, &pt
);
7143 LISTVIEW_MoveIconTo(infoPtr
, nItem
, &pt
, TRUE
);
7146 /* now is the invalidation fun */
7147 LISTVIEW_ScrollOnInsert(infoPtr
, nItem
, 1);
7151 LISTVIEW_ShiftIndices(infoPtr
, nItem
, -1);
7152 DPA_DeletePtr(infoPtr
->hdpaItems
, nItem
);
7153 infoPtr
->nItemCount
--;
7155 DPA_DeletePtr(hdpaSubItems
, 0);
7156 DPA_Destroy (hdpaSubItems
);
7163 * Checks item visibility.
7166 * [I] infoPtr : valid pointer to the listview structure
7167 * [I] nFirst : item index to check for
7170 * Item visible : TRUE
7171 * Item invisible or failure : FALSE
7173 static BOOL
LISTVIEW_IsItemVisible(const LISTVIEW_INFO
*infoPtr
, INT nItem
)
7175 POINT Origin
, Position
;
7180 TRACE("nItem=%d\n", nItem
);
7182 if (nItem
< 0 || nItem
>= DPA_GetPtrCount(infoPtr
->hdpaItems
)) return FALSE
;
7184 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
7185 LISTVIEW_GetItemOrigin(infoPtr
, nItem
, &Position
);
7186 rcItem
.left
= Position
.x
+ Origin
.x
;
7187 rcItem
.top
= Position
.y
+ Origin
.y
;
7188 rcItem
.right
= rcItem
.left
+ infoPtr
->nItemWidth
;
7189 rcItem
.bottom
= rcItem
.top
+ infoPtr
->nItemHeight
;
7191 hdc
= GetDC(infoPtr
->hwndSelf
);
7192 if (!hdc
) return FALSE
;
7193 ret
= RectVisible(hdc
, &rcItem
);
7194 ReleaseDC(infoPtr
->hwndSelf
, hdc
);
7201 * Redraws a range of items.
7204 * [I] infoPtr : valid pointer to the listview structure
7205 * [I] nFirst : first item
7206 * [I] nLast : last item
7212 static BOOL
LISTVIEW_RedrawItems(const LISTVIEW_INFO
*infoPtr
, INT nFirst
, INT nLast
)
7216 if (nLast
< nFirst
|| min(nFirst
, nLast
) < 0 ||
7217 max(nFirst
, nLast
) >= infoPtr
->nItemCount
)
7220 for (i
= nFirst
; i
<= nLast
; i
++)
7221 LISTVIEW_InvalidateItem(infoPtr
, i
);
7228 * Scroll the content of a listview.
7231 * [I] infoPtr : valid pointer to the listview structure
7232 * [I] dx : horizontal scroll amount in pixels
7233 * [I] dy : vertical scroll amount in pixels
7240 * If the control is in report view (LV_VIEW_DETAILS) the control can
7241 * be scrolled only in line increments. "dy" will be rounded to the
7242 * nearest number of pixels that are a whole line. Ex: if line height
7243 * is 16 and an 8 is passed, the list will be scrolled by 16. If a 7
7244 * is passed, then the scroll will be 0. (per MSDN 7/2002)
7246 * For: (per experimentation with native control and CSpy ListView)
7247 * LV_VIEW_ICON dy=1 = 1 pixel (vertical only)
7249 * LV_VIEW_SMALLICON dy=1 = 1 pixel (vertical only)
7251 * LV_VIEW_LIST dx=1 = 1 column (horizontal only)
7252 * but will only scroll 1 column per message
7253 * no matter what the value.
7254 * dy must be 0 or FALSE returned.
7255 * LV_VIEW_DETAILS dx=1 = 1 pixel
7259 static BOOL
LISTVIEW_Scroll(LISTVIEW_INFO
*infoPtr
, INT dx
, INT dy
)
7261 switch(infoPtr
->uView
) {
7262 case LV_VIEW_DETAILS
:
7263 dy
+= (dy
< 0 ? -1 : 1) * infoPtr
->nItemHeight
/2;
7264 dy
/= infoPtr
->nItemHeight
;
7267 if (dy
!= 0) return FALSE
;
7274 if (dx
!= 0) LISTVIEW_HScroll(infoPtr
, SB_INTERNAL
, dx
, 0);
7275 if (dy
!= 0) LISTVIEW_VScroll(infoPtr
, SB_INTERNAL
, dy
, 0);
7282 * Sets the background color.
7285 * [I] infoPtr : valid pointer to the listview structure
7286 * [I] clrBk : background color
7292 static BOOL
LISTVIEW_SetBkColor(LISTVIEW_INFO
*infoPtr
, COLORREF clrBk
)
7294 TRACE("(clrBk=%x)\n", clrBk
);
7296 if(infoPtr
->clrBk
!= clrBk
) {
7297 if (infoPtr
->clrBk
!= CLR_NONE
) DeleteObject(infoPtr
->hBkBrush
);
7298 infoPtr
->clrBk
= clrBk
;
7299 if (clrBk
== CLR_NONE
)
7300 infoPtr
->hBkBrush
= (HBRUSH
)GetClassLongPtrW(infoPtr
->hwndSelf
, GCLP_HBRBACKGROUND
);
7302 infoPtr
->hBkBrush
= CreateSolidBrush(clrBk
);
7303 LISTVIEW_InvalidateList(infoPtr
);
7309 /* LISTVIEW_SetBkImage */
7311 /*** Helper for {Insert,Set}ColumnT *only* */
7312 static void column_fill_hditem(const LISTVIEW_INFO
*infoPtr
, HDITEMW
*lphdi
, INT nColumn
,
7313 const LVCOLUMNW
*lpColumn
, BOOL isW
)
7315 if (lpColumn
->mask
& LVCF_FMT
)
7317 /* format member is valid */
7318 lphdi
->mask
|= HDI_FORMAT
;
7320 /* set text alignment (leftmost column must be left-aligned) */
7321 if (nColumn
== 0 || (lpColumn
->fmt
& LVCFMT_JUSTIFYMASK
) == LVCFMT_LEFT
)
7322 lphdi
->fmt
|= HDF_LEFT
;
7323 else if ((lpColumn
->fmt
& LVCFMT_JUSTIFYMASK
) == LVCFMT_RIGHT
)
7324 lphdi
->fmt
|= HDF_RIGHT
;
7325 else if ((lpColumn
->fmt
& LVCFMT_JUSTIFYMASK
) == LVCFMT_CENTER
)
7326 lphdi
->fmt
|= HDF_CENTER
;
7328 if (lpColumn
->fmt
& LVCFMT_BITMAP_ON_RIGHT
)
7329 lphdi
->fmt
|= HDF_BITMAP_ON_RIGHT
;
7331 if (lpColumn
->fmt
& LVCFMT_COL_HAS_IMAGES
)
7333 lphdi
->fmt
|= HDF_IMAGE
;
7334 lphdi
->iImage
= I_IMAGECALLBACK
;
7338 if (lpColumn
->mask
& LVCF_WIDTH
)
7340 lphdi
->mask
|= HDI_WIDTH
;
7341 if(lpColumn
->cx
== LVSCW_AUTOSIZE_USEHEADER
)
7343 /* make it fill the remainder of the controls width */
7347 for(item_index
= 0; item_index
< (nColumn
- 1); item_index
++)
7349 LISTVIEW_GetHeaderRect(infoPtr
, item_index
, &rcHeader
);
7350 lphdi
->cxy
+= rcHeader
.right
- rcHeader
.left
;
7353 /* retrieve the layout of the header */
7354 GetClientRect(infoPtr
->hwndSelf
, &rcHeader
);
7355 TRACE("start cxy=%d rcHeader=%s\n", lphdi
->cxy
, wine_dbgstr_rect(&rcHeader
));
7357 lphdi
->cxy
= (rcHeader
.right
- rcHeader
.left
) - lphdi
->cxy
;
7360 lphdi
->cxy
= lpColumn
->cx
;
7363 if (lpColumn
->mask
& LVCF_TEXT
)
7365 lphdi
->mask
|= HDI_TEXT
| HDI_FORMAT
;
7366 lphdi
->fmt
|= HDF_STRING
;
7367 lphdi
->pszText
= lpColumn
->pszText
;
7368 lphdi
->cchTextMax
= textlenT(lpColumn
->pszText
, isW
);
7371 if (lpColumn
->mask
& LVCF_IMAGE
)
7373 lphdi
->mask
|= HDI_IMAGE
;
7374 lphdi
->iImage
= lpColumn
->iImage
;
7377 if (lpColumn
->mask
& LVCF_ORDER
)
7379 lphdi
->mask
|= HDI_ORDER
;
7380 lphdi
->iOrder
= lpColumn
->iOrder
;
7387 * Inserts a new column.
7390 * [I] infoPtr : valid pointer to the listview structure
7391 * [I] nColumn : column index
7392 * [I] lpColumn : column information
7393 * [I] isW : TRUE if lpColumn is Unicode, FALSE otherwise
7396 * SUCCESS : new column index
7399 static INT
LISTVIEW_InsertColumnT(LISTVIEW_INFO
*infoPtr
, INT nColumn
,
7400 const LVCOLUMNW
*lpColumn
, BOOL isW
)
7402 COLUMN_INFO
*lpColumnInfo
;
7406 TRACE("(nColumn=%d, lpColumn=%s, isW=%d)\n", nColumn
, debuglvcolumn_t(lpColumn
, isW
), isW
);
7408 if (!lpColumn
|| nColumn
< 0) return -1;
7409 nColumn
= min(nColumn
, DPA_GetPtrCount(infoPtr
->hdpaColumns
));
7411 ZeroMemory(&hdi
, sizeof(HDITEMW
));
7412 column_fill_hditem(infoPtr
, &hdi
, nColumn
, lpColumn
, isW
);
7415 * A mask not including LVCF_WIDTH turns into a mask of width, width 10
7416 * (can be seen in SPY) otherwise column never gets added.
7418 if (!(lpColumn
->mask
& LVCF_WIDTH
)) {
7419 hdi
.mask
|= HDI_WIDTH
;
7424 * when the iSubItem is available Windows copies it to the header lParam. It seems
7425 * to happen only in LVM_INSERTCOLUMN - not in LVM_SETCOLUMN
7427 if (lpColumn
->mask
& LVCF_SUBITEM
)
7429 hdi
.mask
|= HDI_LPARAM
;
7430 hdi
.lParam
= lpColumn
->iSubItem
;
7433 /* create header if not present */
7434 LISTVIEW_CreateHeader(infoPtr
);
7435 if (!(LVS_NOCOLUMNHEADER
& infoPtr
->dwStyle
) &&
7436 (infoPtr
->uView
== LV_VIEW_DETAILS
) && (WS_VISIBLE
& infoPtr
->dwStyle
))
7438 ShowWindow(infoPtr
->hwndHeader
, SW_SHOWNORMAL
);
7441 /* insert item in header control */
7442 nNewColumn
= SendMessageW(infoPtr
->hwndHeader
,
7443 isW
? HDM_INSERTITEMW
: HDM_INSERTITEMA
,
7444 (WPARAM
)nColumn
, (LPARAM
)&hdi
);
7445 if (nNewColumn
== -1) return -1;
7446 if (nNewColumn
!= nColumn
) ERR("nColumn=%d, nNewColumn=%d\n", nColumn
, nNewColumn
);
7448 /* create our own column info */
7449 if (!(lpColumnInfo
= Alloc(sizeof(COLUMN_INFO
)))) goto fail
;
7450 if (DPA_InsertPtr(infoPtr
->hdpaColumns
, nNewColumn
, lpColumnInfo
) == -1) goto fail
;
7452 if (lpColumn
->mask
& LVCF_FMT
) lpColumnInfo
->fmt
= lpColumn
->fmt
;
7453 if (!SendMessageW(infoPtr
->hwndHeader
, HDM_GETITEMRECT
, nNewColumn
, (LPARAM
)&lpColumnInfo
->rcHeader
))
7456 /* now we have to actually adjust the data */
7457 if (!(infoPtr
->dwStyle
& LVS_OWNERDATA
) && infoPtr
->nItemCount
> 0)
7459 SUBITEM_INFO
*lpSubItem
;
7463 for (nItem
= 0; nItem
< infoPtr
->nItemCount
; nItem
++)
7465 hdpaSubItems
= DPA_GetPtr(infoPtr
->hdpaItems
, nItem
);
7466 for (i
= 1; i
< DPA_GetPtrCount(hdpaSubItems
); i
++)
7468 lpSubItem
= DPA_GetPtr(hdpaSubItems
, i
);
7469 if (lpSubItem
->iSubItem
>= nNewColumn
)
7470 lpSubItem
->iSubItem
++;
7475 /* make space for the new column */
7476 LISTVIEW_ScrollColumns(infoPtr
, nNewColumn
+ 1, lpColumnInfo
->rcHeader
.right
- lpColumnInfo
->rcHeader
.left
);
7477 LISTVIEW_UpdateItemSize(infoPtr
);
7482 if (nNewColumn
!= -1) SendMessageW(infoPtr
->hwndHeader
, HDM_DELETEITEM
, nNewColumn
, 0);
7485 DPA_DeletePtr(infoPtr
->hdpaColumns
, nNewColumn
);
7493 * Sets the attributes of a header item.
7496 * [I] infoPtr : valid pointer to the listview structure
7497 * [I] nColumn : column index
7498 * [I] lpColumn : column attributes
7499 * [I] isW: if TRUE, then lpColumn is a LPLVCOLUMNW, else it is a LPLVCOLUMNA
7505 static BOOL
LISTVIEW_SetColumnT(const LISTVIEW_INFO
*infoPtr
, INT nColumn
,
7506 const LVCOLUMNW
*lpColumn
, BOOL isW
)
7508 HDITEMW hdi
, hdiget
;
7511 TRACE("(nColumn=%d, lpColumn=%s, isW=%d)\n", nColumn
, debuglvcolumn_t(lpColumn
, isW
), isW
);
7513 if (!lpColumn
|| nColumn
< 0 || nColumn
>= DPA_GetPtrCount(infoPtr
->hdpaColumns
)) return FALSE
;
7515 ZeroMemory(&hdi
, sizeof(HDITEMW
));
7516 if (lpColumn
->mask
& LVCF_FMT
)
7518 hdi
.mask
|= HDI_FORMAT
;
7519 hdiget
.mask
= HDI_FORMAT
;
7520 if (SendMessageW(infoPtr
->hwndHeader
, HDM_GETITEMW
, nColumn
, (LPARAM
)&hdiget
))
7521 hdi
.fmt
= hdiget
.fmt
& HDF_STRING
;
7523 column_fill_hditem(infoPtr
, &hdi
, nColumn
, lpColumn
, isW
);
7525 /* set header item attributes */
7526 bResult
= SendMessageW(infoPtr
->hwndHeader
, isW
? HDM_SETITEMW
: HDM_SETITEMA
, (WPARAM
)nColumn
, (LPARAM
)&hdi
);
7527 if (!bResult
) return FALSE
;
7529 if (lpColumn
->mask
& LVCF_FMT
)
7531 COLUMN_INFO
*lpColumnInfo
= LISTVIEW_GetColumnInfo(infoPtr
, nColumn
);
7532 int oldFmt
= lpColumnInfo
->fmt
;
7534 lpColumnInfo
->fmt
= lpColumn
->fmt
;
7535 if ((oldFmt
^ lpColumn
->fmt
) & (LVCFMT_JUSTIFYMASK
| LVCFMT_IMAGE
))
7537 if (infoPtr
->uView
== LV_VIEW_DETAILS
) LISTVIEW_InvalidateColumn(infoPtr
, nColumn
);
7546 * Sets the column order array
7549 * [I] infoPtr : valid pointer to the listview structure
7550 * [I] iCount : number of elements in column order array
7551 * [I] lpiArray : pointer to column order array
7557 static BOOL
LISTVIEW_SetColumnOrderArray(LISTVIEW_INFO
*infoPtr
, INT iCount
, const INT
*lpiArray
)
7559 TRACE("iCount %d lpiArray %p\n", iCount
, lpiArray
);
7561 if (!lpiArray
|| !IsWindow(infoPtr
->hwndHeader
)) return FALSE
;
7563 infoPtr
->colRectsDirty
= TRUE
;
7565 return SendMessageW(infoPtr
->hwndHeader
, HDM_SETORDERARRAY
, iCount
, (LPARAM
)lpiArray
);
7570 * Sets the width of a column
7573 * [I] infoPtr : valid pointer to the listview structure
7574 * [I] nColumn : column index
7575 * [I] cx : column width
7581 static BOOL
LISTVIEW_SetColumnWidth(LISTVIEW_INFO
*infoPtr
, INT nColumn
, INT cx
)
7583 WCHAR szDispText
[DISP_TEXT_SIZE
] = { 0 };
7587 TRACE("(nColumn=%d, cx=%d\n", nColumn
, cx
);
7589 /* set column width only if in report or list mode */
7590 if (infoPtr
->uView
!= LV_VIEW_DETAILS
&& infoPtr
->uView
!= LV_VIEW_LIST
) return FALSE
;
7592 /* take care of invalid cx values */
7593 if(infoPtr
->uView
== LV_VIEW_DETAILS
&& cx
< -2) cx
= LVSCW_AUTOSIZE
;
7594 else if (infoPtr
->uView
== LV_VIEW_LIST
&& cx
< 1) return FALSE
;
7596 /* resize all columns if in LV_VIEW_LIST mode */
7597 if(infoPtr
->uView
== LV_VIEW_LIST
)
7599 infoPtr
->nItemWidth
= cx
;
7600 LISTVIEW_InvalidateList(infoPtr
);
7604 if (nColumn
< 0 || nColumn
>= DPA_GetPtrCount(infoPtr
->hdpaColumns
)) return FALSE
;
7606 if (cx
== LVSCW_AUTOSIZE
|| (cx
== LVSCW_AUTOSIZE_USEHEADER
&& nColumn
< DPA_GetPtrCount(infoPtr
->hdpaColumns
) -1))
7611 lvItem
.mask
= LVIF_TEXT
;
7613 lvItem
.iSubItem
= nColumn
;
7614 lvItem
.pszText
= szDispText
;
7615 lvItem
.cchTextMax
= DISP_TEXT_SIZE
;
7616 for (; lvItem
.iItem
< infoPtr
->nItemCount
; lvItem
.iItem
++)
7618 if (!LISTVIEW_GetItemW(infoPtr
, &lvItem
)) continue;
7619 nLabelWidth
= LISTVIEW_GetStringWidthT(infoPtr
, lvItem
.pszText
, TRUE
);
7620 if (max_cx
< nLabelWidth
) max_cx
= nLabelWidth
;
7622 if (infoPtr
->himlSmall
&& (nColumn
== 0 || (LISTVIEW_GetColumnInfo(infoPtr
, nColumn
)->fmt
& LVCFMT_IMAGE
)))
7623 max_cx
+= infoPtr
->iconSize
.cx
;
7624 max_cx
+= TRAILING_LABEL_PADDING
;
7627 /* autosize based on listview items width */
7628 if(cx
== LVSCW_AUTOSIZE
)
7630 else if(cx
== LVSCW_AUTOSIZE_USEHEADER
)
7632 /* if iCol is the last column make it fill the remainder of the controls width */
7633 if(nColumn
== DPA_GetPtrCount(infoPtr
->hdpaColumns
) - 1)
7638 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
7639 LISTVIEW_GetHeaderRect(infoPtr
, nColumn
, &rcHeader
);
7641 cx
= infoPtr
->rcList
.right
- Origin
.x
- rcHeader
.left
;
7645 /* Despite what the MS docs say, if this is not the last
7646 column, then MS resizes the column to the width of the
7647 largest text string in the column, including headers
7648 and items. This is different from LVSCW_AUTOSIZE in that
7649 LVSCW_AUTOSIZE ignores the header string length. */
7652 /* retrieve header text */
7653 hdi
.mask
= HDI_TEXT
;
7654 hdi
.cchTextMax
= DISP_TEXT_SIZE
;
7655 hdi
.pszText
= szDispText
;
7656 if (SendMessageW(infoPtr
->hwndHeader
, HDM_GETITEMW
, nColumn
, (LPARAM
)&hdi
))
7658 HDC hdc
= GetDC(infoPtr
->hwndSelf
);
7659 HFONT old_font
= SelectObject(hdc
, (HFONT
)SendMessageW(infoPtr
->hwndHeader
, WM_GETFONT
, 0, 0));
7662 if (GetTextExtentPoint32W(hdc
, hdi
.pszText
, lstrlenW(hdi
.pszText
), &size
))
7663 cx
= size
.cx
+ TRAILING_HEADER_PADDING
;
7664 /* FIXME: Take into account the header image, if one is present */
7665 SelectObject(hdc
, old_font
);
7666 ReleaseDC(infoPtr
->hwndSelf
, hdc
);
7668 cx
= max (cx
, max_cx
);
7672 if (cx
< 0) return FALSE
;
7674 /* call header to update the column change */
7675 hdi
.mask
= HDI_WIDTH
;
7677 TRACE("hdi.cxy=%d\n", hdi
.cxy
);
7678 return SendMessageW(infoPtr
->hwndHeader
, HDM_SETITEMW
, nColumn
, (LPARAM
)&hdi
);
7682 * Creates the checkbox imagelist. Helper for LISTVIEW_SetExtendedListViewStyle
7685 static HIMAGELIST
LISTVIEW_CreateCheckBoxIL(const LISTVIEW_INFO
*infoPtr
)
7688 HBITMAP hbm_im
, hbm_mask
, hbm_orig
;
7690 HBRUSH hbr_white
= GetStockObject(WHITE_BRUSH
);
7691 HBRUSH hbr_black
= GetStockObject(BLACK_BRUSH
);
7694 himl
= ImageList_Create(GetSystemMetrics(SM_CXSMICON
), GetSystemMetrics(SM_CYSMICON
),
7695 ILC_COLOR
| ILC_MASK
, 2, 2);
7696 hdc_wnd
= GetDC(infoPtr
->hwndSelf
);
7697 hdc
= CreateCompatibleDC(hdc_wnd
);
7698 hbm_im
= CreateCompatibleBitmap(hdc_wnd
, GetSystemMetrics(SM_CXSMICON
), GetSystemMetrics(SM_CYSMICON
));
7699 hbm_mask
= CreateBitmap(GetSystemMetrics(SM_CXSMICON
), GetSystemMetrics(SM_CYSMICON
), 1, 1, NULL
);
7700 ReleaseDC(infoPtr
->hwndSelf
, hdc_wnd
);
7702 rc
.left
= rc
.top
= 0;
7703 rc
.right
= GetSystemMetrics(SM_CXSMICON
);
7704 rc
.bottom
= GetSystemMetrics(SM_CYSMICON
);
7706 hbm_orig
= SelectObject(hdc
, hbm_mask
);
7707 FillRect(hdc
, &rc
, hbr_white
);
7708 InflateRect(&rc
, -2, -2);
7709 FillRect(hdc
, &rc
, hbr_black
);
7711 SelectObject(hdc
, hbm_im
);
7712 DrawFrameControl(hdc
, &rc
, DFC_BUTTON
, DFCS_BUTTONCHECK
| DFCS_MONO
);
7713 SelectObject(hdc
, hbm_orig
);
7714 ImageList_Add(himl
, hbm_im
, hbm_mask
);
7716 SelectObject(hdc
, hbm_im
);
7717 DrawFrameControl(hdc
, &rc
, DFC_BUTTON
, DFCS_BUTTONCHECK
| DFCS_MONO
| DFCS_CHECKED
);
7718 SelectObject(hdc
, hbm_orig
);
7719 ImageList_Add(himl
, hbm_im
, hbm_mask
);
7721 DeleteObject(hbm_mask
);
7722 DeleteObject(hbm_im
);
7730 * Sets the extended listview style.
7733 * [I] infoPtr : valid pointer to the listview structure
7735 * [I] dwStyle : style
7738 * SUCCESS : previous style
7741 static DWORD
LISTVIEW_SetExtendedListViewStyle(LISTVIEW_INFO
*infoPtr
, DWORD dwMask
, DWORD dwExStyle
)
7743 DWORD dwOldExStyle
= infoPtr
->dwLvExStyle
;
7747 infoPtr
->dwLvExStyle
= (dwOldExStyle
& ~dwMask
) | (dwExStyle
& dwMask
);
7749 infoPtr
->dwLvExStyle
= dwExStyle
;
7751 if((infoPtr
->dwLvExStyle
^ dwOldExStyle
) & LVS_EX_CHECKBOXES
)
7753 HIMAGELIST himl
= 0;
7754 if(infoPtr
->dwLvExStyle
& LVS_EX_CHECKBOXES
)
7757 item
.mask
= LVIF_STATE
;
7758 item
.stateMask
= LVIS_STATEIMAGEMASK
;
7759 item
.state
= INDEXTOSTATEIMAGEMASK(1);
7760 LISTVIEW_SetItemState(infoPtr
, -1, &item
);
7762 himl
= LISTVIEW_CreateCheckBoxIL(infoPtr
);
7764 LISTVIEW_SetImageList(infoPtr
, LVSIL_STATE
, himl
);
7767 if((infoPtr
->dwLvExStyle
^ dwOldExStyle
) & LVS_EX_HEADERDRAGDROP
)
7771 /* if not already created */
7772 LISTVIEW_CreateHeader(infoPtr
);
7774 dwStyle
= GetWindowLongW(infoPtr
->hwndHeader
, GWL_STYLE
);
7775 if (infoPtr
->dwLvExStyle
& LVS_EX_HEADERDRAGDROP
)
7776 dwStyle
|= HDS_DRAGDROP
;
7778 dwStyle
&= ~HDS_DRAGDROP
;
7779 SetWindowLongW(infoPtr
->hwndHeader
, GWL_STYLE
, dwStyle
);
7782 /* GRIDLINES adds decoration at top so changes sizes */
7783 if((infoPtr
->dwLvExStyle
^ dwOldExStyle
) & LVS_EX_GRIDLINES
)
7785 LISTVIEW_UpdateSize(infoPtr
);
7789 LISTVIEW_InvalidateList(infoPtr
);
7790 return dwOldExStyle
;
7795 * Sets the new hot cursor used during hot tracking and hover selection.
7798 * [I] infoPtr : valid pointer to the listview structure
7799 * [I] hCursor : the new hot cursor handle
7802 * Returns the previous hot cursor
7804 static HCURSOR
LISTVIEW_SetHotCursor(LISTVIEW_INFO
*infoPtr
, HCURSOR hCursor
)
7806 HCURSOR oldCursor
= infoPtr
->hHotCursor
;
7808 infoPtr
->hHotCursor
= hCursor
;
7816 * Sets the hot item index.
7819 * [I] infoPtr : valid pointer to the listview structure
7820 * [I] iIndex : index
7823 * SUCCESS : previous hot item index
7824 * FAILURE : -1 (no hot item)
7826 static INT
LISTVIEW_SetHotItem(LISTVIEW_INFO
*infoPtr
, INT iIndex
)
7828 INT iOldIndex
= infoPtr
->nHotItem
;
7830 infoPtr
->nHotItem
= iIndex
;
7838 * Sets the amount of time the cursor must hover over an item before it is selected.
7841 * [I] infoPtr : valid pointer to the listview structure
7842 * [I] dwHoverTime : hover time, if -1 the hover time is set to the default
7845 * Returns the previous hover time
7847 static DWORD
LISTVIEW_SetHoverTime(LISTVIEW_INFO
*infoPtr
, DWORD dwHoverTime
)
7849 DWORD oldHoverTime
= infoPtr
->dwHoverTime
;
7851 infoPtr
->dwHoverTime
= dwHoverTime
;
7853 return oldHoverTime
;
7858 * Sets spacing for icons of LVS_ICON style.
7861 * [I] infoPtr : valid pointer to the listview structure
7862 * [I] cx : horizontal spacing (-1 = system spacing, 0 = autosize)
7863 * [I] cy : vertical spacing (-1 = system spacing, 0 = autosize)
7866 * MAKELONG(oldcx, oldcy)
7868 static DWORD
LISTVIEW_SetIconSpacing(LISTVIEW_INFO
*infoPtr
, INT cx
, INT cy
)
7870 DWORD oldspacing
= MAKELONG(infoPtr
->iconSpacing
.cx
, infoPtr
->iconSpacing
.cy
);
7872 TRACE("requested=(%d,%d)\n", cx
, cy
);
7874 /* this is supported only for LVS_ICON style */
7875 if (infoPtr
->uView
!= LV_VIEW_ICON
) return oldspacing
;
7877 /* set to defaults, if instructed to */
7878 if (cx
== -1) cx
= GetSystemMetrics(SM_CXICONSPACING
);
7879 if (cy
== -1) cy
= GetSystemMetrics(SM_CYICONSPACING
);
7881 /* if 0 then compute width
7882 * FIXME: Should scan each item and determine max width of
7883 * icon or label, then make that the width */
7885 cx
= infoPtr
->iconSpacing
.cx
;
7887 /* if 0 then compute height */
7889 cy
= infoPtr
->iconSize
.cy
+ 2 * infoPtr
->ntmHeight
+
7890 ICON_BOTTOM_PADDING
+ ICON_TOP_PADDING
+ LABEL_VERT_PADDING
;
7893 infoPtr
->iconSpacing
.cx
= cx
;
7894 infoPtr
->iconSpacing
.cy
= cy
;
7896 TRACE("old=(%d,%d), new=(%d,%d), iconSize=(%d,%d), ntmH=%d\n",
7897 LOWORD(oldspacing
), HIWORD(oldspacing
), cx
, cy
,
7898 infoPtr
->iconSize
.cx
, infoPtr
->iconSize
.cy
,
7899 infoPtr
->ntmHeight
);
7901 /* these depend on the iconSpacing */
7902 LISTVIEW_UpdateItemSize(infoPtr
);
7907 static inline void set_icon_size(SIZE
*size
, HIMAGELIST himl
, BOOL small
)
7911 if (himl
&& ImageList_GetIconSize(himl
, &cx
, &cy
))
7918 size
->cx
= GetSystemMetrics(small
? SM_CXSMICON
: SM_CXICON
);
7919 size
->cy
= GetSystemMetrics(small
? SM_CYSMICON
: SM_CYICON
);
7928 * [I] infoPtr : valid pointer to the listview structure
7929 * [I] nType : image list type
7930 * [I] himl : image list handle
7933 * SUCCESS : old image list
7936 static HIMAGELIST
LISTVIEW_SetImageList(LISTVIEW_INFO
*infoPtr
, INT nType
, HIMAGELIST himl
)
7938 INT oldHeight
= infoPtr
->nItemHeight
;
7939 HIMAGELIST himlOld
= 0;
7941 TRACE("(nType=%d, himl=%p\n", nType
, himl
);
7946 himlOld
= infoPtr
->himlNormal
;
7947 infoPtr
->himlNormal
= himl
;
7948 if (infoPtr
->uView
== LV_VIEW_ICON
) set_icon_size(&infoPtr
->iconSize
, himl
, FALSE
);
7949 LISTVIEW_SetIconSpacing(infoPtr
, 0, 0);
7953 himlOld
= infoPtr
->himlSmall
;
7954 infoPtr
->himlSmall
= himl
;
7955 if (infoPtr
->uView
!= LV_VIEW_ICON
) set_icon_size(&infoPtr
->iconSize
, himl
, TRUE
);
7959 himlOld
= infoPtr
->himlState
;
7960 infoPtr
->himlState
= himl
;
7961 set_icon_size(&infoPtr
->iconStateSize
, himl
, TRUE
);
7962 ImageList_SetBkColor(infoPtr
->himlState
, CLR_NONE
);
7966 ERR("Unknown icon type=%d\n", nType
);
7970 infoPtr
->nItemHeight
= LISTVIEW_CalculateItemHeight(infoPtr
);
7971 if (infoPtr
->nItemHeight
!= oldHeight
)
7972 LISTVIEW_UpdateScroll(infoPtr
);
7979 * Preallocates memory (does *not* set the actual count of items !)
7982 * [I] infoPtr : valid pointer to the listview structure
7983 * [I] nItems : item count (projected number of items to allocate)
7984 * [I] dwFlags : update flags
7990 static BOOL
LISTVIEW_SetItemCount(LISTVIEW_INFO
*infoPtr
, INT nItems
, DWORD dwFlags
)
7992 TRACE("(nItems=%d, dwFlags=%x)\n", nItems
, dwFlags
);
7994 if (infoPtr
->dwStyle
& LVS_OWNERDATA
)
7996 INT nOldCount
= infoPtr
->nItemCount
;
7998 if (nItems
< nOldCount
)
8000 RANGE range
= { nItems
, nOldCount
};
8001 ranges_del(infoPtr
->selectionRanges
, range
);
8002 if (infoPtr
->nFocusedItem
>= nItems
)
8004 LISTVIEW_SetItemFocus(infoPtr
, -1);
8005 SetRectEmpty(&infoPtr
->rcFocus
);
8009 infoPtr
->nItemCount
= nItems
;
8010 LISTVIEW_UpdateScroll(infoPtr
);
8012 /* the flags are valid only in ownerdata report and list modes */
8013 if (infoPtr
->uView
== LV_VIEW_ICON
|| infoPtr
->uView
== LV_VIEW_SMALLICON
) dwFlags
= 0;
8015 if (!(dwFlags
& LVSICF_NOSCROLL
) && infoPtr
->nFocusedItem
!= -1)
8016 LISTVIEW_EnsureVisible(infoPtr
, infoPtr
->nFocusedItem
, FALSE
);
8018 if (!(dwFlags
& LVSICF_NOINVALIDATEALL
))
8019 LISTVIEW_InvalidateList(infoPtr
);
8026 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
8027 nFrom
= min(nOldCount
, nItems
);
8028 nTo
= max(nOldCount
, nItems
);
8030 if (infoPtr
->uView
== LV_VIEW_DETAILS
)
8033 rcErase
.top
= nFrom
* infoPtr
->nItemHeight
;
8034 rcErase
.right
= infoPtr
->nItemWidth
;
8035 rcErase
.bottom
= nTo
* infoPtr
->nItemHeight
;
8036 OffsetRect(&rcErase
, Origin
.x
, Origin
.y
);
8037 if (IntersectRect(&rcErase
, &rcErase
, &infoPtr
->rcList
))
8038 LISTVIEW_InvalidateRect(infoPtr
, &rcErase
);
8040 else /* LV_VIEW_LIST */
8042 INT nPerCol
= LISTVIEW_GetCountPerColumn(infoPtr
);
8044 rcErase
.left
= (nFrom
/ nPerCol
) * infoPtr
->nItemWidth
;
8045 rcErase
.top
= (nFrom
% nPerCol
) * infoPtr
->nItemHeight
;
8046 rcErase
.right
= rcErase
.left
+ infoPtr
->nItemWidth
;
8047 rcErase
.bottom
= nPerCol
* infoPtr
->nItemHeight
;
8048 OffsetRect(&rcErase
, Origin
.x
, Origin
.y
);
8049 if (IntersectRect(&rcErase
, &rcErase
, &infoPtr
->rcList
))
8050 LISTVIEW_InvalidateRect(infoPtr
, &rcErase
);
8052 rcErase
.left
= (nFrom
/ nPerCol
+ 1) * infoPtr
->nItemWidth
;
8054 rcErase
.right
= (nTo
/ nPerCol
+ 1) * infoPtr
->nItemWidth
;
8055 rcErase
.bottom
= nPerCol
* infoPtr
->nItemHeight
;
8056 OffsetRect(&rcErase
, Origin
.x
, Origin
.y
);
8057 if (IntersectRect(&rcErase
, &rcErase
, &infoPtr
->rcList
))
8058 LISTVIEW_InvalidateRect(infoPtr
, &rcErase
);
8064 /* According to MSDN for non-LVS_OWNERDATA this is just
8065 * a performance issue. The control allocates its internal
8066 * data structures for the number of items specified. It
8067 * cuts down on the number of memory allocations. Therefore
8068 * we will just issue a WARN here
8070 WARN("for non-ownerdata performance option not implemented.\n");
8078 * Sets the position of an item.
8081 * [I] infoPtr : valid pointer to the listview structure
8082 * [I] nItem : item index
8083 * [I] pt : coordinate
8089 static BOOL
LISTVIEW_SetItemPosition(LISTVIEW_INFO
*infoPtr
, INT nItem
, POINT pt
)
8093 TRACE("(nItem=%d, &pt=%s\n", nItem
, wine_dbgstr_point(&pt
));
8095 if (nItem
< 0 || nItem
>= infoPtr
->nItemCount
||
8096 !(infoPtr
->uView
== LV_VIEW_ICON
|| infoPtr
->uView
== LV_VIEW_SMALLICON
)) return FALSE
;
8098 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
8100 /* This point value seems to be an undocumented feature.
8101 * The best guess is that it means either at the origin,
8102 * or at true beginning of the list. I will assume the origin. */
8103 if ((pt
.x
== -1) && (pt
.y
== -1))
8106 if (infoPtr
->uView
== LV_VIEW_ICON
)
8108 pt
.x
-= (infoPtr
->nItemWidth
- infoPtr
->iconSize
.cx
) / 2;
8109 pt
.y
-= ICON_TOP_PADDING
;
8114 infoPtr
->bAutoarrange
= FALSE
;
8116 return LISTVIEW_MoveIconTo(infoPtr
, nItem
, &pt
, FALSE
);
8121 * Sets the state of one or many items.
8124 * [I] infoPtr : valid pointer to the listview structure
8125 * [I] nItem : item index
8126 * [I] lpLVItem : item or subitem info
8132 static BOOL
LISTVIEW_SetItemState(LISTVIEW_INFO
*infoPtr
, INT nItem
, const LVITEMW
*lpLVItem
)
8134 BOOL bResult
= TRUE
;
8137 lvItem
.iItem
= nItem
;
8138 lvItem
.iSubItem
= 0;
8139 lvItem
.mask
= LVIF_STATE
;
8140 lvItem
.state
= lpLVItem
->state
;
8141 lvItem
.stateMask
= lpLVItem
->stateMask
;
8142 TRACE("lvItem=%s\n", debuglvitem_t(&lvItem
, TRUE
));
8146 /* select all isn't allowed in LVS_SINGLESEL */
8147 if ((lvItem
.state
& lvItem
.stateMask
& LVIS_SELECTED
) && (infoPtr
->dwStyle
& LVS_SINGLESEL
))
8150 /* focus all isn't allowed */
8151 if (lvItem
.state
& lvItem
.stateMask
& LVIS_FOCUSED
) return FALSE
;
8153 /* apply to all items */
8154 for (lvItem
.iItem
= 0; lvItem
.iItem
< infoPtr
->nItemCount
; lvItem
.iItem
++)
8155 if (!LISTVIEW_SetItemT(infoPtr
, &lvItem
, TRUE
)) bResult
= FALSE
;
8158 bResult
= LISTVIEW_SetItemT(infoPtr
, &lvItem
, TRUE
);
8165 * Sets the text of an item or subitem.
8168 * [I] hwnd : window handle
8169 * [I] nItem : item index
8170 * [I] lpLVItem : item or subitem info
8171 * [I] isW : TRUE if input is Unicode
8177 static BOOL
LISTVIEW_SetItemTextT(LISTVIEW_INFO
*infoPtr
, INT nItem
, const LVITEMW
*lpLVItem
, BOOL isW
)
8181 if (nItem
< 0 && nItem
>= infoPtr
->nItemCount
) return FALSE
;
8183 lvItem
.iItem
= nItem
;
8184 lvItem
.iSubItem
= lpLVItem
->iSubItem
;
8185 lvItem
.mask
= LVIF_TEXT
;
8186 lvItem
.pszText
= lpLVItem
->pszText
;
8187 lvItem
.cchTextMax
= lpLVItem
->cchTextMax
;
8189 TRACE("(nItem=%d, lpLVItem=%s, isW=%d)\n", nItem
, debuglvitem_t(&lvItem
, isW
), isW
);
8191 return LISTVIEW_SetItemT(infoPtr
, &lvItem
, isW
);
8196 * Set item index that marks the start of a multiple selection.
8199 * [I] infoPtr : valid pointer to the listview structure
8200 * [I] nIndex : index
8203 * Index number or -1 if there is no selection mark.
8205 static INT
LISTVIEW_SetSelectionMark(LISTVIEW_INFO
*infoPtr
, INT nIndex
)
8207 INT nOldIndex
= infoPtr
->nSelectionMark
;
8209 TRACE("(nIndex=%d)\n", nIndex
);
8211 infoPtr
->nSelectionMark
= nIndex
;
8218 * Sets the text background color.
8221 * [I] infoPtr : valid pointer to the listview structure
8222 * [I] clrTextBk : text background color
8228 static BOOL
LISTVIEW_SetTextBkColor(LISTVIEW_INFO
*infoPtr
, COLORREF clrTextBk
)
8230 TRACE("(clrTextBk=%x)\n", clrTextBk
);
8232 if (infoPtr
->clrTextBk
!= clrTextBk
)
8234 infoPtr
->clrTextBk
= clrTextBk
;
8235 LISTVIEW_InvalidateList(infoPtr
);
8243 * Sets the text foreground color.
8246 * [I] infoPtr : valid pointer to the listview structure
8247 * [I] clrText : text color
8253 static BOOL
LISTVIEW_SetTextColor (LISTVIEW_INFO
*infoPtr
, COLORREF clrText
)
8255 TRACE("(clrText=%x)\n", clrText
);
8257 if (infoPtr
->clrText
!= clrText
)
8259 infoPtr
->clrText
= clrText
;
8260 LISTVIEW_InvalidateList(infoPtr
);
8268 * Sets new ToolTip window to ListView control.
8271 * [I] infoPtr : valid pointer to the listview structure
8272 * [I] hwndNewToolTip : handle to new ToolTip
8277 static HWND
LISTVIEW_SetToolTips( LISTVIEW_INFO
*infoPtr
, HWND hwndNewToolTip
)
8279 HWND hwndOldToolTip
= infoPtr
->hwndToolTip
;
8280 infoPtr
->hwndToolTip
= hwndNewToolTip
;
8281 return hwndOldToolTip
;
8286 * sets the Unicode character format flag for the control
8288 * [I] infoPtr :valid pointer to the listview structure
8289 * [I] fUnicode :true to switch to UNICODE false to switch to ANSI
8292 * Old Unicode Format
8294 static BOOL
LISTVIEW_SetUnicodeFormat( LISTVIEW_INFO
*infoPtr
, BOOL fUnicode
)
8296 SHORT rc
= infoPtr
->notifyFormat
;
8297 infoPtr
->notifyFormat
= (fUnicode
) ? NFR_UNICODE
: NFR_ANSI
;
8298 return rc
== NFR_UNICODE
;
8303 * sets the control view mode
8305 * [I] infoPtr :valid pointer to the listview structure
8306 * [I] nView :new view mode value
8312 static INT
LISTVIEW_SetView(LISTVIEW_INFO
*infoPtr
, DWORD nView
)
8314 SIZE oldIconSize
= infoPtr
->iconSize
;
8317 if (infoPtr
->uView
== nView
) return 1;
8319 if ((INT
)nView
< 0 || nView
> LV_VIEW_MAX
) return -1;
8320 if (nView
== LV_VIEW_TILE
)
8322 FIXME("View LV_VIEW_TILE unimplemented\n");
8326 infoPtr
->uView
= nView
;
8328 SendMessageW(infoPtr
->hwndEdit
, WM_KILLFOCUS
, 0, 0);
8329 ShowWindow(infoPtr
->hwndHeader
, SW_HIDE
);
8331 ShowScrollBar(infoPtr
->hwndSelf
, SB_BOTH
, FALSE
);
8332 SetRectEmpty(&infoPtr
->rcFocus
);
8334 himl
= (nView
== LV_VIEW_ICON
? infoPtr
->himlNormal
: infoPtr
->himlSmall
);
8335 set_icon_size(&infoPtr
->iconSize
, himl
, nView
!= LV_VIEW_ICON
);
8340 if ((infoPtr
->iconSize
.cx
!= oldIconSize
.cx
) || (infoPtr
->iconSize
.cy
!= oldIconSize
.cy
))
8342 TRACE("icon old size=(%d,%d), new size=(%d,%d)\n",
8343 oldIconSize
.cx
, oldIconSize
.cy
, infoPtr
->iconSize
.cx
, infoPtr
->iconSize
.cy
);
8344 LISTVIEW_SetIconSpacing(infoPtr
, 0, 0);
8346 LISTVIEW_Arrange(infoPtr
, LVA_DEFAULT
);
8348 case LV_VIEW_SMALLICON
:
8349 LISTVIEW_Arrange(infoPtr
, LVA_DEFAULT
);
8351 case LV_VIEW_DETAILS
:
8356 LISTVIEW_CreateHeader( infoPtr
);
8358 hl
.prc
= &infoPtr
->rcList
;
8360 SendMessageW(infoPtr
->hwndHeader
, HDM_LAYOUT
, 0, (LPARAM
)&hl
);
8361 SetWindowPos(infoPtr
->hwndHeader
, infoPtr
->hwndSelf
, wp
.x
, wp
.y
, wp
.cx
, wp
.cy
,
8362 wp
.flags
| ((infoPtr
->dwStyle
& LVS_NOCOLUMNHEADER
) ? SWP_HIDEWINDOW
: SWP_SHOWWINDOW
));
8369 LISTVIEW_UpdateItemSize(infoPtr
);
8370 LISTVIEW_UpdateSize(infoPtr
);
8371 LISTVIEW_UpdateScroll(infoPtr
);
8372 LISTVIEW_InvalidateList(infoPtr
);
8374 TRACE("nView=%d\n", nView
);
8379 /* LISTVIEW_SetWorkAreas */
8383 * Callback internally used by LISTVIEW_SortItems() in response of LVM_SORTITEMS
8386 * [I] first : pointer to first ITEM_INFO to compare
8387 * [I] second : pointer to second ITEM_INFO to compare
8388 * [I] lParam : HWND of control
8391 * if first comes before second : negative
8392 * if first comes after second : positive
8393 * if first and second are equivalent : zero
8395 static INT WINAPI
LISTVIEW_CallBackCompare(LPVOID first
, LPVOID second
, LPARAM lParam
)
8397 LISTVIEW_INFO
*infoPtr
= (LISTVIEW_INFO
*)lParam
;
8398 ITEM_INFO
* lv_first
= DPA_GetPtr( first
, 0 );
8399 ITEM_INFO
* lv_second
= DPA_GetPtr( second
, 0 );
8401 /* Forward the call to the client defined callback */
8402 return (infoPtr
->pfnCompare
)( lv_first
->lParam
, lv_second
->lParam
, infoPtr
->lParamSort
);
8407 * Callback internally used by LISTVIEW_SortItems() in response of LVM_SORTITEMSEX
8410 * [I] first : pointer to first ITEM_INFO to compare
8411 * [I] second : pointer to second ITEM_INFO to compare
8412 * [I] lParam : HWND of control
8415 * if first comes before second : negative
8416 * if first comes after second : positive
8417 * if first and second are equivalent : zero
8419 static INT WINAPI
LISTVIEW_CallBackCompareEx(LPVOID first
, LPVOID second
, LPARAM lParam
)
8421 LISTVIEW_INFO
*infoPtr
= (LISTVIEW_INFO
*)lParam
;
8422 INT first_idx
= DPA_GetPtrIndex( infoPtr
->hdpaItems
, first
);
8423 INT second_idx
= DPA_GetPtrIndex( infoPtr
->hdpaItems
, second
);
8425 /* Forward the call to the client defined callback */
8426 return (infoPtr
->pfnCompare
)( first_idx
, second_idx
, infoPtr
->lParamSort
);
8431 * Sorts the listview items.
8434 * [I] infoPtr : valid pointer to the listview structure
8435 * [I] pfnCompare : application-defined value
8436 * [I] lParamSort : pointer to comparison callback
8437 * [I] IsEx : TRUE when LVM_SORTITEMSEX used
8443 static BOOL
LISTVIEW_SortItems(LISTVIEW_INFO
*infoPtr
, PFNLVCOMPARE pfnCompare
,
8444 LPARAM lParamSort
, BOOL IsEx
)
8448 LPVOID selectionMarkItem
= NULL
;
8449 LPVOID focusedItem
= NULL
;
8452 TRACE("(pfnCompare=%p, lParamSort=%lx)\n", pfnCompare
, lParamSort
);
8454 if (infoPtr
->dwStyle
& LVS_OWNERDATA
) return FALSE
;
8456 if (!pfnCompare
) return FALSE
;
8457 if (!infoPtr
->hdpaItems
) return FALSE
;
8459 /* if there are 0 or 1 items, there is no need to sort */
8460 if (infoPtr
->nItemCount
< 2) return TRUE
;
8462 /* clear selection */
8463 ranges_clear(infoPtr
->selectionRanges
);
8465 /* save selection mark and focused item */
8466 if (infoPtr
->nSelectionMark
>= 0)
8467 selectionMarkItem
= DPA_GetPtr(infoPtr
->hdpaItems
, infoPtr
->nSelectionMark
);
8468 if (infoPtr
->nFocusedItem
>= 0)
8469 focusedItem
= DPA_GetPtr(infoPtr
->hdpaItems
, infoPtr
->nFocusedItem
);
8471 infoPtr
->pfnCompare
= pfnCompare
;
8472 infoPtr
->lParamSort
= lParamSort
;
8474 DPA_Sort(infoPtr
->hdpaItems
, LISTVIEW_CallBackCompareEx
, (LPARAM
)infoPtr
);
8476 DPA_Sort(infoPtr
->hdpaItems
, LISTVIEW_CallBackCompare
, (LPARAM
)infoPtr
);
8478 /* restore selection ranges */
8479 for (i
=0; i
< infoPtr
->nItemCount
; i
++)
8481 hdpaSubItems
= DPA_GetPtr(infoPtr
->hdpaItems
, i
);
8482 lpItem
= DPA_GetPtr(hdpaSubItems
, 0);
8484 if (lpItem
->state
& LVIS_SELECTED
)
8485 ranges_additem(infoPtr
->selectionRanges
, i
);
8487 /* restore selection mark and focused item */
8488 infoPtr
->nSelectionMark
= DPA_GetPtrIndex(infoPtr
->hdpaItems
, selectionMarkItem
);
8489 infoPtr
->nFocusedItem
= DPA_GetPtrIndex(infoPtr
->hdpaItems
, focusedItem
);
8491 /* I believe nHotItem should be left alone, see LISTVIEW_ShiftIndices */
8493 /* refresh the display */
8494 if (infoPtr
->uView
!= LV_VIEW_ICON
&& infoPtr
->uView
!= LV_VIEW_SMALLICON
)
8495 LISTVIEW_InvalidateList(infoPtr
);
8502 * Update theme handle after a theme change.
8505 * [I] infoPtr : valid pointer to the listview structure
8509 * FAILURE : something else
8511 static LRESULT
LISTVIEW_ThemeChanged(const LISTVIEW_INFO
*infoPtr
)
8513 HTHEME theme
= GetWindowTheme(infoPtr
->hwndSelf
);
8514 CloseThemeData(theme
);
8515 OpenThemeData(infoPtr
->hwndSelf
, themeClass
);
8521 * Updates an items or rearranges the listview control.
8524 * [I] infoPtr : valid pointer to the listview structure
8525 * [I] nItem : item index
8531 static BOOL
LISTVIEW_Update(LISTVIEW_INFO
*infoPtr
, INT nItem
)
8533 TRACE("(nItem=%d)\n", nItem
);
8535 if (nItem
< 0 || nItem
>= infoPtr
->nItemCount
) return FALSE
;
8537 /* rearrange with default alignment style */
8538 if (is_autoarrange(infoPtr
))
8539 LISTVIEW_Arrange(infoPtr
, LVA_DEFAULT
);
8541 LISTVIEW_InvalidateItem(infoPtr
, nItem
);
8548 * Draw the track line at the place defined in the infoPtr structure.
8549 * The line is drawn with a XOR pen so drawing the line for the second time
8550 * in the same place erases the line.
8553 * [I] infoPtr : valid pointer to the listview structure
8559 static BOOL
LISTVIEW_DrawTrackLine(const LISTVIEW_INFO
*infoPtr
)
8565 if (infoPtr
->xTrackLine
== -1)
8568 if (!(hdc
= GetDC(infoPtr
->hwndSelf
)))
8570 hOldPen
= SelectObject(hdc
, GetStockObject(BLACK_PEN
));
8571 oldROP
= SetROP2(hdc
, R2_XORPEN
);
8572 MoveToEx(hdc
, infoPtr
->xTrackLine
, infoPtr
->rcList
.top
, NULL
);
8573 LineTo(hdc
, infoPtr
->xTrackLine
, infoPtr
->rcList
.bottom
);
8574 SetROP2(hdc
, oldROP
);
8575 SelectObject(hdc
, hOldPen
);
8576 ReleaseDC(infoPtr
->hwndSelf
, hdc
);
8582 * Called when an edit control should be displayed. This function is called after
8583 * we are sure that there was a single click - not a double click (this is a TIMERPROC).
8586 * [I] hwnd : Handle to the listview
8587 * [I] uMsg : WM_TIMER (ignored)
8588 * [I] idEvent : The timer ID interpreted as a pointer to a DELAYED_EDIT_ITEM struct
8589 * [I] dwTimer : The elapsed time (ignored)
8594 static VOID CALLBACK
LISTVIEW_DelayedEditItem(HWND hwnd
, UINT uMsg
, UINT_PTR idEvent
, DWORD dwTime
)
8596 DELAYED_ITEM_EDIT
*editItem
= (DELAYED_ITEM_EDIT
*)idEvent
;
8597 LISTVIEW_INFO
*infoPtr
= (LISTVIEW_INFO
*)GetWindowLongPtrW(hwnd
, 0);
8599 KillTimer(hwnd
, idEvent
);
8600 editItem
->fEnabled
= FALSE
;
8601 /* check if the item is still selected */
8602 if (infoPtr
->bFocus
&& LISTVIEW_GetItemState(infoPtr
, editItem
->iItem
, LVIS_SELECTED
))
8603 LISTVIEW_EditLabelT(infoPtr
, editItem
->iItem
, TRUE
);
8608 * Creates the listview control - the WM_NCCREATE phase.
8611 * [I] hwnd : window handle
8612 * [I] lpcs : the create parameters
8618 static LRESULT
LISTVIEW_NCCreate(HWND hwnd
, const CREATESTRUCTW
*lpcs
)
8620 LISTVIEW_INFO
*infoPtr
;
8623 TRACE("(lpcs=%p)\n", lpcs
);
8625 /* initialize info pointer */
8626 infoPtr
= Alloc(sizeof(LISTVIEW_INFO
));
8627 if (!infoPtr
) return FALSE
;
8629 SetWindowLongPtrW(hwnd
, 0, (DWORD_PTR
)infoPtr
);
8631 infoPtr
->hwndSelf
= hwnd
;
8632 infoPtr
->dwStyle
= lpcs
->style
; /* Note: may be changed in WM_CREATE */
8633 map_style_view(infoPtr
);
8634 /* determine the type of structures to use */
8635 infoPtr
->hwndNotify
= lpcs
->hwndParent
;
8636 /* infoPtr->notifyFormat will be filled in WM_CREATE */
8638 /* initialize color information */
8639 infoPtr
->clrBk
= CLR_NONE
;
8640 infoPtr
->clrText
= CLR_DEFAULT
;
8641 infoPtr
->clrTextBk
= CLR_DEFAULT
;
8642 LISTVIEW_SetBkColor(infoPtr
, comctl32_color
.clrWindow
);
8644 /* set default values */
8645 infoPtr
->nFocusedItem
= -1;
8646 infoPtr
->nSelectionMark
= -1;
8647 infoPtr
->nHotItem
= -1;
8648 infoPtr
->bRedraw
= TRUE
;
8649 infoPtr
->bNoItemMetrics
= TRUE
;
8650 infoPtr
->bDoChangeNotify
= TRUE
;
8651 infoPtr
->iconSpacing
.cx
= GetSystemMetrics(SM_CXICONSPACING
);
8652 infoPtr
->iconSpacing
.cy
= GetSystemMetrics(SM_CYICONSPACING
);
8653 infoPtr
->nEditLabelItem
= -1;
8654 infoPtr
->nLButtonDownItem
= -1;
8655 infoPtr
->dwHoverTime
= -1; /* default system hover time */
8656 infoPtr
->nMeasureItemHeight
= 0;
8657 infoPtr
->xTrackLine
= -1; /* no track line */
8658 infoPtr
->itemEdit
.fEnabled
= FALSE
;
8659 infoPtr
->iVersion
= COMCTL32_VERSION
;
8660 infoPtr
->colRectsDirty
= FALSE
;
8662 /* get default font (icon title) */
8663 SystemParametersInfoW(SPI_GETICONTITLELOGFONT
, 0, &logFont
, 0);
8664 infoPtr
->hDefaultFont
= CreateFontIndirectW(&logFont
);
8665 infoPtr
->hFont
= infoPtr
->hDefaultFont
;
8666 LISTVIEW_SaveTextMetrics(infoPtr
);
8668 /* allocate memory for the data structure */
8669 if (!(infoPtr
->selectionRanges
= ranges_create(10))) goto fail
;
8670 if (!(infoPtr
->hdpaItems
= DPA_Create(10))) goto fail
;
8671 if (!(infoPtr
->hdpaItemIds
= DPA_Create(10))) goto fail
;
8672 if (!(infoPtr
->hdpaPosX
= DPA_Create(10))) goto fail
;
8673 if (!(infoPtr
->hdpaPosY
= DPA_Create(10))) goto fail
;
8674 if (!(infoPtr
->hdpaColumns
= DPA_Create(10))) goto fail
;
8678 DestroyWindow(infoPtr
->hwndHeader
);
8679 ranges_destroy(infoPtr
->selectionRanges
);
8680 DPA_Destroy(infoPtr
->hdpaItems
);
8681 DPA_Destroy(infoPtr
->hdpaItemIds
);
8682 DPA_Destroy(infoPtr
->hdpaPosX
);
8683 DPA_Destroy(infoPtr
->hdpaPosY
);
8684 DPA_Destroy(infoPtr
->hdpaColumns
);
8691 * Creates the listview control - the WM_CREATE phase. Most of the data is
8692 * already set up in LISTVIEW_NCCreate
8695 * [I] hwnd : window handle
8696 * [I] lpcs : the create parameters
8702 static LRESULT
LISTVIEW_Create(HWND hwnd
, const CREATESTRUCTW
*lpcs
)
8704 LISTVIEW_INFO
*infoPtr
= (LISTVIEW_INFO
*)GetWindowLongPtrW(hwnd
, 0);
8706 TRACE("(lpcs=%p)\n", lpcs
);
8708 infoPtr
->dwStyle
= lpcs
->style
;
8709 map_style_view(infoPtr
);
8711 infoPtr
->notifyFormat
= SendMessageW(infoPtr
->hwndNotify
, WM_NOTIFYFORMAT
,
8712 (WPARAM
)infoPtr
->hwndSelf
, (LPARAM
)NF_QUERY
);
8713 /* on error defaulting to ANSI notifications */
8714 if (infoPtr
->notifyFormat
== 0) infoPtr
->notifyFormat
= NFR_ANSI
;
8716 if ((infoPtr
->uView
== LV_VIEW_DETAILS
) && (lpcs
->style
& WS_VISIBLE
))
8718 if (LISTVIEW_CreateHeader(infoPtr
) < 0) return -1;
8721 infoPtr
->hwndHeader
= 0;
8723 /* init item size to avoid division by 0 */
8724 LISTVIEW_UpdateItemSize (infoPtr
);
8726 if (infoPtr
->uView
== LV_VIEW_DETAILS
)
8728 if (!(LVS_NOCOLUMNHEADER
& lpcs
->style
) && (WS_VISIBLE
& lpcs
->style
))
8730 ShowWindow(infoPtr
->hwndHeader
, SW_SHOWNORMAL
);
8732 LISTVIEW_UpdateScroll(infoPtr
);
8733 /* send WM_MEASUREITEM notification */
8734 if (infoPtr
->dwStyle
& LVS_OWNERDRAWFIXED
) notify_measureitem(infoPtr
);
8737 OpenThemeData(hwnd
, themeClass
);
8739 /* initialize the icon sizes */
8740 set_icon_size(&infoPtr
->iconSize
, infoPtr
->himlNormal
, infoPtr
->uView
!= LV_VIEW_ICON
);
8741 set_icon_size(&infoPtr
->iconStateSize
, infoPtr
->himlState
, TRUE
);
8747 * Destroys the listview control.
8750 * [I] infoPtr : valid pointer to the listview structure
8756 static LRESULT
LISTVIEW_Destroy(const LISTVIEW_INFO
*infoPtr
)
8758 HTHEME theme
= GetWindowTheme(infoPtr
->hwndSelf
);
8759 CloseThemeData(theme
);
8765 * Enables the listview control.
8768 * [I] infoPtr : valid pointer to the listview structure
8769 * [I] bEnable : specifies whether to enable or disable the window
8775 static BOOL
LISTVIEW_Enable(const LISTVIEW_INFO
*infoPtr
, BOOL bEnable
)
8777 if (infoPtr
->dwStyle
& LVS_OWNERDRAWFIXED
)
8778 InvalidateRect(infoPtr
->hwndSelf
, NULL
, TRUE
);
8784 * Erases the background of the listview control.
8787 * [I] infoPtr : valid pointer to the listview structure
8788 * [I] hdc : device context handle
8794 static inline BOOL
LISTVIEW_EraseBkgnd(const LISTVIEW_INFO
*infoPtr
, HDC hdc
)
8798 TRACE("(hdc=%p)\n", hdc
);
8800 if (!GetClipBox(hdc
, &rc
)) return FALSE
;
8802 if (infoPtr
->clrBk
== CLR_NONE
)
8803 return SendMessageW(infoPtr
->hwndNotify
, WM_ERASEBKGND
, (WPARAM
)hdc
, 0);
8805 /* for double buffered controls we need to do this during refresh */
8806 if (infoPtr
->dwLvExStyle
& LVS_EX_DOUBLEBUFFER
) return FALSE
;
8808 return LISTVIEW_FillBkgnd(infoPtr
, hdc
, &rc
);
8814 * Helper function for LISTVIEW_[HV]Scroll *only*.
8815 * Performs vertical/horizontal scrolling by a give amount.
8818 * [I] infoPtr : valid pointer to the listview structure
8819 * [I] dx : amount of horizontal scroll
8820 * [I] dy : amount of vertical scroll
8822 static void scroll_list(LISTVIEW_INFO
*infoPtr
, INT dx
, INT dy
)
8824 /* now we can scroll the list */
8825 ScrollWindowEx(infoPtr
->hwndSelf
, dx
, dy
, &infoPtr
->rcList
,
8826 &infoPtr
->rcList
, 0, 0, SW_ERASE
| SW_INVALIDATE
);
8827 /* if we have focus, adjust rect */
8828 OffsetRect(&infoPtr
->rcFocus
, dx
, dy
);
8829 UpdateWindow(infoPtr
->hwndSelf
);
8834 * Performs vertical scrolling.
8837 * [I] infoPtr : valid pointer to the listview structure
8838 * [I] nScrollCode : scroll code
8839 * [I] nScrollDiff : units to scroll in SB_INTERNAL mode, 0 otherwise
8840 * [I] hScrollWnd : scrollbar control window handle
8846 * SB_LINEUP/SB_LINEDOWN:
8847 * for LVS_ICON, LVS_SMALLICON is 37 by experiment
8848 * for LVS_REPORT is 1 line
8849 * for LVS_LIST cannot occur
8852 static LRESULT
LISTVIEW_VScroll(LISTVIEW_INFO
*infoPtr
, INT nScrollCode
,
8853 INT nScrollDiff
, HWND hScrollWnd
)
8855 INT nOldScrollPos
, nNewScrollPos
;
8856 SCROLLINFO scrollInfo
;
8859 TRACE("(nScrollCode=%d(%s), nScrollDiff=%d)\n", nScrollCode
,
8860 debugscrollcode(nScrollCode
), nScrollDiff
);
8862 if (infoPtr
->hwndEdit
) SendMessageW(infoPtr
->hwndEdit
, WM_KILLFOCUS
, 0, 0);
8864 scrollInfo
.cbSize
= sizeof(SCROLLINFO
);
8865 scrollInfo
.fMask
= SIF_PAGE
| SIF_POS
| SIF_RANGE
| SIF_TRACKPOS
;
8867 is_an_icon
= ((infoPtr
->uView
== LV_VIEW_ICON
) || (infoPtr
->uView
== LV_VIEW_SMALLICON
));
8869 if (!GetScrollInfo(infoPtr
->hwndSelf
, SB_VERT
, &scrollInfo
)) return 1;
8871 nOldScrollPos
= scrollInfo
.nPos
;
8872 switch (nScrollCode
)
8878 nScrollDiff
= (is_an_icon
) ? -LISTVIEW_SCROLL_ICON_LINE_SIZE
: -1;
8882 nScrollDiff
= (is_an_icon
) ? LISTVIEW_SCROLL_ICON_LINE_SIZE
: 1;
8886 nScrollDiff
= -scrollInfo
.nPage
;
8890 nScrollDiff
= scrollInfo
.nPage
;
8893 case SB_THUMBPOSITION
:
8895 nScrollDiff
= scrollInfo
.nTrackPos
- scrollInfo
.nPos
;
8902 /* quit right away if pos isn't changing */
8903 if (nScrollDiff
== 0) return 0;
8905 /* calculate new position, and handle overflows */
8906 nNewScrollPos
= scrollInfo
.nPos
+ nScrollDiff
;
8907 if (nScrollDiff
> 0) {
8908 if (nNewScrollPos
< nOldScrollPos
||
8909 nNewScrollPos
> scrollInfo
.nMax
)
8910 nNewScrollPos
= scrollInfo
.nMax
;
8912 if (nNewScrollPos
> nOldScrollPos
||
8913 nNewScrollPos
< scrollInfo
.nMin
)
8914 nNewScrollPos
= scrollInfo
.nMin
;
8917 /* set the new position, and reread in case it changed */
8918 scrollInfo
.fMask
= SIF_POS
;
8919 scrollInfo
.nPos
= nNewScrollPos
;
8920 nNewScrollPos
= SetScrollInfo(infoPtr
->hwndSelf
, SB_VERT
, &scrollInfo
, TRUE
);
8922 /* carry on only if it really changed */
8923 if (nNewScrollPos
== nOldScrollPos
) return 0;
8925 /* now adjust to client coordinates */
8926 nScrollDiff
= nOldScrollPos
- nNewScrollPos
;
8927 if (infoPtr
->uView
== LV_VIEW_DETAILS
) nScrollDiff
*= infoPtr
->nItemHeight
;
8929 /* and scroll the window */
8930 scroll_list(infoPtr
, 0, nScrollDiff
);
8937 * Performs horizontal scrolling.
8940 * [I] infoPtr : valid pointer to the listview structure
8941 * [I] nScrollCode : scroll code
8942 * [I] nScrollDiff : units to scroll in SB_INTERNAL mode, 0 otherwise
8943 * [I] hScrollWnd : scrollbar control window handle
8949 * SB_LINELEFT/SB_LINERIGHT:
8950 * for LVS_ICON, LVS_SMALLICON 1 pixel
8951 * for LVS_REPORT is 1 pixel
8952 * for LVS_LIST is 1 column --> which is a 1 because the
8953 * scroll is based on columns not pixels
8956 static LRESULT
LISTVIEW_HScroll(LISTVIEW_INFO
*infoPtr
, INT nScrollCode
,
8957 INT nScrollDiff
, HWND hScrollWnd
)
8959 INT nOldScrollPos
, nNewScrollPos
;
8960 SCROLLINFO scrollInfo
;
8962 TRACE("(nScrollCode=%d(%s), nScrollDiff=%d)\n", nScrollCode
,
8963 debugscrollcode(nScrollCode
), nScrollDiff
);
8965 if (infoPtr
->hwndEdit
) SendMessageW(infoPtr
->hwndEdit
, WM_KILLFOCUS
, 0, 0);
8967 scrollInfo
.cbSize
= sizeof(SCROLLINFO
);
8968 scrollInfo
.fMask
= SIF_PAGE
| SIF_POS
| SIF_RANGE
| SIF_TRACKPOS
;
8970 if (!GetScrollInfo(infoPtr
->hwndSelf
, SB_HORZ
, &scrollInfo
)) return 1;
8972 nOldScrollPos
= scrollInfo
.nPos
;
8974 switch (nScrollCode
)
8988 nScrollDiff
= -scrollInfo
.nPage
;
8992 nScrollDiff
= scrollInfo
.nPage
;
8995 case SB_THUMBPOSITION
:
8997 nScrollDiff
= scrollInfo
.nTrackPos
- scrollInfo
.nPos
;
9004 /* quit right away if pos isn't changing */
9005 if (nScrollDiff
== 0) return 0;
9007 /* calculate new position, and handle overflows */
9008 nNewScrollPos
= scrollInfo
.nPos
+ nScrollDiff
;
9009 if (nScrollDiff
> 0) {
9010 if (nNewScrollPos
< nOldScrollPos
||
9011 nNewScrollPos
> scrollInfo
.nMax
)
9012 nNewScrollPos
= scrollInfo
.nMax
;
9014 if (nNewScrollPos
> nOldScrollPos
||
9015 nNewScrollPos
< scrollInfo
.nMin
)
9016 nNewScrollPos
= scrollInfo
.nMin
;
9019 /* set the new position, and reread in case it changed */
9020 scrollInfo
.fMask
= SIF_POS
;
9021 scrollInfo
.nPos
= nNewScrollPos
;
9022 nNewScrollPos
= SetScrollInfo(infoPtr
->hwndSelf
, SB_HORZ
, &scrollInfo
, TRUE
);
9024 /* carry on only if it really changed */
9025 if (nNewScrollPos
== nOldScrollPos
) return 0;
9027 if (infoPtr
->uView
== LV_VIEW_DETAILS
)
9028 LISTVIEW_UpdateHeaderSize(infoPtr
, nNewScrollPos
);
9030 /* now adjust to client coordinates */
9031 nScrollDiff
= nOldScrollPos
- nNewScrollPos
;
9032 if (infoPtr
->uView
== LV_VIEW_LIST
) nScrollDiff
*= infoPtr
->nItemWidth
;
9034 /* and scroll the window */
9035 scroll_list(infoPtr
, nScrollDiff
, 0);
9040 static LRESULT
LISTVIEW_MouseWheel(LISTVIEW_INFO
*infoPtr
, INT wheelDelta
)
9042 INT gcWheelDelta
= 0;
9043 INT pulScrollLines
= 3;
9044 SCROLLINFO scrollInfo
;
9046 TRACE("(wheelDelta=%d)\n", wheelDelta
);
9048 SystemParametersInfoW(SPI_GETWHEELSCROLLLINES
,0, &pulScrollLines
, 0);
9049 gcWheelDelta
-= wheelDelta
;
9051 scrollInfo
.cbSize
= sizeof(SCROLLINFO
);
9052 scrollInfo
.fMask
= SIF_POS
;
9054 switch(infoPtr
->uView
)
9057 case LV_VIEW_SMALLICON
:
9059 * listview should be scrolled by a multiple of 37 dependently on its dimension or its visible item number
9060 * should be fixed in the future.
9062 LISTVIEW_VScroll(infoPtr
, SB_INTERNAL
, (gcWheelDelta
< 0) ?
9063 -LISTVIEW_SCROLL_ICON_LINE_SIZE
: LISTVIEW_SCROLL_ICON_LINE_SIZE
, 0);
9066 case LV_VIEW_DETAILS
:
9067 if (abs(gcWheelDelta
) >= WHEEL_DELTA
&& pulScrollLines
)
9069 int cLineScroll
= min(LISTVIEW_GetCountPerColumn(infoPtr
), pulScrollLines
);
9070 cLineScroll
*= (gcWheelDelta
/ WHEEL_DELTA
);
9071 LISTVIEW_VScroll(infoPtr
, SB_INTERNAL
, cLineScroll
, 0);
9076 LISTVIEW_HScroll(infoPtr
, (gcWheelDelta
< 0) ? SB_LINELEFT
: SB_LINERIGHT
, 0, 0);
9087 * [I] infoPtr : valid pointer to the listview structure
9088 * [I] nVirtualKey : virtual key
9089 * [I] lKeyData : key data
9094 static LRESULT
LISTVIEW_KeyDown(LISTVIEW_INFO
*infoPtr
, INT nVirtualKey
, LONG lKeyData
)
9096 HWND hwndSelf
= infoPtr
->hwndSelf
;
9098 NMLVKEYDOWN nmKeyDown
;
9100 TRACE("(nVirtualKey=%d, lKeyData=%d)\n", nVirtualKey
, lKeyData
);
9102 /* send LVN_KEYDOWN notification */
9103 nmKeyDown
.wVKey
= nVirtualKey
;
9104 nmKeyDown
.flags
= 0;
9105 notify_hdr(infoPtr
, LVN_KEYDOWN
, &nmKeyDown
.hdr
);
9106 if (!IsWindow(hwndSelf
))
9109 switch (nVirtualKey
)
9112 nItem
= infoPtr
->nFocusedItem
;
9113 if (infoPtr
->dwLvExStyle
& LVS_EX_CHECKBOXES
)
9114 toggle_checkbox_state(infoPtr
, infoPtr
->nFocusedItem
);
9118 if ((infoPtr
->nItemCount
> 0) && (infoPtr
->nFocusedItem
!= -1))
9120 if (!notify(infoPtr
, NM_RETURN
)) return 0;
9121 if (!notify(infoPtr
, LVN_ITEMACTIVATE
)) return 0;
9126 if (infoPtr
->nItemCount
> 0)
9131 if (infoPtr
->nItemCount
> 0)
9132 nItem
= infoPtr
->nItemCount
- 1;
9136 nItem
= LISTVIEW_GetNextItem(infoPtr
, infoPtr
->nFocusedItem
, LVNI_TOLEFT
);
9140 nItem
= LISTVIEW_GetNextItem(infoPtr
, infoPtr
->nFocusedItem
, LVNI_ABOVE
);
9144 nItem
= LISTVIEW_GetNextItem(infoPtr
, infoPtr
->nFocusedItem
, LVNI_TORIGHT
);
9148 nItem
= LISTVIEW_GetNextItem(infoPtr
, infoPtr
->nFocusedItem
, LVNI_BELOW
);
9152 if (infoPtr
->uView
== LV_VIEW_DETAILS
)
9154 INT topidx
= LISTVIEW_GetTopIndex(infoPtr
);
9155 if (infoPtr
->nFocusedItem
== topidx
)
9156 nItem
= topidx
- LISTVIEW_GetCountPerColumn(infoPtr
) + 1;
9161 nItem
= infoPtr
->nFocusedItem
- LISTVIEW_GetCountPerColumn(infoPtr
)
9162 * LISTVIEW_GetCountPerRow(infoPtr
);
9163 if(nItem
< 0) nItem
= 0;
9167 if (infoPtr
->uView
== LV_VIEW_DETAILS
)
9169 INT topidx
= LISTVIEW_GetTopIndex(infoPtr
);
9170 INT cnt
= LISTVIEW_GetCountPerColumn(infoPtr
);
9171 if (infoPtr
->nFocusedItem
== topidx
+ cnt
- 1)
9172 nItem
= infoPtr
->nFocusedItem
+ cnt
- 1;
9174 nItem
= topidx
+ cnt
- 1;
9177 nItem
= infoPtr
->nFocusedItem
+ LISTVIEW_GetCountPerColumn(infoPtr
)
9178 * LISTVIEW_GetCountPerRow(infoPtr
);
9179 if(nItem
>= infoPtr
->nItemCount
) nItem
= infoPtr
->nItemCount
- 1;
9183 if ((nItem
!= -1) && (nItem
!= infoPtr
->nFocusedItem
|| nVirtualKey
== VK_SPACE
))
9184 LISTVIEW_KeySelection(infoPtr
, nItem
, nVirtualKey
== VK_SPACE
);
9194 * [I] infoPtr : valid pointer to the listview structure
9199 static LRESULT
LISTVIEW_KillFocus(LISTVIEW_INFO
*infoPtr
)
9203 /* if we did not have the focus, there's nothing to do */
9204 if (!infoPtr
->bFocus
) return 0;
9206 /* send NM_KILLFOCUS notification */
9207 if (!notify(infoPtr
, NM_KILLFOCUS
)) return 0;
9209 /* if we have a focus rectangle, get rid of it */
9210 LISTVIEW_ShowFocusRect(infoPtr
, FALSE
);
9212 /* set window focus flag */
9213 infoPtr
->bFocus
= FALSE
;
9215 /* invalidate the selected items before resetting focus flag */
9216 LISTVIEW_InvalidateSelectedItems(infoPtr
);
9223 * Processes double click messages (left mouse button).
9226 * [I] infoPtr : valid pointer to the listview structure
9227 * [I] wKey : key flag
9228 * [I] x,y : mouse coordinate
9233 static LRESULT
LISTVIEW_LButtonDblClk(LISTVIEW_INFO
*infoPtr
, WORD wKey
, INT x
, INT y
)
9235 LVHITTESTINFO htInfo
;
9237 TRACE("(key=%hu, X=%hu, Y=%hu)\n", wKey
, x
, y
);
9239 /* Cancel the item edition if any */
9240 if (infoPtr
->itemEdit
.fEnabled
)
9242 KillTimer(infoPtr
->hwndSelf
, (UINT_PTR
)&infoPtr
->itemEdit
);
9243 infoPtr
->itemEdit
.fEnabled
= FALSE
;
9246 /* send NM_RELEASEDCAPTURE notification */
9247 if (!notify(infoPtr
, NM_RELEASEDCAPTURE
)) return 0;
9252 /* send NM_DBLCLK notification */
9253 LISTVIEW_HitTest(infoPtr
, &htInfo
, TRUE
, FALSE
);
9254 if (!notify_click(infoPtr
, NM_DBLCLK
, &htInfo
)) return 0;
9256 /* To send the LVN_ITEMACTIVATE, it must be on an Item */
9257 if(htInfo
.iItem
!= -1) notify_itemactivate(infoPtr
,&htInfo
);
9264 * Processes mouse down messages (left mouse button).
9267 * infoPtr [I ] valid pointer to the listview structure
9268 * wKey [I ] key flag
9269 * x,y [I ] mouse coordinate
9274 static LRESULT
LISTVIEW_LButtonDown(LISTVIEW_INFO
*infoPtr
, WORD wKey
, INT x
, INT y
)
9276 LVHITTESTINFO lvHitTestInfo
;
9277 static BOOL bGroupSelect
= TRUE
;
9278 POINT pt
= { x
, y
};
9281 TRACE("(key=%hu, X=%hu, Y=%hu)\n", wKey
, x
, y
);
9283 /* send NM_RELEASEDCAPTURE notification */
9284 if (!notify(infoPtr
, NM_RELEASEDCAPTURE
)) return 0;
9286 /* set left button down flag and record the click position */
9287 infoPtr
->bLButtonDown
= TRUE
;
9288 infoPtr
->ptClickPos
= pt
;
9289 infoPtr
->bDragging
= FALSE
;
9291 lvHitTestInfo
.pt
.x
= x
;
9292 lvHitTestInfo
.pt
.y
= y
;
9294 nItem
= LISTVIEW_HitTest(infoPtr
, &lvHitTestInfo
, TRUE
, TRUE
);
9295 TRACE("at %s, nItem=%d\n", wine_dbgstr_point(&pt
), nItem
);
9296 if ((nItem
>= 0) && (nItem
< infoPtr
->nItemCount
))
9298 if ((infoPtr
->dwLvExStyle
& LVS_EX_CHECKBOXES
) && (lvHitTestInfo
.flags
& LVHT_ONITEMSTATEICON
))
9300 toggle_checkbox_state(infoPtr
, nItem
);
9304 if (infoPtr
->dwStyle
& LVS_SINGLESEL
)
9306 if (LISTVIEW_GetItemState(infoPtr
, nItem
, LVIS_SELECTED
))
9307 infoPtr
->nEditLabelItem
= nItem
;
9309 LISTVIEW_SetSelection(infoPtr
, nItem
);
9313 if ((wKey
& MK_CONTROL
) && (wKey
& MK_SHIFT
))
9317 if (!LISTVIEW_AddGroupSelection(infoPtr
, nItem
)) return 0;
9318 LISTVIEW_SetItemFocus(infoPtr
, nItem
);
9319 infoPtr
->nSelectionMark
= nItem
;
9325 item
.state
= LVIS_SELECTED
| LVIS_FOCUSED
;
9326 item
.stateMask
= LVIS_SELECTED
| LVIS_FOCUSED
;
9328 LISTVIEW_SetItemState(infoPtr
,nItem
,&item
);
9329 infoPtr
->nSelectionMark
= nItem
;
9332 else if (wKey
& MK_CONTROL
)
9336 bGroupSelect
= (LISTVIEW_GetItemState(infoPtr
, nItem
, LVIS_SELECTED
) == 0);
9338 item
.state
= (bGroupSelect
? LVIS_SELECTED
: 0) | LVIS_FOCUSED
;
9339 item
.stateMask
= LVIS_SELECTED
| LVIS_FOCUSED
;
9340 LISTVIEW_SetItemState(infoPtr
, nItem
, &item
);
9341 infoPtr
->nSelectionMark
= nItem
;
9343 else if (wKey
& MK_SHIFT
)
9345 LISTVIEW_SetGroupSelection(infoPtr
, nItem
);
9349 if (LISTVIEW_GetItemState(infoPtr
, nItem
, LVIS_SELECTED
))
9351 infoPtr
->nEditLabelItem
= nItem
;
9352 infoPtr
->nLButtonDownItem
= nItem
;
9354 LISTVIEW_SetItemFocus(infoPtr
, nItem
);
9357 /* set selection (clears other pre-existing selections) */
9358 LISTVIEW_SetSelection(infoPtr
, nItem
);
9362 if (infoPtr
->dwLvExStyle
& LVS_EX_ONECLICKACTIVATE
)
9363 if(lvHitTestInfo
.iItem
!= -1) notify_itemactivate(infoPtr
,&lvHitTestInfo
);
9367 /* remove all selections */
9368 if (!(wKey
& MK_CONTROL
) && !(wKey
& MK_SHIFT
))
9369 LISTVIEW_DeselectAll(infoPtr
);
9378 * Processes mouse up messages (left mouse button).
9381 * infoPtr [I ] valid pointer to the listview structure
9382 * wKey [I ] key flag
9383 * x,y [I ] mouse coordinate
9388 static LRESULT
LISTVIEW_LButtonUp(LISTVIEW_INFO
*infoPtr
, WORD wKey
, INT x
, INT y
)
9390 LVHITTESTINFO lvHitTestInfo
;
9392 TRACE("(key=%hu, X=%hu, Y=%hu)\n", wKey
, x
, y
);
9394 if (!infoPtr
->bLButtonDown
) return 0;
9396 lvHitTestInfo
.pt
.x
= x
;
9397 lvHitTestInfo
.pt
.y
= y
;
9399 /* send NM_CLICK notification */
9400 LISTVIEW_HitTest(infoPtr
, &lvHitTestInfo
, TRUE
, FALSE
);
9401 if (!notify_click(infoPtr
, NM_CLICK
, &lvHitTestInfo
)) return 0;
9403 /* set left button flag */
9404 infoPtr
->bLButtonDown
= FALSE
;
9406 /* set a single selection, reset others */
9407 if(lvHitTestInfo
.iItem
== infoPtr
->nLButtonDownItem
&& lvHitTestInfo
.iItem
!= -1)
9408 LISTVIEW_SetSelection(infoPtr
, infoPtr
->nLButtonDownItem
);
9409 infoPtr
->nLButtonDownItem
= -1;
9411 if (infoPtr
->bDragging
)
9413 infoPtr
->bDragging
= FALSE
;
9417 /* if we clicked on a selected item, edit the label */
9418 if(lvHitTestInfo
.iItem
== infoPtr
->nEditLabelItem
&& (lvHitTestInfo
.flags
& LVHT_ONITEMLABEL
))
9420 /* we want to make sure the user doesn't want to do a double click. So we will
9421 * delay the edit. WM_LBUTTONDBLCLICK will cancel the timer
9423 infoPtr
->itemEdit
.fEnabled
= TRUE
;
9424 infoPtr
->itemEdit
.iItem
= lvHitTestInfo
.iItem
;
9425 SetTimer(infoPtr
->hwndSelf
,
9426 (UINT_PTR
)&infoPtr
->itemEdit
,
9427 GetDoubleClickTime(),
9428 LISTVIEW_DelayedEditItem
);
9431 if (!infoPtr
->bFocus
)
9432 SetFocus(infoPtr
->hwndSelf
);
9439 * Destroys the listview control (called after WM_DESTROY).
9442 * [I] infoPtr : valid pointer to the listview structure
9447 static LRESULT
LISTVIEW_NCDestroy(LISTVIEW_INFO
*infoPtr
)
9451 /* delete all items */
9452 LISTVIEW_DeleteAllItems(infoPtr
, TRUE
);
9454 /* destroy data structure */
9455 DPA_Destroy(infoPtr
->hdpaItems
);
9456 DPA_Destroy(infoPtr
->hdpaItemIds
);
9457 DPA_Destroy(infoPtr
->hdpaPosX
);
9458 DPA_Destroy(infoPtr
->hdpaPosY
);
9459 DPA_Destroy(infoPtr
->hdpaColumns
);
9460 ranges_destroy(infoPtr
->selectionRanges
);
9462 /* destroy image lists */
9463 if (!(infoPtr
->dwStyle
& LVS_SHAREIMAGELISTS
))
9465 if (infoPtr
->himlNormal
)
9466 ImageList_Destroy(infoPtr
->himlNormal
);
9467 if (infoPtr
->himlSmall
)
9468 ImageList_Destroy(infoPtr
->himlSmall
);
9469 if (infoPtr
->himlState
)
9470 ImageList_Destroy(infoPtr
->himlState
);
9473 /* destroy font, bkgnd brush */
9475 if (infoPtr
->hDefaultFont
) DeleteObject(infoPtr
->hDefaultFont
);
9476 if (infoPtr
->clrBk
!= CLR_NONE
) DeleteObject(infoPtr
->hBkBrush
);
9478 SetWindowLongPtrW(infoPtr
->hwndSelf
, 0, 0);
9480 /* free listview info pointer*/
9488 * Handles notifications from header.
9491 * [I] infoPtr : valid pointer to the listview structure
9492 * [I] nCtrlId : control identifier
9493 * [I] lpnmh : notification information
9498 static LRESULT
LISTVIEW_HeaderNotification(LISTVIEW_INFO
*infoPtr
, const NMHEADERW
*lpnmh
)
9500 HWND hwndSelf
= infoPtr
->hwndSelf
;
9502 TRACE("(lpnmh=%p)\n", lpnmh
);
9504 if (!lpnmh
|| lpnmh
->iItem
< 0 || lpnmh
->iItem
>= DPA_GetPtrCount(infoPtr
->hdpaColumns
)) return 0;
9506 switch (lpnmh
->hdr
.code
)
9511 COLUMN_INFO
*lpColumnInfo
;
9515 if (!lpnmh
->pitem
|| !(lpnmh
->pitem
->mask
& HDI_WIDTH
))
9518 /* remove the old line (if any) */
9519 LISTVIEW_DrawTrackLine(infoPtr
);
9521 /* compute & draw the new line */
9522 lpColumnInfo
= LISTVIEW_GetColumnInfo(infoPtr
, lpnmh
->iItem
);
9523 x
= lpColumnInfo
->rcHeader
.left
+ lpnmh
->pitem
->cxy
;
9524 LISTVIEW_GetOrigin(infoPtr
, &ptOrigin
);
9525 infoPtr
->xTrackLine
= x
+ ptOrigin
.x
;
9526 LISTVIEW_DrawTrackLine(infoPtr
);
9532 /* remove the track line (if any) */
9533 LISTVIEW_DrawTrackLine(infoPtr
);
9534 infoPtr
->xTrackLine
= -1;
9538 notify_forward_header(infoPtr
, lpnmh
);
9539 return (infoPtr
->dwLvExStyle
& LVS_EX_HEADERDRAGDROP
) == 0;
9542 infoPtr
->colRectsDirty
= TRUE
;
9543 LISTVIEW_InvalidateList(infoPtr
);
9544 notify_forward_header(infoPtr
, lpnmh
);
9547 case HDN_ITEMCHANGINGW
:
9548 case HDN_ITEMCHANGINGA
:
9549 return notify_forward_header(infoPtr
, lpnmh
);
9551 case HDN_ITEMCHANGEDW
:
9552 case HDN_ITEMCHANGEDA
:
9554 COLUMN_INFO
*lpColumnInfo
;
9558 notify_forward_header(infoPtr
, lpnmh
);
9559 if (!IsWindow(hwndSelf
))
9562 if (!lpnmh
->pitem
|| !(lpnmh
->pitem
->mask
& HDI_WIDTH
))
9564 hdi
.mask
= HDI_WIDTH
;
9565 if (!SendMessageW(infoPtr
->hwndHeader
, HDM_GETITEMW
, lpnmh
->iItem
, (LPARAM
)&hdi
)) return 0;
9569 cxy
= lpnmh
->pitem
->cxy
;
9571 /* determine how much we change since the last know position */
9572 lpColumnInfo
= LISTVIEW_GetColumnInfo(infoPtr
, lpnmh
->iItem
);
9573 dx
= cxy
- (lpColumnInfo
->rcHeader
.right
- lpColumnInfo
->rcHeader
.left
);
9576 lpColumnInfo
->rcHeader
.right
+= dx
;
9578 hdi
.mask
= HDI_ORDER
;
9579 SendMessageW(infoPtr
->hwndHeader
, HDM_GETITEMW
, lpnmh
->iItem
, (LPARAM
)&hdi
);
9581 /* not the rightmost one */
9582 if (hdi
.iOrder
+ 1 < DPA_GetPtrCount(infoPtr
->hdpaColumns
))
9584 INT nIndex
= SendMessageW(infoPtr
->hwndHeader
, HDM_ORDERTOINDEX
,
9586 LISTVIEW_ScrollColumns(infoPtr
, nIndex
, dx
);
9590 /* only needs to update the scrolls */
9591 infoPtr
->nItemWidth
+= dx
;
9592 LISTVIEW_UpdateScroll(infoPtr
);
9594 LISTVIEW_UpdateItemSize(infoPtr
);
9595 if (infoPtr
->uView
== LV_VIEW_DETAILS
&& is_redrawing(infoPtr
))
9598 RECT rcCol
= lpColumnInfo
->rcHeader
;
9600 LISTVIEW_GetOrigin(infoPtr
, &ptOrigin
);
9601 OffsetRect(&rcCol
, ptOrigin
.x
, 0);
9603 rcCol
.top
= infoPtr
->rcList
.top
;
9604 rcCol
.bottom
= infoPtr
->rcList
.bottom
;
9606 /* resizing left-aligned columns leaves most of the left side untouched */
9607 if ((lpColumnInfo
->fmt
& LVCFMT_JUSTIFYMASK
) == LVCFMT_LEFT
)
9609 INT nMaxDirty
= infoPtr
->nEllipsisWidth
+ infoPtr
->ntmMaxCharWidth
;
9612 rcCol
.left
= max (rcCol
.left
, rcCol
.right
- nMaxDirty
);
9615 /* when shrinking the last column clear the now unused field */
9616 if (hdi
.iOrder
== DPA_GetPtrCount(infoPtr
->hdpaColumns
) - 1)
9622 /* deal with right from rightmost column area */
9623 right
.left
= rcCol
.right
;
9624 right
.top
= rcCol
.top
;
9625 right
.bottom
= rcCol
.bottom
;
9626 right
.right
= infoPtr
->rcList
.right
;
9628 LISTVIEW_InvalidateRect(infoPtr
, &right
);
9631 LISTVIEW_InvalidateRect(infoPtr
, &rcCol
);
9637 case HDN_ITEMCLICKW
:
9638 case HDN_ITEMCLICKA
:
9640 /* Handle sorting by Header Column */
9643 ZeroMemory(&nmlv
, sizeof(NMLISTVIEW
));
9645 nmlv
.iSubItem
= lpnmh
->iItem
;
9646 notify_listview(infoPtr
, LVN_COLUMNCLICK
, &nmlv
);
9647 notify_forward_header(infoPtr
, lpnmh
);
9651 case HDN_DIVIDERDBLCLICKW
:
9652 case HDN_DIVIDERDBLCLICKA
:
9653 LISTVIEW_SetColumnWidth(infoPtr
, lpnmh
->iItem
, LVSCW_AUTOSIZE
);
9654 notify_forward_header(infoPtr
, lpnmh
);
9663 * Paint non-client area of control.
9666 * [I] infoPtr : valid pointer to the listview structureof the sender
9667 * [I] region : update region
9670 * TRUE - frame was painted
9671 * FALSE - call default window proc
9673 static BOOL
LISTVIEW_NCPaint(const LISTVIEW_INFO
*infoPtr
, HRGN region
)
9675 HTHEME theme
= GetWindowTheme (infoPtr
->hwndSelf
);
9679 int cxEdge
= GetSystemMetrics (SM_CXEDGE
),
9680 cyEdge
= GetSystemMetrics (SM_CYEDGE
);
9682 if (!theme
) return FALSE
;
9684 GetWindowRect(infoPtr
->hwndSelf
, &r
);
9686 cliprgn
= CreateRectRgn (r
.left
+ cxEdge
, r
.top
+ cyEdge
,
9687 r
.right
- cxEdge
, r
.bottom
- cyEdge
);
9688 if (region
!= (HRGN
)1)
9689 CombineRgn (cliprgn
, cliprgn
, region
, RGN_AND
);
9690 OffsetRect(&r
, -r
.left
, -r
.top
);
9692 dc
= GetDCEx(infoPtr
->hwndSelf
, region
, DCX_WINDOW
|DCX_INTERSECTRGN
);
9693 OffsetRect(&r
, -r
.left
, -r
.top
);
9695 if (IsThemeBackgroundPartiallyTransparent (theme
, 0, 0))
9696 DrawThemeParentBackground(infoPtr
->hwndSelf
, dc
, &r
);
9697 DrawThemeBackground (theme
, dc
, 0, 0, &r
, 0);
9698 ReleaseDC(infoPtr
->hwndSelf
, dc
);
9700 /* Call default proc to get the scrollbars etc. painted */
9701 DefWindowProcW (infoPtr
->hwndSelf
, WM_NCPAINT
, (WPARAM
)cliprgn
, 0);
9708 * Determines the type of structure to use.
9711 * [I] infoPtr : valid pointer to the listview structureof the sender
9712 * [I] hwndFrom : listview window handle
9713 * [I] nCommand : command specifying the nature of the WM_NOTIFYFORMAT
9718 static LRESULT
LISTVIEW_NotifyFormat(LISTVIEW_INFO
*infoPtr
, HWND hwndFrom
, INT nCommand
)
9720 TRACE("(hwndFrom=%p, nCommand=%d)\n", hwndFrom
, nCommand
);
9722 if (nCommand
== NF_REQUERY
)
9723 infoPtr
->notifyFormat
= SendMessageW(infoPtr
->hwndNotify
, WM_NOTIFYFORMAT
, (WPARAM
)infoPtr
->hwndSelf
, NF_QUERY
);
9725 return infoPtr
->notifyFormat
;
9730 * Paints/Repaints the listview control. Internal use.
9733 * [I] infoPtr : valid pointer to the listview structure
9734 * [I] hdc : device context handle
9739 static LRESULT
LISTVIEW_Paint(LISTVIEW_INFO
*infoPtr
, HDC hdc
)
9741 TRACE("(hdc=%p)\n", hdc
);
9743 if (infoPtr
->bNoItemMetrics
&& infoPtr
->nItemCount
)
9745 infoPtr
->bNoItemMetrics
= FALSE
;
9746 LISTVIEW_UpdateItemSize(infoPtr
);
9747 if (infoPtr
->uView
== LV_VIEW_ICON
|| infoPtr
->uView
== LV_VIEW_SMALLICON
)
9748 LISTVIEW_Arrange(infoPtr
, LVA_DEFAULT
);
9749 LISTVIEW_UpdateScroll(infoPtr
);
9752 if (infoPtr
->hwndHeader
) UpdateWindow(infoPtr
->hwndHeader
);
9755 LISTVIEW_Refresh(infoPtr
, hdc
, NULL
);
9760 hdc
= BeginPaint(infoPtr
->hwndSelf
, &ps
);
9762 LISTVIEW_Refresh(infoPtr
, hdc
, ps
.fErase
? &ps
.rcPaint
: NULL
);
9763 EndPaint(infoPtr
->hwndSelf
, &ps
);
9771 * Paints/Repaints the listview control, WM_PAINT handler.
9774 * [I] infoPtr : valid pointer to the listview structure
9775 * [I] hdc : device context handle
9780 static inline LRESULT
LISTVIEW_WMPaint(LISTVIEW_INFO
*infoPtr
, HDC hdc
)
9782 TRACE("(hdc=%p)\n", hdc
);
9784 if (!is_redrawing(infoPtr
)) return 0;
9786 return LISTVIEW_Paint(infoPtr
, hdc
);
9791 * Paints/Repaints the listview control.
9794 * [I] infoPtr : valid pointer to the listview structure
9795 * [I] hdc : device context handle
9796 * [I] options : drawing options
9801 static LRESULT
LISTVIEW_PrintClient(LISTVIEW_INFO
*infoPtr
, HDC hdc
, DWORD options
)
9803 FIXME("Partial Stub: (hdc=%p options=0x%08x)\n", hdc
, options
);
9805 if ((options
& PRF_CHECKVISIBLE
) && !IsWindowVisible(infoPtr
->hwndSelf
))
9808 if (options
& PRF_ERASEBKGND
)
9809 LISTVIEW_EraseBkgnd(infoPtr
, hdc
);
9811 if (options
& PRF_CLIENT
)
9812 LISTVIEW_Paint(infoPtr
, hdc
);
9820 * Processes double click messages (right mouse button).
9823 * [I] infoPtr : valid pointer to the listview structure
9824 * [I] wKey : key flag
9825 * [I] x,y : mouse coordinate
9830 static LRESULT
LISTVIEW_RButtonDblClk(const LISTVIEW_INFO
*infoPtr
, WORD wKey
, INT x
, INT y
)
9832 LVHITTESTINFO lvHitTestInfo
;
9834 TRACE("(key=%hu,X=%hu,Y=%hu)\n", wKey
, x
, y
);
9836 /* send NM_RELEASEDCAPTURE notification */
9837 if (!notify(infoPtr
, NM_RELEASEDCAPTURE
)) return 0;
9839 /* send NM_RDBLCLK notification */
9840 lvHitTestInfo
.pt
.x
= x
;
9841 lvHitTestInfo
.pt
.y
= y
;
9842 LISTVIEW_HitTest(infoPtr
, &lvHitTestInfo
, TRUE
, FALSE
);
9843 notify_click(infoPtr
, NM_RDBLCLK
, &lvHitTestInfo
);
9850 * Processes mouse down messages (right mouse button).
9853 * [I] infoPtr : valid pointer to the listview structure
9854 * [I] wKey : key flag
9855 * [I] x,y : mouse coordinate
9860 static LRESULT
LISTVIEW_RButtonDown(LISTVIEW_INFO
*infoPtr
, WORD wKey
, INT x
, INT y
)
9862 LVHITTESTINFO lvHitTestInfo
;
9865 TRACE("(key=%hu,X=%hu,Y=%hu)\n", wKey
, x
, y
);
9867 /* send NM_RELEASEDCAPTURE notification */
9868 if (!notify(infoPtr
, NM_RELEASEDCAPTURE
)) return 0;
9870 /* make sure the listview control window has the focus */
9871 if (!infoPtr
->bFocus
) SetFocus(infoPtr
->hwndSelf
);
9873 /* set right button down flag */
9874 infoPtr
->bRButtonDown
= TRUE
;
9876 /* determine the index of the selected item */
9877 lvHitTestInfo
.pt
.x
= x
;
9878 lvHitTestInfo
.pt
.y
= y
;
9879 nItem
= LISTVIEW_HitTest(infoPtr
, &lvHitTestInfo
, TRUE
, TRUE
);
9881 if ((nItem
>= 0) && (nItem
< infoPtr
->nItemCount
))
9883 LISTVIEW_SetItemFocus(infoPtr
, nItem
);
9884 if (!((wKey
& MK_SHIFT
) || (wKey
& MK_CONTROL
)) &&
9885 !LISTVIEW_GetItemState(infoPtr
, nItem
, LVIS_SELECTED
))
9886 LISTVIEW_SetSelection(infoPtr
, nItem
);
9890 LISTVIEW_DeselectAll(infoPtr
);
9898 * Processes mouse up messages (right mouse button).
9901 * [I] infoPtr : valid pointer to the listview structure
9902 * [I] wKey : key flag
9903 * [I] x,y : mouse coordinate
9908 static LRESULT
LISTVIEW_RButtonUp(LISTVIEW_INFO
*infoPtr
, WORD wKey
, INT x
, INT y
)
9910 LVHITTESTINFO lvHitTestInfo
;
9913 TRACE("(key=%hu,X=%hu,Y=%hu)\n", wKey
, x
, y
);
9915 if (!infoPtr
->bRButtonDown
) return 0;
9917 /* set button flag */
9918 infoPtr
->bRButtonDown
= FALSE
;
9920 /* Send NM_RCLICK notification */
9921 lvHitTestInfo
.pt
.x
= x
;
9922 lvHitTestInfo
.pt
.y
= y
;
9923 LISTVIEW_HitTest(infoPtr
, &lvHitTestInfo
, TRUE
, FALSE
);
9924 if (!notify_click(infoPtr
, NM_RCLICK
, &lvHitTestInfo
)) return 0;
9926 /* Change to screen coordinate for WM_CONTEXTMENU */
9927 pt
= lvHitTestInfo
.pt
;
9928 ClientToScreen(infoPtr
->hwndSelf
, &pt
);
9930 /* Send a WM_CONTEXTMENU message in response to the RBUTTONUP */
9931 SendMessageW(infoPtr
->hwndSelf
, WM_CONTEXTMENU
,
9932 (WPARAM
)infoPtr
->hwndSelf
, MAKELPARAM(pt
.x
, pt
.y
));
9943 * [I] infoPtr : valid pointer to the listview structure
9944 * [I] hwnd : window handle of window containing the cursor
9945 * [I] nHittest : hit-test code
9946 * [I] wMouseMsg : ideintifier of the mouse message
9949 * TRUE if cursor is set
9952 static BOOL
LISTVIEW_SetCursor(const LISTVIEW_INFO
*infoPtr
, HWND hwnd
, UINT nHittest
, UINT wMouseMsg
)
9954 LVHITTESTINFO lvHitTestInfo
;
9956 if(!(LISTVIEW_isHotTracking(infoPtr
))) return FALSE
;
9958 if(!infoPtr
->hHotCursor
) return FALSE
;
9960 GetCursorPos(&lvHitTestInfo
.pt
);
9961 if (LISTVIEW_HitTest(infoPtr
, &lvHitTestInfo
, FALSE
, FALSE
) < 0) return FALSE
;
9963 SetCursor(infoPtr
->hHotCursor
);
9973 * [I] infoPtr : valid pointer to the listview structure
9974 * [I] hwndLoseFocus : handle of previously focused window
9979 static LRESULT
LISTVIEW_SetFocus(LISTVIEW_INFO
*infoPtr
, HWND hwndLoseFocus
)
9981 TRACE("(hwndLoseFocus=%p)\n", hwndLoseFocus
);
9983 /* if we have the focus already, there's nothing to do */
9984 if (infoPtr
->bFocus
) return 0;
9986 /* send NM_SETFOCUS notification */
9987 if (!notify(infoPtr
, NM_SETFOCUS
)) return 0;
9989 /* set window focus flag */
9990 infoPtr
->bFocus
= TRUE
;
9992 /* put the focus rect back on */
9993 LISTVIEW_ShowFocusRect(infoPtr
, TRUE
);
9995 /* redraw all visible selected items */
9996 LISTVIEW_InvalidateSelectedItems(infoPtr
);
10006 * [I] infoPtr : valid pointer to the listview structure
10007 * [I] fRedraw : font handle
10008 * [I] fRedraw : redraw flag
10013 static LRESULT
LISTVIEW_SetFont(LISTVIEW_INFO
*infoPtr
, HFONT hFont
, WORD fRedraw
)
10015 HFONT oldFont
= infoPtr
->hFont
;
10017 TRACE("(hfont=%p,redraw=%hu)\n", hFont
, fRedraw
);
10019 infoPtr
->hFont
= hFont
? hFont
: infoPtr
->hDefaultFont
;
10020 if (infoPtr
->hFont
== oldFont
) return 0;
10022 LISTVIEW_SaveTextMetrics(infoPtr
);
10024 if (infoPtr
->uView
== LV_VIEW_DETAILS
)
10026 SendMessageW(infoPtr
->hwndHeader
, WM_SETFONT
, (WPARAM
)hFont
, MAKELPARAM(fRedraw
, 0));
10027 LISTVIEW_UpdateSize(infoPtr
);
10028 LISTVIEW_UpdateScroll(infoPtr
);
10031 if (fRedraw
) LISTVIEW_InvalidateList(infoPtr
);
10038 * Message handling for WM_SETREDRAW.
10039 * For the Listview, it invalidates the entire window (the doc specifies otherwise)
10042 * [I] infoPtr : valid pointer to the listview structure
10043 * [I] bRedraw: state of redraw flag
10046 * DefWinProc return value
10048 static LRESULT
LISTVIEW_SetRedraw(LISTVIEW_INFO
*infoPtr
, BOOL bRedraw
)
10050 TRACE("infoPtr->bRedraw=%d, bRedraw=%d\n", infoPtr
->bRedraw
, bRedraw
);
10052 /* we cannot use straight equality here because _any_ non-zero value is TRUE */
10053 if ((infoPtr
->bRedraw
&& bRedraw
) || (!infoPtr
->bRedraw
&& !bRedraw
)) return 0;
10055 infoPtr
->bRedraw
= bRedraw
;
10057 if(!bRedraw
) return 0;
10059 if (is_autoarrange(infoPtr
))
10060 LISTVIEW_Arrange(infoPtr
, LVA_DEFAULT
);
10061 LISTVIEW_UpdateScroll(infoPtr
);
10063 /* despite what the WM_SETREDRAW docs says, apps expect us
10064 * to invalidate the listview here... stupid! */
10065 LISTVIEW_InvalidateList(infoPtr
);
10072 * Resizes the listview control. This function processes WM_SIZE
10073 * messages. At this time, the width and height are not used.
10076 * [I] infoPtr : valid pointer to the listview structure
10077 * [I] Width : new width
10078 * [I] Height : new height
10083 static LRESULT
LISTVIEW_Size(LISTVIEW_INFO
*infoPtr
, int Width
, int Height
)
10085 RECT rcOld
= infoPtr
->rcList
;
10087 TRACE("(width=%d, height=%d)\n", Width
, Height
);
10089 LISTVIEW_UpdateSize(infoPtr
);
10090 if (EqualRect(&rcOld
, &infoPtr
->rcList
)) return 0;
10092 /* do not bother with display related stuff if we're not redrawing */
10093 if (!is_redrawing(infoPtr
)) return 0;
10095 if (is_autoarrange(infoPtr
))
10096 LISTVIEW_Arrange(infoPtr
, LVA_DEFAULT
);
10098 LISTVIEW_UpdateScroll(infoPtr
);
10100 /* refresh all only for lists whose height changed significantly */
10101 if ((infoPtr
->uView
== LV_VIEW_LIST
) &&
10102 (rcOld
.bottom
- rcOld
.top
) / infoPtr
->nItemHeight
!=
10103 (infoPtr
->rcList
.bottom
- infoPtr
->rcList
.top
) / infoPtr
->nItemHeight
)
10104 LISTVIEW_InvalidateList(infoPtr
);
10111 * Sets the size information.
10114 * [I] infoPtr : valid pointer to the listview structure
10119 static void LISTVIEW_UpdateSize(LISTVIEW_INFO
*infoPtr
)
10121 TRACE("uView=%d, rcList(old)=%s\n", infoPtr
->uView
, wine_dbgstr_rect(&infoPtr
->rcList
));
10123 GetClientRect(infoPtr
->hwndSelf
, &infoPtr
->rcList
);
10125 if (infoPtr
->uView
== LV_VIEW_LIST
)
10127 /* Apparently the "LIST" style is supposed to have the same
10128 * number of items in a column even if there is no scroll bar.
10129 * Since if a scroll bar already exists then the bottom is already
10130 * reduced, only reduce if the scroll bar does not currently exist.
10131 * The "2" is there to mimic the native control. I think it may be
10132 * related to either padding or edges. (GLA 7/2002)
10134 if (!(infoPtr
->dwStyle
& WS_HSCROLL
))
10135 infoPtr
->rcList
.bottom
-= GetSystemMetrics(SM_CYHSCROLL
);
10136 infoPtr
->rcList
.bottom
= max (infoPtr
->rcList
.bottom
- 2, 0);
10138 else if (infoPtr
->uView
== LV_VIEW_DETAILS
)
10143 hl
.prc
= &infoPtr
->rcList
;
10145 SendMessageW( infoPtr
->hwndHeader
, HDM_LAYOUT
, 0, (LPARAM
)&hl
);
10146 TRACE(" wp.flags=0x%08x, wp=%d,%d (%dx%d)\n", wp
.flags
, wp
.x
, wp
.y
, wp
.cx
, wp
.cy
);
10147 SetWindowPos(wp
.hwnd
, wp
.hwndInsertAfter
, wp
.x
, wp
.y
, wp
.cx
, wp
.cy
,
10148 wp
.flags
| ((infoPtr
->dwStyle
& LVS_NOCOLUMNHEADER
)
10149 ? SWP_HIDEWINDOW
: SWP_SHOWWINDOW
));
10150 TRACE(" after SWP wp=%d,%d (%dx%d)\n", wp
.x
, wp
.y
, wp
.cx
, wp
.cy
);
10152 infoPtr
->rcList
.top
= max(wp
.cy
, 0);
10153 infoPtr
->rcList
.top
+= (infoPtr
->dwLvExStyle
& LVS_EX_GRIDLINES
) ? 2 : 0;
10156 TRACE(" rcList=%s\n", wine_dbgstr_rect(&infoPtr
->rcList
));
10161 * Processes WM_STYLECHANGED messages.
10164 * [I] infoPtr : valid pointer to the listview structure
10165 * [I] wStyleType : window style type (normal or extended)
10166 * [I] lpss : window style information
10171 static INT
LISTVIEW_StyleChanged(LISTVIEW_INFO
*infoPtr
, WPARAM wStyleType
,
10172 const STYLESTRUCT
*lpss
)
10174 UINT uNewView
= lpss
->styleNew
& LVS_TYPEMASK
;
10175 UINT uOldView
= lpss
->styleOld
& LVS_TYPEMASK
;
10178 TRACE("(styletype=%lx, styleOld=0x%08x, styleNew=0x%08x)\n",
10179 wStyleType
, lpss
->styleOld
, lpss
->styleNew
);
10181 if (wStyleType
!= GWL_STYLE
) return 0;
10183 infoPtr
->dwStyle
= lpss
->styleNew
;
10184 map_style_view(infoPtr
);
10186 if (((lpss
->styleOld
& WS_HSCROLL
) != 0)&&
10187 ((lpss
->styleNew
& WS_HSCROLL
) == 0))
10188 ShowScrollBar(infoPtr
->hwndSelf
, SB_HORZ
, FALSE
);
10190 if (((lpss
->styleOld
& WS_VSCROLL
) != 0)&&
10191 ((lpss
->styleNew
& WS_VSCROLL
) == 0))
10192 ShowScrollBar(infoPtr
->hwndSelf
, SB_VERT
, FALSE
);
10194 if (uNewView
!= uOldView
)
10196 SIZE oldIconSize
= infoPtr
->iconSize
;
10199 SendMessageW(infoPtr
->hwndEdit
, WM_KILLFOCUS
, 0, 0);
10200 ShowWindow(infoPtr
->hwndHeader
, SW_HIDE
);
10202 ShowScrollBar(infoPtr
->hwndSelf
, SB_BOTH
, FALSE
);
10203 SetRectEmpty(&infoPtr
->rcFocus
);
10205 himl
= (uNewView
== LVS_ICON
? infoPtr
->himlNormal
: infoPtr
->himlSmall
);
10206 set_icon_size(&infoPtr
->iconSize
, himl
, uNewView
!= LVS_ICON
);
10208 if (uNewView
== LVS_ICON
)
10210 if ((infoPtr
->iconSize
.cx
!= oldIconSize
.cx
) || (infoPtr
->iconSize
.cy
!= oldIconSize
.cy
))
10212 TRACE("icon old size=(%d,%d), new size=(%d,%d)\n",
10213 oldIconSize
.cx
, oldIconSize
.cy
, infoPtr
->iconSize
.cx
, infoPtr
->iconSize
.cy
);
10214 LISTVIEW_SetIconSpacing(infoPtr
, 0, 0);
10217 else if (uNewView
== LVS_REPORT
)
10222 LISTVIEW_CreateHeader( infoPtr
);
10224 hl
.prc
= &infoPtr
->rcList
;
10226 SendMessageW( infoPtr
->hwndHeader
, HDM_LAYOUT
, 0, (LPARAM
)&hl
);
10227 SetWindowPos(infoPtr
->hwndHeader
, infoPtr
->hwndSelf
, wp
.x
, wp
.y
, wp
.cx
, wp
.cy
,
10228 wp
.flags
| ((infoPtr
->dwStyle
& LVS_NOCOLUMNHEADER
)
10229 ? SWP_HIDEWINDOW
: SWP_SHOWWINDOW
));
10232 LISTVIEW_UpdateItemSize(infoPtr
);
10235 if (uNewView
== LVS_REPORT
)
10237 if ((lpss
->styleOld
^ lpss
->styleNew
) & LVS_NOCOLUMNHEADER
)
10239 if (lpss
->styleNew
& LVS_NOCOLUMNHEADER
)
10241 /* Turn off the header control */
10242 style
= GetWindowLongW(infoPtr
->hwndHeader
, GWL_STYLE
);
10243 TRACE("Hide header control, was 0x%08x\n", style
);
10244 SetWindowLongW(infoPtr
->hwndHeader
, GWL_STYLE
, style
| HDS_HIDDEN
);
10246 /* Turn on the header control */
10247 if ((style
= GetWindowLongW(infoPtr
->hwndHeader
, GWL_STYLE
)) & HDS_HIDDEN
)
10249 TRACE("Show header control, was 0x%08x\n", style
);
10250 SetWindowLongW(infoPtr
->hwndHeader
, GWL_STYLE
, (style
& ~HDS_HIDDEN
) | WS_VISIBLE
);
10256 if ( (uNewView
== LVS_ICON
|| uNewView
== LVS_SMALLICON
) &&
10257 (uNewView
!= uOldView
|| ((lpss
->styleNew
^ lpss
->styleOld
) & LVS_ALIGNMASK
)) )
10258 LISTVIEW_Arrange(infoPtr
, LVA_DEFAULT
);
10260 /* update the size of the client area */
10261 LISTVIEW_UpdateSize(infoPtr
);
10263 /* add scrollbars if needed */
10264 LISTVIEW_UpdateScroll(infoPtr
);
10266 /* invalidate client area + erase background */
10267 LISTVIEW_InvalidateList(infoPtr
);
10274 * Processes WM_STYLECHANGING messages.
10277 * [I] infoPtr : valid pointer to the listview structure
10278 * [I] wStyleType : window style type (normal or extended)
10279 * [I0] lpss : window style information
10284 static INT
LISTVIEW_StyleChanging(LISTVIEW_INFO
*infoPtr
, WPARAM wStyleType
,
10287 TRACE("(styletype=%lx, styleOld=0x%08x, styleNew=0x%08x)\n",
10288 wStyleType
, lpss
->styleOld
, lpss
->styleNew
);
10290 /* don't forward LVS_OWNERDATA only if not already set to */
10291 if ((lpss
->styleNew
^ lpss
->styleOld
) & LVS_OWNERDATA
)
10293 if (lpss
->styleOld
& LVS_OWNERDATA
)
10294 lpss
->styleNew
|= LVS_OWNERDATA
;
10296 lpss
->styleNew
&= ~LVS_OWNERDATA
;
10304 * Processes WM_SHOWWINDOW messages.
10307 * [I] infoPtr : valid pointer to the listview structure
10308 * [I] bShown : window is being shown (FALSE when hidden)
10309 * [I] iStatus : window show status
10314 static LRESULT
LISTVIEW_ShowWindow(LISTVIEW_INFO
*infoPtr
, BOOL bShown
, INT iStatus
)
10316 /* header delayed creation */
10317 if ((infoPtr
->uView
== LV_VIEW_DETAILS
) && bShown
)
10319 LISTVIEW_CreateHeader(infoPtr
);
10321 if (!(LVS_NOCOLUMNHEADER
& infoPtr
->dwStyle
))
10322 ShowWindow(infoPtr
->hwndHeader
, SW_SHOWNORMAL
);
10330 * Processes CCM_GETVERSION messages.
10333 * [I] infoPtr : valid pointer to the listview structure
10338 static inline LRESULT
LISTVIEW_GetVersion(const LISTVIEW_INFO
*infoPtr
)
10340 return infoPtr
->iVersion
;
10345 * Processes CCM_SETVERSION messages.
10348 * [I] infoPtr : valid pointer to the listview structure
10349 * [I] iVersion : version to be set
10352 * -1 when requested version is greater than DLL version;
10353 * previous version otherwise
10355 static LRESULT
LISTVIEW_SetVersion(LISTVIEW_INFO
*infoPtr
, DWORD iVersion
)
10357 INT iOldVersion
= infoPtr
->iVersion
;
10359 if (iVersion
> COMCTL32_VERSION
)
10362 infoPtr
->iVersion
= iVersion
;
10364 TRACE("new version %d\n", iVersion
);
10366 return iOldVersion
;
10371 * Window procedure of the listview control.
10374 static LRESULT WINAPI
10375 LISTVIEW_WindowProc(HWND hwnd
, UINT uMsg
, WPARAM wParam
, LPARAM lParam
)
10377 LISTVIEW_INFO
*infoPtr
= (LISTVIEW_INFO
*)GetWindowLongPtrW(hwnd
, 0);
10379 TRACE("(uMsg=%x wParam=%lx lParam=%lx)\n", uMsg
, wParam
, lParam
);
10381 if (!infoPtr
&& (uMsg
!= WM_NCCREATE
))
10382 return DefWindowProcW(hwnd
, uMsg
, wParam
, lParam
);
10386 case LVM_APPROXIMATEVIEWRECT
:
10387 return LISTVIEW_ApproximateViewRect(infoPtr
, (INT
)wParam
,
10388 LOWORD(lParam
), HIWORD(lParam
));
10390 return LISTVIEW_Arrange(infoPtr
, (INT
)wParam
);
10392 case LVM_CANCELEDITLABEL
:
10393 return LISTVIEW_CancelEditLabel(infoPtr
);
10395 case LVM_CREATEDRAGIMAGE
:
10396 return (LRESULT
)LISTVIEW_CreateDragImage(infoPtr
, (INT
)wParam
, (LPPOINT
)lParam
);
10398 case LVM_DELETEALLITEMS
:
10399 return LISTVIEW_DeleteAllItems(infoPtr
, FALSE
);
10401 case LVM_DELETECOLUMN
:
10402 return LISTVIEW_DeleteColumn(infoPtr
, (INT
)wParam
);
10404 case LVM_DELETEITEM
:
10405 return LISTVIEW_DeleteItem(infoPtr
, (INT
)wParam
);
10407 case LVM_EDITLABELW
:
10408 return (LRESULT
)LISTVIEW_EditLabelT(infoPtr
, (INT
)wParam
, TRUE
);
10410 case LVM_EDITLABELA
:
10411 return (LRESULT
)LISTVIEW_EditLabelT(infoPtr
, (INT
)wParam
, FALSE
);
10413 /* case LVM_ENABLEGROUPVIEW: */
10415 case LVM_ENSUREVISIBLE
:
10416 return LISTVIEW_EnsureVisible(infoPtr
, (INT
)wParam
, (BOOL
)lParam
);
10418 case LVM_FINDITEMW
:
10419 return LISTVIEW_FindItemW(infoPtr
, (INT
)wParam
, (LPLVFINDINFOW
)lParam
);
10421 case LVM_FINDITEMA
:
10422 return LISTVIEW_FindItemA(infoPtr
, (INT
)wParam
, (LPLVFINDINFOA
)lParam
);
10424 case LVM_GETBKCOLOR
:
10425 return infoPtr
->clrBk
;
10427 /* case LVM_GETBKIMAGE: */
10429 case LVM_GETCALLBACKMASK
:
10430 return infoPtr
->uCallbackMask
;
10432 case LVM_GETCOLUMNA
:
10433 return LISTVIEW_GetColumnT(infoPtr
, (INT
)wParam
, (LPLVCOLUMNW
)lParam
, FALSE
);
10435 case LVM_GETCOLUMNW
:
10436 return LISTVIEW_GetColumnT(infoPtr
, (INT
)wParam
, (LPLVCOLUMNW
)lParam
, TRUE
);
10438 case LVM_GETCOLUMNORDERARRAY
:
10439 return LISTVIEW_GetColumnOrderArray(infoPtr
, (INT
)wParam
, (LPINT
)lParam
);
10441 case LVM_GETCOLUMNWIDTH
:
10442 return LISTVIEW_GetColumnWidth(infoPtr
, (INT
)wParam
);
10444 case LVM_GETCOUNTPERPAGE
:
10445 return LISTVIEW_GetCountPerPage(infoPtr
);
10447 case LVM_GETEDITCONTROL
:
10448 return (LRESULT
)infoPtr
->hwndEdit
;
10450 case LVM_GETEXTENDEDLISTVIEWSTYLE
:
10451 return infoPtr
->dwLvExStyle
;
10453 /* case LVM_GETGROUPINFO: */
10455 /* case LVM_GETGROUPMETRICS: */
10457 case LVM_GETHEADER
:
10458 return (LRESULT
)infoPtr
->hwndHeader
;
10460 case LVM_GETHOTCURSOR
:
10461 return (LRESULT
)infoPtr
->hHotCursor
;
10463 case LVM_GETHOTITEM
:
10464 return infoPtr
->nHotItem
;
10466 case LVM_GETHOVERTIME
:
10467 return infoPtr
->dwHoverTime
;
10469 case LVM_GETIMAGELIST
:
10470 return (LRESULT
)LISTVIEW_GetImageList(infoPtr
, (INT
)wParam
);
10472 /* case LVM_GETINSERTMARK: */
10474 /* case LVM_GETINSERTMARKCOLOR: */
10476 /* case LVM_GETINSERTMARKRECT: */
10478 case LVM_GETISEARCHSTRINGA
:
10479 case LVM_GETISEARCHSTRINGW
:
10480 FIXME("LVM_GETISEARCHSTRING: unimplemented\n");
10484 return LISTVIEW_GetItemExtT(infoPtr
, (LPLVITEMW
)lParam
, FALSE
);
10487 return LISTVIEW_GetItemExtT(infoPtr
, (LPLVITEMW
)lParam
, TRUE
);
10489 case LVM_GETITEMCOUNT
:
10490 return infoPtr
->nItemCount
;
10492 case LVM_GETITEMPOSITION
:
10493 return LISTVIEW_GetItemPosition(infoPtr
, (INT
)wParam
, (LPPOINT
)lParam
);
10495 case LVM_GETITEMRECT
:
10496 return LISTVIEW_GetItemRect(infoPtr
, (INT
)wParam
, (LPRECT
)lParam
);
10498 case LVM_GETITEMSPACING
:
10499 return LISTVIEW_GetItemSpacing(infoPtr
, (BOOL
)wParam
);
10501 case LVM_GETITEMSTATE
:
10502 return LISTVIEW_GetItemState(infoPtr
, (INT
)wParam
, (UINT
)lParam
);
10504 case LVM_GETITEMTEXTA
:
10505 return LISTVIEW_GetItemTextT(infoPtr
, (INT
)wParam
, (LPLVITEMW
)lParam
, FALSE
);
10507 case LVM_GETITEMTEXTW
:
10508 return LISTVIEW_GetItemTextT(infoPtr
, (INT
)wParam
, (LPLVITEMW
)lParam
, TRUE
);
10510 case LVM_GETNEXTITEM
:
10511 return LISTVIEW_GetNextItem(infoPtr
, (INT
)wParam
, LOWORD(lParam
));
10513 case LVM_GETNUMBEROFWORKAREAS
:
10514 FIXME("LVM_GETNUMBEROFWORKAREAS: unimplemented\n");
10517 case LVM_GETORIGIN
:
10518 if (!lParam
) return FALSE
;
10519 if (infoPtr
->uView
== LV_VIEW_DETAILS
||
10520 infoPtr
->uView
== LV_VIEW_LIST
) return FALSE
;
10521 LISTVIEW_GetOrigin(infoPtr
, (LPPOINT
)lParam
);
10524 /* case LVM_GETOUTLINECOLOR: */
10526 /* case LVM_GETSELECTEDCOLUMN: */
10528 case LVM_GETSELECTEDCOUNT
:
10529 return LISTVIEW_GetSelectedCount(infoPtr
);
10531 case LVM_GETSELECTIONMARK
:
10532 return infoPtr
->nSelectionMark
;
10534 case LVM_GETSTRINGWIDTHA
:
10535 return LISTVIEW_GetStringWidthT(infoPtr
, (LPCWSTR
)lParam
, FALSE
);
10537 case LVM_GETSTRINGWIDTHW
:
10538 return LISTVIEW_GetStringWidthT(infoPtr
, (LPCWSTR
)lParam
, TRUE
);
10540 case LVM_GETSUBITEMRECT
:
10541 return LISTVIEW_GetSubItemRect(infoPtr
, (UINT
)wParam
, (LPRECT
)lParam
);
10543 case LVM_GETTEXTBKCOLOR
:
10544 return infoPtr
->clrTextBk
;
10546 case LVM_GETTEXTCOLOR
:
10547 return infoPtr
->clrText
;
10549 /* case LVM_GETTILEINFO: */
10551 /* case LVM_GETTILEVIEWINFO: */
10553 case LVM_GETTOOLTIPS
:
10554 if( !infoPtr
->hwndToolTip
)
10555 infoPtr
->hwndToolTip
= COMCTL32_CreateToolTip( hwnd
);
10556 return (LRESULT
)infoPtr
->hwndToolTip
;
10558 case LVM_GETTOPINDEX
:
10559 return LISTVIEW_GetTopIndex(infoPtr
);
10561 case LVM_GETUNICODEFORMAT
:
10562 return (infoPtr
->notifyFormat
== NFR_UNICODE
);
10565 return infoPtr
->uView
;
10567 case LVM_GETVIEWRECT
:
10568 return LISTVIEW_GetViewRect(infoPtr
, (LPRECT
)lParam
);
10570 case LVM_GETWORKAREAS
:
10571 FIXME("LVM_GETWORKAREAS: unimplemented\n");
10574 /* case LVM_HASGROUP: */
10577 return LISTVIEW_HitTest(infoPtr
, (LPLVHITTESTINFO
)lParam
, FALSE
, TRUE
);
10579 case LVM_INSERTCOLUMNA
:
10580 return LISTVIEW_InsertColumnT(infoPtr
, (INT
)wParam
, (LPLVCOLUMNW
)lParam
, FALSE
);
10582 case LVM_INSERTCOLUMNW
:
10583 return LISTVIEW_InsertColumnT(infoPtr
, (INT
)wParam
, (LPLVCOLUMNW
)lParam
, TRUE
);
10585 /* case LVM_INSERTGROUP: */
10587 /* case LVM_INSERTGROUPSORTED: */
10589 case LVM_INSERTITEMA
:
10590 return LISTVIEW_InsertItemT(infoPtr
, (LPLVITEMW
)lParam
, FALSE
);
10592 case LVM_INSERTITEMW
:
10593 return LISTVIEW_InsertItemT(infoPtr
, (LPLVITEMW
)lParam
, TRUE
);
10595 /* case LVM_INSERTMARKHITTEST: */
10597 /* case LVM_ISGROUPVIEWENABLED: */
10599 case LVM_ISITEMVISIBLE
:
10600 return LISTVIEW_IsItemVisible(infoPtr
, (INT
)wParam
);
10602 case LVM_MAPIDTOINDEX
:
10603 return LISTVIEW_MapIdToIndex(infoPtr
, (UINT
)wParam
);
10605 case LVM_MAPINDEXTOID
:
10606 return LISTVIEW_MapIndexToId(infoPtr
, (INT
)wParam
);
10608 /* case LVM_MOVEGROUP: */
10610 /* case LVM_MOVEITEMTOGROUP: */
10612 case LVM_REDRAWITEMS
:
10613 return LISTVIEW_RedrawItems(infoPtr
, (INT
)wParam
, (INT
)lParam
);
10615 /* case LVM_REMOVEALLGROUPS: */
10617 /* case LVM_REMOVEGROUP: */
10620 return LISTVIEW_Scroll(infoPtr
, (INT
)wParam
, (INT
)lParam
);
10622 case LVM_SETBKCOLOR
:
10623 return LISTVIEW_SetBkColor(infoPtr
, (COLORREF
)lParam
);
10625 /* case LVM_SETBKIMAGE: */
10627 case LVM_SETCALLBACKMASK
:
10628 infoPtr
->uCallbackMask
= (UINT
)wParam
;
10631 case LVM_SETCOLUMNA
:
10632 return LISTVIEW_SetColumnT(infoPtr
, (INT
)wParam
, (LPLVCOLUMNW
)lParam
, FALSE
);
10634 case LVM_SETCOLUMNW
:
10635 return LISTVIEW_SetColumnT(infoPtr
, (INT
)wParam
, (LPLVCOLUMNW
)lParam
, TRUE
);
10637 case LVM_SETCOLUMNORDERARRAY
:
10638 return LISTVIEW_SetColumnOrderArray(infoPtr
, (INT
)wParam
, (LPINT
)lParam
);
10640 case LVM_SETCOLUMNWIDTH
:
10641 return LISTVIEW_SetColumnWidth(infoPtr
, (INT
)wParam
, (short)LOWORD(lParam
));
10643 case LVM_SETEXTENDEDLISTVIEWSTYLE
:
10644 return LISTVIEW_SetExtendedListViewStyle(infoPtr
, (DWORD
)wParam
, (DWORD
)lParam
);
10646 /* case LVM_SETGROUPINFO: */
10648 /* case LVM_SETGROUPMETRICS: */
10650 case LVM_SETHOTCURSOR
:
10651 return (LRESULT
)LISTVIEW_SetHotCursor(infoPtr
, (HCURSOR
)lParam
);
10653 case LVM_SETHOTITEM
:
10654 return LISTVIEW_SetHotItem(infoPtr
, (INT
)wParam
);
10656 case LVM_SETHOVERTIME
:
10657 return LISTVIEW_SetHoverTime(infoPtr
, (DWORD
)wParam
);
10659 case LVM_SETICONSPACING
:
10660 return LISTVIEW_SetIconSpacing(infoPtr
, (short)LOWORD(lParam
), (short)HIWORD(lParam
));
10662 case LVM_SETIMAGELIST
:
10663 return (LRESULT
)LISTVIEW_SetImageList(infoPtr
, (INT
)wParam
, (HIMAGELIST
)lParam
);
10665 /* case LVM_SETINFOTIP: */
10667 /* case LVM_SETINSERTMARK: */
10669 /* case LVM_SETINSERTMARKCOLOR: */
10674 if (infoPtr
->dwStyle
& LVS_OWNERDATA
) return FALSE
;
10675 return LISTVIEW_SetItemT(infoPtr
, (LPLVITEMW
)lParam
, (uMsg
== LVM_SETITEMW
));
10678 case LVM_SETITEMCOUNT
:
10679 return LISTVIEW_SetItemCount(infoPtr
, (INT
)wParam
, (DWORD
)lParam
);
10681 case LVM_SETITEMPOSITION
:
10684 pt
.x
= (short)LOWORD(lParam
);
10685 pt
.y
= (short)HIWORD(lParam
);
10686 return LISTVIEW_SetItemPosition(infoPtr
, (INT
)wParam
, pt
);
10689 case LVM_SETITEMPOSITION32
:
10690 if (lParam
== 0) return FALSE
;
10691 return LISTVIEW_SetItemPosition(infoPtr
, (INT
)wParam
, *((POINT
*)lParam
));
10693 case LVM_SETITEMSTATE
:
10694 if (lParam
== 0) return FALSE
;
10695 return LISTVIEW_SetItemState(infoPtr
, (INT
)wParam
, (LPLVITEMW
)lParam
);
10697 case LVM_SETITEMTEXTA
:
10698 return LISTVIEW_SetItemTextT(infoPtr
, (INT
)wParam
, (LPLVITEMW
)lParam
, FALSE
);
10700 case LVM_SETITEMTEXTW
:
10701 return LISTVIEW_SetItemTextT(infoPtr
, (INT
)wParam
, (LPLVITEMW
)lParam
, TRUE
);
10703 /* case LVM_SETOUTLINECOLOR: */
10705 /* case LVM_SETSELECTEDCOLUMN: */
10707 case LVM_SETSELECTIONMARK
:
10708 return LISTVIEW_SetSelectionMark(infoPtr
, (INT
)lParam
);
10710 case LVM_SETTEXTBKCOLOR
:
10711 return LISTVIEW_SetTextBkColor(infoPtr
, (COLORREF
)lParam
);
10713 case LVM_SETTEXTCOLOR
:
10714 return LISTVIEW_SetTextColor(infoPtr
, (COLORREF
)lParam
);
10716 /* case LVM_SETTILEINFO: */
10718 /* case LVM_SETTILEVIEWINFO: */
10720 /* case LVM_SETTILEWIDTH: */
10722 case LVM_SETTOOLTIPS
:
10723 return (LRESULT
)LISTVIEW_SetToolTips(infoPtr
, (HWND
)lParam
);
10725 case LVM_SETUNICODEFORMAT
:
10726 return LISTVIEW_SetUnicodeFormat(infoPtr
, wParam
);
10729 return LISTVIEW_SetView(infoPtr
, wParam
);
10731 /* case LVM_SETWORKAREAS: */
10733 /* case LVM_SORTGROUPS: */
10735 case LVM_SORTITEMS
:
10736 return LISTVIEW_SortItems(infoPtr
, (PFNLVCOMPARE
)lParam
, (LPARAM
)wParam
, FALSE
);
10738 case LVM_SORTITEMSEX
:
10739 return LISTVIEW_SortItems(infoPtr
, (PFNLVCOMPARE
)lParam
, (LPARAM
)wParam
, TRUE
);
10741 case LVM_SUBITEMHITTEST
:
10742 return LISTVIEW_HitTest(infoPtr
, (LPLVHITTESTINFO
)lParam
, TRUE
, FALSE
);
10745 return LISTVIEW_Update(infoPtr
, (INT
)wParam
);
10747 case CCM_GETVERSION
:
10748 return LISTVIEW_GetVersion(infoPtr
);
10750 case CCM_SETVERSION
:
10751 return LISTVIEW_SetVersion(infoPtr
, wParam
);
10754 return LISTVIEW_ProcessLetterKeys( infoPtr
, wParam
, lParam
);
10757 return LISTVIEW_Command(infoPtr
, wParam
, lParam
);
10760 return LISTVIEW_NCCreate(hwnd
, (LPCREATESTRUCTW
)lParam
);
10763 return LISTVIEW_Create(hwnd
, (LPCREATESTRUCTW
)lParam
);
10766 return LISTVIEW_Destroy(infoPtr
);
10769 return LISTVIEW_Enable(infoPtr
, (BOOL
)wParam
);
10771 case WM_ERASEBKGND
:
10772 return LISTVIEW_EraseBkgnd(infoPtr
, (HDC
)wParam
);
10774 case WM_GETDLGCODE
:
10775 return DLGC_WANTCHARS
| DLGC_WANTARROWS
;
10778 return (LRESULT
)infoPtr
->hFont
;
10781 return LISTVIEW_HScroll(infoPtr
, (INT
)LOWORD(wParam
), 0, (HWND
)lParam
);
10784 return LISTVIEW_KeyDown(infoPtr
, (INT
)wParam
, (LONG
)lParam
);
10787 return LISTVIEW_KillFocus(infoPtr
);
10789 case WM_LBUTTONDBLCLK
:
10790 return LISTVIEW_LButtonDblClk(infoPtr
, (WORD
)wParam
, (SHORT
)LOWORD(lParam
), (SHORT
)HIWORD(lParam
));
10792 case WM_LBUTTONDOWN
:
10793 return LISTVIEW_LButtonDown(infoPtr
, (WORD
)wParam
, (SHORT
)LOWORD(lParam
), (SHORT
)HIWORD(lParam
));
10796 return LISTVIEW_LButtonUp(infoPtr
, (WORD
)wParam
, (SHORT
)LOWORD(lParam
), (SHORT
)HIWORD(lParam
));
10799 return LISTVIEW_MouseMove (infoPtr
, (WORD
)wParam
, (SHORT
)LOWORD(lParam
), (SHORT
)HIWORD(lParam
));
10801 case WM_MOUSEHOVER
:
10802 return LISTVIEW_MouseHover(infoPtr
, (WORD
)wParam
, (SHORT
)LOWORD(lParam
), (SHORT
)HIWORD(lParam
));
10805 return LISTVIEW_NCDestroy(infoPtr
);
10808 if (LISTVIEW_NCPaint(infoPtr
, (HRGN
)wParam
))
10813 if (lParam
&& ((LPNMHDR
)lParam
)->hwndFrom
== infoPtr
->hwndHeader
)
10814 return LISTVIEW_HeaderNotification(infoPtr
, (LPNMHEADERW
)lParam
);
10817 case WM_NOTIFYFORMAT
:
10818 return LISTVIEW_NotifyFormat(infoPtr
, (HWND
)wParam
, (INT
)lParam
);
10820 case WM_PRINTCLIENT
:
10821 return LISTVIEW_PrintClient(infoPtr
, (HDC
)wParam
, (DWORD
)lParam
);
10824 return LISTVIEW_WMPaint(infoPtr
, (HDC
)wParam
);
10826 case WM_RBUTTONDBLCLK
:
10827 return LISTVIEW_RButtonDblClk(infoPtr
, (WORD
)wParam
, (SHORT
)LOWORD(lParam
), (SHORT
)HIWORD(lParam
));
10829 case WM_RBUTTONDOWN
:
10830 return LISTVIEW_RButtonDown(infoPtr
, (WORD
)wParam
, (SHORT
)LOWORD(lParam
), (SHORT
)HIWORD(lParam
));
10833 return LISTVIEW_RButtonUp(infoPtr
, (WORD
)wParam
, (SHORT
)LOWORD(lParam
), (SHORT
)HIWORD(lParam
));
10836 if(LISTVIEW_SetCursor(infoPtr
, (HWND
)wParam
, LOWORD(lParam
), HIWORD(lParam
)))
10841 return LISTVIEW_SetFocus(infoPtr
, (HWND
)wParam
);
10844 return LISTVIEW_SetFont(infoPtr
, (HFONT
)wParam
, (WORD
)lParam
);
10847 return LISTVIEW_SetRedraw(infoPtr
, (BOOL
)wParam
);
10849 case WM_SHOWWINDOW
:
10850 LISTVIEW_ShowWindow(infoPtr
, (BOOL
)wParam
, (INT
)lParam
);
10851 return DefWindowProcW(hwnd
, uMsg
, wParam
, lParam
);
10854 return LISTVIEW_Size(infoPtr
, (short)LOWORD(lParam
), (short)HIWORD(lParam
));
10856 case WM_STYLECHANGED
:
10857 return LISTVIEW_StyleChanged(infoPtr
, wParam
, (LPSTYLESTRUCT
)lParam
);
10859 case WM_STYLECHANGING
:
10860 return LISTVIEW_StyleChanging(infoPtr
, wParam
, (LPSTYLESTRUCT
)lParam
);
10862 case WM_SYSCOLORCHANGE
:
10863 COMCTL32_RefreshSysColors();
10866 /* case WM_TIMER: */
10867 case WM_THEMECHANGED
:
10868 return LISTVIEW_ThemeChanged(infoPtr
);
10871 return LISTVIEW_VScroll(infoPtr
, (INT
)LOWORD(wParam
), 0, (HWND
)lParam
);
10873 case WM_MOUSEWHEEL
:
10874 if (wParam
& (MK_SHIFT
| MK_CONTROL
))
10875 return DefWindowProcW(hwnd
, uMsg
, wParam
, lParam
);
10876 return LISTVIEW_MouseWheel(infoPtr
, (short int)HIWORD(wParam
));
10878 case WM_WINDOWPOSCHANGED
:
10879 if (!(((WINDOWPOS
*)lParam
)->flags
& SWP_NOSIZE
))
10881 SetWindowPos(infoPtr
->hwndSelf
, 0, 0, 0, 0, 0, SWP_FRAMECHANGED
| SWP_NOACTIVATE
|
10882 SWP_NOZORDER
| SWP_NOMOVE
| SWP_NOSIZE
);
10884 if ((infoPtr
->dwStyle
& LVS_OWNERDRAWFIXED
) && (infoPtr
->uView
== LV_VIEW_DETAILS
))
10886 if (notify_measureitem(infoPtr
)) LISTVIEW_InvalidateList(infoPtr
);
10889 LISTVIEW_UpdateSize(infoPtr
);
10890 LISTVIEW_UpdateScroll(infoPtr
);
10892 return DefWindowProcW(hwnd
, uMsg
, wParam
, lParam
);
10894 /* case WM_WININICHANGE: */
10897 if ((uMsg
>= WM_USER
) && (uMsg
< WM_APP
) && !COMCTL32_IsReflectedMessage(uMsg
))
10898 ERR("unknown msg %04x wp=%08lx lp=%08lx\n", uMsg
, wParam
, lParam
);
10901 /* call default window procedure */
10902 return DefWindowProcW(hwnd
, uMsg
, wParam
, lParam
);
10909 * Registers the window class.
10917 void LISTVIEW_Register(void)
10919 WNDCLASSW wndClass
;
10921 ZeroMemory(&wndClass
, sizeof(WNDCLASSW
));
10922 wndClass
.style
= CS_GLOBALCLASS
| CS_DBLCLKS
;
10923 wndClass
.lpfnWndProc
= LISTVIEW_WindowProc
;
10924 wndClass
.cbClsExtra
= 0;
10925 wndClass
.cbWndExtra
= sizeof(LISTVIEW_INFO
*);
10926 wndClass
.hCursor
= LoadCursorW(0, (LPWSTR
)IDC_ARROW
);
10927 wndClass
.hbrBackground
= (HBRUSH
)(COLOR_WINDOW
+ 1);
10928 wndClass
.lpszClassName
= WC_LISTVIEWW
;
10929 RegisterClassW(&wndClass
);
10934 * Unregisters the window class.
10942 void LISTVIEW_Unregister(void)
10944 UnregisterClassW(WC_LISTVIEWW
, NULL
);
10949 * Handle any WM_COMMAND messages
10952 * [I] infoPtr : valid pointer to the listview structure
10953 * [I] wParam : the first message parameter
10954 * [I] lParam : the second message parameter
10959 static LRESULT
LISTVIEW_Command(LISTVIEW_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
10961 switch (HIWORD(wParam
))
10966 * Adjust the edit window size
10968 WCHAR buffer
[1024];
10969 HDC hdc
= GetDC(infoPtr
->hwndEdit
);
10970 HFONT hFont
, hOldFont
= 0;
10974 if (!infoPtr
->hwndEdit
|| !hdc
) return 0;
10975 GetWindowTextW(infoPtr
->hwndEdit
, buffer
, sizeof(buffer
)/sizeof(buffer
[0]));
10976 GetWindowRect(infoPtr
->hwndEdit
, &rect
);
10978 /* Select font to get the right dimension of the string */
10979 hFont
= (HFONT
)SendMessageW(infoPtr
->hwndEdit
, WM_GETFONT
, 0, 0);
10982 hOldFont
= SelectObject(hdc
, hFont
);
10985 if (GetTextExtentPoint32W(hdc
, buffer
, lstrlenW(buffer
), &sz
))
10987 TEXTMETRICW textMetric
;
10989 /* Add Extra spacing for the next character */
10990 GetTextMetricsW(hdc
, &textMetric
);
10991 sz
.cx
+= (textMetric
.tmMaxCharWidth
* 2);
10999 rect
.bottom
- rect
.top
,
11000 SWP_DRAWFRAME
|SWP_NOMOVE
);
11003 SelectObject(hdc
, hOldFont
);
11005 ReleaseDC(infoPtr
->hwndEdit
, hdc
);
11011 LISTVIEW_CancelEditLabel(infoPtr
);
11015 return SendMessageW (infoPtr
->hwndNotify
, WM_COMMAND
, wParam
, lParam
);
11024 * Subclassed edit control windproc function
11027 * [I] hwnd : the edit window handle
11028 * [I] uMsg : the message that is to be processed
11029 * [I] wParam : first message parameter
11030 * [I] lParam : second message parameter
11031 * [I] isW : TRUE if input is Unicode
11036 static LRESULT
EditLblWndProcT(HWND hwnd
, UINT uMsg
, WPARAM wParam
, LPARAM lParam
, BOOL isW
)
11038 LISTVIEW_INFO
*infoPtr
= (LISTVIEW_INFO
*)GetWindowLongPtrW(GetParent(hwnd
), 0);
11041 TRACE("(hwnd=%p, uMsg=%x, wParam=%lx, lParam=%lx, isW=%d)\n",
11042 hwnd
, uMsg
, wParam
, lParam
, isW
);
11046 case WM_GETDLGCODE
:
11047 return DLGC_WANTARROWS
| DLGC_WANTALLKEYS
;
11051 WNDPROC editProc
= infoPtr
->EditWndProc
;
11052 infoPtr
->EditWndProc
= 0;
11053 SetWindowLongPtrW(hwnd
, GWLP_WNDPROC
, (DWORD_PTR
)editProc
);
11054 return CallWindowProcT(editProc
, hwnd
, uMsg
, wParam
, lParam
, isW
);
11058 if (VK_ESCAPE
== (INT
)wParam
)
11063 else if (VK_RETURN
== (INT
)wParam
)
11067 return CallWindowProcT(infoPtr
->EditWndProc
, hwnd
, uMsg
, wParam
, lParam
, isW
);
11070 /* kill the edit */
11071 if (infoPtr
->hwndEdit
)
11072 LISTVIEW_EndEditLabelT(infoPtr
, save
, isW
);
11074 SendMessageW(hwnd
, WM_CLOSE
, 0, 0);
11080 * Subclassed edit control Unicode windproc function
11083 * [I] hwnd : the edit window handle
11084 * [I] uMsg : the message that is to be processed
11085 * [I] wParam : first message parameter
11086 * [I] lParam : second message parameter
11090 static LRESULT CALLBACK
EditLblWndProcW(HWND hwnd
, UINT uMsg
, WPARAM wParam
, LPARAM lParam
)
11092 return EditLblWndProcT(hwnd
, uMsg
, wParam
, lParam
, TRUE
);
11097 * Subclassed edit control ANSI windproc function
11100 * [I] hwnd : the edit window handle
11101 * [I] uMsg : the message that is to be processed
11102 * [I] wParam : first message parameter
11103 * [I] lParam : second message parameter
11107 static LRESULT CALLBACK
EditLblWndProcA(HWND hwnd
, UINT uMsg
, WPARAM wParam
, LPARAM lParam
)
11109 return EditLblWndProcT(hwnd
, uMsg
, wParam
, lParam
, FALSE
);
11114 * Creates a subclassed edit control
11117 * [I] infoPtr : valid pointer to the listview structure
11118 * [I] text : initial text for the edit
11119 * [I] style : the window style
11120 * [I] isW : TRUE if input is Unicode
11124 static HWND
CreateEditLabelT(LISTVIEW_INFO
*infoPtr
, LPCWSTR text
, DWORD style
, BOOL isW
)
11126 WCHAR editName
[5] = { 'E', 'd', 'i', 't', '\0' };
11128 HINSTANCE hinst
= (HINSTANCE
)GetWindowLongPtrW(infoPtr
->hwndSelf
, GWLP_HINSTANCE
);
11130 TRACE("(text=%s, ..., isW=%d)\n", debugtext_t(text
, isW
), isW
);
11132 style
|= WS_CHILDWINDOW
|WS_CLIPSIBLINGS
|ES_LEFT
|ES_AUTOHSCROLL
|WS_BORDER
;
11134 /* Window will be resized and positioned after LVN_BEGINLABELEDIT */
11136 hedit
= CreateWindowW(editName
, text
, style
, 0, 0, 0, 0, infoPtr
->hwndSelf
, 0, hinst
, 0);
11138 hedit
= CreateWindowA("Edit", (LPCSTR
)text
, style
, 0, 0, 0, 0, infoPtr
->hwndSelf
, 0, hinst
, 0);
11140 if (!hedit
) return 0;
11142 infoPtr
->EditWndProc
= (WNDPROC
)
11143 (isW
? SetWindowLongPtrW(hedit
, GWLP_WNDPROC
, (DWORD_PTR
)EditLblWndProcW
) :
11144 SetWindowLongPtrA(hedit
, GWLP_WNDPROC
, (DWORD_PTR
)EditLblWndProcA
) );
11146 SendMessageW(hedit
, WM_SETFONT
, (WPARAM
)infoPtr
->hFont
, FALSE
);