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
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with this library; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
26 * This code was audited for completeness against the documented features
27 * of Comctl32.dll version 6.0 on May. 20, 2005, by James Hawkins.
29 * Unless otherwise noted, we believe this code to be complete, as per
30 * the specification mentioned above.
31 * If you discover missing features, or bugs, please note them below.
35 * Default Message Processing
36 * -- EN_KILLFOCUS should be handled in WM_COMMAND
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_ERASEBKGND: forward this message to the parent window if the bkgnd
41 * -- WM_WINDOWPOSCHANGED: arrange the list items if the current view is icon
42 * or small icon and the LVS_AUTOARRANGE style is specified.
47 * -- Hot item handling, mouse hovering
48 * -- Workareas support
53 * -- Expand large item in ICON mode when the cursor is flying over the icon or text.
54 * -- Support CustomDraw options for _WIN32_IE >= 0x560 (see NMLVCUSTOMDRAW docs).
55 * -- LVA_SNAPTOGRID not implemented
56 * -- LISTVIEW_ApproximateViewRect partially implemented
57 * -- LISTVIEW_[GS]etColumnOrderArray stubs
58 * -- LISTVIEW_SetColumnWidth ignores header images & bitmap
59 * -- LISTVIEW_SetIconSpacing is incomplete
60 * -- LISTVIEW_StyleChanged doesn't handle some changes too well
63 * -- LISTVIEW_GetNextItem needs to be rewritten. It is currently
64 * linear in the number of items in the list, and this is
65 * unacceptable for large lists.
66 * -- in sorted mode, LISTVIEW_InsertItemT sorts the array,
67 * instead of inserting in the right spot
68 * -- we should keep an ordered array of coordinates in iconic mode
69 * this would allow to frame items (iterator_frameditems),
70 * and find nearest item (LVFI_NEARESTXY) a lot more efficiently
78 * -- LVIS_ACTIVATING (not currently supported by comctl32.dll version 6.0)
85 * -- LVS_NOSCROLL (see Q137520)
86 * -- LVS_SORTASCENDING, LVS_SORTDESCENDING
88 * -- LVS_TYPESTYLEMASK
91 * -- LVS_EX_BORDERSELECT
93 * -- LVS_EX_HEADERDRAGDROP
96 * -- LVS_EX_MULTIWORKAREAS
98 * -- LVS_EX_SIMPLESELECT
99 * -- LVS_EX_TWOCLICKACTIVATE
100 * -- LVS_EX_UNDERLINECOLD
101 * -- LVS_EX_UNDERLINEHOT
104 * -- LVN_BEGINSCROLL, LVN_ENDSCROLL
107 * -- LVN_MARQUEEBEGIN
113 * -- LVM_CANCELEDITLABEL
114 * -- LVM_ENABLEGROUPVIEW
115 * -- LVM_GETBKIMAGE, LVM_SETBKIMAGE
116 * -- LVM_GETGROUPINFO, LVM_SETGROUPINFO
117 * -- LVM_GETGROUPMETRICS, LVM_SETGROUPMETRICS
118 * -- LVM_GETINSERTMARK, LVM_SETINSERTMARK
119 * -- LVM_GETINSERTMARKCOLOR, LVM_SETINSERTMARKCOLOR
120 * -- LVM_GETINSERTMARKRECT
121 * -- LVM_GETNUMBEROFWORKAREAS
122 * -- LVM_GETOUTLINECOLOR, LVM_SETOUTLINECOLOR
123 * -- LVM_GETSELECTEDCOLUMN, LVM_SETSELECTEDCOLUMN
124 * -- LVM_GETISEARCHSTRINGW, LVM_GETISEARCHSTRINGA
125 * -- LVM_GETTILEINFO, LVM_SETTILEINFO
126 * -- LVM_GETTILEVIEWINFO, LVM_SETTILEVIEWINFO
127 * -- LVM_GETUNICODEFORMAT, LVM_SETUNICODEFORMAT
128 * -- LVM_GETVIEW, LVM_SETVIEW
129 * -- LVM_GETWORKAREAS, LVM_SETWORKAREAS
130 * -- LVM_HASGROUP, LVM_INSERTGROUP, LVM_REMOVEGROUP, LVM_REMOVEALLGROUPS
131 * -- LVM_INSERTGROUPSORTED
132 * -- LVM_INSERTMARKHITTEST
133 * -- LVM_ISGROUPVIEWENABLED
134 * -- LVM_MAPIDTOINDEX, LVM_MAPINDEXTOID
136 * -- LVM_MOVEITEMTOGROUP
138 * -- LVM_SETTILEWIDTH
142 * -- ListView_GetCheckSate, ListView_SetCheckState
143 * -- ListView_GetHoverTime, ListView_SetHoverTime
144 * -- ListView_GetISearchString
145 * -- ListView_GetNumberOfWorkAreas
146 * -- ListView_GetOrigin
147 * -- ListView_GetUnicodeFormat, ListView_SetUnicodeFormat
148 * -- ListView_GetWorkAreas, ListView_SetWorkAreas
153 * Known differences in message stream from native control (not known if
154 * these differences cause problems):
155 * LVM_INSERTITEM issues LVM_SETITEMSTATE and LVM_SETITEM in certain cases.
156 * LVM_SETITEM does not always issue LVN_ITEMCHANGING/LVN_ITEMCHANGED.
157 * WM_CREATE does not issue WM_QUERYUISTATE and associated registry
158 * processing for "USEDOUBLECLICKTIME".
162 #include "wine/port.h"
177 #include "commctrl.h"
178 #include "comctl32.h"
181 #include "wine/debug.h"
182 #include "wine/unicode.h"
184 WINE_DEFAULT_DEBUG_CHANNEL(listview
);
186 /* make sure you set this to 0 for production use! */
187 #define DEBUG_RANGES 1
189 typedef struct tagCOLUMN_INFO
191 RECT rcHeader
; /* tracks the header's rectangle */
192 int fmt
; /* same as LVCOLUMN.fmt */
195 typedef struct tagITEMHDR
199 } ITEMHDR
, *LPITEMHDR
;
201 typedef struct tagSUBITEM_INFO
207 typedef struct tagITEM_INFO
215 typedef struct tagRANGE
221 typedef struct tagRANGES
226 typedef struct tagITERATOR
235 typedef struct tagDELAYED_ITEM_EDIT
241 typedef struct tagLISTVIEW_INFO
248 HIMAGELIST himlNormal
;
249 HIMAGELIST himlSmall
;
250 HIMAGELIST himlState
;
254 POINT ptClickPos
; /* point where the user clicked */
255 BOOL bNoItemMetrics
; /* flags if item metrics are not yet computed */
258 RANGES selectionRanges
;
263 RECT rcList
; /* This rectangle is really the window
264 * client rectangle possibly reduced by the
265 * horizontal scroll bar and/or header - see
266 * LISTVIEW_UpdateSize. This rectangle offset
267 * by the LISTVIEW_GetOrigin value is in
268 * client coordinates */
277 INT ntmHeight
; /* Some cached metrics of the font used */
278 INT ntmMaxCharWidth
; /* by the listview to draw items */
280 BOOL bRedraw
; /* Turns on/off repaints & invalidations */
281 BOOL bAutoarrange
; /* Autoarrange flag when NOT in LVS_AUTOARRANGE */
283 BOOL bDoChangeNotify
; /* send change notification messages? */
286 DWORD dwStyle
; /* the cached window GWL_STYLE */
287 DWORD dwLvExStyle
; /* extended listview style */
288 INT nItemCount
; /* the number of items in the list */
289 HDPA hdpaItems
; /* array ITEM_INFO pointers */
290 HDPA hdpaPosX
; /* maintains the (X, Y) coordinates of the */
291 HDPA hdpaPosY
; /* items in LVS_ICON, and LVS_SMALLICON modes */
292 HDPA hdpaColumns
; /* array of COLUMN_INFO pointers */
293 POINT currIconPos
; /* this is the position next icon will be placed */
294 PFNLVCOMPARE pfnCompare
;
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 */
317 /* How many we debug buffer to allocate */
318 #define DEBUG_BUFFERS 20
319 /* The size of a single debug bbuffer */
320 #define DEBUG_BUFFER_SIZE 256
322 /* Internal interface to LISTVIEW_HScroll and LISTVIEW_VScroll */
323 #define SB_INTERNAL -1
325 /* maximum size of a label */
326 #define DISP_TEXT_SIZE 512
328 /* padding for items in list and small icon display modes */
329 #define WIDTH_PADDING 12
331 /* padding for items in list, report and small icon display modes */
332 #define HEIGHT_PADDING 1
334 /* offset of items in report display mode */
335 #define REPORT_MARGINX 2
337 /* padding for icon in large icon display mode
338 * ICON_TOP_PADDING_NOTHITABLE - space between top of box and area
339 * that HITTEST will see.
340 * ICON_TOP_PADDING_HITABLE - spacing between above and icon.
341 * ICON_TOP_PADDING - sum of the two above.
342 * ICON_BOTTOM_PADDING - between bottom of icon and top of text
343 * LABEL_HOR_PADDING - between text and sides of box
344 * LABEL_VERT_PADDING - between bottom of text and end of box
346 * ICON_LR_PADDING - additional width above icon size.
347 * ICON_LR_HALF - half of the above value
349 #define ICON_TOP_PADDING_NOTHITABLE 2
350 #define ICON_TOP_PADDING_HITABLE 2
351 #define ICON_TOP_PADDING (ICON_TOP_PADDING_NOTHITABLE + ICON_TOP_PADDING_HITABLE)
352 #define ICON_BOTTOM_PADDING 4
353 #define LABEL_HOR_PADDING 5
354 #define LABEL_VERT_PADDING 7
355 #define ICON_LR_PADDING 16
356 #define ICON_LR_HALF (ICON_LR_PADDING/2)
358 /* default label width for items in list and small icon display modes */
359 #define DEFAULT_LABEL_WIDTH 40
361 /* default column width for items in list display mode */
362 #define DEFAULT_COLUMN_WIDTH 128
364 /* Size of "line" scroll for V & H scrolls */
365 #define LISTVIEW_SCROLL_ICON_LINE_SIZE 37
367 /* Padding between image and label */
368 #define IMAGE_PADDING 2
370 /* Padding behind the label */
371 #define TRAILING_LABEL_PADDING 12
372 #define TRAILING_HEADER_PADDING 11
374 /* Border for the icon caption */
375 #define CAPTION_BORDER 2
377 /* Standard DrawText flags */
378 #define LV_ML_DT_FLAGS (DT_TOP | DT_NOPREFIX | DT_EDITCONTROL | DT_CENTER | DT_WORDBREAK | DT_WORD_ELLIPSIS | DT_END_ELLIPSIS)
379 #define LV_FL_DT_FLAGS (DT_TOP | DT_NOPREFIX | DT_EDITCONTROL | DT_CENTER | DT_WORDBREAK | DT_NOCLIP)
380 #define LV_SL_DT_FLAGS (DT_VCENTER | DT_NOPREFIX | DT_EDITCONTROL | DT_SINGLELINE | DT_WORD_ELLIPSIS | DT_END_ELLIPSIS)
382 /* Image index from state */
383 #define STATEIMAGEINDEX(x) (((x) & LVIS_STATEIMAGEMASK) >> 12)
385 /* The time in milliseconds to reset the search in the list */
386 #define KEY_DELAY 450
388 /* Dump the LISTVIEW_INFO structure to the debug channel */
389 #define LISTVIEW_DUMP(iP) do { \
390 TRACE("hwndSelf=%p, clrBk=0x%06x, clrText=0x%06x, clrTextBk=0x%06x, ItemHeight=%d, ItemWidth=%d, Style=0x%08x\n", \
391 iP->hwndSelf, iP->clrBk, iP->clrText, iP->clrTextBk, \
392 iP->nItemHeight, iP->nItemWidth, iP->dwStyle); \
393 TRACE("hwndSelf=%p, himlNor=%p, himlSml=%p, himlState=%p, Focused=%d, Hot=%d, exStyle=0x%08x, Focus=%d\n", \
394 iP->hwndSelf, iP->himlNormal, iP->himlSmall, iP->himlState, \
395 iP->nFocusedItem, iP->nHotItem, iP->dwLvExStyle, iP->bFocus ); \
396 TRACE("hwndSelf=%p, ntmH=%d, icSz.cx=%d, icSz.cy=%d, icSp.cx=%d, icSp.cy=%d, notifyFmt=%d\n", \
397 iP->hwndSelf, iP->ntmHeight, iP->iconSize.cx, iP->iconSize.cy, \
398 iP->iconSpacing.cx, iP->iconSpacing.cy, iP->notifyFormat); \
399 TRACE("hwndSelf=%p, rcList=%s\n", iP->hwndSelf, wine_dbgstr_rect(&iP->rcList)); \
402 static const WCHAR themeClass
[] = {'L','i','s','t','V','i','e','w',0};
405 * forward declarations
407 static BOOL
LISTVIEW_GetItemT(const LISTVIEW_INFO
*, LPLVITEMW
, BOOL
);
408 static void LISTVIEW_GetItemBox(const LISTVIEW_INFO
*, INT
, LPRECT
);
409 static void LISTVIEW_GetItemOrigin(const LISTVIEW_INFO
*, INT
, LPPOINT
);
410 static BOOL
LISTVIEW_GetItemPosition(const LISTVIEW_INFO
*, INT
, LPPOINT
);
411 static BOOL
LISTVIEW_GetItemRect(const LISTVIEW_INFO
*, INT
, LPRECT
);
412 static INT
LISTVIEW_GetLabelWidth(const LISTVIEW_INFO
*, INT
);
413 static void LISTVIEW_GetOrigin(const LISTVIEW_INFO
*, LPPOINT
);
414 static BOOL
LISTVIEW_GetViewRect(const LISTVIEW_INFO
*, LPRECT
);
415 static void LISTVIEW_SetGroupSelection(LISTVIEW_INFO
*, INT
);
416 static BOOL
LISTVIEW_SetItemT(LISTVIEW_INFO
*, LVITEMW
*, BOOL
);
417 static void LISTVIEW_UpdateScroll(const LISTVIEW_INFO
*);
418 static void LISTVIEW_SetSelection(LISTVIEW_INFO
*, INT
);
419 static void LISTVIEW_UpdateSize(LISTVIEW_INFO
*);
420 static HWND
LISTVIEW_EditLabelT(LISTVIEW_INFO
*, INT
, BOOL
);
421 static LRESULT
LISTVIEW_Command(const LISTVIEW_INFO
*, WPARAM
, LPARAM
);
422 static INT
LISTVIEW_GetStringWidthT(const LISTVIEW_INFO
*, LPCWSTR
, BOOL
);
423 static BOOL
LISTVIEW_KeySelection(LISTVIEW_INFO
*, INT
, BOOL
);
424 static UINT
LISTVIEW_GetItemState(const LISTVIEW_INFO
*, INT
, UINT
);
425 static BOOL
LISTVIEW_SetItemState(LISTVIEW_INFO
*, INT
, const LVITEMW
*);
426 static LRESULT
LISTVIEW_VScroll(LISTVIEW_INFO
*, INT
, INT
, HWND
);
427 static LRESULT
LISTVIEW_HScroll(LISTVIEW_INFO
*, INT
, INT
, HWND
);
428 static INT
LISTVIEW_GetTopIndex(const LISTVIEW_INFO
*);
429 static BOOL
LISTVIEW_EnsureVisible(LISTVIEW_INFO
*, INT
, BOOL
);
430 static HWND
CreateEditLabelT(LISTVIEW_INFO
*, LPCWSTR
, DWORD
, INT
, INT
, INT
, INT
, BOOL
);
431 static HIMAGELIST
LISTVIEW_SetImageList(LISTVIEW_INFO
*, INT
, HIMAGELIST
);
432 static INT
LISTVIEW_HitTest(const LISTVIEW_INFO
*, LPLVHITTESTINFO
, BOOL
, BOOL
);
434 /******** Text handling functions *************************************/
436 /* A text pointer is either NULL, LPSTR_TEXTCALLBACK, or points to a
437 * text string. The string may be ANSI or Unicode, in which case
438 * the boolean isW tells us the type of the string.
440 * The name of the function tell what type of strings it expects:
441 * W: Unicode, T: ANSI/Unicode - function of isW
444 static inline BOOL
is_textW(LPCWSTR text
)
446 return text
!= NULL
&& text
!= LPSTR_TEXTCALLBACKW
;
449 static inline BOOL
is_textT(LPCWSTR text
, BOOL isW
)
451 /* we can ignore isW since LPSTR_TEXTCALLBACKW == LPSTR_TEXTCALLBACKA */
452 return is_textW(text
);
455 static inline int textlenT(LPCWSTR text
, BOOL isW
)
457 return !is_textT(text
, isW
) ? 0 :
458 isW
? lstrlenW(text
) : lstrlenA((LPCSTR
)text
);
461 static inline void textcpynT(LPWSTR dest
, BOOL isDestW
, LPCWSTR src
, BOOL isSrcW
, INT max
)
464 if (isSrcW
) lstrcpynW(dest
, src
, max
);
465 else MultiByteToWideChar(CP_ACP
, 0, (LPCSTR
)src
, -1, dest
, max
);
467 if (isSrcW
) WideCharToMultiByte(CP_ACP
, 0, src
, -1, (LPSTR
)dest
, max
, NULL
, NULL
);
468 else lstrcpynA((LPSTR
)dest
, (LPCSTR
)src
, max
);
471 static inline LPWSTR
textdupTtoW(LPCWSTR text
, BOOL isW
)
473 LPWSTR wstr
= (LPWSTR
)text
;
475 if (!isW
&& is_textT(text
, isW
))
477 INT len
= MultiByteToWideChar(CP_ACP
, 0, (LPCSTR
)text
, -1, NULL
, 0);
478 wstr
= Alloc(len
* sizeof(WCHAR
));
479 if (wstr
) MultiByteToWideChar(CP_ACP
, 0, (LPCSTR
)text
, -1, wstr
, len
);
481 TRACE(" wstr=%s\n", text
== LPSTR_TEXTCALLBACKW
? "(callback)" : debugstr_w(wstr
));
485 static inline void textfreeT(LPWSTR wstr
, BOOL isW
)
487 if (!isW
&& is_textT(wstr
, isW
)) Free (wstr
);
491 * dest is a pointer to a Unicode string
492 * src is a pointer to a string (Unicode if isW, ANSI if !isW)
494 static BOOL
textsetptrT(LPWSTR
*dest
, LPCWSTR src
, BOOL isW
)
498 if (src
== LPSTR_TEXTCALLBACKW
)
500 if (is_textW(*dest
)) Free(*dest
);
501 *dest
= LPSTR_TEXTCALLBACKW
;
505 LPWSTR pszText
= textdupTtoW(src
, isW
);
506 if (*dest
== LPSTR_TEXTCALLBACKW
) *dest
= NULL
;
507 bResult
= Str_SetPtrW(dest
, pszText
);
508 textfreeT(pszText
, isW
);
514 * compares a Unicode to a Unicode/ANSI text string
516 static inline int textcmpWT(LPCWSTR aw
, LPCWSTR bt
, BOOL isW
)
518 if (!aw
) return bt
? -1 : 0;
519 if (!bt
) return aw
? 1 : 0;
520 if (aw
== LPSTR_TEXTCALLBACKW
)
521 return bt
== LPSTR_TEXTCALLBACKW
? 0 : -1;
522 if (bt
!= LPSTR_TEXTCALLBACKW
)
524 LPWSTR bw
= textdupTtoW(bt
, isW
);
525 int r
= bw
? lstrcmpW(aw
, bw
) : 1;
533 static inline int lstrncmpiW(LPCWSTR s1
, LPCWSTR s2
, int n
)
537 n
= min(min(n
, lstrlenW(s1
)), lstrlenW(s2
));
538 res
= CompareStringW(LOCALE_USER_DEFAULT
, NORM_IGNORECASE
, s1
, n
, s2
, n
);
539 return res
? res
- sizeof(WCHAR
) : res
;
542 /******** Debugging functions *****************************************/
544 static inline LPCSTR
debugtext_t(LPCWSTR text
, BOOL isW
)
546 if (text
== LPSTR_TEXTCALLBACKW
) return "(callback)";
547 return isW
? debugstr_w(text
) : debugstr_a((LPCSTR
)text
);
550 static inline LPCSTR
debugtext_tn(LPCWSTR text
, BOOL isW
, INT n
)
552 if (text
== LPSTR_TEXTCALLBACKW
) return "(callback)";
553 n
= min(textlenT(text
, isW
), n
);
554 return isW
? debugstr_wn(text
, n
) : debugstr_an((LPCSTR
)text
, n
);
557 static char* debug_getbuf(void)
559 static int index
= 0;
560 static char buffers
[DEBUG_BUFFERS
][DEBUG_BUFFER_SIZE
];
561 return buffers
[index
++ % DEBUG_BUFFERS
];
564 static inline const char* debugrange(const RANGE
*lprng
)
566 if (!lprng
) return "(null)";
567 return wine_dbg_sprintf("[%d, %d]", lprng
->lower
, lprng
->upper
);
570 static const char* debugscrollinfo(const SCROLLINFO
*pScrollInfo
)
572 char* buf
= debug_getbuf(), *text
= buf
;
573 int len
, size
= DEBUG_BUFFER_SIZE
;
575 if (pScrollInfo
== NULL
) return "(null)";
576 len
= snprintf(buf
, size
, "{cbSize=%d, ", pScrollInfo
->cbSize
);
577 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
578 if (pScrollInfo
->fMask
& SIF_RANGE
)
579 len
= snprintf(buf
, size
, "nMin=%d, nMax=%d, ", pScrollInfo
->nMin
, pScrollInfo
->nMax
);
581 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
582 if (pScrollInfo
->fMask
& SIF_PAGE
)
583 len
= snprintf(buf
, size
, "nPage=%u, ", pScrollInfo
->nPage
);
585 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
586 if (pScrollInfo
->fMask
& SIF_POS
)
587 len
= snprintf(buf
, size
, "nPos=%d, ", pScrollInfo
->nPos
);
589 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
590 if (pScrollInfo
->fMask
& SIF_TRACKPOS
)
591 len
= snprintf(buf
, size
, "nTrackPos=%d, ", pScrollInfo
->nTrackPos
);
593 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
596 buf
= text
+ strlen(text
);
598 if (buf
- text
> 2) { buf
[-2] = '}'; buf
[-1] = 0; }
602 static const char* debugnmlistview(const NMLISTVIEW
*plvnm
)
604 if (!plvnm
) return "(null)";
605 return wine_dbg_sprintf("iItem=%d, iSubItem=%d, uNewState=0x%x,"
606 " uOldState=0x%x, uChanged=0x%x, ptAction=%s, lParam=%ld",
607 plvnm
->iItem
, plvnm
->iSubItem
, plvnm
->uNewState
, plvnm
->uOldState
,
608 plvnm
->uChanged
, wine_dbgstr_point(&plvnm
->ptAction
), plvnm
->lParam
);
611 static const char* debuglvitem_t(const LVITEMW
*lpLVItem
, BOOL isW
)
613 char* buf
= debug_getbuf(), *text
= buf
;
614 int len
, size
= DEBUG_BUFFER_SIZE
;
616 if (lpLVItem
== NULL
) return "(null)";
617 len
= snprintf(buf
, size
, "{iItem=%d, iSubItem=%d, ", lpLVItem
->iItem
, lpLVItem
->iSubItem
);
618 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
619 if (lpLVItem
->mask
& LVIF_STATE
)
620 len
= snprintf(buf
, size
, "state=%x, stateMask=%x, ", lpLVItem
->state
, lpLVItem
->stateMask
);
622 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
623 if (lpLVItem
->mask
& LVIF_TEXT
)
624 len
= snprintf(buf
, size
, "pszText=%s, cchTextMax=%d, ", debugtext_tn(lpLVItem
->pszText
, isW
, 80), lpLVItem
->cchTextMax
);
626 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
627 if (lpLVItem
->mask
& LVIF_IMAGE
)
628 len
= snprintf(buf
, size
, "iImage=%d, ", lpLVItem
->iImage
);
630 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
631 if (lpLVItem
->mask
& LVIF_PARAM
)
632 len
= snprintf(buf
, size
, "lParam=%lx, ", lpLVItem
->lParam
);
634 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
635 if (lpLVItem
->mask
& LVIF_INDENT
)
636 len
= snprintf(buf
, size
, "iIndent=%d, ", lpLVItem
->iIndent
);
638 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
641 buf
= text
+ strlen(text
);
643 if (buf
- text
> 2) { buf
[-2] = '}'; buf
[-1] = 0; }
647 static const char* debuglvcolumn_t(const LVCOLUMNW
*lpColumn
, BOOL isW
)
649 char* buf
= debug_getbuf(), *text
= buf
;
650 int len
, size
= DEBUG_BUFFER_SIZE
;
652 if (lpColumn
== NULL
) return "(null)";
653 len
= snprintf(buf
, size
, "{");
654 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
655 if (lpColumn
->mask
& LVCF_SUBITEM
)
656 len
= snprintf(buf
, size
, "iSubItem=%d, ", lpColumn
->iSubItem
);
658 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
659 if (lpColumn
->mask
& LVCF_FMT
)
660 len
= snprintf(buf
, size
, "fmt=%x, ", lpColumn
->fmt
);
662 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
663 if (lpColumn
->mask
& LVCF_WIDTH
)
664 len
= snprintf(buf
, size
, "cx=%d, ", lpColumn
->cx
);
666 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
667 if (lpColumn
->mask
& LVCF_TEXT
)
668 len
= snprintf(buf
, size
, "pszText=%s, cchTextMax=%d, ", debugtext_tn(lpColumn
->pszText
, isW
, 80), lpColumn
->cchTextMax
);
670 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
671 if (lpColumn
->mask
& LVCF_IMAGE
)
672 len
= snprintf(buf
, size
, "iImage=%d, ", lpColumn
->iImage
);
674 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
675 if (lpColumn
->mask
& LVCF_ORDER
)
676 len
= snprintf(buf
, size
, "iOrder=%d, ", lpColumn
->iOrder
);
678 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
681 buf
= text
+ strlen(text
);
683 if (buf
- text
> 2) { buf
[-2] = '}'; buf
[-1] = 0; }
687 static const char* debuglvhittestinfo(const LVHITTESTINFO
*lpht
)
689 if (!lpht
) return "(null)";
691 return wine_dbg_sprintf("{pt=%s, flags=0x%x, iItem=%d, iSubItem=%d}",
692 wine_dbgstr_point(&lpht
->pt
), lpht
->flags
, lpht
->iItem
, lpht
->iSubItem
);
695 /* Return the corresponding text for a given scroll value */
696 static inline LPCSTR
debugscrollcode(int nScrollCode
)
700 case SB_LINELEFT
: return "SB_LINELEFT";
701 case SB_LINERIGHT
: return "SB_LINERIGHT";
702 case SB_PAGELEFT
: return "SB_PAGELEFT";
703 case SB_PAGERIGHT
: return "SB_PAGERIGHT";
704 case SB_THUMBPOSITION
: return "SB_THUMBPOSITION";
705 case SB_THUMBTRACK
: return "SB_THUMBTRACK";
706 case SB_ENDSCROLL
: return "SB_ENDSCROLL";
707 case SB_INTERNAL
: return "SB_INTERNAL";
708 default: return "unknown";
713 /******** Notification functions ************************************/
715 static LRESULT
notify_forward_header(const LISTVIEW_INFO
*infoPtr
, const NMHEADERW
*lpnmh
)
717 return SendMessageW(infoPtr
->hwndNotify
, WM_NOTIFY
,
718 (WPARAM
)lpnmh
->hdr
.idFrom
, (LPARAM
)lpnmh
);
721 static LRESULT
notify_hdr(const LISTVIEW_INFO
*infoPtr
, INT code
, LPNMHDR pnmh
)
725 TRACE("(code=%d)\n", code
);
727 pnmh
->hwndFrom
= infoPtr
->hwndSelf
;
728 pnmh
->idFrom
= GetWindowLongPtrW(infoPtr
->hwndSelf
, GWLP_ID
);
730 result
= SendMessageW(infoPtr
->hwndNotify
, WM_NOTIFY
, pnmh
->idFrom
, (LPARAM
)pnmh
);
732 TRACE(" <= %ld\n", result
);
737 static inline BOOL
notify(const LISTVIEW_INFO
*infoPtr
, INT code
)
740 HWND hwnd
= infoPtr
->hwndSelf
;
741 notify_hdr(infoPtr
, code
, &nmh
);
742 return IsWindow(hwnd
);
745 static inline void notify_itemactivate(const LISTVIEW_INFO
*infoPtr
, const LVHITTESTINFO
*htInfo
)
756 item
.mask
= LVIF_PARAM
|LVIF_STATE
;
757 item
.iItem
= htInfo
->iItem
;
759 if (LISTVIEW_GetItemT(infoPtr
, &item
, TRUE
)) {
760 nmia
.lParam
= item
.lParam
;
761 nmia
.uOldState
= item
.state
;
762 nmia
.uNewState
= item
.state
| LVIS_ACTIVATING
;
763 nmia
.uChanged
= LVIF_STATE
;
766 nmia
.iItem
= htInfo
->iItem
;
767 nmia
.iSubItem
= htInfo
->iSubItem
;
768 nmia
.ptAction
= htInfo
->pt
;
770 if (GetKeyState(VK_SHIFT
) & 0x8000) nmia
.uKeyFlags
|= LVKF_SHIFT
;
771 if (GetKeyState(VK_CONTROL
) & 0x8000) nmia
.uKeyFlags
|= LVKF_CONTROL
;
772 if (GetKeyState(VK_MENU
) & 0x8000) nmia
.uKeyFlags
|= LVKF_ALT
;
774 notify_hdr(infoPtr
, LVN_ITEMACTIVATE
, (LPNMHDR
)&nmia
);
777 static inline LRESULT
notify_listview(const LISTVIEW_INFO
*infoPtr
, INT code
, LPNMLISTVIEW plvnm
)
779 TRACE("(code=%d, plvnm=%s)\n", code
, debugnmlistview(plvnm
));
780 return notify_hdr(infoPtr
, code
, (LPNMHDR
)plvnm
);
783 static BOOL
notify_click(const LISTVIEW_INFO
*infoPtr
, INT code
, const LVHITTESTINFO
*lvht
)
787 HWND hwnd
= infoPtr
->hwndSelf
;
789 TRACE("code=%d, lvht=%s\n", code
, debuglvhittestinfo(lvht
));
790 ZeroMemory(&nmlv
, sizeof(nmlv
));
791 nmlv
.iItem
= lvht
->iItem
;
792 nmlv
.iSubItem
= lvht
->iSubItem
;
793 nmlv
.ptAction
= lvht
->pt
;
794 item
.mask
= LVIF_PARAM
;
795 item
.iItem
= lvht
->iItem
;
797 if (LISTVIEW_GetItemT(infoPtr
, &item
, TRUE
)) nmlv
.lParam
= item
.lParam
;
798 notify_listview(infoPtr
, code
, &nmlv
);
799 return IsWindow(hwnd
);
802 static BOOL
notify_deleteitem(const LISTVIEW_INFO
*infoPtr
, INT nItem
)
806 HWND hwnd
= infoPtr
->hwndSelf
;
808 ZeroMemory(&nmlv
, sizeof (NMLISTVIEW
));
810 item
.mask
= LVIF_PARAM
;
813 if (LISTVIEW_GetItemT(infoPtr
, &item
, TRUE
)) nmlv
.lParam
= item
.lParam
;
814 notify_listview(infoPtr
, LVN_DELETEITEM
, &nmlv
);
815 return IsWindow(hwnd
);
818 static int get_ansi_notification(UINT unicodeNotificationCode
)
820 switch (unicodeNotificationCode
)
822 case LVN_BEGINLABELEDITW
: return LVN_BEGINLABELEDITA
;
823 case LVN_ENDLABELEDITW
: return LVN_ENDLABELEDITA
;
824 case LVN_GETDISPINFOW
: return LVN_GETDISPINFOA
;
825 case LVN_SETDISPINFOW
: return LVN_SETDISPINFOA
;
826 case LVN_ODFINDITEMW
: return LVN_ODFINDITEMA
;
827 case LVN_GETINFOTIPW
: return LVN_GETINFOTIPA
;
829 ERR("unknown notification %x\n", unicodeNotificationCode
);
835 Send notification. depends on dispinfoW having same
836 structure as dispinfoA.
837 infoPtr : listview struct
838 notificationCode : *Unicode* notification code
839 pdi : dispinfo structure (can be unicode or ansi)
840 isW : TRUE if dispinfo is Unicode
842 static BOOL
notify_dispinfoT(const LISTVIEW_INFO
*infoPtr
, UINT notificationCode
, LPNMLVDISPINFOW pdi
, BOOL isW
)
844 BOOL bResult
= FALSE
;
845 BOOL convertToAnsi
= FALSE
, convertToUnicode
= FALSE
;
846 INT cchTempBufMax
= 0, savCchTextMax
= 0;
848 LPWSTR pszTempBuf
= NULL
, savPszText
= NULL
;
850 if ((pdi
->item
.mask
& LVIF_TEXT
) && is_textT(pdi
->item
.pszText
, isW
))
852 convertToAnsi
= (isW
&& infoPtr
->notifyFormat
== NFR_ANSI
);
853 convertToUnicode
= (!isW
&& infoPtr
->notifyFormat
== NFR_UNICODE
);
856 if (convertToAnsi
|| convertToUnicode
)
858 if (notificationCode
!= LVN_GETDISPINFOW
)
860 cchTempBufMax
= convertToUnicode
?
861 MultiByteToWideChar(CP_ACP
, 0, (LPCSTR
)pdi
->item
.pszText
, -1, NULL
, 0):
862 WideCharToMultiByte(CP_ACP
, 0, pdi
->item
.pszText
, -1, NULL
, 0, NULL
, NULL
);
866 cchTempBufMax
= pdi
->item
.cchTextMax
;
867 *pdi
->item
.pszText
= 0; /* make sure we don't process garbage */
870 pszTempBuf
= Alloc( (convertToUnicode
? sizeof(WCHAR
) : sizeof(CHAR
)) * cchTempBufMax
);
871 if (!pszTempBuf
) return FALSE
;
873 if (convertToUnicode
)
874 MultiByteToWideChar(CP_ACP
, 0, (LPCSTR
)pdi
->item
.pszText
, -1,
875 pszTempBuf
, cchTempBufMax
);
877 WideCharToMultiByte(CP_ACP
, 0, pdi
->item
.pszText
, -1, (LPSTR
) pszTempBuf
,
878 cchTempBufMax
, NULL
, NULL
);
880 savCchTextMax
= pdi
->item
.cchTextMax
;
881 savPszText
= pdi
->item
.pszText
;
882 pdi
->item
.pszText
= pszTempBuf
;
883 pdi
->item
.cchTextMax
= cchTempBufMax
;
886 if (infoPtr
->notifyFormat
== NFR_ANSI
)
887 realNotifCode
= get_ansi_notification(notificationCode
);
889 realNotifCode
= notificationCode
;
890 TRACE(" pdi->item=%s\n", debuglvitem_t(&pdi
->item
, infoPtr
->notifyFormat
!= NFR_ANSI
));
891 bResult
= notify_hdr(infoPtr
, realNotifCode
, &pdi
->hdr
);
893 if (convertToUnicode
|| convertToAnsi
)
895 if (convertToUnicode
) /* note : pointer can be changed by app ! */
896 WideCharToMultiByte(CP_ACP
, 0, pdi
->item
.pszText
, -1, (LPSTR
) savPszText
,
897 savCchTextMax
, NULL
, NULL
);
899 MultiByteToWideChar(CP_ACP
, 0, (LPSTR
) pdi
->item
.pszText
, -1,
900 savPszText
, savCchTextMax
);
901 pdi
->item
.pszText
= savPszText
; /* restores our buffer */
902 pdi
->item
.cchTextMax
= savCchTextMax
;
908 static void customdraw_fill(NMLVCUSTOMDRAW
*lpnmlvcd
, const LISTVIEW_INFO
*infoPtr
, HDC hdc
,
909 const RECT
*rcBounds
, const LVITEMW
*lplvItem
)
911 ZeroMemory(lpnmlvcd
, sizeof(NMLVCUSTOMDRAW
));
912 lpnmlvcd
->nmcd
.hdc
= hdc
;
913 lpnmlvcd
->nmcd
.rc
= *rcBounds
;
914 lpnmlvcd
->clrTextBk
= infoPtr
->clrTextBk
;
915 lpnmlvcd
->clrText
= infoPtr
->clrText
;
916 if (!lplvItem
) return;
917 lpnmlvcd
->nmcd
.dwItemSpec
= lplvItem
->iItem
+ 1;
918 lpnmlvcd
->iSubItem
= lplvItem
->iSubItem
;
919 if (lplvItem
->state
& LVIS_SELECTED
) lpnmlvcd
->nmcd
.uItemState
|= CDIS_SELECTED
;
920 if (lplvItem
->state
& LVIS_FOCUSED
) lpnmlvcd
->nmcd
.uItemState
|= CDIS_FOCUS
;
921 if (lplvItem
->iItem
== infoPtr
->nHotItem
) lpnmlvcd
->nmcd
.uItemState
|= CDIS_HOT
;
922 lpnmlvcd
->nmcd
.lItemlParam
= lplvItem
->lParam
;
925 static inline DWORD
notify_customdraw (const LISTVIEW_INFO
*infoPtr
, DWORD dwDrawStage
, NMLVCUSTOMDRAW
*lpnmlvcd
)
927 BOOL isForItem
= (lpnmlvcd
->nmcd
.dwItemSpec
!= 0);
930 lpnmlvcd
->nmcd
.dwDrawStage
= dwDrawStage
;
931 if (isForItem
) lpnmlvcd
->nmcd
.dwDrawStage
|= CDDS_ITEM
;
932 if (lpnmlvcd
->iSubItem
) lpnmlvcd
->nmcd
.dwDrawStage
|= CDDS_SUBITEM
;
933 if (isForItem
) lpnmlvcd
->nmcd
.dwItemSpec
--;
934 result
= notify_hdr(infoPtr
, NM_CUSTOMDRAW
, &lpnmlvcd
->nmcd
.hdr
);
935 if (isForItem
) lpnmlvcd
->nmcd
.dwItemSpec
++;
939 static void prepaint_setup (const LISTVIEW_INFO
*infoPtr
, HDC hdc
, NMLVCUSTOMDRAW
*lpnmlvcd
, BOOL SubItem
)
941 if (lpnmlvcd
->clrTextBk
== CLR_DEFAULT
)
942 lpnmlvcd
->clrTextBk
= comctl32_color
.clrWindow
;
943 if (lpnmlvcd
->clrText
== CLR_DEFAULT
)
944 lpnmlvcd
->clrText
= comctl32_color
.clrWindowText
;
946 /* apparently, for selected items, we have to override the returned values */
949 if (lpnmlvcd
->nmcd
.uItemState
& CDIS_SELECTED
)
953 lpnmlvcd
->clrTextBk
= comctl32_color
.clrHighlight
;
954 lpnmlvcd
->clrText
= comctl32_color
.clrHighlightText
;
956 else if (infoPtr
->dwStyle
& LVS_SHOWSELALWAYS
)
958 lpnmlvcd
->clrTextBk
= comctl32_color
.clr3dFace
;
959 lpnmlvcd
->clrText
= comctl32_color
.clrBtnText
;
964 /* Set the text attributes */
965 if (lpnmlvcd
->clrTextBk
!= CLR_NONE
)
967 SetBkMode(hdc
, OPAQUE
);
968 SetBkColor(hdc
,lpnmlvcd
->clrTextBk
);
971 SetBkMode(hdc
, TRANSPARENT
);
972 SetTextColor(hdc
, lpnmlvcd
->clrText
);
975 static inline DWORD
notify_postpaint (const LISTVIEW_INFO
*infoPtr
, NMLVCUSTOMDRAW
*lpnmlvcd
)
977 return notify_customdraw(infoPtr
, CDDS_POSTPAINT
, lpnmlvcd
);
980 /******** Item iterator functions **********************************/
982 static RANGES
ranges_create(int count
);
983 static void ranges_destroy(RANGES ranges
);
984 static BOOL
ranges_add(RANGES ranges
, RANGE range
);
985 static BOOL
ranges_del(RANGES ranges
, RANGE range
);
986 static void ranges_dump(RANGES ranges
);
988 static inline BOOL
ranges_additem(RANGES ranges
, INT nItem
)
990 RANGE range
= { nItem
, nItem
+ 1 };
992 return ranges_add(ranges
, range
);
995 static inline BOOL
ranges_delitem(RANGES ranges
, INT nItem
)
997 RANGE range
= { nItem
, nItem
+ 1 };
999 return ranges_del(ranges
, range
);
1003 * ITERATOR DOCUMENTATION
1005 * The iterator functions allow for easy, and convenient iteration
1006 * over items of interest in the list. Typically, you create a
1007 * iterator, use it, and destroy it, as such:
1010 * iterator_xxxitems(&i, ...);
1011 * while (iterator_{prev,next}(&i)
1013 * //code which uses i.nItem
1015 * iterator_destroy(&i);
1017 * where xxx is either: framed, or visible.
1018 * Note that it is important that the code destroys the iterator
1019 * after it's done with it, as the creation of the iterator may
1020 * allocate memory, which thus needs to be freed.
1022 * You can iterate both forwards, and backwards through the list,
1023 * by using iterator_next or iterator_prev respectively.
1025 * Lower numbered items are draw on top of higher number items in
1026 * LVS_ICON, and LVS_SMALLICON (which are the only modes where
1027 * items may overlap). So, to test items, you should use
1029 * which lists the items top to bottom (in Z-order).
1030 * For drawing items, you should use
1032 * which lists the items bottom to top (in Z-order).
1033 * If you keep iterating over the items after the end-of-items
1034 * marker (-1) is returned, the iterator will start from the
1035 * beginning. Typically, you don't need to test for -1,
1036 * because iterator_{next,prev} will return TRUE if more items
1037 * are to be iterated over, or FALSE otherwise.
1039 * Note: the iterator is defined to be bidirectional. That is,
1040 * any number of prev followed by any number of next, or
1041 * five versa, should leave the iterator at the same item:
1042 * prev * n, next * n = next * n, prev * n
1044 * The iterator has a notion of an out-of-order, special item,
1045 * which sits at the start of the list. This is used in
1046 * LVS_ICON, and LVS_SMALLICON mode to handle the focused item,
1047 * which needs to be first, as it may overlap other items.
1049 * The code is a bit messy because we have:
1050 * - a special item to deal with
1051 * - simple range, or composite range
1053 * If you find bugs, or want to add features, please make sure you
1054 * always check/modify *both* iterator_prev, and iterator_next.
1058 * This function iterates through the items in increasing order,
1059 * but prefixed by the special item, then -1. That is:
1060 * special, 1, 2, 3, ..., n, -1.
1061 * Each item is listed only once.
1063 static inline BOOL
iterator_next(ITERATOR
* i
)
1067 i
->nItem
= i
->nSpecial
;
1068 if (i
->nItem
!= -1) return TRUE
;
1070 if (i
->nItem
== i
->nSpecial
)
1072 if (i
->ranges
) i
->index
= 0;
1078 if (i
->nItem
== i
->nSpecial
) i
->nItem
++;
1079 if (i
->nItem
< i
->range
.upper
) return TRUE
;
1084 if (i
->index
< DPA_GetPtrCount(i
->ranges
->hdpa
))
1085 i
->range
= *(RANGE
*)DPA_GetPtr(i
->ranges
->hdpa
, i
->index
++);
1088 else if (i
->nItem
>= i
->range
.upper
) goto end
;
1090 i
->nItem
= i
->range
.lower
;
1091 if (i
->nItem
>= 0) goto testitem
;
1098 * This function iterates through the items in decreasing order,
1099 * followed by the special item, then -1. That is:
1100 * n, n-1, ..., 3, 2, 1, special, -1.
1101 * Each item is listed only once.
1103 static inline BOOL
iterator_prev(ITERATOR
* i
)
1110 if (i
->ranges
) i
->index
= DPA_GetPtrCount(i
->ranges
->hdpa
);
1113 if (i
->nItem
== i
->nSpecial
)
1121 if (i
->nItem
== i
->nSpecial
) i
->nItem
--;
1122 if (i
->nItem
>= i
->range
.lower
) return TRUE
;
1128 i
->range
= *(RANGE
*)DPA_GetPtr(i
->ranges
->hdpa
, --i
->index
);
1131 else if (!start
&& i
->nItem
< i
->range
.lower
) goto end
;
1133 i
->nItem
= i
->range
.upper
;
1134 if (i
->nItem
> 0) goto testitem
;
1136 return (i
->nItem
= i
->nSpecial
) != -1;
1139 static RANGE
iterator_range(const ITERATOR
*i
)
1143 if (!i
->ranges
) return i
->range
;
1145 if (DPA_GetPtrCount(i
->ranges
->hdpa
) > 0)
1147 range
.lower
= (*(RANGE
*)DPA_GetPtr(i
->ranges
->hdpa
, 0)).lower
;
1148 range
.upper
= (*(RANGE
*)DPA_GetPtr(i
->ranges
->hdpa
, DPA_GetPtrCount(i
->ranges
->hdpa
) - 1)).upper
;
1150 else range
.lower
= range
.upper
= 0;
1156 * Releases resources associated with this ierator.
1158 static inline void iterator_destroy(const ITERATOR
*i
)
1160 ranges_destroy(i
->ranges
);
1164 * Create an empty iterator.
1166 static inline BOOL
iterator_empty(ITERATOR
* i
)
1168 ZeroMemory(i
, sizeof(*i
));
1169 i
->nItem
= i
->nSpecial
= i
->range
.lower
= i
->range
.upper
= -1;
1174 * Create an iterator over a range.
1176 static inline BOOL
iterator_rangeitems(ITERATOR
* i
, RANGE range
)
1184 * Create an iterator over a bunch of ranges.
1185 * Please note that the iterator will take ownership of the ranges,
1186 * and will free them upon destruction.
1188 static inline BOOL
iterator_rangesitems(ITERATOR
* i
, RANGES ranges
)
1196 * Creates an iterator over the items which intersect lprc.
1198 static BOOL
iterator_frameditems(ITERATOR
* i
, const LISTVIEW_INFO
* infoPtr
, const RECT
*lprc
)
1200 UINT uView
= infoPtr
->dwStyle
& LVS_TYPEMASK
;
1201 RECT frame
= *lprc
, rcItem
, rcTemp
;
1204 /* in case we fail, we want to return an empty iterator */
1205 if (!iterator_empty(i
)) return FALSE
;
1207 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
1209 TRACE("(lprc=%s)\n", wine_dbgstr_rect(lprc
));
1210 OffsetRect(&frame
, -Origin
.x
, -Origin
.y
);
1212 if (uView
== LVS_ICON
|| uView
== LVS_SMALLICON
)
1216 if (uView
== LVS_ICON
&& infoPtr
->nFocusedItem
!= -1)
1218 LISTVIEW_GetItemBox(infoPtr
, infoPtr
->nFocusedItem
, &rcItem
);
1219 if (IntersectRect(&rcTemp
, &rcItem
, lprc
))
1220 i
->nSpecial
= infoPtr
->nFocusedItem
;
1222 if (!(iterator_rangesitems(i
, ranges_create(50)))) return FALSE
;
1223 /* to do better here, we need to have PosX, and PosY sorted */
1224 TRACE("building icon ranges:\n");
1225 for (nItem
= 0; nItem
< infoPtr
->nItemCount
; nItem
++)
1227 rcItem
.left
= (LONG_PTR
)DPA_GetPtr(infoPtr
->hdpaPosX
, nItem
);
1228 rcItem
.top
= (LONG_PTR
)DPA_GetPtr(infoPtr
->hdpaPosY
, nItem
);
1229 rcItem
.right
= rcItem
.left
+ infoPtr
->nItemWidth
;
1230 rcItem
.bottom
= rcItem
.top
+ infoPtr
->nItemHeight
;
1231 if (IntersectRect(&rcTemp
, &rcItem
, &frame
))
1232 ranges_additem(i
->ranges
, nItem
);
1236 else if (uView
== LVS_REPORT
)
1240 if (frame
.left
>= infoPtr
->nItemWidth
) return TRUE
;
1241 if (frame
.top
>= infoPtr
->nItemHeight
* infoPtr
->nItemCount
) return TRUE
;
1243 range
.lower
= max(frame
.top
/ infoPtr
->nItemHeight
, 0);
1244 range
.upper
= min((frame
.bottom
- 1) / infoPtr
->nItemHeight
, infoPtr
->nItemCount
- 1) + 1;
1245 if (range
.upper
<= range
.lower
) return TRUE
;
1246 if (!iterator_rangeitems(i
, range
)) return FALSE
;
1247 TRACE(" report=%s\n", debugrange(&i
->range
));
1251 INT nPerCol
= max((infoPtr
->rcList
.bottom
- infoPtr
->rcList
.top
) / infoPtr
->nItemHeight
, 1);
1252 INT nFirstRow
= max(frame
.top
/ infoPtr
->nItemHeight
, 0);
1253 INT nLastRow
= min((frame
.bottom
- 1) / infoPtr
->nItemHeight
, nPerCol
- 1);
1254 INT nFirstCol
= max(frame
.left
/ infoPtr
->nItemWidth
, 0);
1255 INT nLastCol
= min((frame
.right
- 1) / infoPtr
->nItemWidth
, (infoPtr
->nItemCount
+ nPerCol
- 1) / nPerCol
);
1256 INT lower
= nFirstCol
* nPerCol
+ nFirstRow
;
1260 TRACE("nPerCol=%d, nFirstRow=%d, nLastRow=%d, nFirstCol=%d, nLastCol=%d, lower=%d\n",
1261 nPerCol
, nFirstRow
, nLastRow
, nFirstCol
, nLastCol
, lower
);
1263 if (nLastCol
< nFirstCol
|| nLastRow
< nFirstRow
) return TRUE
;
1265 if (!(iterator_rangesitems(i
, ranges_create(nLastCol
- nFirstCol
+ 1)))) return FALSE
;
1266 TRACE("building list ranges:\n");
1267 for (nCol
= nFirstCol
; nCol
<= nLastCol
; nCol
++)
1269 item_range
.lower
= nCol
* nPerCol
+ nFirstRow
;
1270 if(item_range
.lower
>= infoPtr
->nItemCount
) break;
1271 item_range
.upper
= min(nCol
* nPerCol
+ nLastRow
+ 1, infoPtr
->nItemCount
);
1272 TRACE(" list=%s\n", debugrange(&item_range
));
1273 ranges_add(i
->ranges
, item_range
);
1281 * Creates an iterator over the items which intersect the visible region of hdc.
1283 static BOOL
iterator_visibleitems(ITERATOR
*i
, const LISTVIEW_INFO
*infoPtr
, HDC hdc
)
1285 POINT Origin
, Position
;
1286 RECT rcItem
, rcClip
;
1289 rgntype
= GetClipBox(hdc
, &rcClip
);
1290 if (rgntype
== NULLREGION
) return iterator_empty(i
);
1291 if (!iterator_frameditems(i
, infoPtr
, &rcClip
)) return FALSE
;
1292 if (rgntype
== SIMPLEREGION
) return TRUE
;
1294 /* first deal with the special item */
1295 if (i
->nSpecial
!= -1)
1297 LISTVIEW_GetItemBox(infoPtr
, i
->nSpecial
, &rcItem
);
1298 if (!RectVisible(hdc
, &rcItem
)) i
->nSpecial
= -1;
1301 /* if we can't deal with the region, we'll just go with the simple range */
1302 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
1303 TRACE("building visible range:\n");
1304 if (!i
->ranges
&& i
->range
.lower
< i
->range
.upper
)
1306 if (!(i
->ranges
= ranges_create(50))) return TRUE
;
1307 if (!ranges_add(i
->ranges
, i
->range
))
1309 ranges_destroy(i
->ranges
);
1315 /* now delete the invisible items from the list */
1316 while(iterator_next(i
))
1318 LISTVIEW_GetItemOrigin(infoPtr
, i
->nItem
, &Position
);
1319 rcItem
.left
= Position
.x
+ Origin
.x
;
1320 rcItem
.top
= Position
.y
+ Origin
.y
;
1321 rcItem
.right
= rcItem
.left
+ infoPtr
->nItemWidth
;
1322 rcItem
.bottom
= rcItem
.top
+ infoPtr
->nItemHeight
;
1323 if (!RectVisible(hdc
, &rcItem
))
1324 ranges_delitem(i
->ranges
, i
->nItem
);
1326 /* the iterator should restart on the next iterator_next */
1332 /******** Misc helper functions ************************************/
1334 static inline LRESULT
CallWindowProcT(WNDPROC proc
, HWND hwnd
, UINT uMsg
,
1335 WPARAM wParam
, LPARAM lParam
, BOOL isW
)
1337 if (isW
) return CallWindowProcW(proc
, hwnd
, uMsg
, wParam
, lParam
);
1338 else return CallWindowProcA(proc
, hwnd
, uMsg
, wParam
, lParam
);
1341 static inline BOOL
is_autoarrange(const LISTVIEW_INFO
*infoPtr
)
1343 UINT uView
= infoPtr
->dwStyle
& LVS_TYPEMASK
;
1345 return ((infoPtr
->dwStyle
& LVS_AUTOARRANGE
) || infoPtr
->bAutoarrange
) &&
1346 (uView
== LVS_ICON
|| uView
== LVS_SMALLICON
);
1349 static void toggle_checkbox_state(LISTVIEW_INFO
*infoPtr
, INT nItem
)
1351 DWORD state
= STATEIMAGEINDEX(LISTVIEW_GetItemState(infoPtr
, nItem
, LVIS_STATEIMAGEMASK
));
1352 if(state
== 1 || state
== 2)
1356 lvitem
.state
= INDEXTOSTATEIMAGEMASK(state
);
1357 lvitem
.stateMask
= LVIS_STATEIMAGEMASK
;
1358 LISTVIEW_SetItemState(infoPtr
, nItem
, &lvitem
);
1362 /******** Internal API functions ************************************/
1364 static inline COLUMN_INFO
* LISTVIEW_GetColumnInfo(const LISTVIEW_INFO
*infoPtr
, INT nSubItem
)
1366 static COLUMN_INFO mainItem
;
1368 if (nSubItem
== 0 && DPA_GetPtrCount(infoPtr
->hdpaColumns
) == 0) return &mainItem
;
1369 assert (nSubItem
>= 0 && nSubItem
< DPA_GetPtrCount(infoPtr
->hdpaColumns
));
1370 return DPA_GetPtr(infoPtr
->hdpaColumns
, nSubItem
);
1373 static INT
LISTVIEW_CreateHeader(LISTVIEW_INFO
*infoPtr
)
1375 DWORD dFlags
= WS_CHILD
| HDS_HORZ
| HDS_FULLDRAG
| HDS_DRAGDROP
;
1378 if (infoPtr
->hwndHeader
) return 0;
1380 TRACE("Creating header for list %p\n", infoPtr
->hwndSelf
);
1382 /* setup creation flags */
1383 dFlags
|= (LVS_NOSORTHEADER
& infoPtr
->dwStyle
) ? 0 : HDS_BUTTONS
;
1384 dFlags
|= (LVS_NOCOLUMNHEADER
& infoPtr
->dwStyle
) ? HDS_HIDDEN
: 0;
1386 hInst
= (HINSTANCE
)GetWindowLongPtrW(infoPtr
->hwndSelf
, GWLP_HINSTANCE
);
1389 infoPtr
->hwndHeader
= CreateWindowW(WC_HEADERW
, NULL
, dFlags
,
1390 0, 0, 0, 0, infoPtr
->hwndSelf
, NULL
, hInst
, NULL
);
1391 if (!infoPtr
->hwndHeader
) return -1;
1393 /* set header unicode format */
1394 SendMessageW(infoPtr
->hwndHeader
, HDM_SETUNICODEFORMAT
, TRUE
, 0);
1396 /* set header font */
1397 SendMessageW(infoPtr
->hwndHeader
, WM_SETFONT
, (WPARAM
)infoPtr
->hFont
, (LPARAM
)TRUE
);
1399 LISTVIEW_UpdateSize(infoPtr
);
1404 static inline void LISTVIEW_GetHeaderRect(const LISTVIEW_INFO
*infoPtr
, INT nSubItem
, LPRECT lprc
)
1406 *lprc
= LISTVIEW_GetColumnInfo(infoPtr
, nSubItem
)->rcHeader
;
1409 static inline BOOL
LISTVIEW_GetItemW(const LISTVIEW_INFO
*infoPtr
, LPLVITEMW lpLVItem
)
1411 return LISTVIEW_GetItemT(infoPtr
, lpLVItem
, TRUE
);
1414 /* Listview invalidation functions: use _only_ these functions to invalidate */
1416 static inline BOOL
is_redrawing(const LISTVIEW_INFO
*infoPtr
)
1418 return infoPtr
->bRedraw
;
1421 static inline void LISTVIEW_InvalidateRect(const LISTVIEW_INFO
*infoPtr
, const RECT
* rect
)
1423 if(!is_redrawing(infoPtr
)) return;
1424 TRACE(" invalidating rect=%s\n", wine_dbgstr_rect(rect
));
1425 InvalidateRect(infoPtr
->hwndSelf
, rect
, TRUE
);
1428 static inline void LISTVIEW_InvalidateItem(const LISTVIEW_INFO
*infoPtr
, INT nItem
)
1432 if(!is_redrawing(infoPtr
)) return;
1433 LISTVIEW_GetItemBox(infoPtr
, nItem
, &rcBox
);
1434 LISTVIEW_InvalidateRect(infoPtr
, &rcBox
);
1437 static inline void LISTVIEW_InvalidateSubItem(const LISTVIEW_INFO
*infoPtr
, INT nItem
, INT nSubItem
)
1439 POINT Origin
, Position
;
1442 if(!is_redrawing(infoPtr
)) return;
1443 assert ((infoPtr
->dwStyle
& LVS_TYPEMASK
) == LVS_REPORT
);
1444 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
1445 LISTVIEW_GetItemOrigin(infoPtr
, nItem
, &Position
);
1446 LISTVIEW_GetHeaderRect(infoPtr
, nSubItem
, &rcBox
);
1448 rcBox
.bottom
= infoPtr
->nItemHeight
;
1449 OffsetRect(&rcBox
, Origin
.x
+ Position
.x
, Origin
.y
+ Position
.y
);
1450 LISTVIEW_InvalidateRect(infoPtr
, &rcBox
);
1453 static inline void LISTVIEW_InvalidateList(const LISTVIEW_INFO
*infoPtr
)
1455 LISTVIEW_InvalidateRect(infoPtr
, NULL
);
1458 static inline void LISTVIEW_InvalidateColumn(const LISTVIEW_INFO
*infoPtr
, INT nColumn
)
1462 if(!is_redrawing(infoPtr
)) return;
1463 LISTVIEW_GetHeaderRect(infoPtr
, nColumn
, &rcCol
);
1464 rcCol
.top
= infoPtr
->rcList
.top
;
1465 rcCol
.bottom
= infoPtr
->rcList
.bottom
;
1466 LISTVIEW_InvalidateRect(infoPtr
, &rcCol
);
1471 * Retrieves the number of items that can fit vertically in the client area.
1474 * [I] infoPtr : valid pointer to the listview structure
1477 * Number of items per row.
1479 static inline INT
LISTVIEW_GetCountPerRow(const LISTVIEW_INFO
*infoPtr
)
1481 INT nListWidth
= infoPtr
->rcList
.right
- infoPtr
->rcList
.left
;
1483 return max(nListWidth
/infoPtr
->nItemWidth
, 1);
1488 * Retrieves the number of items that can fit horizontally in the client
1492 * [I] infoPtr : valid pointer to the listview structure
1495 * Number of items per column.
1497 static inline INT
LISTVIEW_GetCountPerColumn(const LISTVIEW_INFO
*infoPtr
)
1499 INT nListHeight
= infoPtr
->rcList
.bottom
- infoPtr
->rcList
.top
;
1501 return max(nListHeight
/ infoPtr
->nItemHeight
, 1);
1505 /*************************************************************************
1506 * LISTVIEW_ProcessLetterKeys
1508 * Processes keyboard messages generated by pressing the letter keys
1510 * What this does is perform a case insensitive search from the
1511 * current position with the following quirks:
1512 * - If two chars or more are pressed in quick succession we search
1513 * for the corresponding string (e.g. 'abc').
1514 * - If there is a delay we wipe away the current search string and
1515 * restart with just that char.
1516 * - If the user keeps pressing the same character, whether slowly or
1517 * fast, so that the search string is entirely composed of this
1518 * character ('aaaaa' for instance), then we search for first item
1519 * that starting with that character.
1520 * - If the user types the above character in quick succession, then
1521 * we must also search for the corresponding string ('aaaaa'), and
1522 * go to that string if there is a match.
1525 * [I] hwnd : handle to the window
1526 * [I] charCode : the character code, the actual character
1527 * [I] keyData : key data
1535 * - The current implementation has a list of characters it will
1536 * accept and it ignores everything else. In particular it will
1537 * ignore accentuated characters which seems to match what
1538 * Windows does. But I'm not sure it makes sense to follow
1540 * - We don't sound a beep when the search fails.
1544 * TREEVIEW_ProcessLetterKeys
1546 static INT
LISTVIEW_ProcessLetterKeys(LISTVIEW_INFO
*infoPtr
, WPARAM charCode
, LPARAM keyData
)
1551 WCHAR buffer
[MAX_PATH
];
1552 DWORD lastKeyPressTimestamp
= infoPtr
->lastKeyPressTimestamp
;
1554 /* simple parameter checking */
1555 if (!charCode
|| !keyData
) return 0;
1557 /* only allow the valid WM_CHARs through */
1558 if (!isalnumW(charCode
) &&
1559 charCode
!= '.' && charCode
!= '`' && charCode
!= '!' &&
1560 charCode
!= '@' && charCode
!= '#' && charCode
!= '$' &&
1561 charCode
!= '%' && charCode
!= '^' && charCode
!= '&' &&
1562 charCode
!= '*' && charCode
!= '(' && charCode
!= ')' &&
1563 charCode
!= '-' && charCode
!= '_' && charCode
!= '+' &&
1564 charCode
!= '=' && charCode
!= '\\'&& charCode
!= ']' &&
1565 charCode
!= '}' && charCode
!= '[' && charCode
!= '{' &&
1566 charCode
!= '/' && charCode
!= '?' && charCode
!= '>' &&
1567 charCode
!= '<' && charCode
!= ',' && charCode
!= '~')
1570 /* if there's one item or less, there is no where to go */
1571 if (infoPtr
->nItemCount
<= 1) return 0;
1573 /* update the search parameters */
1574 infoPtr
->lastKeyPressTimestamp
= GetTickCount();
1575 if (infoPtr
->lastKeyPressTimestamp
- lastKeyPressTimestamp
< KEY_DELAY
) {
1576 if (infoPtr
->nSearchParamLength
< MAX_PATH
-1)
1577 infoPtr
->szSearchParam
[infoPtr
->nSearchParamLength
++]=charCode
;
1578 if (infoPtr
->charCode
!= charCode
)
1579 infoPtr
->charCode
= charCode
= 0;
1581 infoPtr
->charCode
=charCode
;
1582 infoPtr
->szSearchParam
[0]=charCode
;
1583 infoPtr
->nSearchParamLength
=1;
1584 /* Redundant with the 1 char string */
1588 /* and search from the current position */
1590 if (infoPtr
->nFocusedItem
>= 0) {
1591 endidx
=infoPtr
->nFocusedItem
;
1593 /* if looking for single character match,
1594 * then we must always move forward
1596 if (infoPtr
->nSearchParamLength
== 1)
1599 endidx
=infoPtr
->nItemCount
;
1603 /* Let application handle this for virtual listview */
1604 if (infoPtr
->dwStyle
& LVS_OWNERDATA
)
1609 ZeroMemory(&lvfi
, sizeof(lvfi
));
1610 lvfi
.flags
= (LVFI_WRAP
| LVFI_PARTIAL
);
1611 infoPtr
->szSearchParam
[infoPtr
->nSearchParamLength
] = '\0';
1612 lvfi
.psz
= infoPtr
->szSearchParam
;
1616 nItem
= notify_hdr(infoPtr
, LVN_ODFINDITEMW
, (LPNMHDR
)&nmlv
.hdr
);
1619 LISTVIEW_KeySelection(infoPtr
, nItem
, FALSE
);
1625 if (idx
== infoPtr
->nItemCount
) {
1626 if (endidx
== infoPtr
->nItemCount
|| endidx
== 0)
1632 item
.mask
= LVIF_TEXT
;
1635 item
.pszText
= buffer
;
1636 item
.cchTextMax
= MAX_PATH
;
1637 if (!LISTVIEW_GetItemW(infoPtr
, &item
)) return 0;
1639 /* check for a match */
1640 if (lstrncmpiW(item
.pszText
,infoPtr
->szSearchParam
,infoPtr
->nSearchParamLength
) == 0) {
1643 } else if ( (charCode
!= 0) && (nItem
== -1) && (nItem
!= infoPtr
->nFocusedItem
) &&
1644 (lstrncmpiW(item
.pszText
,infoPtr
->szSearchParam
,1) == 0) ) {
1645 /* This would work but we must keep looking for a longer match */
1649 } while (idx
!= endidx
);
1652 LISTVIEW_KeySelection(infoPtr
, nItem
, FALSE
);
1657 /*************************************************************************
1658 * LISTVIEW_UpdateHeaderSize [Internal]
1660 * Function to resize the header control
1663 * [I] hwnd : handle to a window
1664 * [I] nNewScrollPos : scroll pos to set
1669 static void LISTVIEW_UpdateHeaderSize(const LISTVIEW_INFO
*infoPtr
, INT nNewScrollPos
)
1674 TRACE("nNewScrollPos=%d\n", nNewScrollPos
);
1676 if (!infoPtr
->hwndHeader
) return;
1678 GetWindowRect(infoPtr
->hwndHeader
, &winRect
);
1679 point
[0].x
= winRect
.left
;
1680 point
[0].y
= winRect
.top
;
1681 point
[1].x
= winRect
.right
;
1682 point
[1].y
= winRect
.bottom
;
1684 MapWindowPoints(HWND_DESKTOP
, infoPtr
->hwndSelf
, point
, 2);
1685 point
[0].x
= -nNewScrollPos
;
1686 point
[1].x
+= nNewScrollPos
;
1688 SetWindowPos(infoPtr
->hwndHeader
,0,
1689 point
[0].x
,point
[0].y
,point
[1].x
,point
[1].y
,
1690 (infoPtr
->dwStyle
& LVS_NOCOLUMNHEADER
) ? SWP_HIDEWINDOW
: SWP_SHOWWINDOW
|
1691 SWP_NOZORDER
| SWP_NOACTIVATE
);
1696 * Update the scrollbars. This functions should be called whenever
1697 * the content, size or view changes.
1700 * [I] infoPtr : valid pointer to the listview structure
1705 static void LISTVIEW_UpdateScroll(const LISTVIEW_INFO
*infoPtr
)
1707 UINT uView
= infoPtr
->dwStyle
& LVS_TYPEMASK
;
1708 SCROLLINFO horzInfo
, vertInfo
;
1711 if ((infoPtr
->dwStyle
& LVS_NOSCROLL
) || !is_redrawing(infoPtr
)) return;
1713 ZeroMemory(&horzInfo
, sizeof(SCROLLINFO
));
1714 horzInfo
.cbSize
= sizeof(SCROLLINFO
);
1715 horzInfo
.nPage
= infoPtr
->rcList
.right
- infoPtr
->rcList
.left
;
1717 /* for now, we'll set info.nMax to the _count_, and adjust it later */
1718 if (uView
== LVS_LIST
)
1720 INT nPerCol
= LISTVIEW_GetCountPerColumn(infoPtr
);
1721 horzInfo
.nMax
= (infoPtr
->nItemCount
+ nPerCol
- 1) / nPerCol
;
1723 /* scroll by at least one column per page */
1724 if(horzInfo
.nPage
< infoPtr
->nItemWidth
)
1725 horzInfo
.nPage
= infoPtr
->nItemWidth
;
1727 horzInfo
.nPage
/= infoPtr
->nItemWidth
;
1729 else if (uView
== LVS_REPORT
)
1731 horzInfo
.nMax
= infoPtr
->nItemWidth
;
1733 else /* LVS_ICON, or LVS_SMALLICON */
1737 if (LISTVIEW_GetViewRect(infoPtr
, &rcView
)) horzInfo
.nMax
= rcView
.right
- rcView
.left
;
1740 horzInfo
.fMask
= SIF_RANGE
| SIF_PAGE
;
1741 horzInfo
.nMax
= max(horzInfo
.nMax
- 1, 0);
1742 dx
= GetScrollPos(infoPtr
->hwndSelf
, SB_HORZ
);
1743 dx
-= SetScrollInfo(infoPtr
->hwndSelf
, SB_HORZ
, &horzInfo
, TRUE
);
1744 TRACE("horzInfo=%s\n", debugscrollinfo(&horzInfo
));
1746 /* Setting the horizontal scroll can change the listview size
1747 * (and potentially everything else) so we need to recompute
1748 * everything again for the vertical scroll
1751 ZeroMemory(&vertInfo
, sizeof(SCROLLINFO
));
1752 vertInfo
.cbSize
= sizeof(SCROLLINFO
);
1753 vertInfo
.nPage
= infoPtr
->rcList
.bottom
- infoPtr
->rcList
.top
;
1755 if (uView
== LVS_REPORT
)
1757 vertInfo
.nMax
= infoPtr
->nItemCount
;
1759 /* scroll by at least one page */
1760 if(vertInfo
.nPage
< infoPtr
->nItemHeight
)
1761 vertInfo
.nPage
= infoPtr
->nItemHeight
;
1763 if (infoPtr
->nItemHeight
> 0)
1764 vertInfo
.nPage
/= infoPtr
->nItemHeight
;
1766 else if (uView
!= LVS_LIST
) /* LVS_ICON, or LVS_SMALLICON */
1770 if (LISTVIEW_GetViewRect(infoPtr
, &rcView
)) vertInfo
.nMax
= rcView
.bottom
- rcView
.top
;
1773 vertInfo
.fMask
= SIF_RANGE
| SIF_PAGE
;
1774 vertInfo
.nMax
= max(vertInfo
.nMax
- 1, 0);
1775 dy
= GetScrollPos(infoPtr
->hwndSelf
, SB_VERT
);
1776 dy
-= SetScrollInfo(infoPtr
->hwndSelf
, SB_VERT
, &vertInfo
, TRUE
);
1777 TRACE("vertInfo=%s\n", debugscrollinfo(&vertInfo
));
1779 /* Change of the range may have changed the scroll pos. If so move the content */
1780 if (dx
!= 0 || dy
!= 0)
1783 listRect
= infoPtr
->rcList
;
1784 ScrollWindowEx(infoPtr
->hwndSelf
, dx
, dy
, &listRect
, &listRect
, 0, 0,
1785 SW_ERASE
| SW_INVALIDATE
);
1788 /* Update the Header Control */
1789 if (uView
== LVS_REPORT
)
1791 horzInfo
.fMask
= SIF_POS
;
1792 GetScrollInfo(infoPtr
->hwndSelf
, SB_HORZ
, &horzInfo
);
1793 LISTVIEW_UpdateHeaderSize(infoPtr
, horzInfo
.nPos
);
1800 * Shows/hides the focus rectangle.
1803 * [I] infoPtr : valid pointer to the listview structure
1804 * [I] fShow : TRUE to show the focus, FALSE to hide it.
1809 static void LISTVIEW_ShowFocusRect(const LISTVIEW_INFO
*infoPtr
, BOOL fShow
)
1811 UINT uView
= infoPtr
->dwStyle
& LVS_TYPEMASK
;
1814 TRACE("fShow=%d, nItem=%d\n", fShow
, infoPtr
->nFocusedItem
);
1816 if (infoPtr
->nFocusedItem
< 0) return;
1818 /* we need some gymnastics in ICON mode to handle large items */
1819 if ( (infoPtr
->dwStyle
& LVS_TYPEMASK
) == LVS_ICON
)
1823 LISTVIEW_GetItemBox(infoPtr
, infoPtr
->nFocusedItem
, &rcBox
);
1824 if ((rcBox
.bottom
- rcBox
.top
) > infoPtr
->nItemHeight
)
1826 LISTVIEW_InvalidateRect(infoPtr
, &rcBox
);
1831 if (!(hdc
= GetDC(infoPtr
->hwndSelf
))) return;
1833 /* for some reason, owner draw should work only in report mode */
1834 if ((infoPtr
->dwStyle
& LVS_OWNERDRAWFIXED
) && (uView
== LVS_REPORT
))
1839 HFONT hFont
= infoPtr
->hFont
? infoPtr
->hFont
: infoPtr
->hDefaultFont
;
1840 HFONT hOldFont
= SelectObject(hdc
, hFont
);
1842 item
.iItem
= infoPtr
->nFocusedItem
;
1844 item
.mask
= LVIF_PARAM
;
1845 if (!LISTVIEW_GetItemW(infoPtr
, &item
)) goto done
;
1847 ZeroMemory(&dis
, sizeof(dis
));
1848 dis
.CtlType
= ODT_LISTVIEW
;
1849 dis
.CtlID
= (UINT
)GetWindowLongPtrW(infoPtr
->hwndSelf
, GWLP_ID
);
1850 dis
.itemID
= item
.iItem
;
1851 dis
.itemAction
= ODA_FOCUS
;
1852 if (fShow
) dis
.itemState
|= ODS_FOCUS
;
1853 dis
.hwndItem
= infoPtr
->hwndSelf
;
1855 LISTVIEW_GetItemBox(infoPtr
, dis
.itemID
, &dis
.rcItem
);
1856 dis
.itemData
= item
.lParam
;
1858 SendMessageW(infoPtr
->hwndNotify
, WM_DRAWITEM
, dis
.CtlID
, (LPARAM
)&dis
);
1860 SelectObject(hdc
, hOldFont
);
1864 DrawFocusRect(hdc
, &infoPtr
->rcFocus
);
1867 ReleaseDC(infoPtr
->hwndSelf
, hdc
);
1871 * Invalidates all visible selected items.
1873 static void LISTVIEW_InvalidateSelectedItems(const LISTVIEW_INFO
*infoPtr
)
1877 iterator_frameditems(&i
, infoPtr
, &infoPtr
->rcList
);
1878 while(iterator_next(&i
))
1880 if (LISTVIEW_GetItemState(infoPtr
, i
.nItem
, LVIS_SELECTED
))
1881 LISTVIEW_InvalidateItem(infoPtr
, i
.nItem
);
1883 iterator_destroy(&i
);
1888 * DESCRIPTION: [INTERNAL]
1889 * Computes an item's (left,top) corner, relative to rcView.
1890 * That is, the position has NOT been made relative to the Origin.
1891 * This is deliberate, to avoid computing the Origin over, and
1892 * over again, when this function is called in a loop. Instead,
1893 * one can factor the computation of the Origin before the loop,
1894 * and offset the value returned by this function, on every iteration.
1897 * [I] infoPtr : valid pointer to the listview structure
1898 * [I] nItem : item number
1899 * [O] lpptOrig : item top, left corner
1904 static void LISTVIEW_GetItemOrigin(const LISTVIEW_INFO
*infoPtr
, INT nItem
, LPPOINT lpptPosition
)
1906 UINT uView
= infoPtr
->dwStyle
& LVS_TYPEMASK
;
1908 assert(nItem
>= 0 && nItem
< infoPtr
->nItemCount
);
1910 if ((uView
== LVS_SMALLICON
) || (uView
== LVS_ICON
))
1912 lpptPosition
->x
= (LONG_PTR
)DPA_GetPtr(infoPtr
->hdpaPosX
, nItem
);
1913 lpptPosition
->y
= (LONG_PTR
)DPA_GetPtr(infoPtr
->hdpaPosY
, nItem
);
1915 else if (uView
== LVS_LIST
)
1917 INT nCountPerColumn
= LISTVIEW_GetCountPerColumn(infoPtr
);
1918 lpptPosition
->x
= nItem
/ nCountPerColumn
* infoPtr
->nItemWidth
;
1919 lpptPosition
->y
= nItem
% nCountPerColumn
* infoPtr
->nItemHeight
;
1921 else /* LVS_REPORT */
1923 lpptPosition
->x
= 0;
1924 lpptPosition
->y
= nItem
* infoPtr
->nItemHeight
;
1929 * DESCRIPTION: [INTERNAL]
1930 * Compute the rectangles of an item. This is to localize all
1931 * the computations in one place. If you are not interested in some
1932 * of these values, simply pass in a NULL -- the function is smart
1933 * enough to compute only what's necessary. The function computes
1934 * the standard rectangles (BOUNDS, ICON, LABEL) plus a non-standard
1935 * one, the BOX rectangle. This rectangle is very cheap to compute,
1936 * and is guaranteed to contain all the other rectangles. Computing
1937 * the ICON rect is also cheap, but all the others are potentially
1938 * expensive. This gives an easy and effective optimization when
1939 * searching (like point inclusion, or rectangle intersection):
1940 * first test against the BOX, and if TRUE, test against the desired
1942 * If the function does not have all the necessary information
1943 * to computed the requested rectangles, will crash with a
1944 * failed assertion. This is done so we catch all programming
1945 * errors, given that the function is called only from our code.
1947 * We have the following 'special' meanings for a few fields:
1948 * * If LVIS_FOCUSED is set, we assume the item has the focus
1949 * This is important in ICON mode, where it might get a larger
1950 * then usual rectangle
1952 * Please note that subitem support works only in REPORT mode.
1955 * [I] infoPtr : valid pointer to the listview structure
1956 * [I] lpLVItem : item to compute the measures for
1957 * [O] lprcBox : ptr to Box rectangle
1958 * Same as LVM_GETITEMRECT with LVIR_BOUNDS
1959 * [0] lprcSelectBox : ptr to select box rectangle
1960 * Same as LVM_GETITEMRECT with LVIR_SELECTEDBOUNDS
1961 * [O] lprcIcon : ptr to Icon rectangle
1962 * Same as LVM_GETITEMRECT with LVIR_ICON
1963 * [O] lprcStateIcon: ptr to State Icon rectangle
1964 * [O] lprcLabel : ptr to Label rectangle
1965 * Same as LVM_GETITEMRECT with LVIR_LABEL
1970 static void LISTVIEW_GetItemMetrics(const LISTVIEW_INFO
*infoPtr
, const LVITEMW
*lpLVItem
,
1971 LPRECT lprcBox
, LPRECT lprcSelectBox
,
1972 LPRECT lprcIcon
, LPRECT lprcStateIcon
, LPRECT lprcLabel
)
1974 UINT uView
= infoPtr
->dwStyle
& LVS_TYPEMASK
;
1975 BOOL doSelectBox
= FALSE
, doIcon
= FALSE
, doLabel
= FALSE
, oversizedBox
= FALSE
;
1976 RECT Box
, SelectBox
, Icon
, Label
;
1977 COLUMN_INFO
*lpColumnInfo
= NULL
;
1978 SIZE labelSize
= { 0, 0 };
1980 TRACE("(lpLVItem=%s)\n", debuglvitem_t(lpLVItem
, TRUE
));
1982 /* Be smart and try to figure out the minimum we have to do */
1983 if (lpLVItem
->iSubItem
) assert(uView
== LVS_REPORT
);
1984 if (uView
== LVS_ICON
&& (lprcBox
|| lprcLabel
))
1986 assert((lpLVItem
->mask
& LVIF_STATE
) && (lpLVItem
->stateMask
& LVIS_FOCUSED
));
1987 if (lpLVItem
->state
& LVIS_FOCUSED
) oversizedBox
= doLabel
= TRUE
;
1989 if (lprcSelectBox
) doSelectBox
= TRUE
;
1990 if (lprcLabel
) doLabel
= TRUE
;
1991 if (doLabel
|| lprcIcon
|| lprcStateIcon
) doIcon
= TRUE
;
1998 /************************************************************/
1999 /* compute the box rectangle (it should be cheap to do) */
2000 /************************************************************/
2001 if (lpLVItem
->iSubItem
|| uView
== LVS_REPORT
)
2002 lpColumnInfo
= LISTVIEW_GetColumnInfo(infoPtr
, lpLVItem
->iSubItem
);
2004 if (lpLVItem
->iSubItem
)
2006 Box
= lpColumnInfo
->rcHeader
;
2011 Box
.right
= infoPtr
->nItemWidth
;
2014 Box
.bottom
= infoPtr
->nItemHeight
;
2016 /******************************************************************/
2017 /* compute ICON bounding box (ala LVM_GETITEMRECT) and STATEICON */
2018 /******************************************************************/
2021 LONG state_width
= 0;
2023 if (infoPtr
->himlState
&& lpLVItem
->iSubItem
== 0)
2024 state_width
= infoPtr
->iconStateSize
.cx
;
2026 if (uView
== LVS_ICON
)
2028 Icon
.left
= Box
.left
+ state_width
;
2029 if (infoPtr
->himlNormal
)
2030 Icon
.left
+= (infoPtr
->nItemWidth
- infoPtr
->iconSize
.cx
- state_width
) / 2;
2031 Icon
.top
= Box
.top
+ ICON_TOP_PADDING
;
2032 Icon
.right
= Icon
.left
;
2033 Icon
.bottom
= Icon
.top
;
2034 if (infoPtr
->himlNormal
)
2036 Icon
.right
+= infoPtr
->iconSize
.cx
;
2037 Icon
.bottom
+= infoPtr
->iconSize
.cy
;
2040 else /* LVS_SMALLICON, LVS_LIST or LVS_REPORT */
2042 Icon
.left
= Box
.left
+ state_width
;
2044 if (uView
== LVS_REPORT
)
2045 Icon
.left
+= REPORT_MARGINX
;
2048 Icon
.right
= Icon
.left
;
2049 if (infoPtr
->himlSmall
&&
2050 (!lpColumnInfo
|| lpLVItem
->iSubItem
== 0 || (lpColumnInfo
->fmt
& LVCFMT_IMAGE
) ||
2051 ((infoPtr
->dwLvExStyle
& LVS_EX_SUBITEMIMAGES
) && lpLVItem
->iImage
!= I_IMAGECALLBACK
)))
2052 Icon
.right
+= infoPtr
->iconSize
.cx
;
2053 Icon
.bottom
= Icon
.top
+ infoPtr
->iconSize
.cy
;
2055 if(lprcIcon
) *lprcIcon
= Icon
;
2056 TRACE(" - icon=%s\n", wine_dbgstr_rect(&Icon
));
2058 /* TODO: is this correct? */
2061 lprcStateIcon
->left
= Icon
.left
- state_width
;
2062 lprcStateIcon
->right
= Icon
.left
;
2063 lprcStateIcon
->top
= Icon
.top
;
2064 lprcStateIcon
->bottom
= lprcStateIcon
->top
+ infoPtr
->iconSize
.cy
;
2065 TRACE(" - state icon=%s\n", wine_dbgstr_rect(lprcStateIcon
));
2068 else Icon
.right
= 0;
2070 /************************************************************/
2071 /* compute LABEL bounding box (ala LVM_GETITEMRECT) */
2072 /************************************************************/
2075 /* calculate how far to the right can the label stretch */
2076 Label
.right
= Box
.right
;
2077 if (uView
== LVS_REPORT
)
2079 if (lpLVItem
->iSubItem
== 0) Label
= lpColumnInfo
->rcHeader
;
2082 if (lpLVItem
->iSubItem
|| ((infoPtr
->dwStyle
& LVS_OWNERDRAWFIXED
) && uView
== LVS_REPORT
))
2084 labelSize
.cx
= infoPtr
->nItemWidth
;
2085 labelSize
.cy
= infoPtr
->nItemHeight
;
2089 /* we need the text in non owner draw mode */
2090 assert(lpLVItem
->mask
& LVIF_TEXT
);
2091 if (is_textT(lpLVItem
->pszText
, TRUE
))
2093 HFONT hFont
= infoPtr
->hFont
? infoPtr
->hFont
: infoPtr
->hDefaultFont
;
2094 HDC hdc
= GetDC(infoPtr
->hwndSelf
);
2095 HFONT hOldFont
= SelectObject(hdc
, hFont
);
2099 /* compute rough rectangle where the label will go */
2100 SetRectEmpty(&rcText
);
2101 rcText
.right
= infoPtr
->nItemWidth
- TRAILING_LABEL_PADDING
;
2102 rcText
.bottom
= infoPtr
->nItemHeight
;
2103 if (uView
== LVS_ICON
)
2104 rcText
.bottom
-= ICON_TOP_PADDING
+ infoPtr
->iconSize
.cy
+ ICON_BOTTOM_PADDING
;
2106 /* now figure out the flags */
2107 if (uView
== LVS_ICON
)
2108 uFormat
= oversizedBox
? LV_FL_DT_FLAGS
: LV_ML_DT_FLAGS
;
2110 uFormat
= LV_SL_DT_FLAGS
;
2112 DrawTextW (hdc
, lpLVItem
->pszText
, -1, &rcText
, uFormat
| DT_CALCRECT
);
2114 labelSize
.cx
= min(rcText
.right
- rcText
.left
+ TRAILING_LABEL_PADDING
, infoPtr
->nItemWidth
);
2115 labelSize
.cy
= rcText
.bottom
- rcText
.top
;
2117 SelectObject(hdc
, hOldFont
);
2118 ReleaseDC(infoPtr
->hwndSelf
, hdc
);
2122 if (uView
== LVS_ICON
)
2124 Label
.left
= Box
.left
+ (infoPtr
->nItemWidth
- labelSize
.cx
) / 2;
2125 Label
.top
= Box
.top
+ ICON_TOP_PADDING_HITABLE
+
2126 infoPtr
->iconSize
.cy
+ ICON_BOTTOM_PADDING
;
2127 Label
.right
= Label
.left
+ labelSize
.cx
;
2128 Label
.bottom
= Label
.top
+ infoPtr
->nItemHeight
;
2129 if (!oversizedBox
&& labelSize
.cy
> infoPtr
->ntmHeight
)
2131 labelSize
.cy
= min(Box
.bottom
- Label
.top
, labelSize
.cy
);
2132 labelSize
.cy
/= infoPtr
->ntmHeight
;
2133 labelSize
.cy
= max(labelSize
.cy
, 1);
2134 labelSize
.cy
*= infoPtr
->ntmHeight
;
2136 Label
.bottom
= Label
.top
+ labelSize
.cy
+ HEIGHT_PADDING
;
2138 else if (uView
== LVS_REPORT
)
2140 Label
.left
= Icon
.right
;
2141 Label
.top
= Box
.top
;
2142 Label
.right
= lpColumnInfo
->rcHeader
.right
;
2143 Label
.bottom
= Label
.top
+ infoPtr
->nItemHeight
;
2145 else /* LVS_SMALLICON, LVS_LIST or LVS_REPORT */
2147 Label
.left
= Icon
.right
;
2148 Label
.top
= Box
.top
;
2149 Label
.right
= min(Label
.left
+ labelSize
.cx
, Label
.right
);
2150 Label
.bottom
= Label
.top
+ infoPtr
->nItemHeight
;
2153 if (lprcLabel
) *lprcLabel
= Label
;
2154 TRACE(" - label=%s\n", wine_dbgstr_rect(&Label
));
2157 /************************************************************/
2158 /* compute STATEICON bounding box */
2159 /************************************************************/
2162 if (uView
== LVS_REPORT
)
2164 SelectBox
.left
= Icon
.right
; /* FIXME: should be Icon.left */
2165 SelectBox
.top
= Box
.top
;
2166 SelectBox
.bottom
= Box
.bottom
;
2167 if (lpLVItem
->iSubItem
== 0)
2169 /* we need the indent in report mode */
2170 assert(lpLVItem
->mask
& LVIF_INDENT
);
2171 SelectBox
.left
+= infoPtr
->iconSize
.cx
* lpLVItem
->iIndent
;
2173 SelectBox
.right
= min(SelectBox
.left
+ labelSize
.cx
, Label
.right
);
2177 UnionRect(&SelectBox
, &Icon
, &Label
);
2179 if (lprcSelectBox
) *lprcSelectBox
= SelectBox
;
2180 TRACE(" - select box=%s\n", wine_dbgstr_rect(&SelectBox
));
2183 /* Fix the Box if necessary */
2186 if (oversizedBox
) UnionRect(lprcBox
, &Box
, &Label
);
2187 else *lprcBox
= Box
;
2189 TRACE(" - box=%s\n", wine_dbgstr_rect(&Box
));
2193 * DESCRIPTION: [INTERNAL]
2196 * [I] infoPtr : valid pointer to the listview structure
2197 * [I] nItem : item number
2198 * [O] lprcBox : ptr to Box rectangle
2203 static void LISTVIEW_GetItemBox(const LISTVIEW_INFO
*infoPtr
, INT nItem
, LPRECT lprcBox
)
2205 UINT uView
= infoPtr
->dwStyle
& LVS_TYPEMASK
;
2206 WCHAR szDispText
[DISP_TEXT_SIZE
] = { '\0' };
2207 POINT Position
, Origin
;
2210 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
2211 LISTVIEW_GetItemOrigin(infoPtr
, nItem
, &Position
);
2213 /* Be smart and try to figure out the minimum we have to do */
2215 if (uView
== LVS_ICON
&& infoPtr
->bFocus
&& LISTVIEW_GetItemState(infoPtr
, nItem
, LVIS_FOCUSED
))
2216 lvItem
.mask
|= LVIF_TEXT
;
2217 lvItem
.iItem
= nItem
;
2218 lvItem
.iSubItem
= 0;
2219 lvItem
.pszText
= szDispText
;
2220 lvItem
.cchTextMax
= DISP_TEXT_SIZE
;
2221 if (lvItem
.mask
) LISTVIEW_GetItemW(infoPtr
, &lvItem
);
2222 if (uView
== LVS_ICON
)
2224 lvItem
.mask
|= LVIF_STATE
;
2225 lvItem
.stateMask
= LVIS_FOCUSED
;
2226 lvItem
.state
= (lvItem
.mask
& LVIF_TEXT
? LVIS_FOCUSED
: 0);
2228 LISTVIEW_GetItemMetrics(infoPtr
, &lvItem
, lprcBox
, 0, 0, 0, 0);
2230 OffsetRect(lprcBox
, Position
.x
+ Origin
.x
, Position
.y
+ Origin
.y
);
2236 * Returns the current icon position, and advances it along the top.
2237 * The returned position is not offset by Origin.
2240 * [I] infoPtr : valid pointer to the listview structure
2241 * [O] lpPos : will get the current icon position
2246 static void LISTVIEW_NextIconPosTop(LISTVIEW_INFO
*infoPtr
, LPPOINT lpPos
)
2248 INT nListWidth
= infoPtr
->rcList
.right
- infoPtr
->rcList
.left
;
2250 *lpPos
= infoPtr
->currIconPos
;
2252 infoPtr
->currIconPos
.x
+= infoPtr
->nItemWidth
;
2253 if (infoPtr
->currIconPos
.x
+ infoPtr
->nItemWidth
<= nListWidth
) return;
2255 infoPtr
->currIconPos
.x
= 0;
2256 infoPtr
->currIconPos
.y
+= infoPtr
->nItemHeight
;
2262 * Returns the current icon position, and advances it down the left edge.
2263 * The returned position is not offset by Origin.
2266 * [I] infoPtr : valid pointer to the listview structure
2267 * [O] lpPos : will get the current icon position
2272 static void LISTVIEW_NextIconPosLeft(LISTVIEW_INFO
*infoPtr
, LPPOINT lpPos
)
2274 INT nListHeight
= infoPtr
->rcList
.bottom
- infoPtr
->rcList
.top
;
2276 *lpPos
= infoPtr
->currIconPos
;
2278 infoPtr
->currIconPos
.y
+= infoPtr
->nItemHeight
;
2279 if (infoPtr
->currIconPos
.y
+ infoPtr
->nItemHeight
<= nListHeight
) return;
2281 infoPtr
->currIconPos
.x
+= infoPtr
->nItemWidth
;
2282 infoPtr
->currIconPos
.y
= 0;
2288 * Moves an icon to the specified position.
2289 * It takes care of invalidating the item, etc.
2292 * [I] infoPtr : valid pointer to the listview structure
2293 * [I] nItem : the item to move
2294 * [I] lpPos : the new icon position
2295 * [I] isNew : flags the item as being new
2301 static BOOL
LISTVIEW_MoveIconTo(const LISTVIEW_INFO
*infoPtr
, INT nItem
, const POINT
*lppt
, BOOL isNew
)
2307 old
.x
= (LONG_PTR
)DPA_GetPtr(infoPtr
->hdpaPosX
, nItem
);
2308 old
.y
= (LONG_PTR
)DPA_GetPtr(infoPtr
->hdpaPosY
, nItem
);
2310 if (lppt
->x
== old
.x
&& lppt
->y
== old
.y
) return TRUE
;
2311 LISTVIEW_InvalidateItem(infoPtr
, nItem
);
2314 /* Allocating a POINTER for every item is too resource intensive,
2315 * so we'll keep the (x,y) in different arrays */
2316 if (!DPA_SetPtr(infoPtr
->hdpaPosX
, nItem
, (void *)(LONG_PTR
)lppt
->x
)) return FALSE
;
2317 if (!DPA_SetPtr(infoPtr
->hdpaPosY
, nItem
, (void *)(LONG_PTR
)lppt
->y
)) return FALSE
;
2319 LISTVIEW_InvalidateItem(infoPtr
, nItem
);
2326 * Arranges listview items in icon display mode.
2329 * [I] infoPtr : valid pointer to the listview structure
2330 * [I] nAlignCode : alignment code
2336 static BOOL
LISTVIEW_Arrange(LISTVIEW_INFO
*infoPtr
, INT nAlignCode
)
2338 UINT uView
= infoPtr
->dwStyle
& LVS_TYPEMASK
;
2339 void (*next_pos
)(LISTVIEW_INFO
*, LPPOINT
);
2343 if (uView
!= LVS_ICON
&& uView
!= LVS_SMALLICON
) return FALSE
;
2345 TRACE("nAlignCode=%d\n", nAlignCode
);
2347 if (nAlignCode
== LVA_DEFAULT
)
2349 if (infoPtr
->dwStyle
& LVS_ALIGNLEFT
) nAlignCode
= LVA_ALIGNLEFT
;
2350 else nAlignCode
= LVA_ALIGNTOP
;
2355 case LVA_ALIGNLEFT
: next_pos
= LISTVIEW_NextIconPosLeft
; break;
2356 case LVA_ALIGNTOP
: next_pos
= LISTVIEW_NextIconPosTop
; break;
2357 case LVA_SNAPTOGRID
: next_pos
= LISTVIEW_NextIconPosTop
; break; /* FIXME */
2358 default: return FALSE
;
2361 infoPtr
->bAutoarrange
= TRUE
;
2362 infoPtr
->currIconPos
.x
= infoPtr
->currIconPos
.y
= 0;
2363 for (i
= 0; i
< infoPtr
->nItemCount
; i
++)
2365 next_pos(infoPtr
, &pos
);
2366 LISTVIEW_MoveIconTo(infoPtr
, i
, &pos
, FALSE
);
2374 * Retrieves the bounding rectangle of all the items, not offset by Origin.
2377 * [I] infoPtr : valid pointer to the listview structure
2378 * [O] lprcView : bounding rectangle
2384 static void LISTVIEW_GetAreaRect(const LISTVIEW_INFO
*infoPtr
, LPRECT lprcView
)
2388 SetRectEmpty(lprcView
);
2390 switch (infoPtr
->dwStyle
& LVS_TYPEMASK
)
2394 for (i
= 0; i
< infoPtr
->nItemCount
; i
++)
2396 x
= (LONG_PTR
)DPA_GetPtr(infoPtr
->hdpaPosX
, i
);
2397 y
= (LONG_PTR
)DPA_GetPtr(infoPtr
->hdpaPosY
, i
);
2398 lprcView
->right
= max(lprcView
->right
, x
);
2399 lprcView
->bottom
= max(lprcView
->bottom
, y
);
2401 if (infoPtr
->nItemCount
> 0)
2403 lprcView
->right
+= infoPtr
->nItemWidth
;
2404 lprcView
->bottom
+= infoPtr
->nItemHeight
;
2409 y
= LISTVIEW_GetCountPerColumn(infoPtr
);
2410 x
= infoPtr
->nItemCount
/ y
;
2411 if (infoPtr
->nItemCount
% y
) x
++;
2412 lprcView
->right
= x
* infoPtr
->nItemWidth
;
2413 lprcView
->bottom
= y
* infoPtr
->nItemHeight
;
2417 lprcView
->right
= infoPtr
->nItemWidth
;
2418 lprcView
->bottom
= infoPtr
->nItemCount
* infoPtr
->nItemHeight
;
2425 * Retrieves the bounding rectangle of all the items.
2428 * [I] infoPtr : valid pointer to the listview structure
2429 * [O] lprcView : bounding rectangle
2435 static BOOL
LISTVIEW_GetViewRect(const LISTVIEW_INFO
*infoPtr
, LPRECT lprcView
)
2439 TRACE("(lprcView=%p)\n", lprcView
);
2441 if (!lprcView
) return FALSE
;
2443 LISTVIEW_GetOrigin(infoPtr
, &ptOrigin
);
2444 LISTVIEW_GetAreaRect(infoPtr
, lprcView
);
2445 OffsetRect(lprcView
, ptOrigin
.x
, ptOrigin
.y
);
2447 TRACE("lprcView=%s\n", wine_dbgstr_rect(lprcView
));
2454 * Retrieves the subitem pointer associated with the subitem index.
2457 * [I] hdpaSubItems : DPA handle for a specific item
2458 * [I] nSubItem : index of subitem
2461 * SUCCESS : subitem pointer
2464 static SUBITEM_INFO
* LISTVIEW_GetSubItemPtr(HDPA hdpaSubItems
, INT nSubItem
)
2466 SUBITEM_INFO
*lpSubItem
;
2469 /* we should binary search here if need be */
2470 for (i
= 1; i
< DPA_GetPtrCount(hdpaSubItems
); i
++)
2472 lpSubItem
= DPA_GetPtr(hdpaSubItems
, i
);
2473 if (lpSubItem
->iSubItem
== nSubItem
)
2483 * Calculates the desired item width.
2486 * [I] infoPtr : valid pointer to the listview structure
2489 * The desired item width.
2491 static INT
LISTVIEW_CalculateItemWidth(const LISTVIEW_INFO
*infoPtr
)
2493 UINT uView
= infoPtr
->dwStyle
& LVS_TYPEMASK
;
2496 TRACE("uView=%d\n", uView
);
2498 if (uView
== LVS_ICON
)
2499 nItemWidth
= infoPtr
->iconSpacing
.cx
;
2500 else if (uView
== LVS_REPORT
)
2504 if (DPA_GetPtrCount(infoPtr
->hdpaColumns
) > 0)
2506 LISTVIEW_GetHeaderRect(infoPtr
, DPA_GetPtrCount(infoPtr
->hdpaColumns
) - 1, &rcHeader
);
2507 nItemWidth
= rcHeader
.right
;
2510 else /* LVS_SMALLICON, or LVS_LIST */
2514 for (i
= 0; i
< infoPtr
->nItemCount
; i
++)
2515 nItemWidth
= max(LISTVIEW_GetLabelWidth(infoPtr
, i
), nItemWidth
);
2517 if (infoPtr
->himlSmall
) nItemWidth
+= infoPtr
->iconSize
.cx
;
2518 if (infoPtr
->himlState
) nItemWidth
+= infoPtr
->iconStateSize
.cx
;
2520 nItemWidth
= max(DEFAULT_COLUMN_WIDTH
, nItemWidth
+ WIDTH_PADDING
);
2523 return max(nItemWidth
, 1);
2528 * Calculates the desired item height.
2531 * [I] infoPtr : valid pointer to the listview structure
2534 * The desired item height.
2536 static INT
LISTVIEW_CalculateItemHeight(const LISTVIEW_INFO
*infoPtr
)
2538 UINT uView
= infoPtr
->dwStyle
& LVS_TYPEMASK
;
2541 TRACE("uView=%d\n", uView
);
2543 if (uView
== LVS_ICON
)
2544 nItemHeight
= infoPtr
->iconSpacing
.cy
;
2547 nItemHeight
= infoPtr
->ntmHeight
;
2548 if (uView
== LVS_REPORT
&& infoPtr
->dwLvExStyle
& LVS_EX_GRIDLINES
)
2550 if (infoPtr
->himlState
)
2551 nItemHeight
= max(nItemHeight
, infoPtr
->iconStateSize
.cy
);
2552 if (infoPtr
->himlSmall
)
2553 nItemHeight
= max(nItemHeight
, infoPtr
->iconSize
.cy
);
2554 if (infoPtr
->himlState
|| infoPtr
->himlSmall
)
2555 nItemHeight
+= HEIGHT_PADDING
;
2556 if (infoPtr
->nMeasureItemHeight
> 0)
2557 nItemHeight
= infoPtr
->nMeasureItemHeight
;
2560 return max(nItemHeight
, 1);
2565 * Updates the width, and height of an item.
2568 * [I] infoPtr : valid pointer to the listview structure
2573 static inline void LISTVIEW_UpdateItemSize(LISTVIEW_INFO
*infoPtr
)
2575 infoPtr
->nItemWidth
= LISTVIEW_CalculateItemWidth(infoPtr
);
2576 infoPtr
->nItemHeight
= LISTVIEW_CalculateItemHeight(infoPtr
);
2582 * Retrieves and saves important text metrics info for the current
2586 * [I] infoPtr : valid pointer to the listview structure
2589 static void LISTVIEW_SaveTextMetrics(LISTVIEW_INFO
*infoPtr
)
2591 HDC hdc
= GetDC(infoPtr
->hwndSelf
);
2592 HFONT hFont
= infoPtr
->hFont
? infoPtr
->hFont
: infoPtr
->hDefaultFont
;
2593 HFONT hOldFont
= SelectObject(hdc
, hFont
);
2597 if (GetTextMetricsW(hdc
, &tm
))
2599 infoPtr
->ntmHeight
= tm
.tmHeight
;
2600 infoPtr
->ntmMaxCharWidth
= tm
.tmMaxCharWidth
;
2603 if (GetTextExtentPoint32A(hdc
, "...", 3, &sz
))
2604 infoPtr
->nEllipsisWidth
= sz
.cx
;
2606 SelectObject(hdc
, hOldFont
);
2607 ReleaseDC(infoPtr
->hwndSelf
, hdc
);
2609 TRACE("tmHeight=%d\n", infoPtr
->ntmHeight
);
2614 * A compare function for ranges
2617 * [I] range1 : pointer to range 1;
2618 * [I] range2 : pointer to range 2;
2622 * > 0 : if range 1 > range 2
2623 * < 0 : if range 2 > range 1
2624 * = 0 : if range intersects range 2
2626 static INT CALLBACK
ranges_cmp(LPVOID range1
, LPVOID range2
, LPARAM flags
)
2630 if (((RANGE
*)range1
)->upper
<= ((RANGE
*)range2
)->lower
)
2632 else if (((RANGE
*)range2
)->upper
<= ((RANGE
*)range1
)->lower
)
2637 TRACE("range1=%s, range2=%s, cmp=%d\n", debugrange(range1
), debugrange(range2
), cmp
);
2643 #define ranges_check(ranges, desc) ranges_assert(ranges, desc, __FUNCTION__, __LINE__)
2645 #define ranges_check(ranges, desc) do { } while(0)
2648 static void ranges_assert(RANGES ranges
, LPCSTR desc
, const char *func
, int line
)
2653 TRACE("*** Checking %s:%d:%s ***\n", func
, line
, desc
);
2655 assert (DPA_GetPtrCount(ranges
->hdpa
) >= 0);
2656 ranges_dump(ranges
);
2657 if (DPA_GetPtrCount(ranges
->hdpa
) > 0)
2659 prev
= DPA_GetPtr(ranges
->hdpa
, 0);
2660 assert (prev
->lower
>= 0 && prev
->lower
< prev
->upper
);
2661 for (i
= 1; i
< DPA_GetPtrCount(ranges
->hdpa
); i
++)
2663 curr
= DPA_GetPtr(ranges
->hdpa
, i
);
2664 assert (prev
->upper
<= curr
->lower
);
2665 assert (curr
->lower
< curr
->upper
);
2669 TRACE("--- Done checking---\n");
2672 static RANGES
ranges_create(int count
)
2674 RANGES ranges
= Alloc(sizeof(struct tagRANGES
));
2675 if (!ranges
) return NULL
;
2676 ranges
->hdpa
= DPA_Create(count
);
2677 if (ranges
->hdpa
) return ranges
;
2682 static void ranges_clear(RANGES ranges
)
2686 for(i
= 0; i
< DPA_GetPtrCount(ranges
->hdpa
); i
++)
2687 Free(DPA_GetPtr(ranges
->hdpa
, i
));
2688 DPA_DeleteAllPtrs(ranges
->hdpa
);
2692 static void ranges_destroy(RANGES ranges
)
2694 if (!ranges
) return;
2695 ranges_clear(ranges
);
2696 DPA_Destroy(ranges
->hdpa
);
2700 static RANGES
ranges_clone(RANGES ranges
)
2705 if (!(clone
= ranges_create(DPA_GetPtrCount(ranges
->hdpa
)))) goto fail
;
2707 for (i
= 0; i
< DPA_GetPtrCount(ranges
->hdpa
); i
++)
2709 RANGE
*newrng
= Alloc(sizeof(RANGE
));
2710 if (!newrng
) goto fail
;
2711 *newrng
= *((RANGE
*)DPA_GetPtr(ranges
->hdpa
, i
));
2712 DPA_SetPtr(clone
->hdpa
, i
, newrng
);
2717 TRACE ("clone failed\n");
2718 ranges_destroy(clone
);
2722 static RANGES
ranges_diff(RANGES ranges
, RANGES sub
)
2726 for (i
= 0; i
< DPA_GetPtrCount(sub
->hdpa
); i
++)
2727 ranges_del(ranges
, *((RANGE
*)DPA_GetPtr(sub
->hdpa
, i
)));
2732 static void ranges_dump(RANGES ranges
)
2736 for (i
= 0; i
< DPA_GetPtrCount(ranges
->hdpa
); i
++)
2737 TRACE(" %s\n", debugrange(DPA_GetPtr(ranges
->hdpa
, i
)));
2740 static inline BOOL
ranges_contain(RANGES ranges
, INT nItem
)
2742 RANGE srchrng
= { nItem
, nItem
+ 1 };
2744 TRACE("(nItem=%d)\n", nItem
);
2745 ranges_check(ranges
, "before contain");
2746 return DPA_Search(ranges
->hdpa
, &srchrng
, 0, ranges_cmp
, 0, DPAS_SORTED
) != -1;
2749 static INT
ranges_itemcount(RANGES ranges
)
2753 for (i
= 0; i
< DPA_GetPtrCount(ranges
->hdpa
); i
++)
2755 RANGE
*sel
= DPA_GetPtr(ranges
->hdpa
, i
);
2756 count
+= sel
->upper
- sel
->lower
;
2762 static BOOL
ranges_shift(RANGES ranges
, INT nItem
, INT delta
, INT nUpper
)
2764 RANGE srchrng
= { nItem
, nItem
+ 1 }, *chkrng
;
2767 index
= DPA_Search(ranges
->hdpa
, &srchrng
, 0, ranges_cmp
, 0, DPAS_SORTED
| DPAS_INSERTAFTER
);
2768 if (index
== -1) return TRUE
;
2770 for (; index
< DPA_GetPtrCount(ranges
->hdpa
); index
++)
2772 chkrng
= DPA_GetPtr(ranges
->hdpa
, index
);
2773 if (chkrng
->lower
>= nItem
)
2774 chkrng
->lower
= max(min(chkrng
->lower
+ delta
, nUpper
- 1), 0);
2775 if (chkrng
->upper
> nItem
)
2776 chkrng
->upper
= max(min(chkrng
->upper
+ delta
, nUpper
), 0);
2781 static BOOL
ranges_add(RANGES ranges
, RANGE range
)
2786 TRACE("(%s)\n", debugrange(&range
));
2787 ranges_check(ranges
, "before add");
2789 /* try find overlapping regions first */
2790 srchrgn
.lower
= range
.lower
- 1;
2791 srchrgn
.upper
= range
.upper
+ 1;
2792 index
= DPA_Search(ranges
->hdpa
, &srchrgn
, 0, ranges_cmp
, 0, DPAS_SORTED
);
2798 TRACE("Adding new range\n");
2800 /* create the brand new range to insert */
2801 newrgn
= Alloc(sizeof(RANGE
));
2802 if(!newrgn
) goto fail
;
2805 /* figure out where to insert it */
2806 index
= DPA_Search(ranges
->hdpa
, newrgn
, 0, ranges_cmp
, 0, DPAS_SORTED
| DPAS_INSERTAFTER
);
2807 TRACE("index=%d\n", index
);
2808 if (index
== -1) index
= 0;
2810 /* and get it over with */
2811 if (DPA_InsertPtr(ranges
->hdpa
, index
, newrgn
) == -1)
2819 RANGE
*chkrgn
, *mrgrgn
;
2820 INT fromindex
, mergeindex
;
2822 chkrgn
= DPA_GetPtr(ranges
->hdpa
, index
);
2823 TRACE("Merge with %s @%d\n", debugrange(chkrgn
), index
);
2825 chkrgn
->lower
= min(range
.lower
, chkrgn
->lower
);
2826 chkrgn
->upper
= max(range
.upper
, chkrgn
->upper
);
2828 TRACE("New range %s @%d\n", debugrange(chkrgn
), index
);
2830 /* merge now common ranges */
2832 srchrgn
.lower
= chkrgn
->lower
- 1;
2833 srchrgn
.upper
= chkrgn
->upper
+ 1;
2837 mergeindex
= DPA_Search(ranges
->hdpa
, &srchrgn
, fromindex
, ranges_cmp
, 0, 0);
2838 if (mergeindex
== -1) break;
2839 if (mergeindex
== index
)
2841 fromindex
= index
+ 1;
2845 TRACE("Merge with index %i\n", mergeindex
);
2847 mrgrgn
= DPA_GetPtr(ranges
->hdpa
, mergeindex
);
2848 chkrgn
->lower
= min(chkrgn
->lower
, mrgrgn
->lower
);
2849 chkrgn
->upper
= max(chkrgn
->upper
, mrgrgn
->upper
);
2851 DPA_DeletePtr(ranges
->hdpa
, mergeindex
);
2852 if (mergeindex
< index
) index
--;
2856 ranges_check(ranges
, "after add");
2860 ranges_check(ranges
, "failed add");
2864 static BOOL
ranges_del(RANGES ranges
, RANGE range
)
2869 TRACE("(%s)\n", debugrange(&range
));
2870 ranges_check(ranges
, "before del");
2872 /* we don't use DPAS_SORTED here, since we need *
2873 * to find the first overlapping range */
2874 index
= DPA_Search(ranges
->hdpa
, &range
, 0, ranges_cmp
, 0, 0);
2877 chkrgn
= DPA_GetPtr(ranges
->hdpa
, index
);
2879 TRACE("Matches range %s @%d\n", debugrange(chkrgn
), index
);
2881 /* case 1: Same range */
2882 if ( (chkrgn
->upper
== range
.upper
) &&
2883 (chkrgn
->lower
== range
.lower
) )
2885 DPA_DeletePtr(ranges
->hdpa
, index
);
2888 /* case 2: engulf */
2889 else if ( (chkrgn
->upper
<= range
.upper
) &&
2890 (chkrgn
->lower
>= range
.lower
) )
2892 DPA_DeletePtr(ranges
->hdpa
, index
);
2894 /* case 3: overlap upper */
2895 else if ( (chkrgn
->upper
<= range
.upper
) &&
2896 (chkrgn
->lower
< range
.lower
) )
2898 chkrgn
->upper
= range
.lower
;
2900 /* case 4: overlap lower */
2901 else if ( (chkrgn
->upper
> range
.upper
) &&
2902 (chkrgn
->lower
>= range
.lower
) )
2904 chkrgn
->lower
= range
.upper
;
2907 /* case 5: fully internal */
2910 RANGE tmprgn
= *chkrgn
, *newrgn
;
2912 if (!(newrgn
= Alloc(sizeof(RANGE
)))) goto fail
;
2913 newrgn
->lower
= chkrgn
->lower
;
2914 newrgn
->upper
= range
.lower
;
2915 chkrgn
->lower
= range
.upper
;
2916 if (DPA_InsertPtr(ranges
->hdpa
, index
, newrgn
) == -1)
2925 index
= DPA_Search(ranges
->hdpa
, &range
, index
, ranges_cmp
, 0, 0);
2928 ranges_check(ranges
, "after del");
2932 ranges_check(ranges
, "failed del");
2938 * Removes all selection ranges
2941 * [I] infoPtr : valid pointer to the listview structure
2942 * [I] toSkip : item range to skip removing the selection
2948 static BOOL
LISTVIEW_DeselectAllSkipItems(LISTVIEW_INFO
*infoPtr
, RANGES toSkip
)
2957 lvItem
.stateMask
= LVIS_SELECTED
;
2959 /* need to clone the DPA because callbacks can change it */
2960 if (!(clone
= ranges_clone(infoPtr
->selectionRanges
))) return FALSE
;
2961 iterator_rangesitems(&i
, ranges_diff(clone
, toSkip
));
2962 while(iterator_next(&i
))
2963 LISTVIEW_SetItemState(infoPtr
, i
.nItem
, &lvItem
);
2964 /* note that the iterator destructor will free the cloned range */
2965 iterator_destroy(&i
);
2970 static inline BOOL
LISTVIEW_DeselectAllSkipItem(LISTVIEW_INFO
*infoPtr
, INT nItem
)
2974 if (!(toSkip
= ranges_create(1))) return FALSE
;
2975 if (nItem
!= -1) ranges_additem(toSkip
, nItem
);
2976 LISTVIEW_DeselectAllSkipItems(infoPtr
, toSkip
);
2977 ranges_destroy(toSkip
);
2981 static inline BOOL
LISTVIEW_DeselectAll(LISTVIEW_INFO
*infoPtr
)
2983 return LISTVIEW_DeselectAllSkipItem(infoPtr
, -1);
2988 * Retrieves the number of items that are marked as selected.
2991 * [I] infoPtr : valid pointer to the listview structure
2994 * Number of items selected.
2996 static INT
LISTVIEW_GetSelectedCount(const LISTVIEW_INFO
*infoPtr
)
2998 INT nSelectedCount
= 0;
3000 if (infoPtr
->uCallbackMask
& LVIS_SELECTED
)
3003 for (i
= 0; i
< infoPtr
->nItemCount
; i
++)
3005 if (LISTVIEW_GetItemState(infoPtr
, i
, LVIS_SELECTED
))
3010 nSelectedCount
= ranges_itemcount(infoPtr
->selectionRanges
);
3012 TRACE("nSelectedCount=%d\n", nSelectedCount
);
3013 return nSelectedCount
;
3018 * Manages the item focus.
3021 * [I] infoPtr : valid pointer to the listview structure
3022 * [I] nItem : item index
3025 * TRUE : focused item changed
3026 * FALSE : focused item has NOT changed
3028 static inline BOOL
LISTVIEW_SetItemFocus(LISTVIEW_INFO
*infoPtr
, INT nItem
)
3030 INT oldFocus
= infoPtr
->nFocusedItem
;
3033 if (nItem
== infoPtr
->nFocusedItem
) return FALSE
;
3035 lvItem
.state
= nItem
== -1 ? 0 : LVIS_FOCUSED
;
3036 lvItem
.stateMask
= LVIS_FOCUSED
;
3037 LISTVIEW_SetItemState(infoPtr
, nItem
== -1 ? infoPtr
->nFocusedItem
: nItem
, &lvItem
);
3039 return oldFocus
!= infoPtr
->nFocusedItem
;
3042 /* Helper function for LISTVIEW_ShiftIndices *only* */
3043 static INT
shift_item(const LISTVIEW_INFO
*infoPtr
, INT nShiftItem
, INT nItem
, INT direction
)
3045 if (nShiftItem
< nItem
) return nShiftItem
;
3047 if (nShiftItem
> nItem
) return nShiftItem
+ direction
;
3049 if (direction
> 0) return nShiftItem
+ direction
;
3051 return min(nShiftItem
, infoPtr
->nItemCount
- 1);
3056 * Updates the various indices after an item has been inserted or deleted.
3059 * [I] infoPtr : valid pointer to the listview structure
3060 * [I] nItem : item index
3061 * [I] direction : Direction of shift, +1 or -1.
3066 static void LISTVIEW_ShiftIndices(LISTVIEW_INFO
*infoPtr
, INT nItem
, INT direction
)
3071 /* temporarily disable change notification while shifting items */
3072 bOldChange
= infoPtr
->bDoChangeNotify
;
3073 infoPtr
->bDoChangeNotify
= FALSE
;
3075 TRACE("Shifting %iu, %i steps\n", nItem
, direction
);
3077 ranges_shift(infoPtr
->selectionRanges
, nItem
, direction
, infoPtr
->nItemCount
);
3079 assert(abs(direction
) == 1);
3081 infoPtr
->nSelectionMark
= shift_item(infoPtr
, infoPtr
->nSelectionMark
, nItem
, direction
);
3083 nNewFocus
= shift_item(infoPtr
, infoPtr
->nFocusedItem
, nItem
, direction
);
3084 if (nNewFocus
!= infoPtr
->nFocusedItem
)
3085 LISTVIEW_SetItemFocus(infoPtr
, nNewFocus
);
3087 /* But we are not supposed to modify nHotItem! */
3089 infoPtr
->bDoChangeNotify
= bOldChange
;
3095 * Adds a block of selections.
3098 * [I] infoPtr : valid pointer to the listview structure
3099 * [I] nItem : item index
3102 * Whether the window is still valid.
3104 static BOOL
LISTVIEW_AddGroupSelection(LISTVIEW_INFO
*infoPtr
, INT nItem
)
3106 INT nFirst
= min(infoPtr
->nSelectionMark
, nItem
);
3107 INT nLast
= max(infoPtr
->nSelectionMark
, nItem
);
3108 HWND hwndSelf
= infoPtr
->hwndSelf
;
3109 NMLVODSTATECHANGE nmlv
;
3114 /* Temporarily disable change notification
3115 * If the control is LVS_OWNERDATA, we need to send
3116 * only one LVN_ODSTATECHANGED notification.
3117 * See MSDN documentation for LVN_ITEMCHANGED.
3119 bOldChange
= infoPtr
->bDoChangeNotify
;
3120 if (infoPtr
->dwStyle
& LVS_OWNERDATA
) infoPtr
->bDoChangeNotify
= FALSE
;
3122 if (nFirst
== -1) nFirst
= nItem
;
3124 item
.state
= LVIS_SELECTED
;
3125 item
.stateMask
= LVIS_SELECTED
;
3127 for (i
= nFirst
; i
<= nLast
; i
++)
3128 LISTVIEW_SetItemState(infoPtr
,i
,&item
);
3130 ZeroMemory(&nmlv
, sizeof(nmlv
));
3131 nmlv
.iFrom
= nFirst
;
3134 nmlv
.uOldState
= item
.state
;
3136 notify_hdr(infoPtr
, LVN_ODSTATECHANGED
, (LPNMHDR
)&nmlv
);
3137 if (!IsWindow(hwndSelf
))
3139 infoPtr
->bDoChangeNotify
= bOldChange
;
3146 * Sets a single group selection.
3149 * [I] infoPtr : valid pointer to the listview structure
3150 * [I] nItem : item index
3155 static void LISTVIEW_SetGroupSelection(LISTVIEW_INFO
*infoPtr
, INT nItem
)
3157 UINT uView
= infoPtr
->dwStyle
& LVS_TYPEMASK
;
3163 if (!(selection
= ranges_create(100))) return;
3165 item
.state
= LVIS_SELECTED
;
3166 item
.stateMask
= LVIS_SELECTED
;
3168 if ((uView
== LVS_LIST
) || (uView
== LVS_REPORT
))
3170 if (infoPtr
->nSelectionMark
== -1)
3172 infoPtr
->nSelectionMark
= nItem
;
3173 ranges_additem(selection
, nItem
);
3179 sel
.lower
= min(infoPtr
->nSelectionMark
, nItem
);
3180 sel
.upper
= max(infoPtr
->nSelectionMark
, nItem
) + 1;
3181 ranges_add(selection
, sel
);
3186 RECT rcItem
, rcSel
, rcSelMark
;
3189 rcItem
.left
= LVIR_BOUNDS
;
3190 if (!LISTVIEW_GetItemRect(infoPtr
, nItem
, &rcItem
)) return;
3191 rcSelMark
.left
= LVIR_BOUNDS
;
3192 if (!LISTVIEW_GetItemRect(infoPtr
, infoPtr
->nSelectionMark
, &rcSelMark
)) return;
3193 UnionRect(&rcSel
, &rcItem
, &rcSelMark
);
3194 iterator_frameditems(&i
, infoPtr
, &rcSel
);
3195 while(iterator_next(&i
))
3197 LISTVIEW_GetItemPosition(infoPtr
, i
.nItem
, &ptItem
);
3198 if (PtInRect(&rcSel
, ptItem
)) ranges_additem(selection
, i
.nItem
);
3200 iterator_destroy(&i
);
3203 /* disable per item notifications on LVS_OWNERDATA style
3204 FIXME: single LVN_ODSTATECHANGED should be used */
3205 bOldChange
= infoPtr
->bDoChangeNotify
;
3206 if (infoPtr
->dwStyle
& LVS_OWNERDATA
) infoPtr
->bDoChangeNotify
= FALSE
;
3208 LISTVIEW_DeselectAllSkipItems(infoPtr
, selection
);
3211 iterator_rangesitems(&i
, selection
);
3212 while(iterator_next(&i
))
3213 LISTVIEW_SetItemState(infoPtr
, i
.nItem
, &item
);
3214 /* this will also destroy the selection */
3215 iterator_destroy(&i
);
3217 infoPtr
->bDoChangeNotify
= bOldChange
;
3219 LISTVIEW_SetItemFocus(infoPtr
, nItem
);
3224 * Sets a single selection.
3227 * [I] infoPtr : valid pointer to the listview structure
3228 * [I] nItem : item index
3233 static void LISTVIEW_SetSelection(LISTVIEW_INFO
*infoPtr
, INT nItem
)
3237 TRACE("nItem=%d\n", nItem
);
3239 LISTVIEW_DeselectAllSkipItem(infoPtr
, nItem
);
3241 lvItem
.state
= LVIS_FOCUSED
| LVIS_SELECTED
;
3242 lvItem
.stateMask
= LVIS_FOCUSED
| LVIS_SELECTED
;
3243 LISTVIEW_SetItemState(infoPtr
, nItem
, &lvItem
);
3245 infoPtr
->nSelectionMark
= nItem
;
3250 * Set selection(s) with keyboard.
3253 * [I] infoPtr : valid pointer to the listview structure
3254 * [I] nItem : item index
3255 * [I] space : VK_SPACE code sent
3258 * SUCCESS : TRUE (needs to be repainted)
3259 * FAILURE : FALSE (nothing has changed)
3261 static BOOL
LISTVIEW_KeySelection(LISTVIEW_INFO
*infoPtr
, INT nItem
, BOOL space
)
3263 /* FIXME: pass in the state */
3264 WORD wShift
= HIWORD(GetKeyState(VK_SHIFT
));
3265 WORD wCtrl
= HIWORD(GetKeyState(VK_CONTROL
));
3266 BOOL bResult
= FALSE
;
3268 TRACE("nItem=%d, wShift=%d, wCtrl=%d\n", nItem
, wShift
, wCtrl
);
3269 if ((nItem
>= 0) && (nItem
< infoPtr
->nItemCount
))
3271 if (infoPtr
->dwStyle
& LVS_SINGLESEL
)
3274 LISTVIEW_SetSelection(infoPtr
, nItem
);
3281 LISTVIEW_SetGroupSelection(infoPtr
, nItem
);
3286 lvItem
.state
= ~LISTVIEW_GetItemState(infoPtr
, nItem
, LVIS_SELECTED
);
3287 lvItem
.stateMask
= LVIS_SELECTED
;
3290 LISTVIEW_SetItemState(infoPtr
, nItem
, &lvItem
);
3291 if (lvItem
.state
& LVIS_SELECTED
)
3292 infoPtr
->nSelectionMark
= nItem
;
3294 bResult
= LISTVIEW_SetItemFocus(infoPtr
, nItem
);
3299 LISTVIEW_SetSelection(infoPtr
, nItem
);
3302 LISTVIEW_EnsureVisible(infoPtr
, nItem
, FALSE
);
3305 UpdateWindow(infoPtr
->hwndSelf
); /* update client area */
3309 static BOOL
LISTVIEW_GetItemAtPt(const LISTVIEW_INFO
*infoPtr
, LPLVITEMW lpLVItem
, POINT pt
)
3311 LVHITTESTINFO lvHitTestInfo
;
3313 ZeroMemory(&lvHitTestInfo
, sizeof(lvHitTestInfo
));
3314 lvHitTestInfo
.pt
.x
= pt
.x
;
3315 lvHitTestInfo
.pt
.y
= pt
.y
;
3317 LISTVIEW_HitTest(infoPtr
, &lvHitTestInfo
, TRUE
, FALSE
);
3319 lpLVItem
->mask
= LVIF_PARAM
;
3320 lpLVItem
->iItem
= lvHitTestInfo
.iItem
;
3321 lpLVItem
->iSubItem
= 0;
3323 return LISTVIEW_GetItemT(infoPtr
, lpLVItem
, TRUE
);
3326 static inline BOOL
LISTVIEW_isHotTracking(const LISTVIEW_INFO
*infoPtr
)
3328 return ((infoPtr
->dwLvExStyle
& LVS_EX_TRACKSELECT
) ||
3329 (infoPtr
->dwLvExStyle
& LVS_EX_ONECLICKACTIVATE
) ||
3330 (infoPtr
->dwLvExStyle
& LVS_EX_TWOCLICKACTIVATE
));
3335 * Called when the mouse is being actively tracked and has hovered for a specified
3339 * [I] infoPtr : valid pointer to the listview structure
3340 * [I] fwKeys : key indicator
3341 * [I] x,y : mouse position
3344 * 0 if the message was processed, non-zero if there was an error
3347 * LVS_EX_TRACKSELECT: An item is automatically selected when the cursor remains
3348 * over the item for a certain period of time.
3351 static LRESULT
LISTVIEW_MouseHover(LISTVIEW_INFO
*infoPtr
, WORD fwKeys
, INT x
, INT y
)
3353 if (LISTVIEW_isHotTracking(infoPtr
))
3361 if (LISTVIEW_GetItemAtPt(infoPtr
, &item
, pt
))
3362 LISTVIEW_SetSelection(infoPtr
, item
.iItem
);
3370 * Called whenever WM_MOUSEMOVE is received.
3373 * [I] infoPtr : valid pointer to the listview structure
3374 * [I] fwKeys : key indicator
3375 * [I] x,y : mouse position
3378 * 0 if the message is processed, non-zero if there was an error
3380 static LRESULT
LISTVIEW_MouseMove(LISTVIEW_INFO
*infoPtr
, WORD fwKeys
, INT x
, INT y
)
3382 TRACKMOUSEEVENT trackinfo
;
3384 if (!(fwKeys
& MK_LBUTTON
))
3385 infoPtr
->bLButtonDown
= FALSE
;
3387 if (infoPtr
->bLButtonDown
)
3391 WORD wDragWidth
= GetSystemMetrics(SM_CXDRAG
);
3392 WORD wDragHeight
= GetSystemMetrics(SM_CYDRAG
);
3394 rect
.left
= infoPtr
->ptClickPos
.x
- wDragWidth
;
3395 rect
.right
= infoPtr
->ptClickPos
.x
+ wDragWidth
;
3396 rect
.top
= infoPtr
->ptClickPos
.y
- wDragHeight
;
3397 rect
.bottom
= infoPtr
->ptClickPos
.y
+ wDragHeight
;
3402 if (!PtInRect(&rect
, tmp
))
3404 LVHITTESTINFO lvHitTestInfo
;
3407 lvHitTestInfo
.pt
= infoPtr
->ptClickPos
;
3408 LISTVIEW_HitTest(infoPtr
, &lvHitTestInfo
, TRUE
, TRUE
);
3410 ZeroMemory(&nmlv
, sizeof(nmlv
));
3411 nmlv
.iItem
= lvHitTestInfo
.iItem
;
3412 nmlv
.ptAction
= infoPtr
->ptClickPos
;
3414 if (!infoPtr
->bDragging
)
3416 notify_listview(infoPtr
, LVN_BEGINDRAG
, &nmlv
);
3417 infoPtr
->bDragging
= TRUE
;
3424 infoPtr
->bLButtonDown
= FALSE
;
3426 /* see if we are supposed to be tracking mouse hovering */
3427 if (LISTVIEW_isHotTracking(infoPtr
)) {
3428 /* fill in the trackinfo struct */
3429 trackinfo
.cbSize
= sizeof(TRACKMOUSEEVENT
);
3430 trackinfo
.dwFlags
= TME_QUERY
;
3431 trackinfo
.hwndTrack
= infoPtr
->hwndSelf
;
3432 trackinfo
.dwHoverTime
= infoPtr
->dwHoverTime
;
3434 /* see if we are already tracking this hwnd */
3435 _TrackMouseEvent(&trackinfo
);
3437 if(!(trackinfo
.dwFlags
& TME_HOVER
)) {
3438 trackinfo
.dwFlags
= TME_HOVER
;
3440 /* call TRACKMOUSEEVENT so we receive WM_MOUSEHOVER messages */
3441 _TrackMouseEvent(&trackinfo
);
3450 * Tests whether the item is assignable to a list with style lStyle
3452 static inline BOOL
is_assignable_item(const LVITEMW
*lpLVItem
, LONG lStyle
)
3454 if ( (lpLVItem
->mask
& LVIF_TEXT
) &&
3455 (lpLVItem
->pszText
== LPSTR_TEXTCALLBACKW
) &&
3456 (lStyle
& (LVS_SORTASCENDING
| LVS_SORTDESCENDING
)) ) return FALSE
;
3464 * Helper for LISTVIEW_SetItemT *only*: sets item attributes.
3467 * [I] infoPtr : valid pointer to the listview structure
3468 * [I] lpLVItem : valid pointer to new item attributes
3469 * [I] isNew : the item being set is being inserted
3470 * [I] isW : TRUE if lpLVItem is Unicode, FALSE if it's ANSI
3471 * [O] bChanged : will be set to TRUE if the item really changed
3477 static BOOL
set_main_item(LISTVIEW_INFO
*infoPtr
, const LVITEMW
*lpLVItem
, BOOL isNew
, BOOL isW
, BOOL
*bChanged
)
3479 UINT uView
= infoPtr
->dwStyle
& LVS_TYPEMASK
;
3484 /* stateMask is ignored for LVM_INSERTITEM */
3485 UINT stateMask
= isNew
? ~0 : lpLVItem
->stateMask
;
3489 assert(lpLVItem
->iItem
>= 0 && lpLVItem
->iItem
< infoPtr
->nItemCount
);
3491 if (lpLVItem
->mask
== 0) return TRUE
;
3493 if (infoPtr
->dwStyle
& LVS_OWNERDATA
)
3495 /* a virtual listview only stores selection and focus */
3496 if (lpLVItem
->mask
& ~LVIF_STATE
)
3502 HDPA hdpaSubItems
= DPA_GetPtr(infoPtr
->hdpaItems
, lpLVItem
->iItem
);
3503 lpItem
= DPA_GetPtr(hdpaSubItems
, 0);
3507 /* we need to get the lParam and state of the item */
3508 item
.iItem
= lpLVItem
->iItem
;
3509 item
.iSubItem
= lpLVItem
->iSubItem
;
3510 item
.mask
= LVIF_STATE
| LVIF_PARAM
;
3511 item
.stateMask
= ~0;
3514 if (!isNew
&& !LISTVIEW_GetItemW(infoPtr
, &item
)) return FALSE
;
3516 TRACE("oldState=%x, newState=%x\n", item
.state
, lpLVItem
->state
);
3517 /* determine what fields will change */
3518 if ((lpLVItem
->mask
& LVIF_STATE
) && ((item
.state
^ lpLVItem
->state
) & stateMask
& ~infoPtr
->uCallbackMask
))
3519 uChanged
|= LVIF_STATE
;
3521 if ((lpLVItem
->mask
& LVIF_IMAGE
) && (lpItem
->hdr
.iImage
!= lpLVItem
->iImage
))
3522 uChanged
|= LVIF_IMAGE
;
3524 if ((lpLVItem
->mask
& LVIF_PARAM
) && (lpItem
->lParam
!= lpLVItem
->lParam
))
3525 uChanged
|= LVIF_PARAM
;
3527 if ((lpLVItem
->mask
& LVIF_INDENT
) && (lpItem
->iIndent
!= lpLVItem
->iIndent
))
3528 uChanged
|= LVIF_INDENT
;
3530 if ((lpLVItem
->mask
& LVIF_TEXT
) && textcmpWT(lpItem
->hdr
.pszText
, lpLVItem
->pszText
, isW
))
3531 uChanged
|= LVIF_TEXT
;
3533 TRACE("uChanged=0x%x\n", uChanged
);
3534 if (!uChanged
) return TRUE
;
3537 ZeroMemory(&nmlv
, sizeof(NMLISTVIEW
));
3538 nmlv
.iItem
= lpLVItem
->iItem
;
3539 nmlv
.uNewState
= (item
.state
& ~stateMask
) | (lpLVItem
->state
& stateMask
);
3540 nmlv
.uOldState
= item
.state
;
3541 nmlv
.uChanged
= uChanged
;
3542 nmlv
.lParam
= item
.lParam
;
3544 /* send LVN_ITEMCHANGING notification, if the item is not being inserted */
3545 /* and we are _NOT_ virtual (LVS_OWNERDATA), and change notifications */
3547 if(lpItem
&& !isNew
&& infoPtr
->bDoChangeNotify
)
3549 HWND hwndSelf
= infoPtr
->hwndSelf
;
3551 if (notify_listview(infoPtr
, LVN_ITEMCHANGING
, &nmlv
))
3553 if (!IsWindow(hwndSelf
))
3557 /* copy information */
3558 if (lpLVItem
->mask
& LVIF_TEXT
)
3559 textsetptrT(&lpItem
->hdr
.pszText
, lpLVItem
->pszText
, isW
);
3561 if (lpLVItem
->mask
& LVIF_IMAGE
)
3562 lpItem
->hdr
.iImage
= lpLVItem
->iImage
;
3564 if (lpLVItem
->mask
& LVIF_PARAM
)
3565 lpItem
->lParam
= lpLVItem
->lParam
;
3567 if (lpLVItem
->mask
& LVIF_INDENT
)
3568 lpItem
->iIndent
= lpLVItem
->iIndent
;
3570 if (uChanged
& LVIF_STATE
)
3572 if (lpItem
&& (stateMask
& ~infoPtr
->uCallbackMask
))
3574 lpItem
->state
&= ~stateMask
;
3575 lpItem
->state
|= (lpLVItem
->state
& stateMask
);
3577 if (lpLVItem
->state
& stateMask
& ~infoPtr
->uCallbackMask
& LVIS_SELECTED
)
3579 if (infoPtr
->dwStyle
& LVS_SINGLESEL
) LISTVIEW_DeselectAllSkipItem(infoPtr
, lpLVItem
->iItem
);
3580 ranges_additem(infoPtr
->selectionRanges
, lpLVItem
->iItem
);
3582 else if (stateMask
& LVIS_SELECTED
)
3584 ranges_delitem(infoPtr
->selectionRanges
, lpLVItem
->iItem
);
3586 /* if we are asked to change focus, and we manage it, do it */
3587 if (stateMask
& ~infoPtr
->uCallbackMask
& LVIS_FOCUSED
)
3589 if (lpLVItem
->state
& LVIS_FOCUSED
)
3591 if (infoPtr
->nFocusedItem
!= -1)
3593 /* remove current focus */
3594 item
.mask
= LVIF_STATE
;
3596 item
.stateMask
= LVIS_FOCUSED
;
3598 /* recurse with redrawing an item */
3599 LISTVIEW_SetItemState(infoPtr
, infoPtr
->nFocusedItem
, &item
);
3602 infoPtr
->nFocusedItem
= lpLVItem
->iItem
;
3603 LISTVIEW_EnsureVisible(infoPtr
, lpLVItem
->iItem
, uView
== LVS_LIST
);
3605 else if (infoPtr
->nFocusedItem
== lpLVItem
->iItem
)
3607 infoPtr
->nFocusedItem
= -1;
3612 /* if we're inserting the item, we're done */
3613 if (isNew
) return TRUE
;
3615 /* send LVN_ITEMCHANGED notification */
3616 if (lpLVItem
->mask
& LVIF_PARAM
) nmlv
.lParam
= lpLVItem
->lParam
;
3617 if (infoPtr
->bDoChangeNotify
) notify_listview(infoPtr
, LVN_ITEMCHANGED
, &nmlv
);
3624 * Helper for LISTVIEW_{Set,Insert}ItemT *only*: sets subitem attributes.
3627 * [I] infoPtr : valid pointer to the listview structure
3628 * [I] lpLVItem : valid pointer to new subitem attributes
3629 * [I] isW : TRUE if lpLVItem is Unicode, FALSE if it's ANSI
3630 * [O] bChanged : will be set to TRUE if the item really changed
3636 static BOOL
set_sub_item(const LISTVIEW_INFO
*infoPtr
, const LVITEMW
*lpLVItem
, BOOL isW
, BOOL
*bChanged
)
3639 SUBITEM_INFO
*lpSubItem
;
3641 /* we do not support subitems for virtual listviews */
3642 if (infoPtr
->dwStyle
& LVS_OWNERDATA
) return FALSE
;
3644 /* set subitem only if column is present */
3645 if (lpLVItem
->iSubItem
>= DPA_GetPtrCount(infoPtr
->hdpaColumns
)) return FALSE
;
3647 /* First do some sanity checks */
3648 /* The LVIF_STATE flag is valid for subitems, but does not appear to be
3649 particularly useful. We currently do not actually do anything with
3650 the flag on subitems.
3652 if (lpLVItem
->mask
& ~(LVIF_TEXT
| LVIF_IMAGE
| LVIF_STATE
)) return FALSE
;
3653 if (!(lpLVItem
->mask
& (LVIF_TEXT
| LVIF_IMAGE
| LVIF_STATE
))) return TRUE
;
3655 /* get the subitem structure, and create it if not there */
3656 hdpaSubItems
= DPA_GetPtr(infoPtr
->hdpaItems
, lpLVItem
->iItem
);
3657 assert (hdpaSubItems
);
3659 lpSubItem
= LISTVIEW_GetSubItemPtr(hdpaSubItems
, lpLVItem
->iSubItem
);
3662 SUBITEM_INFO
*tmpSubItem
;
3665 lpSubItem
= Alloc(sizeof(SUBITEM_INFO
));
3666 if (!lpSubItem
) return FALSE
;
3667 /* we could binary search here, if need be...*/
3668 for (i
= 1; i
< DPA_GetPtrCount(hdpaSubItems
); i
++)
3670 tmpSubItem
= DPA_GetPtr(hdpaSubItems
, i
);
3671 if (tmpSubItem
->iSubItem
> lpLVItem
->iSubItem
) break;
3673 if (DPA_InsertPtr(hdpaSubItems
, i
, lpSubItem
) == -1)
3678 lpSubItem
->iSubItem
= lpLVItem
->iSubItem
;
3679 lpSubItem
->hdr
.iImage
= I_IMAGECALLBACK
;
3683 if (lpLVItem
->mask
& LVIF_IMAGE
)
3684 if (lpSubItem
->hdr
.iImage
!= lpLVItem
->iImage
)
3686 lpSubItem
->hdr
.iImage
= lpLVItem
->iImage
;
3690 if (lpLVItem
->mask
& LVIF_TEXT
)
3691 if (lpSubItem
->hdr
.pszText
!= lpLVItem
->pszText
)
3693 textsetptrT(&lpSubItem
->hdr
.pszText
, lpLVItem
->pszText
, isW
);
3702 * Sets item attributes.
3705 * [I] infoPtr : valid pointer to the listview structure
3706 * [I] lpLVItem : new item attributes
3707 * [I] isW : TRUE if lpLVItem is Unicode, FALSE if it's ANSI
3713 static BOOL
LISTVIEW_SetItemT(LISTVIEW_INFO
*infoPtr
, LVITEMW
*lpLVItem
, BOOL isW
)
3715 UINT uView
= infoPtr
->dwStyle
& LVS_TYPEMASK
;
3716 HWND hwndSelf
= infoPtr
->hwndSelf
;
3717 LPWSTR pszText
= NULL
;
3718 BOOL bResult
, bChanged
= FALSE
;
3720 TRACE("(lpLVItem=%s, isW=%d)\n", debuglvitem_t(lpLVItem
, isW
), isW
);
3722 if (!lpLVItem
|| lpLVItem
->iItem
< 0 || lpLVItem
->iItem
>= infoPtr
->nItemCount
)
3725 /* For efficiency, we transform the lpLVItem->pszText to Unicode here */
3726 if ((lpLVItem
->mask
& LVIF_TEXT
) && is_textW(lpLVItem
->pszText
))
3728 pszText
= lpLVItem
->pszText
;
3729 lpLVItem
->pszText
= textdupTtoW(lpLVItem
->pszText
, isW
);
3732 /* actually set the fields */
3733 if (!is_assignable_item(lpLVItem
, infoPtr
->dwStyle
)) return FALSE
;
3735 if (lpLVItem
->iSubItem
)
3736 bResult
= set_sub_item(infoPtr
, lpLVItem
, TRUE
, &bChanged
);
3738 bResult
= set_main_item(infoPtr
, lpLVItem
, FALSE
, TRUE
, &bChanged
);
3739 if (!IsWindow(hwndSelf
))
3742 /* redraw item, if necessary */
3743 if (bChanged
&& !infoPtr
->bIsDrawing
)
3745 /* this little optimization eliminates some nasty flicker */
3746 if ( uView
== LVS_REPORT
&& !(infoPtr
->dwStyle
& LVS_OWNERDRAWFIXED
) &&
3747 !(infoPtr
->dwLvExStyle
& LVS_EX_FULLROWSELECT
) &&
3748 lpLVItem
->iSubItem
> 0 && lpLVItem
->iSubItem
<= DPA_GetPtrCount(infoPtr
->hdpaColumns
) )
3749 LISTVIEW_InvalidateSubItem(infoPtr
, lpLVItem
->iItem
, lpLVItem
->iSubItem
);
3751 LISTVIEW_InvalidateItem(infoPtr
, lpLVItem
->iItem
);
3756 textfreeT(lpLVItem
->pszText
, isW
);
3757 lpLVItem
->pszText
= pszText
;
3765 * Retrieves the index of the item at coordinate (0, 0) of the client area.
3768 * [I] infoPtr : valid pointer to the listview structure
3773 static INT
LISTVIEW_GetTopIndex(const LISTVIEW_INFO
*infoPtr
)
3775 UINT uView
= infoPtr
->dwStyle
& LVS_TYPEMASK
;
3777 SCROLLINFO scrollInfo
;
3779 scrollInfo
.cbSize
= sizeof(SCROLLINFO
);
3780 scrollInfo
.fMask
= SIF_POS
;
3782 if (uView
== LVS_LIST
)
3784 if (GetScrollInfo(infoPtr
->hwndSelf
, SB_HORZ
, &scrollInfo
))
3785 nItem
= scrollInfo
.nPos
* LISTVIEW_GetCountPerColumn(infoPtr
);
3787 else if (uView
== LVS_REPORT
)
3789 if (GetScrollInfo(infoPtr
->hwndSelf
, SB_VERT
, &scrollInfo
))
3790 nItem
= scrollInfo
.nPos
;
3794 if (GetScrollInfo(infoPtr
->hwndSelf
, SB_VERT
, &scrollInfo
))
3795 nItem
= LISTVIEW_GetCountPerRow(infoPtr
) * (scrollInfo
.nPos
/ infoPtr
->nItemHeight
);
3798 TRACE("nItem=%d\n", nItem
);
3806 * Erases the background of the given rectangle
3809 * [I] infoPtr : valid pointer to the listview structure
3810 * [I] hdc : device context handle
3811 * [I] lprcBox : clipping rectangle
3817 static inline BOOL
LISTVIEW_FillBkgnd(const LISTVIEW_INFO
*infoPtr
, HDC hdc
, const RECT
*lprcBox
)
3819 if (!infoPtr
->hBkBrush
) return FALSE
;
3821 TRACE("(hdc=%p, lprcBox=%s, hBkBrush=%p)\n", hdc
, wine_dbgstr_rect(lprcBox
), infoPtr
->hBkBrush
);
3823 return FillRect(hdc
, lprcBox
, infoPtr
->hBkBrush
);
3831 * [I] infoPtr : valid pointer to the listview structure
3832 * [I] hdc : device context handle
3833 * [I] nItem : item index
3834 * [I] nSubItem : subitem index
3835 * [I] pos : item position in client coordinates
3836 * [I] cdmode : custom draw mode
3842 static BOOL
LISTVIEW_DrawItem(LISTVIEW_INFO
*infoPtr
, HDC hdc
, INT nItem
, INT nSubItem
, POINT pos
, DWORD cdmode
)
3844 UINT uFormat
, uView
= infoPtr
->dwStyle
& LVS_TYPEMASK
;
3845 WCHAR szDispText
[DISP_TEXT_SIZE
] = { '\0' };
3846 static WCHAR szCallback
[] = { '(', 'c', 'a', 'l', 'l', 'b', 'a', 'c', 'k', ')', 0 };
3847 DWORD cdsubitemmode
= CDRF_DODEFAULT
;
3849 RECT rcSelect
, rcBox
, rcIcon
, rcLabel
, rcStateIcon
;
3850 NMLVCUSTOMDRAW nmlvcd
;
3855 TRACE("(hdc=%p, nItem=%d, nSubItem=%d, pos=%s)\n", hdc
, nItem
, nSubItem
, wine_dbgstr_point(&pos
));
3857 /* get information needed for drawing the item */
3858 lvItem
.mask
= LVIF_TEXT
| LVIF_IMAGE
| LVIF_PARAM
;
3859 if (nSubItem
== 0) lvItem
.mask
|= LVIF_STATE
;
3860 if (uView
== LVS_REPORT
) lvItem
.mask
|= LVIF_INDENT
;
3861 lvItem
.stateMask
= LVIS_SELECTED
| LVIS_FOCUSED
| LVIS_STATEIMAGEMASK
;
3862 lvItem
.iItem
= nItem
;
3863 lvItem
.iSubItem
= nSubItem
;
3866 lvItem
.cchTextMax
= DISP_TEXT_SIZE
;
3867 lvItem
.pszText
= szDispText
;
3868 if (!LISTVIEW_GetItemW(infoPtr
, &lvItem
)) return FALSE
;
3869 if (nSubItem
> 0 && (infoPtr
->dwLvExStyle
& LVS_EX_FULLROWSELECT
))
3870 lvItem
.state
= LISTVIEW_GetItemState(infoPtr
, nItem
, LVIS_SELECTED
);
3871 if (lvItem
.pszText
== LPSTR_TEXTCALLBACKW
) lvItem
.pszText
= szCallback
;
3872 TRACE(" lvItem=%s\n", debuglvitem_t(&lvItem
, TRUE
));
3874 /* now check if we need to update the focus rectangle */
3875 lprcFocus
= infoPtr
->bFocus
&& (lvItem
.state
& LVIS_FOCUSED
) ? &infoPtr
->rcFocus
: 0;
3877 if (!lprcFocus
) lvItem
.state
&= ~LVIS_FOCUSED
;
3878 LISTVIEW_GetItemMetrics(infoPtr
, &lvItem
, &rcBox
, &rcSelect
, &rcIcon
, &rcStateIcon
, &rcLabel
);
3879 OffsetRect(&rcBox
, pos
.x
, pos
.y
);
3880 OffsetRect(&rcSelect
, pos
.x
, pos
.y
);
3881 OffsetRect(&rcIcon
, pos
.x
, pos
.y
);
3882 OffsetRect(&rcStateIcon
, pos
.x
, pos
.y
);
3883 OffsetRect(&rcLabel
, pos
.x
, pos
.y
);
3884 TRACE(" rcBox=%s, rcSelect=%s, rcIcon=%s. rcLabel=%s\n",
3885 wine_dbgstr_rect(&rcBox
), wine_dbgstr_rect(&rcSelect
),
3886 wine_dbgstr_rect(&rcIcon
), wine_dbgstr_rect(&rcLabel
));
3888 /* fill in the custom draw structure */
3889 customdraw_fill(&nmlvcd
, infoPtr
, hdc
, &rcBox
, &lvItem
);
3891 hOldFont
= GetCurrentObject(hdc
, OBJ_FONT
);
3892 if (nSubItem
> 0) cdmode
= infoPtr
->cditemmode
;
3893 if (cdmode
& CDRF_SKIPDEFAULT
) goto postpaint
;
3894 if (cdmode
& CDRF_NOTIFYITEMDRAW
)
3895 cdsubitemmode
= notify_customdraw(infoPtr
, CDDS_PREPAINT
, &nmlvcd
);
3896 if (nSubItem
== 0) infoPtr
->cditemmode
= cdsubitemmode
;
3897 if (cdsubitemmode
& CDRF_SKIPDEFAULT
) goto postpaint
;
3898 /* we have to send a CDDS_SUBITEM customdraw explicitly for subitem 0 */
3899 if (nSubItem
== 0 && cdsubitemmode
== CDRF_NOTIFYITEMDRAW
)
3901 cdsubitemmode
= notify_customdraw(infoPtr
, CDDS_SUBITEM
| CDDS_ITEMPREPAINT
, &nmlvcd
);
3902 if (cdsubitemmode
& CDRF_SKIPDEFAULT
) goto postpaint
;
3904 if (nSubItem
== 0 || (cdmode
& CDRF_NOTIFYITEMDRAW
))
3905 prepaint_setup(infoPtr
, hdc
, &nmlvcd
, FALSE
);
3906 else if ((infoPtr
->dwLvExStyle
& LVS_EX_FULLROWSELECT
) == FALSE
)
3907 prepaint_setup(infoPtr
, hdc
, &nmlvcd
, TRUE
);
3909 /* in full row select, subitems, will just use main item's colors */
3910 if (nSubItem
&& uView
== LVS_REPORT
&& (infoPtr
->dwLvExStyle
& LVS_EX_FULLROWSELECT
))
3911 nmlvcd
.clrTextBk
= CLR_NONE
;
3914 if (infoPtr
->himlState
&& STATEIMAGEINDEX(lvItem
.state
) && (nSubItem
== 0))
3916 UINT uStateImage
= STATEIMAGEINDEX(lvItem
.state
);
3919 TRACE("uStateImage=%d\n", uStateImage
);
3920 ImageList_Draw(infoPtr
->himlState
, uStateImage
- 1, hdc
,
3921 rcStateIcon
.left
, rcStateIcon
.top
, ILD_NORMAL
);
3926 himl
= (uView
== LVS_ICON
? infoPtr
->himlNormal
: infoPtr
->himlSmall
);
3927 if (himl
&& lvItem
.iImage
>= 0 && !IsRectEmpty(&rcIcon
))
3929 TRACE("iImage=%d\n", lvItem
.iImage
);
3930 ImageList_DrawEx(himl
, lvItem
.iImage
, hdc
, rcIcon
.left
, rcIcon
.top
,
3931 rcIcon
.right
- rcIcon
.left
, rcIcon
.bottom
- rcIcon
.top
, infoPtr
->clrBk
, CLR_DEFAULT
,
3932 (lvItem
.state
& LVIS_SELECTED
) && (infoPtr
->bFocus
) ? ILD_SELECTED
: ILD_NORMAL
);
3935 /* Don't bother painting item being edited */
3936 if (infoPtr
->hwndEdit
&& nItem
== infoPtr
->nEditLabelItem
&& nSubItem
== 0) goto postpaint
;
3938 /* FIXME: temporary hack */
3939 rcSelect
.left
= rcLabel
.left
;
3941 /* draw the selection background, if we're drawing the main item */
3944 /* in icon mode, the label rect is really what we want to draw the
3946 if (uView
== LVS_ICON
)
3949 if (uView
== LVS_REPORT
&& (infoPtr
->dwLvExStyle
& LVS_EX_FULLROWSELECT
))
3950 rcSelect
.right
= rcBox
.right
;
3952 if (nmlvcd
.clrTextBk
!= CLR_NONE
)
3953 ExtTextOutW(hdc
, rcSelect
.left
, rcSelect
.top
, ETO_OPAQUE
, &rcSelect
, 0, 0, 0);
3954 if(lprcFocus
) *lprcFocus
= rcSelect
;
3957 /* figure out the text drawing flags */
3958 uFormat
= (uView
== LVS_ICON
? (lprcFocus
? LV_FL_DT_FLAGS
: LV_ML_DT_FLAGS
) : LV_SL_DT_FLAGS
);
3959 if (uView
== LVS_ICON
)
3960 uFormat
= (lprcFocus
? LV_FL_DT_FLAGS
: LV_ML_DT_FLAGS
);
3963 switch (LISTVIEW_GetColumnInfo(infoPtr
, nSubItem
)->fmt
& LVCFMT_JUSTIFYMASK
)
3965 case LVCFMT_RIGHT
: uFormat
|= DT_RIGHT
; break;
3966 case LVCFMT_CENTER
: uFormat
|= DT_CENTER
; break;
3967 default: uFormat
|= DT_LEFT
;
3970 if (!(uFormat
& (DT_RIGHT
| DT_CENTER
)))
3972 if (himl
&& lvItem
.iImage
>= 0 && !IsRectEmpty(&rcIcon
)) rcLabel
.left
+= IMAGE_PADDING
;
3973 else rcLabel
.left
+= LABEL_HOR_PADDING
;
3975 else if (uFormat
& DT_RIGHT
) rcLabel
.right
-= LABEL_HOR_PADDING
;
3977 /* for GRIDLINES reduce the bottom so the text formats correctly */
3978 if (uView
== LVS_REPORT
&& infoPtr
->dwLvExStyle
& LVS_EX_GRIDLINES
)
3981 DrawTextW(hdc
, lvItem
.pszText
, -1, &rcLabel
, uFormat
);
3984 if (cdsubitemmode
& CDRF_NOTIFYPOSTPAINT
)
3985 notify_postpaint(infoPtr
, &nmlvcd
);
3986 if (cdsubitemmode
& CDRF_NEWFONT
)
3987 SelectObject(hdc
, hOldFont
);
3993 * Draws listview items when in owner draw mode.
3996 * [I] infoPtr : valid pointer to the listview structure
3997 * [I] hdc : device context handle
4002 static void LISTVIEW_RefreshOwnerDraw(const LISTVIEW_INFO
*infoPtr
, ITERATOR
*i
, HDC hdc
, DWORD cdmode
)
4004 UINT uID
= (UINT
)GetWindowLongPtrW(infoPtr
->hwndSelf
, GWLP_ID
);
4005 DWORD cditemmode
= CDRF_DODEFAULT
;
4006 NMLVCUSTOMDRAW nmlvcd
;
4007 POINT Origin
, Position
;
4013 ZeroMemory(&dis
, sizeof(dis
));
4015 /* Get scroll info once before loop */
4016 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
4018 /* iterate through the invalidated rows */
4019 while(iterator_next(i
))
4021 item
.iItem
= i
->nItem
;
4023 item
.mask
= LVIF_PARAM
| LVIF_STATE
;
4024 item
.stateMask
= LVIS_SELECTED
| LVIS_FOCUSED
;
4025 if (!LISTVIEW_GetItemW(infoPtr
, &item
)) continue;
4027 dis
.CtlType
= ODT_LISTVIEW
;
4029 dis
.itemID
= item
.iItem
;
4030 dis
.itemAction
= ODA_DRAWENTIRE
;
4032 if (item
.state
& LVIS_SELECTED
) dis
.itemState
|= ODS_SELECTED
;
4033 if (infoPtr
->bFocus
&& (item
.state
& LVIS_FOCUSED
)) dis
.itemState
|= ODS_FOCUS
;
4034 dis
.hwndItem
= infoPtr
->hwndSelf
;
4036 LISTVIEW_GetItemOrigin(infoPtr
, dis
.itemID
, &Position
);
4037 dis
.rcItem
.left
= Position
.x
+ Origin
.x
;
4038 dis
.rcItem
.right
= dis
.rcItem
.left
+ infoPtr
->nItemWidth
;
4039 dis
.rcItem
.top
= Position
.y
+ Origin
.y
;
4040 dis
.rcItem
.bottom
= dis
.rcItem
.top
+ infoPtr
->nItemHeight
;
4041 dis
.itemData
= item
.lParam
;
4043 TRACE("item=%s, rcItem=%s\n", debuglvitem_t(&item
, TRUE
), wine_dbgstr_rect(&dis
.rcItem
));
4046 * Even if we do not send the CDRF_NOTIFYITEMDRAW we need to fill the nmlvcd
4047 * structure for the rest. of the paint cycle
4049 customdraw_fill(&nmlvcd
, infoPtr
, hdc
, &dis
.rcItem
, &item
);
4050 if (cdmode
& CDRF_NOTIFYITEMDRAW
)
4051 cditemmode
= notify_customdraw(infoPtr
, CDDS_PREPAINT
, &nmlvcd
);
4053 if (!(cditemmode
& CDRF_SKIPDEFAULT
))
4055 prepaint_setup (infoPtr
, hdc
, &nmlvcd
, FALSE
);
4056 SendMessageW(infoPtr
->hwndNotify
, WM_DRAWITEM
, dis
.CtlID
, (LPARAM
)&dis
);
4059 if (cditemmode
& CDRF_NOTIFYPOSTPAINT
)
4060 notify_postpaint(infoPtr
, &nmlvcd
);
4066 * Draws listview items when in report display mode.
4069 * [I] infoPtr : valid pointer to the listview structure
4070 * [I] hdc : device context handle
4071 * [I] cdmode : custom draw mode
4076 static void LISTVIEW_RefreshReport(LISTVIEW_INFO
*infoPtr
, ITERATOR
*i
, HDC hdc
, DWORD cdmode
)
4079 RECT rcClip
, rcItem
;
4080 POINT Origin
, Position
;
4086 /* figure out what to draw */
4087 rgntype
= GetClipBox(hdc
, &rcClip
);
4088 if (rgntype
== NULLREGION
) return;
4090 /* Get scroll info once before loop */
4091 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
4093 /* narrow down the columns we need to paint */
4094 for(colRange
.lower
= 0; colRange
.lower
< DPA_GetPtrCount(infoPtr
->hdpaColumns
); colRange
.lower
++)
4096 LISTVIEW_GetHeaderRect(infoPtr
, colRange
.lower
, &rcItem
);
4097 if (rcItem
.right
+ Origin
.x
>= rcClip
.left
) break;
4099 for(colRange
.upper
= DPA_GetPtrCount(infoPtr
->hdpaColumns
); colRange
.upper
> 0; colRange
.upper
--)
4101 LISTVIEW_GetHeaderRect(infoPtr
, colRange
.upper
- 1, &rcItem
);
4102 if (rcItem
.left
+ Origin
.x
< rcClip
.right
) break;
4104 iterator_rangeitems(&j
, colRange
);
4106 /* in full row select, we _have_ to draw the main item */
4107 if (infoPtr
->dwLvExStyle
& LVS_EX_FULLROWSELECT
)
4110 /* iterate through the invalidated rows */
4111 while(iterator_next(i
))
4113 /* iterate through the invalidated columns */
4114 while(iterator_next(&j
))
4116 LISTVIEW_GetItemOrigin(infoPtr
, i
->nItem
, &Position
);
4117 Position
.x
+= Origin
.x
;
4118 Position
.y
+= Origin
.y
;
4120 if (rgntype
== COMPLEXREGION
&& !((infoPtr
->dwLvExStyle
& LVS_EX_FULLROWSELECT
) && j
.nItem
== 0))
4122 LISTVIEW_GetHeaderRect(infoPtr
, j
.nItem
, &rcItem
);
4124 rcItem
.bottom
= infoPtr
->nItemHeight
;
4125 OffsetRect(&rcItem
, Position
.x
, Position
.y
);
4126 if (!RectVisible(hdc
, &rcItem
)) continue;
4129 LISTVIEW_DrawItem(infoPtr
, hdc
, i
->nItem
, j
.nItem
, Position
, cdmode
);
4132 iterator_destroy(&j
);
4137 * Draws the gridlines if necessary when in report display mode.
4140 * [I] infoPtr : valid pointer to the listview structure
4141 * [I] hdc : device context handle
4146 static void LISTVIEW_RefreshReportGrid(LISTVIEW_INFO
*infoPtr
, HDC hdc
)
4151 RECT rcClip
, rcItem
;
4158 /* figure out what to draw */
4159 rgntype
= GetClipBox(hdc
, &rcClip
);
4160 if (rgntype
== NULLREGION
) return;
4162 /* Get scroll info once before loop */
4163 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
4165 /* narrow down the columns we need to paint */
4166 for(colRange
.lower
= 0; colRange
.lower
< DPA_GetPtrCount(infoPtr
->hdpaColumns
); colRange
.lower
++)
4168 LISTVIEW_GetHeaderRect(infoPtr
, colRange
.lower
, &rcItem
);
4169 if (rcItem
.right
+ Origin
.x
>= rcClip
.left
) break;
4171 for(colRange
.upper
= DPA_GetPtrCount(infoPtr
->hdpaColumns
); colRange
.upper
> 0; colRange
.upper
--)
4173 LISTVIEW_GetHeaderRect(infoPtr
, colRange
.upper
- 1, &rcItem
);
4174 if (rcItem
.left
+ Origin
.x
< rcClip
.right
) break;
4176 iterator_rangeitems(&j
, colRange
);
4178 if ((hPen
= CreatePen( PS_SOLID
, 1, comctl32_color
.clr3dFace
)))
4180 hOldPen
= SelectObject ( hdc
, hPen
);
4182 /* draw the vertical lines for the columns */
4183 iterator_rangeitems(&j
, colRange
);
4184 while(iterator_next(&j
))
4186 LISTVIEW_GetHeaderRect(infoPtr
, j
.nItem
, &rcItem
);
4187 if (rcItem
.left
== 0) continue; /* skip first column */
4188 rcItem
.left
+= Origin
.x
;
4189 rcItem
.right
+= Origin
.x
;
4190 rcItem
.top
= infoPtr
->rcList
.top
;
4191 rcItem
.bottom
= infoPtr
->rcList
.bottom
;
4192 TRACE("vert col=%d, rcItem=%s\n", j
.nItem
, wine_dbgstr_rect(&rcItem
));
4193 MoveToEx (hdc
, rcItem
.left
, rcItem
.top
, NULL
);
4194 LineTo (hdc
, rcItem
.left
, rcItem
.bottom
);
4196 iterator_destroy(&j
);
4198 /* draw the horizontial lines for the rows */
4199 itemheight
= LISTVIEW_CalculateItemHeight(infoPtr
);
4200 rcItem
.left
= infoPtr
->rcList
.left
+ Origin
.x
;
4201 rcItem
.right
= infoPtr
->rcList
.right
+ Origin
.x
;
4202 rcItem
.bottom
= rcItem
.top
= Origin
.y
- 1;
4203 MoveToEx(hdc
, rcItem
.left
, rcItem
.top
, NULL
);
4204 LineTo(hdc
, rcItem
.right
, rcItem
.top
);
4205 for(y
=itemheight
-1+Origin
.y
; y
<=infoPtr
->rcList
.bottom
; y
+=itemheight
)
4207 rcItem
.bottom
= rcItem
.top
= y
;
4208 TRACE("horz rcItem=%s\n", wine_dbgstr_rect(&rcItem
));
4209 MoveToEx (hdc
, rcItem
.left
, rcItem
.top
, NULL
);
4210 LineTo (hdc
, rcItem
.right
, rcItem
.top
);
4213 SelectObject( hdc
, hOldPen
);
4214 DeleteObject( hPen
);
4220 * Draws listview items when in list display mode.
4223 * [I] infoPtr : valid pointer to the listview structure
4224 * [I] hdc : device context handle
4225 * [I] cdmode : custom draw mode
4230 static void LISTVIEW_RefreshList(LISTVIEW_INFO
*infoPtr
, ITERATOR
*i
, HDC hdc
, DWORD cdmode
)
4232 POINT Origin
, Position
;
4234 /* Get scroll info once before loop */
4235 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
4237 while(iterator_prev(i
))
4239 LISTVIEW_GetItemOrigin(infoPtr
, i
->nItem
, &Position
);
4240 Position
.x
+= Origin
.x
;
4241 Position
.y
+= Origin
.y
;
4243 LISTVIEW_DrawItem(infoPtr
, hdc
, i
->nItem
, 0, Position
, cdmode
);
4250 * Draws listview items.
4253 * [I] infoPtr : valid pointer to the listview structure
4254 * [I] hdc : device context handle
4255 * [I] prcErase : rect to be erased before refresh (may be NULL)
4260 static void LISTVIEW_Refresh(LISTVIEW_INFO
*infoPtr
, HDC hdc
, const RECT
*prcErase
)
4262 UINT uView
= infoPtr
->dwStyle
& LVS_TYPEMASK
;
4263 COLORREF oldTextColor
= 0, oldBkColor
= 0, oldClrTextBk
, oldClrText
;
4264 NMLVCUSTOMDRAW nmlvcd
;
4271 HBITMAP hbmp
= NULL
;
4273 LISTVIEW_DUMP(infoPtr
);
4275 if (infoPtr
->dwLvExStyle
& LVS_EX_DOUBLEBUFFER
) {
4276 TRACE("double buffering\n");
4278 hdc
= CreateCompatibleDC(hdcOrig
);
4280 ERR("Failed to create DC for backbuffer\n");
4283 hbmp
= CreateCompatibleBitmap(hdcOrig
, infoPtr
->rcList
.right
,
4284 infoPtr
->rcList
.bottom
);
4286 ERR("Failed to create bitmap for backbuffer\n");
4291 SelectObject(hdc
, hbmp
);
4292 SelectObject(hdc
, infoPtr
->hFont
);
4294 /* Save dc values we're gonna trash while drawing
4295 * FIXME: Should be done in LISTVIEW_DrawItem() */
4296 hOldFont
= SelectObject(hdc
, infoPtr
->hFont
);
4297 oldBkMode
= GetBkMode(hdc
);
4298 oldBkColor
= GetBkColor(hdc
);
4299 oldTextColor
= GetTextColor(hdc
);
4302 infoPtr
->bIsDrawing
= TRUE
;
4305 LISTVIEW_FillBkgnd(infoPtr
, hdc
, prcErase
);
4306 } else if (infoPtr
->dwLvExStyle
& LVS_EX_DOUBLEBUFFER
) {
4307 /* If no erasing was done (usually because RedrawWindow was called
4308 * with RDW_INVALIDATE only) we need to copy the old contents into
4309 * the backbuffer before continuing. */
4310 BitBlt(hdc
, infoPtr
->rcList
.left
, infoPtr
->rcList
.top
,
4311 infoPtr
->rcList
.right
- infoPtr
->rcList
.left
,
4312 infoPtr
->rcList
.bottom
- infoPtr
->rcList
.top
,
4313 hdcOrig
, infoPtr
->rcList
.left
, infoPtr
->rcList
.top
, SRCCOPY
);
4316 /* FIXME: Shouldn't need to do this */
4317 oldClrTextBk
= infoPtr
->clrTextBk
;
4318 oldClrText
= infoPtr
->clrText
;
4320 infoPtr
->cditemmode
= CDRF_DODEFAULT
;
4322 GetClientRect(infoPtr
->hwndSelf
, &rcClient
);
4323 customdraw_fill(&nmlvcd
, infoPtr
, hdc
, &rcClient
, 0);
4324 cdmode
= notify_customdraw(infoPtr
, CDDS_PREPAINT
, &nmlvcd
);
4325 if (cdmode
& CDRF_SKIPDEFAULT
) goto enddraw
;
4326 prepaint_setup(infoPtr
, hdc
, &nmlvcd
, FALSE
);
4328 /* Use these colors to draw the items */
4329 infoPtr
->clrTextBk
= nmlvcd
.clrTextBk
;
4330 infoPtr
->clrText
= nmlvcd
.clrText
;
4332 /* nothing to draw */
4333 if(infoPtr
->nItemCount
== 0) goto enddraw
;
4335 /* figure out what we need to draw */
4336 iterator_visibleitems(&i
, infoPtr
, hdc
);
4338 /* send cache hint notification */
4339 if (infoPtr
->dwStyle
& LVS_OWNERDATA
)
4341 RANGE range
= iterator_range(&i
);
4344 ZeroMemory(&nmlv
, sizeof(NMLVCACHEHINT
));
4345 nmlv
.iFrom
= range
.lower
;
4346 nmlv
.iTo
= range
.upper
- 1;
4347 notify_hdr(infoPtr
, LVN_ODCACHEHINT
, &nmlv
.hdr
);
4350 if ((infoPtr
->dwStyle
& LVS_OWNERDRAWFIXED
) && (uView
== LVS_REPORT
))
4351 LISTVIEW_RefreshOwnerDraw(infoPtr
, &i
, hdc
, cdmode
);
4354 if (uView
== LVS_REPORT
)
4355 LISTVIEW_RefreshReport(infoPtr
, &i
, hdc
, cdmode
);
4356 else /* LVS_LIST, LVS_ICON or LVS_SMALLICON */
4357 LISTVIEW_RefreshList(infoPtr
, &i
, hdc
, cdmode
);
4359 /* if we have a focus rect, draw it */
4360 if (infoPtr
->bFocus
)
4361 DrawFocusRect(hdc
, &infoPtr
->rcFocus
);
4363 iterator_destroy(&i
);
4366 /* For LVS_EX_GRIDLINES go and draw lines */
4367 /* This includes the case where there were *no* items */
4368 if ((infoPtr
->dwStyle
& LVS_TYPEMASK
) == LVS_REPORT
&&
4369 infoPtr
->dwLvExStyle
& LVS_EX_GRIDLINES
)
4370 LISTVIEW_RefreshReportGrid(infoPtr
, hdc
);
4372 if (cdmode
& CDRF_NOTIFYPOSTPAINT
)
4373 notify_postpaint(infoPtr
, &nmlvcd
);
4375 infoPtr
->clrTextBk
= oldClrTextBk
;
4376 infoPtr
->clrText
= oldClrText
;
4379 BitBlt(hdcOrig
, infoPtr
->rcList
.left
, infoPtr
->rcList
.top
,
4380 infoPtr
->rcList
.right
- infoPtr
->rcList
.left
,
4381 infoPtr
->rcList
.bottom
- infoPtr
->rcList
.top
,
4382 hdc
, infoPtr
->rcList
.left
, infoPtr
->rcList
.top
, SRCCOPY
);
4387 SelectObject(hdc
, hOldFont
);
4388 SetBkMode(hdc
, oldBkMode
);
4389 SetBkColor(hdc
, oldBkColor
);
4390 SetTextColor(hdc
, oldTextColor
);
4393 infoPtr
->bIsDrawing
= FALSE
;
4399 * Calculates the approximate width and height of a given number of items.
4402 * [I] infoPtr : valid pointer to the listview structure
4403 * [I] nItemCount : number of items
4404 * [I] wWidth : width
4405 * [I] wHeight : height
4408 * Returns a DWORD. The width in the low word and the height in high word.
4410 static DWORD
LISTVIEW_ApproximateViewRect(const LISTVIEW_INFO
*infoPtr
, INT nItemCount
,
4411 WORD wWidth
, WORD wHeight
)
4413 UINT uView
= infoPtr
->dwStyle
& LVS_TYPEMASK
;
4414 INT nItemCountPerColumn
= 1;
4415 INT nColumnCount
= 0;
4416 DWORD dwViewRect
= 0;
4418 if (nItemCount
== -1)
4419 nItemCount
= infoPtr
->nItemCount
;
4421 if (uView
== LVS_LIST
)
4423 if (wHeight
== 0xFFFF)
4425 /* use current height */
4426 wHeight
= infoPtr
->rcList
.bottom
- infoPtr
->rcList
.top
;
4429 if (wHeight
< infoPtr
->nItemHeight
)
4430 wHeight
= infoPtr
->nItemHeight
;
4434 if (infoPtr
->nItemHeight
> 0)
4436 nItemCountPerColumn
= wHeight
/ infoPtr
->nItemHeight
;
4437 if (nItemCountPerColumn
== 0)
4438 nItemCountPerColumn
= 1;
4440 if (nItemCount
% nItemCountPerColumn
!= 0)
4441 nColumnCount
= nItemCount
/ nItemCountPerColumn
;
4443 nColumnCount
= nItemCount
/ nItemCountPerColumn
+ 1;
4447 /* Microsoft padding magic */
4448 wHeight
= nItemCountPerColumn
* infoPtr
->nItemHeight
+ 2;
4449 wWidth
= nColumnCount
* infoPtr
->nItemWidth
+ 2;
4451 dwViewRect
= MAKELONG(wWidth
, wHeight
);
4453 else if (uView
== LVS_REPORT
)
4457 if (infoPtr
->nItemCount
> 0)
4459 LISTVIEW_GetItemBox(infoPtr
, 0, &rcBox
);
4460 wWidth
= rcBox
.right
- rcBox
.left
;
4461 wHeight
= (rcBox
.bottom
- rcBox
.top
) * nItemCount
;
4465 /* use current height and width */
4466 if (wHeight
== 0xffff)
4467 wHeight
= infoPtr
->rcList
.bottom
- infoPtr
->rcList
.top
;
4468 if (wWidth
== 0xffff)
4469 wWidth
= infoPtr
->rcList
.right
- infoPtr
->rcList
.left
;
4472 dwViewRect
= MAKELONG(wWidth
, wHeight
);
4474 else if (uView
== LVS_SMALLICON
)
4475 FIXME("uView == LVS_SMALLICON: not implemented\n");
4476 else if (uView
== LVS_ICON
)
4477 FIXME("uView == LVS_ICON: not implemented\n");
4485 * Create a drag image list for the specified item.
4488 * [I] infoPtr : valid pointer to the listview structure
4489 * [I] iItem : index of item
4490 * [O] lppt : Upper-left corner of the image
4493 * Returns a handle to the image list if successful, NULL otherwise.
4495 static HIMAGELIST
LISTVIEW_CreateDragImage(LISTVIEW_INFO
*infoPtr
, INT iItem
, LPPOINT lppt
)
4501 HBITMAP hbmp
, hOldbmp
;
4502 HIMAGELIST dragList
= 0;
4503 TRACE("iItem=%d Count=%d\n", iItem
, infoPtr
->nItemCount
);
4505 if (iItem
< 0 || iItem
>= infoPtr
->nItemCount
)
4508 rcItem
.left
= LVIR_BOUNDS
;
4509 if (!LISTVIEW_GetItemRect(infoPtr
, iItem
, &rcItem
))
4512 lppt
->x
= rcItem
.left
;
4513 lppt
->y
= rcItem
.top
;
4515 size
.cx
= rcItem
.right
- rcItem
.left
;
4516 size
.cy
= rcItem
.bottom
- rcItem
.top
;
4518 hdcOrig
= GetDC(infoPtr
->hwndSelf
);
4519 hdc
= CreateCompatibleDC(hdcOrig
);
4520 hbmp
= CreateCompatibleBitmap(hdcOrig
, size
.cx
, size
.cy
);
4521 hOldbmp
= SelectObject(hdc
, hbmp
);
4523 rcItem
.left
= rcItem
.top
= 0;
4524 rcItem
.right
= size
.cx
;
4525 rcItem
.bottom
= size
.cy
;
4526 FillRect(hdc
, &rcItem
, infoPtr
->hBkBrush
);
4529 if (LISTVIEW_DrawItem(infoPtr
, hdc
, iItem
, 0, pos
, infoPtr
->cditemmode
))
4531 dragList
= ImageList_Create(size
.cx
, size
.cy
, ILC_COLOR
, 10, 10);
4532 SelectObject(hdc
, hOldbmp
);
4533 ImageList_Add(dragList
, hbmp
, 0);
4536 SelectObject(hdc
, hOldbmp
);
4540 ReleaseDC(infoPtr
->hwndSelf
, hdcOrig
);
4542 TRACE("ret=%p\n", dragList
);
4550 * Removes all listview items and subitems.
4553 * [I] infoPtr : valid pointer to the listview structure
4559 static BOOL
LISTVIEW_DeleteAllItems(LISTVIEW_INFO
*infoPtr
, BOOL destroy
)
4562 HDPA hdpaSubItems
= NULL
;
4569 /* we do it directly, to avoid notifications */
4570 ranges_clear(infoPtr
->selectionRanges
);
4571 infoPtr
->nSelectionMark
= -1;
4572 infoPtr
->nFocusedItem
= -1;
4573 SetRectEmpty(&infoPtr
->rcFocus
);
4574 /* But we are supposed to leave nHotItem as is! */
4577 /* send LVN_DELETEALLITEMS notification */
4578 ZeroMemory(&nmlv
, sizeof(NMLISTVIEW
));
4580 bSuppress
= notify_listview(infoPtr
, LVN_DELETEALLITEMS
, &nmlv
);
4582 for (i
= infoPtr
->nItemCount
- 1; i
>= 0; i
--)
4584 if (!(infoPtr
->dwStyle
& LVS_OWNERDATA
))
4586 /* send LVN_DELETEITEM notification, if not suppressed
4587 and if it is not a virtual listview */
4588 if (!bSuppress
) notify_deleteitem(infoPtr
, i
);
4589 hdpaSubItems
= DPA_GetPtr(infoPtr
->hdpaItems
, i
);
4590 for (j
= 0; j
< DPA_GetPtrCount(hdpaSubItems
); j
++)
4592 hdrItem
= DPA_GetPtr(hdpaSubItems
, j
);
4593 if (is_textW(hdrItem
->pszText
)) Free(hdrItem
->pszText
);
4596 DPA_Destroy(hdpaSubItems
);
4597 DPA_DeletePtr(infoPtr
->hdpaItems
, i
);
4599 DPA_DeletePtr(infoPtr
->hdpaPosX
, i
);
4600 DPA_DeletePtr(infoPtr
->hdpaPosY
, i
);
4601 infoPtr
->nItemCount
--;
4606 LISTVIEW_Arrange(infoPtr
, LVA_DEFAULT
);
4607 LISTVIEW_UpdateScroll(infoPtr
);
4609 LISTVIEW_InvalidateList(infoPtr
);
4616 * Scrolls, and updates the columns, when a column is changing width.
4619 * [I] infoPtr : valid pointer to the listview structure
4620 * [I] nColumn : column to scroll
4621 * [I] dx : amount of scroll, in pixels
4626 static void LISTVIEW_ScrollColumns(LISTVIEW_INFO
*infoPtr
, INT nColumn
, INT dx
)
4628 COLUMN_INFO
*lpColumnInfo
;
4633 if (nColumn
< 0 || DPA_GetPtrCount(infoPtr
->hdpaColumns
) < 1) return;
4634 lpColumnInfo
= LISTVIEW_GetColumnInfo(infoPtr
, min(nColumn
, DPA_GetPtrCount(infoPtr
->hdpaColumns
) - 1));
4635 rcCol
= lpColumnInfo
->rcHeader
;
4636 if (nColumn
>= DPA_GetPtrCount(infoPtr
->hdpaColumns
))
4637 rcCol
.left
= rcCol
.right
;
4639 /* adjust the other columns */
4640 for (nCol
= nColumn
; nCol
< DPA_GetPtrCount(infoPtr
->hdpaColumns
); nCol
++)
4642 lpColumnInfo
= LISTVIEW_GetColumnInfo(infoPtr
, nCol
);
4643 lpColumnInfo
->rcHeader
.left
+= dx
;
4644 lpColumnInfo
->rcHeader
.right
+= dx
;
4647 /* do not update screen if not in report mode */
4648 if (!is_redrawing(infoPtr
) || (infoPtr
->dwStyle
& LVS_TYPEMASK
) != LVS_REPORT
) return;
4650 /* if we have a focus, we must first erase the focus rect */
4651 if (infoPtr
->bFocus
) LISTVIEW_ShowFocusRect(infoPtr
, FALSE
);
4653 /* Need to reset the item width when inserting a new column */
4654 infoPtr
->nItemWidth
+= dx
;
4656 LISTVIEW_UpdateScroll(infoPtr
);
4657 LISTVIEW_GetOrigin(infoPtr
, &ptOrigin
);
4659 /* scroll to cover the deleted column, and invalidate for redraw */
4660 rcOld
= infoPtr
->rcList
;
4661 rcOld
.left
= ptOrigin
.x
+ rcCol
.left
+ dx
;
4662 ScrollWindowEx(infoPtr
->hwndSelf
, dx
, 0, &rcOld
, &rcOld
, 0, 0, SW_ERASE
| SW_INVALIDATE
);
4664 /* we can restore focus now */
4665 if (infoPtr
->bFocus
) LISTVIEW_ShowFocusRect(infoPtr
, TRUE
);
4670 * Removes a column from the listview control.
4673 * [I] infoPtr : valid pointer to the listview structure
4674 * [I] nColumn : column index
4680 static BOOL
LISTVIEW_DeleteColumn(LISTVIEW_INFO
*infoPtr
, INT nColumn
)
4684 TRACE("nColumn=%d\n", nColumn
);
4686 if (nColumn
< 0 || DPA_GetPtrCount(infoPtr
->hdpaColumns
) == 0
4687 || nColumn
>= DPA_GetPtrCount(infoPtr
->hdpaColumns
)) return FALSE
;
4689 /* While the MSDN specifically says that column zero should not be deleted,
4690 what actually happens is that the column itself is deleted but no items or subitems
4694 LISTVIEW_GetHeaderRect(infoPtr
, nColumn
, &rcCol
);
4696 if (!Header_DeleteItem(infoPtr
->hwndHeader
, nColumn
))
4699 Free(DPA_GetPtr(infoPtr
->hdpaColumns
, nColumn
));
4700 DPA_DeletePtr(infoPtr
->hdpaColumns
, nColumn
);
4702 if (!(infoPtr
->dwStyle
& LVS_OWNERDATA
) && nColumn
)
4704 SUBITEM_INFO
*lpSubItem
, *lpDelItem
;
4706 INT nItem
, nSubItem
, i
;
4708 for (nItem
= 0; nItem
< infoPtr
->nItemCount
; nItem
++)
4710 hdpaSubItems
= DPA_GetPtr(infoPtr
->hdpaItems
, nItem
);
4713 for (i
= 1; i
< DPA_GetPtrCount(hdpaSubItems
); i
++)
4715 lpSubItem
= DPA_GetPtr(hdpaSubItems
, i
);
4716 if (lpSubItem
->iSubItem
== nColumn
)
4719 lpDelItem
= lpSubItem
;
4721 else if (lpSubItem
->iSubItem
> nColumn
)
4723 lpSubItem
->iSubItem
--;
4727 /* if we found our subitem, zapp it */
4731 if (is_textW(lpDelItem
->hdr
.pszText
))
4732 Free(lpDelItem
->hdr
.pszText
);
4737 /* free dpa memory */
4738 DPA_DeletePtr(hdpaSubItems
, nSubItem
);
4743 /* update the other column info */
4744 LISTVIEW_UpdateItemSize(infoPtr
);
4745 if(DPA_GetPtrCount(infoPtr
->hdpaColumns
) == 0)
4746 LISTVIEW_InvalidateList(infoPtr
);
4748 LISTVIEW_ScrollColumns(infoPtr
, nColumn
, -(rcCol
.right
- rcCol
.left
));
4755 * Invalidates the listview after an item's insertion or deletion.
4758 * [I] infoPtr : valid pointer to the listview structure
4759 * [I] nItem : item index
4760 * [I] dir : -1 if deleting, 1 if inserting
4765 static void LISTVIEW_ScrollOnInsert(LISTVIEW_INFO
*infoPtr
, INT nItem
, INT dir
)
4767 UINT uView
= infoPtr
->dwStyle
& LVS_TYPEMASK
;
4768 INT nPerCol
, nItemCol
, nItemRow
;
4772 /* if we don't refresh, what's the point of scrolling? */
4773 if (!is_redrawing(infoPtr
)) return;
4775 assert (abs(dir
) == 1);
4777 /* arrange icons if autoarrange is on */
4778 if (is_autoarrange(infoPtr
))
4780 BOOL arrange
= TRUE
;
4781 if (dir
< 0 && nItem
>= infoPtr
->nItemCount
) arrange
= FALSE
;
4782 if (dir
> 0 && nItem
== infoPtr
->nItemCount
- 1) arrange
= FALSE
;
4783 if (arrange
) LISTVIEW_Arrange(infoPtr
, LVA_DEFAULT
);
4786 /* scrollbars need updating */
4787 LISTVIEW_UpdateScroll(infoPtr
);
4789 /* figure out the item's position */
4790 if (uView
== LVS_REPORT
)
4791 nPerCol
= infoPtr
->nItemCount
+ 1;
4792 else if (uView
== LVS_LIST
)
4793 nPerCol
= LISTVIEW_GetCountPerColumn(infoPtr
);
4794 else /* LVS_ICON, or LVS_SMALLICON */
4797 nItemCol
= nItem
/ nPerCol
;
4798 nItemRow
= nItem
% nPerCol
;
4799 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
4801 /* move the items below up a slot */
4802 rcScroll
.left
= nItemCol
* infoPtr
->nItemWidth
;
4803 rcScroll
.top
= nItemRow
* infoPtr
->nItemHeight
;
4804 rcScroll
.right
= rcScroll
.left
+ infoPtr
->nItemWidth
;
4805 rcScroll
.bottom
= nPerCol
* infoPtr
->nItemHeight
;
4806 OffsetRect(&rcScroll
, Origin
.x
, Origin
.y
);
4807 TRACE("rcScroll=%s, dx=%d\n", wine_dbgstr_rect(&rcScroll
), dir
* infoPtr
->nItemHeight
);
4808 if (IntersectRect(&rcScroll
, &rcScroll
, &infoPtr
->rcList
))
4810 TRACE("Scrolling rcScroll=%s, rcList=%s\n", wine_dbgstr_rect(&rcScroll
), wine_dbgstr_rect(&infoPtr
->rcList
));
4811 ScrollWindowEx(infoPtr
->hwndSelf
, 0, dir
* infoPtr
->nItemHeight
,
4812 &rcScroll
, &rcScroll
, 0, 0, SW_ERASE
| SW_INVALIDATE
);
4815 /* report has only that column, so we're done */
4816 if (uView
== LVS_REPORT
) return;
4818 /* now for LISTs, we have to deal with the columns to the right */
4819 rcScroll
.left
= (nItemCol
+ 1) * infoPtr
->nItemWidth
;
4821 rcScroll
.right
= (infoPtr
->nItemCount
/ nPerCol
+ 1) * infoPtr
->nItemWidth
;
4822 rcScroll
.bottom
= nPerCol
* infoPtr
->nItemHeight
;
4823 OffsetRect(&rcScroll
, Origin
.x
, Origin
.y
);
4824 if (IntersectRect(&rcScroll
, &rcScroll
, &infoPtr
->rcList
))
4825 ScrollWindowEx(infoPtr
->hwndSelf
, 0, dir
* infoPtr
->nItemHeight
,
4826 &rcScroll
, &rcScroll
, 0, 0, SW_ERASE
| SW_INVALIDATE
);
4831 * Removes an item from the listview control.
4834 * [I] infoPtr : valid pointer to the listview structure
4835 * [I] nItem : item index
4841 static BOOL
LISTVIEW_DeleteItem(LISTVIEW_INFO
*infoPtr
, INT nItem
)
4844 const UINT uView
= infoPtr
->dwStyle
& LVS_TYPEMASK
;
4845 const BOOL is_icon
= (uView
== LVS_SMALLICON
|| uView
== LVS_ICON
);
4847 TRACE("(nItem=%d)\n", nItem
);
4849 if (nItem
< 0 || nItem
>= infoPtr
->nItemCount
) return FALSE
;
4851 /* remove selection, and focus */
4853 item
.stateMask
= LVIS_SELECTED
| LVIS_FOCUSED
;
4854 LISTVIEW_SetItemState(infoPtr
, nItem
, &item
);
4856 /* send LVN_DELETEITEM notification. */
4857 if (!notify_deleteitem(infoPtr
, nItem
)) return FALSE
;
4859 /* we need to do this here, because we'll be deleting stuff */
4861 LISTVIEW_InvalidateItem(infoPtr
, nItem
);
4863 if (!(infoPtr
->dwStyle
& LVS_OWNERDATA
))
4869 hdpaSubItems
= DPA_DeletePtr(infoPtr
->hdpaItems
, nItem
);
4870 for (i
= 0; i
< DPA_GetPtrCount(hdpaSubItems
); i
++)
4872 hdrItem
= DPA_GetPtr(hdpaSubItems
, i
);
4873 if (is_textW(hdrItem
->pszText
)) Free(hdrItem
->pszText
);
4876 DPA_Destroy(hdpaSubItems
);
4881 DPA_DeletePtr(infoPtr
->hdpaPosX
, nItem
);
4882 DPA_DeletePtr(infoPtr
->hdpaPosY
, nItem
);
4885 infoPtr
->nItemCount
--;
4886 LISTVIEW_ShiftIndices(infoPtr
, nItem
, -1);
4888 /* now is the invalidation fun */
4890 LISTVIEW_ScrollOnInsert(infoPtr
, nItem
, -1);
4897 * Callback implementation for editlabel control
4900 * [I] infoPtr : valid pointer to the listview structure
4901 * [I] pszText : modified text
4902 * [I] isW : TRUE if psxText is Unicode, FALSE if it's ANSI
4908 static BOOL
LISTVIEW_EndEditLabelT(LISTVIEW_INFO
*infoPtr
, LPWSTR pszText
, BOOL isW
)
4910 HWND hwndSelf
= infoPtr
->hwndSelf
;
4911 NMLVDISPINFOW dispInfo
;
4912 INT editedItem
= infoPtr
->nEditLabelItem
;
4915 TRACE("(pszText=%s, isW=%d)\n", debugtext_t(pszText
, isW
), isW
);
4917 infoPtr
->nEditLabelItem
= -1;
4919 ZeroMemory(&dispInfo
, sizeof(dispInfo
));
4920 dispInfo
.item
.mask
= LVIF_PARAM
| LVIF_STATE
| LVIF_TEXT
;
4921 dispInfo
.item
.iItem
= editedItem
;
4922 dispInfo
.item
.iSubItem
= 0;
4923 dispInfo
.item
.stateMask
= ~0;
4924 if (!LISTVIEW_GetItemW(infoPtr
, &dispInfo
.item
)) return FALSE
;
4927 bSame
= (lstrcmpW(dispInfo
.item
.pszText
, pszText
) == 0);
4930 LPWSTR tmp
= textdupTtoW(pszText
, FALSE
);
4931 bSame
= (lstrcmpW(dispInfo
.item
.pszText
, tmp
) == 0);
4932 textfreeT(tmp
, FALSE
);
4934 if (bSame
) return TRUE
;
4936 /* add the text from the edit in */
4937 dispInfo
.item
.mask
|= LVIF_TEXT
;
4938 dispInfo
.item
.pszText
= pszText
;
4939 dispInfo
.item
.cchTextMax
= textlenT(pszText
, isW
);
4941 /* Do we need to update the Item Text */
4942 if (!notify_dispinfoT(infoPtr
, LVN_ENDLABELEDITW
, &dispInfo
, isW
)) return FALSE
;
4943 if (!IsWindow(hwndSelf
))
4945 if (!pszText
) return TRUE
;
4947 if (!(infoPtr
->dwStyle
& LVS_OWNERDATA
))
4949 HDPA hdpaSubItems
= DPA_GetPtr(infoPtr
->hdpaItems
, editedItem
);
4950 ITEM_INFO
* lpItem
= DPA_GetPtr(hdpaSubItems
, 0);
4951 if (lpItem
&& lpItem
->hdr
.pszText
== LPSTR_TEXTCALLBACKW
)
4953 LISTVIEW_InvalidateItem(infoPtr
, editedItem
);
4958 ZeroMemory(&dispInfo
, sizeof(dispInfo
));
4959 dispInfo
.item
.mask
= LVIF_TEXT
;
4960 dispInfo
.item
.iItem
= editedItem
;
4961 dispInfo
.item
.iSubItem
= 0;
4962 dispInfo
.item
.pszText
= pszText
;
4963 dispInfo
.item
.cchTextMax
= textlenT(pszText
, isW
);
4964 return LISTVIEW_SetItemT(infoPtr
, &dispInfo
.item
, isW
);
4969 * Begin in place editing of specified list view item
4972 * [I] infoPtr : valid pointer to the listview structure
4973 * [I] nItem : item index
4974 * [I] isW : TRUE if it's a Unicode req, FALSE if ASCII
4980 static HWND
LISTVIEW_EditLabelT(LISTVIEW_INFO
*infoPtr
, INT nItem
, BOOL isW
)
4982 WCHAR szDispText
[DISP_TEXT_SIZE
] = { 0 };
4983 NMLVDISPINFOW dispInfo
;
4985 HWND hwndSelf
= infoPtr
->hwndSelf
;
4987 TRACE("(nItem=%d, isW=%d)\n", nItem
, isW
);
4989 if (~infoPtr
->dwStyle
& LVS_EDITLABELS
) return 0;
4990 if (nItem
< 0 || nItem
>= infoPtr
->nItemCount
) return 0;
4992 infoPtr
->nEditLabelItem
= nItem
;
4994 /* Is the EditBox still there, if so remove it */
4995 if(infoPtr
->hwndEdit
!= 0)
4997 SetFocus(infoPtr
->hwndSelf
);
4998 infoPtr
->hwndEdit
= 0;
5001 LISTVIEW_SetSelection(infoPtr
, nItem
);
5002 LISTVIEW_SetItemFocus(infoPtr
, nItem
);
5003 LISTVIEW_InvalidateItem(infoPtr
, nItem
);
5005 rect
.left
= LVIR_LABEL
;
5006 if (!LISTVIEW_GetItemRect(infoPtr
, nItem
, &rect
)) return 0;
5008 ZeroMemory(&dispInfo
, sizeof(dispInfo
));
5009 dispInfo
.item
.mask
= LVIF_PARAM
| LVIF_STATE
| LVIF_TEXT
;
5010 dispInfo
.item
.iItem
= nItem
;
5011 dispInfo
.item
.iSubItem
= 0;
5012 dispInfo
.item
.stateMask
= ~0;
5013 dispInfo
.item
.pszText
= szDispText
;
5014 dispInfo
.item
.cchTextMax
= DISP_TEXT_SIZE
;
5015 if (!LISTVIEW_GetItemT(infoPtr
, &dispInfo
.item
, isW
)) return 0;
5017 infoPtr
->hwndEdit
= CreateEditLabelT(infoPtr
, dispInfo
.item
.pszText
, WS_VISIBLE
,
5018 rect
.left
-2, rect
.top
-1, 0, rect
.bottom
- rect
.top
+2, isW
);
5019 if (!infoPtr
->hwndEdit
) return 0;
5021 if (notify_dispinfoT(infoPtr
, LVN_BEGINLABELEDITW
, &dispInfo
, isW
))
5023 if (!IsWindow(hwndSelf
))
5025 SendMessageW(infoPtr
->hwndEdit
, WM_CLOSE
, 0, 0);
5026 infoPtr
->hwndEdit
= 0;
5030 ShowWindow(infoPtr
->hwndEdit
, SW_NORMAL
);
5031 SetFocus(infoPtr
->hwndEdit
);
5032 SendMessageW(infoPtr
->hwndEdit
, EM_SETSEL
, 0, -1);
5033 return infoPtr
->hwndEdit
;
5039 * Ensures the specified item is visible, scrolling into view if necessary.
5042 * [I] infoPtr : valid pointer to the listview structure
5043 * [I] nItem : item index
5044 * [I] bPartial : partially or entirely visible
5050 static BOOL
LISTVIEW_EnsureVisible(LISTVIEW_INFO
*infoPtr
, INT nItem
, BOOL bPartial
)
5052 UINT uView
= infoPtr
->dwStyle
& LVS_TYPEMASK
;
5053 INT nScrollPosHeight
= 0;
5054 INT nScrollPosWidth
= 0;
5055 INT nHorzAdjust
= 0;
5056 INT nVertAdjust
= 0;
5059 RECT rcItem
, rcTemp
;
5061 rcItem
.left
= LVIR_BOUNDS
;
5062 if (!LISTVIEW_GetItemRect(infoPtr
, nItem
, &rcItem
)) return FALSE
;
5064 if (bPartial
&& IntersectRect(&rcTemp
, &infoPtr
->rcList
, &rcItem
)) return TRUE
;
5066 if (rcItem
.left
< infoPtr
->rcList
.left
|| rcItem
.right
> infoPtr
->rcList
.right
)
5068 /* scroll left/right, but in LVS_REPORT mode */
5069 if (uView
== LVS_LIST
)
5070 nScrollPosWidth
= infoPtr
->nItemWidth
;
5071 else if ((uView
== LVS_SMALLICON
) || (uView
== LVS_ICON
))
5072 nScrollPosWidth
= 1;
5074 if (rcItem
.left
< infoPtr
->rcList
.left
)
5077 if (uView
!= LVS_REPORT
) nHorzDiff
= rcItem
.left
- infoPtr
->rcList
.left
;
5082 if (uView
!= LVS_REPORT
) nHorzDiff
= rcItem
.right
- infoPtr
->rcList
.right
;
5086 if (rcItem
.top
< infoPtr
->rcList
.top
|| rcItem
.bottom
> infoPtr
->rcList
.bottom
)
5088 /* scroll up/down, but not in LVS_LIST mode */
5089 if (uView
== LVS_REPORT
)
5090 nScrollPosHeight
= infoPtr
->nItemHeight
;
5091 else if ((uView
== LVS_ICON
) || (uView
== LVS_SMALLICON
))
5092 nScrollPosHeight
= 1;
5094 if (rcItem
.top
< infoPtr
->rcList
.top
)
5097 if (uView
!= LVS_LIST
) nVertDiff
= rcItem
.top
- infoPtr
->rcList
.top
;
5102 if (uView
!= LVS_LIST
) nVertDiff
= rcItem
.bottom
- infoPtr
->rcList
.bottom
;
5106 if (!nScrollPosWidth
&& !nScrollPosHeight
) return TRUE
;
5108 if (nScrollPosWidth
)
5110 INT diff
= nHorzDiff
/ nScrollPosWidth
;
5111 if (nHorzDiff
% nScrollPosWidth
) diff
+= nHorzAdjust
;
5112 LISTVIEW_HScroll(infoPtr
, SB_INTERNAL
, diff
, 0);
5115 if (nScrollPosHeight
)
5117 INT diff
= nVertDiff
/ nScrollPosHeight
;
5118 if (nVertDiff
% nScrollPosHeight
) diff
+= nVertAdjust
;
5119 LISTVIEW_VScroll(infoPtr
, SB_INTERNAL
, diff
, 0);
5127 * Searches for an item with specific characteristics.
5130 * [I] hwnd : window handle
5131 * [I] nStart : base item index
5132 * [I] lpFindInfo : item information to look for
5135 * SUCCESS : index of item
5138 static INT
LISTVIEW_FindItemW(const LISTVIEW_INFO
*infoPtr
, INT nStart
,
5139 const LVFINDINFOW
*lpFindInfo
)
5141 UINT uView
= infoPtr
->dwStyle
& LVS_TYPEMASK
;
5142 WCHAR szDispText
[DISP_TEXT_SIZE
] = { '\0' };
5143 BOOL bWrap
= FALSE
, bNearest
= FALSE
;
5144 INT nItem
= nStart
+ 1, nLast
= infoPtr
->nItemCount
, nNearestItem
= -1;
5145 ULONG xdist
, ydist
, dist
, mindist
= 0x7fffffff;
5146 POINT Position
, Destination
;
5149 /* Search in virtual listviews should be done by application, not by
5150 listview control, so we just send LVN_ODFINDITEMW and return the result */
5151 if (infoPtr
->dwStyle
& LVS_OWNERDATA
)
5155 nmlv
.iStart
= nStart
;
5156 nmlv
.lvfi
= *lpFindInfo
;
5157 return notify_hdr(infoPtr
, LVN_ODFINDITEMW
, (LPNMHDR
)&nmlv
.hdr
);
5160 if (!lpFindInfo
|| nItem
< 0) return -1;
5163 if (lpFindInfo
->flags
& (LVFI_STRING
| LVFI_PARTIAL
))
5165 lvItem
.mask
|= LVIF_TEXT
;
5166 lvItem
.pszText
= szDispText
;
5167 lvItem
.cchTextMax
= DISP_TEXT_SIZE
;
5170 if (lpFindInfo
->flags
& LVFI_WRAP
)
5173 if ((lpFindInfo
->flags
& LVFI_NEARESTXY
) &&
5174 (uView
== LVS_ICON
|| uView
==LVS_SMALLICON
))
5179 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
5180 Destination
.x
= lpFindInfo
->pt
.x
- Origin
.x
;
5181 Destination
.y
= lpFindInfo
->pt
.y
- Origin
.y
;
5182 switch(lpFindInfo
->vkDirection
)
5184 case VK_DOWN
: Destination
.y
+= infoPtr
->nItemHeight
; break;
5185 case VK_UP
: Destination
.y
-= infoPtr
->nItemHeight
; break;
5186 case VK_RIGHT
: Destination
.x
+= infoPtr
->nItemWidth
; break;
5187 case VK_LEFT
: Destination
.x
-= infoPtr
->nItemWidth
; break;
5188 case VK_HOME
: Destination
.x
= Destination
.y
= 0; break;
5189 case VK_NEXT
: Destination
.y
+= infoPtr
->rcList
.bottom
- infoPtr
->rcList
.top
; break;
5190 case VK_PRIOR
: Destination
.y
-= infoPtr
->rcList
.bottom
- infoPtr
->rcList
.top
; break;
5192 LISTVIEW_GetAreaRect(infoPtr
, &rcArea
);
5193 Destination
.x
= rcArea
.right
;
5194 Destination
.y
= rcArea
.bottom
;
5196 default: ERR("Unknown vkDirection=%d\n", lpFindInfo
->vkDirection
);
5200 else Destination
.x
= Destination
.y
= 0;
5202 /* if LVFI_PARAM is specified, all other flags are ignored */
5203 if (lpFindInfo
->flags
& LVFI_PARAM
)
5205 lvItem
.mask
|= LVIF_PARAM
;
5207 lvItem
.mask
&= ~LVIF_TEXT
;
5211 for (; nItem
< nLast
; nItem
++)
5213 lvItem
.iItem
= nItem
;
5214 lvItem
.iSubItem
= 0;
5215 if (!LISTVIEW_GetItemW(infoPtr
, &lvItem
)) continue;
5217 if (lvItem
.mask
& LVIF_PARAM
)
5219 if (lpFindInfo
->lParam
== lvItem
.lParam
)
5225 if (lvItem
.mask
& LVIF_TEXT
)
5227 if (lpFindInfo
->flags
& LVFI_PARTIAL
)
5229 if (strstrW(lvItem
.pszText
, lpFindInfo
->psz
) == NULL
) continue;
5233 if (lstrcmpW(lvItem
.pszText
, lpFindInfo
->psz
) != 0) continue;
5237 if (!bNearest
) return nItem
;
5239 /* This is very inefficient. To do a good job here,
5240 * we need a sorted array of (x,y) item positions */
5241 LISTVIEW_GetItemOrigin(infoPtr
, nItem
, &Position
);
5243 /* compute the distance^2 to the destination */
5244 xdist
= Destination
.x
- Position
.x
;
5245 ydist
= Destination
.y
- Position
.y
;
5246 dist
= xdist
* xdist
+ ydist
* ydist
;
5248 /* remember the distance, and item if it's closer */
5252 nNearestItem
= nItem
;
5259 nLast
= min(nStart
+ 1, infoPtr
->nItemCount
);
5264 return nNearestItem
;
5269 * Searches for an item with specific characteristics.
5272 * [I] hwnd : window handle
5273 * [I] nStart : base item index
5274 * [I] lpFindInfo : item information to look for
5277 * SUCCESS : index of item
5280 static INT
LISTVIEW_FindItemA(const LISTVIEW_INFO
*infoPtr
, INT nStart
,
5281 const LVFINDINFOA
*lpFindInfo
)
5283 BOOL hasText
= lpFindInfo
->flags
& (LVFI_STRING
| LVFI_PARTIAL
);
5288 memcpy(&fiw
, lpFindInfo
, sizeof(fiw
));
5289 if (hasText
) fiw
.psz
= strW
= textdupTtoW((LPCWSTR
)lpFindInfo
->psz
, FALSE
);
5290 res
= LISTVIEW_FindItemW(infoPtr
, nStart
, &fiw
);
5291 textfreeT(strW
, FALSE
);
5297 * Retrieves the background image of the listview control.
5300 * [I] infoPtr : valid pointer to the listview structure
5301 * [O] lpBkImage : background image attributes
5307 /* static BOOL LISTVIEW_GetBkImage(const LISTVIEW_INFO *infoPtr, LPLVBKIMAGE lpBkImage) */
5309 /* FIXME (listview, "empty stub!\n"); */
5315 * Retrieves column attributes.
5318 * [I] infoPtr : valid pointer to the listview structure
5319 * [I] nColumn : column index
5320 * [IO] lpColumn : column information
5321 * [I] isW : if TRUE, then lpColumn is a LPLVCOLUMNW
5322 * otherwise it is in fact a LPLVCOLUMNA
5328 static BOOL
LISTVIEW_GetColumnT(const LISTVIEW_INFO
*infoPtr
, INT nColumn
, LPLVCOLUMNW lpColumn
, BOOL isW
)
5330 COLUMN_INFO
*lpColumnInfo
;
5333 if (!lpColumn
|| nColumn
< 0 || nColumn
>= DPA_GetPtrCount(infoPtr
->hdpaColumns
)) return FALSE
;
5334 lpColumnInfo
= LISTVIEW_GetColumnInfo(infoPtr
, nColumn
);
5336 /* initialize memory */
5337 ZeroMemory(&hdi
, sizeof(hdi
));
5339 if (lpColumn
->mask
& LVCF_TEXT
)
5341 hdi
.mask
|= HDI_TEXT
;
5342 hdi
.pszText
= lpColumn
->pszText
;
5343 hdi
.cchTextMax
= lpColumn
->cchTextMax
;
5346 if (lpColumn
->mask
& LVCF_IMAGE
)
5347 hdi
.mask
|= HDI_IMAGE
;
5349 if (lpColumn
->mask
& LVCF_ORDER
)
5350 hdi
.mask
|= HDI_ORDER
;
5352 if (lpColumn
->mask
& LVCF_SUBITEM
)
5353 hdi
.mask
|= HDI_LPARAM
;
5355 if (!SendMessageW(infoPtr
->hwndHeader
, isW
? HDM_GETITEMW
: HDM_GETITEMA
, nColumn
, (LPARAM
)&hdi
)) return FALSE
;
5357 if (lpColumn
->mask
& LVCF_FMT
)
5358 lpColumn
->fmt
= lpColumnInfo
->fmt
;
5360 if (lpColumn
->mask
& LVCF_WIDTH
)
5361 lpColumn
->cx
= lpColumnInfo
->rcHeader
.right
- lpColumnInfo
->rcHeader
.left
;
5363 if (lpColumn
->mask
& LVCF_IMAGE
)
5364 lpColumn
->iImage
= hdi
.iImage
;
5366 if (lpColumn
->mask
& LVCF_ORDER
)
5367 lpColumn
->iOrder
= hdi
.iOrder
;
5369 if (lpColumn
->mask
& LVCF_SUBITEM
)
5370 lpColumn
->iSubItem
= hdi
.lParam
;
5376 static BOOL
LISTVIEW_GetColumnOrderArray(const LISTVIEW_INFO
*infoPtr
, INT iCount
, LPINT lpiArray
)
5378 TRACE("iCount=%d, lpiArray=%p\n", iCount
, lpiArray
);
5383 return SendMessageW(infoPtr
->hwndHeader
, HDM_GETORDERARRAY
, iCount
, (LPARAM
)lpiArray
);
5388 * Retrieves the column width.
5391 * [I] infoPtr : valid pointer to the listview structure
5392 * [I] int : column index
5395 * SUCCESS : column width
5398 static INT
LISTVIEW_GetColumnWidth(const LISTVIEW_INFO
*infoPtr
, INT nColumn
)
5400 INT nColumnWidth
= 0;
5403 TRACE("nColumn=%d\n", nColumn
);
5405 /* we have a 'column' in LIST and REPORT mode only */
5406 switch(infoPtr
->dwStyle
& LVS_TYPEMASK
)
5409 nColumnWidth
= infoPtr
->nItemWidth
;
5412 /* We are not using LISTVIEW_GetHeaderRect as this data is updated only after a HDM_ITEMCHANGED.
5413 * There is an application that subclasses the listview, calls LVM_GETCOLUMNWIDTH in the
5414 * HDM_ITEMCHANGED handler and goes into infinite recursion if it receives old data.
5416 * TODO: should we do the same in LVM_GETCOLUMN?
5418 hdItem
.mask
= HDI_WIDTH
;
5419 if (!SendMessageW(infoPtr
->hwndHeader
, HDM_GETITEMW
, nColumn
, (LPARAM
)&hdItem
))
5421 WARN("(%p): HDM_GETITEMW failed for item %d\n", infoPtr
->hwndSelf
, nColumn
);
5424 nColumnWidth
= hdItem
.cxy
;
5428 TRACE("nColumnWidth=%d\n", nColumnWidth
);
5429 return nColumnWidth
;
5434 * In list or report display mode, retrieves the number of items that can fit
5435 * vertically in the visible area. In icon or small icon display mode,
5436 * retrieves the total number of visible items.
5439 * [I] infoPtr : valid pointer to the listview structure
5442 * Number of fully visible items.
5444 static INT
LISTVIEW_GetCountPerPage(const LISTVIEW_INFO
*infoPtr
)
5446 switch (infoPtr
->dwStyle
& LVS_TYPEMASK
)
5450 return infoPtr
->nItemCount
;
5452 return LISTVIEW_GetCountPerColumn(infoPtr
);
5454 return LISTVIEW_GetCountPerRow(infoPtr
) * LISTVIEW_GetCountPerColumn(infoPtr
);
5462 * Retrieves an image list handle.
5465 * [I] infoPtr : valid pointer to the listview structure
5466 * [I] nImageList : image list identifier
5469 * SUCCESS : image list handle
5472 static HIMAGELIST
LISTVIEW_GetImageList(const LISTVIEW_INFO
*infoPtr
, INT nImageList
)
5476 case LVSIL_NORMAL
: return infoPtr
->himlNormal
;
5477 case LVSIL_SMALL
: return infoPtr
->himlSmall
;
5478 case LVSIL_STATE
: return infoPtr
->himlState
;
5483 /* LISTVIEW_GetISearchString */
5487 * Retrieves item attributes.
5490 * [I] hwnd : window handle
5491 * [IO] lpLVItem : item info
5492 * [I] isW : if TRUE, then lpLVItem is a LPLVITEMW,
5493 * if FALSE, then lpLVItem is a LPLVITEMA.
5496 * This is the internal 'GetItem' interface -- it tries to
5497 * be smart and avoid text copies, if possible, by modifying
5498 * lpLVItem->pszText to point to the text string. Please note
5499 * that this is not always possible (e.g. OWNERDATA), so on
5500 * entry you *must* supply valid values for pszText, and cchTextMax.
5501 * The only difference to the documented interface is that upon
5502 * return, you should use *only* the lpLVItem->pszText, rather than
5503 * the buffer pointer you provided on input. Most code already does
5504 * that, so it's not a problem.
5505 * For the two cases when the text must be copied (that is,
5506 * for LVM_GETITEM, and LVM_GETITEMTEXT), use LISTVIEW_GetItemExtT.
5512 static BOOL
LISTVIEW_GetItemT(const LISTVIEW_INFO
*infoPtr
, LPLVITEMW lpLVItem
, BOOL isW
)
5514 ITEMHDR callbackHdr
= { LPSTR_TEXTCALLBACKW
, I_IMAGECALLBACK
};
5515 NMLVDISPINFOW dispInfo
;
5521 TRACE("(lpLVItem=%s, isW=%d)\n", debuglvitem_t(lpLVItem
, isW
), isW
);
5523 if (!lpLVItem
|| lpLVItem
->iItem
< 0 || lpLVItem
->iItem
>= infoPtr
->nItemCount
)
5526 if (lpLVItem
->mask
== 0) return TRUE
;
5528 /* make a local copy */
5529 isubitem
= lpLVItem
->iSubItem
;
5531 /* a quick optimization if all we're asked is the focus state
5532 * these queries are worth optimising since they are common,
5533 * and can be answered in constant time, without the heavy accesses */
5534 if ( (lpLVItem
->mask
== LVIF_STATE
) && (lpLVItem
->stateMask
== LVIS_FOCUSED
) &&
5535 !(infoPtr
->uCallbackMask
& LVIS_FOCUSED
) )
5537 lpLVItem
->state
= 0;
5538 if (infoPtr
->nFocusedItem
== lpLVItem
->iItem
)
5539 lpLVItem
->state
|= LVIS_FOCUSED
;
5543 ZeroMemory(&dispInfo
, sizeof(dispInfo
));
5545 /* if the app stores all the data, handle it separately */
5546 if (infoPtr
->dwStyle
& LVS_OWNERDATA
)
5548 dispInfo
.item
.state
= 0;
5550 /* apparently, we should not callback for lParam in LVS_OWNERDATA */
5551 if ((lpLVItem
->mask
& ~(LVIF_STATE
| LVIF_PARAM
)) || infoPtr
->uCallbackMask
)
5553 /* NOTE: copy only fields which we _know_ are initialized, some apps
5554 * depend on the uninitialized fields being 0 */
5555 dispInfo
.item
.mask
= lpLVItem
->mask
& ~LVIF_PARAM
;
5556 dispInfo
.item
.iItem
= lpLVItem
->iItem
;
5557 dispInfo
.item
.iSubItem
= isubitem
;
5558 if (lpLVItem
->mask
& LVIF_TEXT
)
5560 dispInfo
.item
.pszText
= lpLVItem
->pszText
;
5561 dispInfo
.item
.cchTextMax
= lpLVItem
->cchTextMax
;
5563 if (lpLVItem
->mask
& LVIF_STATE
)
5564 dispInfo
.item
.stateMask
= lpLVItem
->stateMask
& infoPtr
->uCallbackMask
;
5565 notify_dispinfoT(infoPtr
, LVN_GETDISPINFOW
, &dispInfo
, isW
);
5566 dispInfo
.item
.stateMask
= lpLVItem
->stateMask
;
5567 if (lpLVItem
->mask
& (LVIF_GROUPID
|LVIF_COLUMNS
))
5569 /* full size structure expected - _WIN32IE >= 0x560 */
5570 *lpLVItem
= dispInfo
.item
;
5572 else if (lpLVItem
->mask
& LVIF_INDENT
)
5574 /* indent member expected - _WIN32IE >= 0x300 */
5575 memcpy(lpLVItem
, &dispInfo
.item
, offsetof( LVITEMW
, iGroupId
));
5579 /* minimal structure expected */
5580 memcpy(lpLVItem
, &dispInfo
.item
, offsetof( LVITEMW
, iIndent
));
5582 TRACE(" getdispinfo(1):lpLVItem=%s\n", debuglvitem_t(lpLVItem
, isW
));
5585 /* make sure lParam is zeroed out */
5586 if (lpLVItem
->mask
& LVIF_PARAM
) lpLVItem
->lParam
= 0;
5588 /* we store only a little state, so if we're not asked, we're done */
5589 if (!(lpLVItem
->mask
& LVIF_STATE
) || isubitem
) return TRUE
;
5591 /* if focus is handled by us, report it */
5592 if ( lpLVItem
->stateMask
& ~infoPtr
->uCallbackMask
& LVIS_FOCUSED
)
5594 lpLVItem
->state
&= ~LVIS_FOCUSED
;
5595 if (infoPtr
->nFocusedItem
== lpLVItem
->iItem
)
5596 lpLVItem
->state
|= LVIS_FOCUSED
;
5599 /* and do the same for selection, if we handle it */
5600 if ( lpLVItem
->stateMask
& ~infoPtr
->uCallbackMask
& LVIS_SELECTED
)
5602 lpLVItem
->state
&= ~LVIS_SELECTED
;
5603 if (ranges_contain(infoPtr
->selectionRanges
, lpLVItem
->iItem
))
5604 lpLVItem
->state
|= LVIS_SELECTED
;
5610 /* find the item and subitem structures before we proceed */
5611 hdpaSubItems
= DPA_GetPtr(infoPtr
->hdpaItems
, lpLVItem
->iItem
);
5612 lpItem
= DPA_GetPtr(hdpaSubItems
, 0);
5617 SUBITEM_INFO
*lpSubItem
= LISTVIEW_GetSubItemPtr(hdpaSubItems
, isubitem
);
5618 pItemHdr
= lpSubItem
? &lpSubItem
->hdr
: &callbackHdr
;
5621 WARN(" iSubItem invalid (%08x), ignored.\n", isubitem
);
5626 pItemHdr
= &lpItem
->hdr
;
5628 /* Do we need to query the state from the app? */
5629 if ((lpLVItem
->mask
& LVIF_STATE
) && infoPtr
->uCallbackMask
&& isubitem
== 0)
5631 dispInfo
.item
.mask
|= LVIF_STATE
;
5632 dispInfo
.item
.stateMask
= infoPtr
->uCallbackMask
;
5635 /* Do we need to enquire about the image? */
5636 if ((lpLVItem
->mask
& LVIF_IMAGE
) && pItemHdr
->iImage
== I_IMAGECALLBACK
&&
5637 (isubitem
== 0 || (infoPtr
->dwLvExStyle
& LVS_EX_SUBITEMIMAGES
)))
5639 dispInfo
.item
.mask
|= LVIF_IMAGE
;
5640 dispInfo
.item
.iImage
= I_IMAGECALLBACK
;
5643 /* Apps depend on calling back for text if it is NULL or LPSTR_TEXTCALLBACKW */
5644 if ((lpLVItem
->mask
& LVIF_TEXT
) && !is_textW(pItemHdr
->pszText
))
5646 dispInfo
.item
.mask
|= LVIF_TEXT
;
5647 dispInfo
.item
.pszText
= lpLVItem
->pszText
;
5648 dispInfo
.item
.cchTextMax
= lpLVItem
->cchTextMax
;
5649 if (dispInfo
.item
.pszText
&& dispInfo
.item
.cchTextMax
> 0)
5650 *dispInfo
.item
.pszText
= '\0';
5653 /* If we don't have all the requested info, query the application */
5654 if (dispInfo
.item
.mask
!= 0)
5656 dispInfo
.item
.iItem
= lpLVItem
->iItem
;
5657 dispInfo
.item
.iSubItem
= lpLVItem
->iSubItem
; /* yes: the original subitem */
5658 dispInfo
.item
.lParam
= lpItem
->lParam
;
5659 notify_dispinfoT(infoPtr
, LVN_GETDISPINFOW
, &dispInfo
, isW
);
5660 TRACE(" getdispinfo(2):item=%s\n", debuglvitem_t(&dispInfo
.item
, isW
));
5663 /* we should not store values for subitems */
5664 if (isubitem
) dispInfo
.item
.mask
&= ~LVIF_DI_SETITEM
;
5666 /* Now, handle the iImage field */
5667 if (dispInfo
.item
.mask
& LVIF_IMAGE
)
5669 lpLVItem
->iImage
= dispInfo
.item
.iImage
;
5670 if ((dispInfo
.item
.mask
& LVIF_DI_SETITEM
) && pItemHdr
->iImage
== I_IMAGECALLBACK
)
5671 pItemHdr
->iImage
= dispInfo
.item
.iImage
;
5673 else if (lpLVItem
->mask
& LVIF_IMAGE
)
5675 if(isubitem
== 0 || (infoPtr
->dwLvExStyle
& LVS_EX_SUBITEMIMAGES
))
5676 lpLVItem
->iImage
= pItemHdr
->iImage
;
5678 lpLVItem
->iImage
= 0;
5681 /* The pszText field */
5682 if (dispInfo
.item
.mask
& LVIF_TEXT
)
5684 if ((dispInfo
.item
.mask
& LVIF_DI_SETITEM
) && pItemHdr
->pszText
)
5685 textsetptrT(&pItemHdr
->pszText
, dispInfo
.item
.pszText
, isW
);
5687 lpLVItem
->pszText
= dispInfo
.item
.pszText
;
5689 else if (lpLVItem
->mask
& LVIF_TEXT
)
5691 if (isW
) lpLVItem
->pszText
= pItemHdr
->pszText
;
5692 else textcpynT(lpLVItem
->pszText
, isW
, pItemHdr
->pszText
, TRUE
, lpLVItem
->cchTextMax
);
5695 /* Next is the lParam field */
5696 if (dispInfo
.item
.mask
& LVIF_PARAM
)
5698 lpLVItem
->lParam
= dispInfo
.item
.lParam
;
5699 if ((dispInfo
.item
.mask
& LVIF_DI_SETITEM
))
5700 lpItem
->lParam
= dispInfo
.item
.lParam
;
5702 else if (lpLVItem
->mask
& LVIF_PARAM
)
5703 lpLVItem
->lParam
= lpItem
->lParam
;
5705 /* if this is a subitem, we're done */
5706 if (isubitem
) return TRUE
;
5708 /* ... the state field (this one is different due to uCallbackmask) */
5709 if (lpLVItem
->mask
& LVIF_STATE
)
5711 lpLVItem
->state
= lpItem
->state
& lpLVItem
->stateMask
;
5712 if (dispInfo
.item
.mask
& LVIF_STATE
)
5714 lpLVItem
->state
&= ~dispInfo
.item
.stateMask
;
5715 lpLVItem
->state
|= (dispInfo
.item
.state
& dispInfo
.item
.stateMask
);
5717 if ( lpLVItem
->stateMask
& ~infoPtr
->uCallbackMask
& LVIS_FOCUSED
)
5719 lpLVItem
->state
&= ~LVIS_FOCUSED
;
5720 if (infoPtr
->nFocusedItem
== lpLVItem
->iItem
)
5721 lpLVItem
->state
|= LVIS_FOCUSED
;
5723 if ( lpLVItem
->stateMask
& ~infoPtr
->uCallbackMask
& LVIS_SELECTED
)
5725 lpLVItem
->state
&= ~LVIS_SELECTED
;
5726 if (ranges_contain(infoPtr
->selectionRanges
, lpLVItem
->iItem
))
5727 lpLVItem
->state
|= LVIS_SELECTED
;
5731 /* and last, but not least, the indent field */
5732 if (lpLVItem
->mask
& LVIF_INDENT
)
5733 lpLVItem
->iIndent
= lpItem
->iIndent
;
5740 * Retrieves item attributes.
5743 * [I] hwnd : window handle
5744 * [IO] lpLVItem : item info
5745 * [I] isW : if TRUE, then lpLVItem is a LPLVITEMW,
5746 * if FALSE, then lpLVItem is a LPLVITEMA.
5749 * This is the external 'GetItem' interface -- it properly copies
5750 * the text in the provided buffer.
5756 static BOOL
LISTVIEW_GetItemExtT(const LISTVIEW_INFO
*infoPtr
, LPLVITEMW lpLVItem
, BOOL isW
)
5761 if (!lpLVItem
|| lpLVItem
->iItem
< 0 || lpLVItem
->iItem
>= infoPtr
->nItemCount
)
5764 pszText
= lpLVItem
->pszText
;
5765 bResult
= LISTVIEW_GetItemT(infoPtr
, lpLVItem
, isW
);
5766 if (bResult
&& lpLVItem
->pszText
!= pszText
)
5767 textcpynT(pszText
, isW
, lpLVItem
->pszText
, isW
, lpLVItem
->cchTextMax
);
5768 lpLVItem
->pszText
= pszText
;
5776 * Retrieves the position (upper-left) of the listview control item.
5777 * Note that for LVS_ICON style, the upper-left is that of the icon
5778 * and not the bounding box.
5781 * [I] infoPtr : valid pointer to the listview structure
5782 * [I] nItem : item index
5783 * [O] lpptPosition : coordinate information
5789 static BOOL
LISTVIEW_GetItemPosition(const LISTVIEW_INFO
*infoPtr
, INT nItem
, LPPOINT lpptPosition
)
5791 UINT uView
= infoPtr
->dwStyle
& LVS_TYPEMASK
;
5794 TRACE("(nItem=%d, lpptPosition=%p)\n", nItem
, lpptPosition
);
5796 if (!lpptPosition
|| nItem
< 0 || nItem
>= infoPtr
->nItemCount
) return FALSE
;
5798 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
5799 LISTVIEW_GetItemOrigin(infoPtr
, nItem
, lpptPosition
);
5801 if (uView
== LVS_ICON
)
5803 lpptPosition
->x
+= (infoPtr
->nItemWidth
- infoPtr
->iconSize
.cx
) / 2;
5804 lpptPosition
->y
+= ICON_TOP_PADDING
;
5806 lpptPosition
->x
+= Origin
.x
;
5807 lpptPosition
->y
+= Origin
.y
;
5809 TRACE (" lpptPosition=%s\n", wine_dbgstr_point(lpptPosition
));
5816 * Retrieves the bounding rectangle for a listview control item.
5819 * [I] infoPtr : valid pointer to the listview structure
5820 * [I] nItem : item index
5821 * [IO] lprc : bounding rectangle coordinates
5822 * lprc->left specifies the portion of the item for which the bounding
5823 * rectangle will be retrieved.
5825 * LVIR_BOUNDS Returns the bounding rectangle of the entire item,
5826 * including the icon and label.
5829 * * Experiment shows that native control returns:
5830 * * width = min (48, length of text line)
5831 * * .left = position.x - (width - iconsize.cx)/2
5832 * * .right = .left + width
5833 * * height = #lines of text * ntmHeight + icon height + 8
5834 * * .top = position.y - 2
5835 * * .bottom = .top + height
5836 * * separation between items .y = itemSpacing.cy - height
5837 * * .x = itemSpacing.cx - width
5838 * LVIR_ICON Returns the bounding rectangle of the icon or small icon.
5841 * * Experiment shows that native control returns:
5842 * * width = iconSize.cx + 16
5843 * * .left = position.x - (width - iconsize.cx)/2
5844 * * .right = .left + width
5845 * * height = iconSize.cy + 4
5846 * * .top = position.y - 2
5847 * * .bottom = .top + height
5848 * * separation between items .y = itemSpacing.cy - height
5849 * * .x = itemSpacing.cx - width
5850 * LVIR_LABEL Returns the bounding rectangle of the item text.
5853 * * Experiment shows that native control returns:
5854 * * width = text length
5855 * * .left = position.x - width/2
5856 * * .right = .left + width
5857 * * height = ntmH * linecount + 2
5858 * * .top = position.y + iconSize.cy + 6
5859 * * .bottom = .top + height
5860 * * separation between items .y = itemSpacing.cy - height
5861 * * .x = itemSpacing.cx - width
5862 * LVIR_SELECTBOUNDS Returns the union of the LVIR_ICON and LVIR_LABEL
5863 * rectangles, but excludes columns in report view.
5870 * Note that the bounding rectangle of the label in the LVS_ICON view depends
5871 * upon whether the window has the focus currently and on whether the item
5872 * is the one with the focus. Ensure that the control's record of which
5873 * item has the focus agrees with the items' records.
5875 static BOOL
LISTVIEW_GetItemRect(const LISTVIEW_INFO
*infoPtr
, INT nItem
, LPRECT lprc
)
5877 UINT uView
= infoPtr
->dwStyle
& LVS_TYPEMASK
;
5878 WCHAR szDispText
[DISP_TEXT_SIZE
] = { '\0' };
5879 BOOL doLabel
= TRUE
, oversizedBox
= FALSE
;
5880 POINT Position
, Origin
;
5883 TRACE("(hwnd=%p, nItem=%d, lprc=%p)\n", infoPtr
->hwndSelf
, nItem
, lprc
);
5885 if (!lprc
|| nItem
< 0 || nItem
>= infoPtr
->nItemCount
) return FALSE
;
5887 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
5888 LISTVIEW_GetItemOrigin(infoPtr
, nItem
, &Position
);
5890 /* Be smart and try to figure out the minimum we have to do */
5891 if (lprc
->left
== LVIR_ICON
) doLabel
= FALSE
;
5892 if (uView
== LVS_REPORT
&& lprc
->left
== LVIR_BOUNDS
) doLabel
= FALSE
;
5893 if (uView
== LVS_ICON
&& lprc
->left
!= LVIR_ICON
&&
5894 infoPtr
->bFocus
&& LISTVIEW_GetItemState(infoPtr
, nItem
, LVIS_FOCUSED
))
5895 oversizedBox
= TRUE
;
5897 /* get what we need from the item before hand, so we make
5898 * only one request. This can speed up things, if data
5899 * is stored on the app side */
5901 if (uView
== LVS_REPORT
) lvItem
.mask
|= LVIF_INDENT
;
5902 if (doLabel
) lvItem
.mask
|= LVIF_TEXT
;
5903 lvItem
.iItem
= nItem
;
5904 lvItem
.iSubItem
= 0;
5905 lvItem
.pszText
= szDispText
;
5906 lvItem
.cchTextMax
= DISP_TEXT_SIZE
;
5907 if (lvItem
.mask
&& !LISTVIEW_GetItemW(infoPtr
, &lvItem
)) return FALSE
;
5908 /* we got the state already up, simulate it here, to avoid a reget */
5909 if (uView
== LVS_ICON
&& (lprc
->left
!= LVIR_ICON
))
5911 lvItem
.mask
|= LVIF_STATE
;
5912 lvItem
.stateMask
= LVIS_FOCUSED
;
5913 lvItem
.state
= (oversizedBox
? LVIS_FOCUSED
: 0);
5916 if (uView
== LVS_REPORT
&& (infoPtr
->dwLvExStyle
& LVS_EX_FULLROWSELECT
) && lprc
->left
== LVIR_SELECTBOUNDS
)
5917 lprc
->left
= LVIR_BOUNDS
;
5921 LISTVIEW_GetItemMetrics(infoPtr
, &lvItem
, NULL
, NULL
, lprc
, NULL
, NULL
);
5925 LISTVIEW_GetItemMetrics(infoPtr
, &lvItem
, NULL
, NULL
, NULL
, NULL
, lprc
);
5929 LISTVIEW_GetItemMetrics(infoPtr
, &lvItem
, lprc
, NULL
, NULL
, NULL
, NULL
);
5932 case LVIR_SELECTBOUNDS
:
5933 LISTVIEW_GetItemMetrics(infoPtr
, &lvItem
, NULL
, lprc
, NULL
, NULL
, NULL
);
5937 WARN("Unknown value: %d\n", lprc
->left
);
5941 OffsetRect(lprc
, Position
.x
+ Origin
.x
, Position
.y
+ Origin
.y
);
5943 TRACE(" rect=%s\n", wine_dbgstr_rect(lprc
));
5950 * Retrieves the spacing between listview control items.
5953 * [I] infoPtr : valid pointer to the listview structure
5954 * [IO] lprc : rectangle to receive the output
5955 * on input, lprc->top = nSubItem
5956 * lprc->left = LVIR_ICON | LVIR_BOUNDS | LVIR_LABEL
5958 * NOTE: for subItem = 0, we should return the bounds of the _entire_ item,
5959 * not only those of the first column.
5960 * Fortunately, LISTVIEW_GetItemMetrics does the right thing.
5966 static BOOL
LISTVIEW_GetSubItemRect(const LISTVIEW_INFO
*infoPtr
, INT nItem
, LPRECT lprc
)
5972 if (!lprc
) return FALSE
;
5974 nColumn
= lprc
->top
;
5976 TRACE("(nItem=%d, nSubItem=%d)\n", nItem
, lprc
->top
);
5977 /* On WinNT, a subitem of '0' calls LISTVIEW_GetItemRect */
5979 return LISTVIEW_GetItemRect(infoPtr
, nItem
, lprc
);
5981 if ((infoPtr
->dwStyle
& LVS_TYPEMASK
) != LVS_REPORT
) return FALSE
;
5983 /* special case for header items */
5986 if (lprc
->left
!= LVIR_BOUNDS
)
5988 FIXME("Only LVIR_BOUNDS is implemented for header, got %d\n", lprc
->left
);
5992 if (infoPtr
->hwndHeader
)
5993 return Header_GetItemRect(infoPtr
->hwndHeader
, lprc
->top
, lprc
);
5996 memset(lprc
, 0, sizeof(RECT
));
6001 if (!LISTVIEW_GetItemPosition(infoPtr
, nItem
, &Position
)) return FALSE
;
6003 if (nColumn
< 0 || nColumn
>= DPA_GetPtrCount(infoPtr
->hdpaColumns
)) return FALSE
;
6006 lvItem
.iItem
= nItem
;
6007 lvItem
.iSubItem
= nColumn
;
6009 if (lvItem
.mask
&& !LISTVIEW_GetItemW(infoPtr
, &lvItem
)) return FALSE
;
6013 LISTVIEW_GetItemMetrics(infoPtr
, &lvItem
, NULL
, NULL
, lprc
, NULL
, NULL
);
6018 LISTVIEW_GetItemMetrics(infoPtr
, &lvItem
, lprc
, NULL
, NULL
, NULL
, NULL
);
6022 ERR("Unknown bounds=%d\n", lprc
->left
);
6026 OffsetRect(lprc
, Position
.x
, Position
.y
);
6033 * Retrieves the width of a label.
6036 * [I] infoPtr : valid pointer to the listview structure
6039 * SUCCESS : string width (in pixels)
6042 static INT
LISTVIEW_GetLabelWidth(const LISTVIEW_INFO
*infoPtr
, INT nItem
)
6044 WCHAR szDispText
[DISP_TEXT_SIZE
] = { '\0' };
6047 TRACE("(nItem=%d)\n", nItem
);
6049 lvItem
.mask
= LVIF_TEXT
;
6050 lvItem
.iItem
= nItem
;
6051 lvItem
.iSubItem
= 0;
6052 lvItem
.pszText
= szDispText
;
6053 lvItem
.cchTextMax
= DISP_TEXT_SIZE
;
6054 if (!LISTVIEW_GetItemW(infoPtr
, &lvItem
)) return 0;
6056 return LISTVIEW_GetStringWidthT(infoPtr
, lvItem
.pszText
, TRUE
);
6061 * Retrieves the spacing between listview control items.
6064 * [I] infoPtr : valid pointer to the listview structure
6065 * [I] bSmall : flag for small or large icon
6068 * Horizontal + vertical spacing
6070 static LONG
LISTVIEW_GetItemSpacing(const LISTVIEW_INFO
*infoPtr
, BOOL bSmall
)
6076 lResult
= MAKELONG(infoPtr
->iconSpacing
.cx
, infoPtr
->iconSpacing
.cy
);
6080 if ((infoPtr
->dwStyle
& LVS_TYPEMASK
) == LVS_ICON
)
6081 lResult
= MAKELONG(DEFAULT_COLUMN_WIDTH
, GetSystemMetrics(SM_CXSMICON
)+HEIGHT_PADDING
);
6083 lResult
= MAKELONG(infoPtr
->nItemWidth
, infoPtr
->nItemHeight
);
6090 * Retrieves the state of a listview control item.
6093 * [I] infoPtr : valid pointer to the listview structure
6094 * [I] nItem : item index
6095 * [I] uMask : state mask
6098 * State specified by the mask.
6100 static UINT
LISTVIEW_GetItemState(const LISTVIEW_INFO
*infoPtr
, INT nItem
, UINT uMask
)
6104 if (nItem
< 0 || nItem
>= infoPtr
->nItemCount
) return 0;
6106 lvItem
.iItem
= nItem
;
6107 lvItem
.iSubItem
= 0;
6108 lvItem
.mask
= LVIF_STATE
;
6109 lvItem
.stateMask
= uMask
;
6110 if (!LISTVIEW_GetItemW(infoPtr
, &lvItem
)) return 0;
6112 return lvItem
.state
& uMask
;
6117 * Retrieves the text of a listview control item or subitem.
6120 * [I] hwnd : window handle
6121 * [I] nItem : item index
6122 * [IO] lpLVItem : item information
6123 * [I] isW : TRUE if lpLVItem is Unicode
6126 * SUCCESS : string length
6129 static INT
LISTVIEW_GetItemTextT(const LISTVIEW_INFO
*infoPtr
, INT nItem
, LPLVITEMW lpLVItem
, BOOL isW
)
6131 if (!lpLVItem
|| nItem
< 0 || nItem
>= infoPtr
->nItemCount
) return 0;
6133 lpLVItem
->mask
= LVIF_TEXT
;
6134 lpLVItem
->iItem
= nItem
;
6135 if (!LISTVIEW_GetItemExtT(infoPtr
, lpLVItem
, isW
)) return 0;
6137 return textlenT(lpLVItem
->pszText
, isW
);
6142 * Searches for an item based on properties + relationships.
6145 * [I] infoPtr : valid pointer to the listview structure
6146 * [I] nItem : item index
6147 * [I] uFlags : relationship flag
6150 * SUCCESS : item index
6153 static INT
LISTVIEW_GetNextItem(const LISTVIEW_INFO
*infoPtr
, INT nItem
, UINT uFlags
)
6155 UINT uView
= infoPtr
->dwStyle
& LVS_TYPEMASK
;
6157 LVFINDINFOW lvFindInfo
;
6158 INT nCountPerColumn
;
6162 TRACE("nItem=%d, uFlags=%x, nItemCount=%d\n", nItem
, uFlags
, infoPtr
->nItemCount
);
6163 if (nItem
< -1 || nItem
>= infoPtr
->nItemCount
) return -1;
6165 ZeroMemory(&lvFindInfo
, sizeof(lvFindInfo
));
6167 if (uFlags
& LVNI_CUT
)
6170 if (uFlags
& LVNI_DROPHILITED
)
6171 uMask
|= LVIS_DROPHILITED
;
6173 if (uFlags
& LVNI_FOCUSED
)
6174 uMask
|= LVIS_FOCUSED
;
6176 if (uFlags
& LVNI_SELECTED
)
6177 uMask
|= LVIS_SELECTED
;
6179 /* if we're asked for the focused item, that's only one,
6180 * so it's worth optimizing */
6181 if (uFlags
& LVNI_FOCUSED
)
6183 if ((LISTVIEW_GetItemState(infoPtr
, infoPtr
->nFocusedItem
, uMask
) & uMask
) != uMask
) return -1;
6184 return (infoPtr
->nFocusedItem
== nItem
) ? -1 : infoPtr
->nFocusedItem
;
6187 if (uFlags
& LVNI_ABOVE
)
6189 if ((uView
== LVS_LIST
) || (uView
== LVS_REPORT
))
6194 if ((ListView_GetItemState(infoPtr
->hwndSelf
, nItem
, uMask
) & uMask
) == uMask
)
6200 /* Special case for autoarrange - move 'til the top of a list */
6201 if (is_autoarrange(infoPtr
))
6203 nCountPerRow
= LISTVIEW_GetCountPerRow(infoPtr
);
6204 while (nItem
- nCountPerRow
>= 0)
6206 nItem
-= nCountPerRow
;
6207 if ((LISTVIEW_GetItemState(infoPtr
, nItem
, uMask
) & uMask
) == uMask
)
6212 lvFindInfo
.flags
= LVFI_NEARESTXY
;
6213 lvFindInfo
.vkDirection
= VK_UP
;
6214 SendMessageW( infoPtr
->hwndSelf
, LVM_GETITEMPOSITION
, nItem
, (LPARAM
)&lvFindInfo
.pt
);
6215 while ((nItem
= ListView_FindItemW(infoPtr
->hwndSelf
, nItem
, &lvFindInfo
)) != -1)
6217 if ((ListView_GetItemState(infoPtr
->hwndSelf
, nItem
, uMask
) & uMask
) == uMask
)
6222 else if (uFlags
& LVNI_BELOW
)
6224 if ((uView
== LVS_LIST
) || (uView
== LVS_REPORT
))
6226 while (nItem
< infoPtr
->nItemCount
)
6229 if ((LISTVIEW_GetItemState(infoPtr
, nItem
, uMask
) & uMask
) == uMask
)
6235 /* Special case for autoarrange - move 'til the bottom of a list */
6236 if (is_autoarrange(infoPtr
))
6238 nCountPerRow
= LISTVIEW_GetCountPerRow(infoPtr
);
6239 while (nItem
+ nCountPerRow
< infoPtr
->nItemCount
)
6241 nItem
+= nCountPerRow
;
6242 if ((LISTVIEW_GetItemState(infoPtr
, nItem
, uMask
) & uMask
) == uMask
)
6247 lvFindInfo
.flags
= LVFI_NEARESTXY
;
6248 lvFindInfo
.vkDirection
= VK_DOWN
;
6249 SendMessageW( infoPtr
->hwndSelf
, LVM_GETITEMPOSITION
, nItem
, (LPARAM
)&lvFindInfo
.pt
);
6250 while ((nItem
= ListView_FindItemW(infoPtr
->hwndSelf
, nItem
, &lvFindInfo
)) != -1)
6252 if ((LISTVIEW_GetItemState(infoPtr
, nItem
, uMask
) & uMask
) == uMask
)
6257 else if (uFlags
& LVNI_TOLEFT
)
6259 if (uView
== LVS_LIST
)
6261 nCountPerColumn
= LISTVIEW_GetCountPerColumn(infoPtr
);
6262 while (nItem
- nCountPerColumn
>= 0)
6264 nItem
-= nCountPerColumn
;
6265 if ((LISTVIEW_GetItemState(infoPtr
, nItem
, uMask
) & uMask
) == uMask
)
6269 else if ((uView
== LVS_SMALLICON
) || (uView
== LVS_ICON
))
6271 /* Special case for autoarrange - move 'til the beginning of a row */
6272 if (is_autoarrange(infoPtr
))
6274 nCountPerRow
= LISTVIEW_GetCountPerRow(infoPtr
);
6275 while (nItem
% nCountPerRow
> 0)
6278 if ((LISTVIEW_GetItemState(infoPtr
, nItem
, uMask
) & uMask
) == uMask
)
6283 lvFindInfo
.flags
= LVFI_NEARESTXY
;
6284 lvFindInfo
.vkDirection
= VK_LEFT
;
6285 SendMessageW( infoPtr
->hwndSelf
, LVM_GETITEMPOSITION
, nItem
, (LPARAM
)&lvFindInfo
.pt
);
6286 while ((nItem
= ListView_FindItemW(infoPtr
->hwndSelf
, nItem
, &lvFindInfo
)) != -1)
6288 if ((ListView_GetItemState(infoPtr
->hwndSelf
, nItem
, uMask
) & uMask
) == uMask
)
6293 else if (uFlags
& LVNI_TORIGHT
)
6295 if (uView
== LVS_LIST
)
6297 nCountPerColumn
= LISTVIEW_GetCountPerColumn(infoPtr
);
6298 while (nItem
+ nCountPerColumn
< infoPtr
->nItemCount
)
6300 nItem
+= nCountPerColumn
;
6301 if ((ListView_GetItemState(infoPtr
->hwndSelf
, nItem
, uMask
) & uMask
) == uMask
)
6305 else if ((uView
== LVS_SMALLICON
) || (uView
== LVS_ICON
))
6307 /* Special case for autoarrange - move 'til the end of a row */
6308 if (is_autoarrange(infoPtr
))
6310 nCountPerRow
= LISTVIEW_GetCountPerRow(infoPtr
);
6311 while (nItem
% nCountPerRow
< nCountPerRow
- 1 )
6314 if ((LISTVIEW_GetItemState(infoPtr
, nItem
, uMask
) & uMask
) == uMask
)
6319 lvFindInfo
.flags
= LVFI_NEARESTXY
;
6320 lvFindInfo
.vkDirection
= VK_RIGHT
;
6321 SendMessageW( infoPtr
->hwndSelf
, LVM_GETITEMPOSITION
, nItem
, (LPARAM
)&lvFindInfo
.pt
);
6322 while ((nItem
= ListView_FindItemW(infoPtr
->hwndSelf
, nItem
, &lvFindInfo
)) != -1)
6324 if ((LISTVIEW_GetItemState(infoPtr
, nItem
, uMask
) & uMask
) == uMask
)
6333 /* search by index */
6334 for (i
= nItem
; i
< infoPtr
->nItemCount
; i
++)
6336 if ((LISTVIEW_GetItemState(infoPtr
, i
, uMask
) & uMask
) == uMask
)
6344 /* LISTVIEW_GetNumberOfWorkAreas */
6348 * Retrieves the origin coordinates when in icon or small icon display mode.
6351 * [I] infoPtr : valid pointer to the listview structure
6352 * [O] lpptOrigin : coordinate information
6357 static void LISTVIEW_GetOrigin(const LISTVIEW_INFO
*infoPtr
, LPPOINT lpptOrigin
)
6359 UINT uView
= infoPtr
->dwStyle
& LVS_TYPEMASK
;
6360 INT nHorzPos
= 0, nVertPos
= 0;
6361 SCROLLINFO scrollInfo
;
6363 scrollInfo
.cbSize
= sizeof(SCROLLINFO
);
6364 scrollInfo
.fMask
= SIF_POS
;
6366 if (GetScrollInfo(infoPtr
->hwndSelf
, SB_HORZ
, &scrollInfo
))
6367 nHorzPos
= scrollInfo
.nPos
;
6368 if (GetScrollInfo(infoPtr
->hwndSelf
, SB_VERT
, &scrollInfo
))
6369 nVertPos
= scrollInfo
.nPos
;
6371 TRACE("nHorzPos=%d, nVertPos=%d\n", nHorzPos
, nVertPos
);
6373 lpptOrigin
->x
= infoPtr
->rcList
.left
;
6374 lpptOrigin
->y
= infoPtr
->rcList
.top
;
6375 if (uView
== LVS_LIST
)
6376 nHorzPos
*= infoPtr
->nItemWidth
;
6377 else if (uView
== LVS_REPORT
)
6378 nVertPos
*= infoPtr
->nItemHeight
;
6380 lpptOrigin
->x
-= nHorzPos
;
6381 lpptOrigin
->y
-= nVertPos
;
6383 TRACE(" origin=%s\n", wine_dbgstr_point(lpptOrigin
));
6388 * Retrieves the width of a string.
6391 * [I] hwnd : window handle
6392 * [I] lpszText : text string to process
6393 * [I] isW : TRUE if lpszText is Unicode, FALSE otherwise
6396 * SUCCESS : string width (in pixels)
6399 static INT
LISTVIEW_GetStringWidthT(const LISTVIEW_INFO
*infoPtr
, LPCWSTR lpszText
, BOOL isW
)
6404 if (is_textT(lpszText
, isW
))
6406 HFONT hFont
= infoPtr
->hFont
? infoPtr
->hFont
: infoPtr
->hDefaultFont
;
6407 HDC hdc
= GetDC(infoPtr
->hwndSelf
);
6408 HFONT hOldFont
= SelectObject(hdc
, hFont
);
6411 GetTextExtentPointW(hdc
, lpszText
, lstrlenW(lpszText
), &stringSize
);
6413 GetTextExtentPointA(hdc
, (LPCSTR
)lpszText
, lstrlenA((LPCSTR
)lpszText
), &stringSize
);
6414 SelectObject(hdc
, hOldFont
);
6415 ReleaseDC(infoPtr
->hwndSelf
, hdc
);
6417 return stringSize
.cx
;
6422 * Determines which listview item is located at the specified position.
6425 * [I] infoPtr : valid pointer to the listview structure
6426 * [IO] lpht : hit test information
6427 * [I] subitem : fill out iSubItem.
6428 * [I] select : return the index only if the hit selects the item
6431 * (mm 20001022): We must not allow iSubItem to be touched, for
6432 * an app might pass only a structure with space up to iItem!
6433 * (MS Office 97 does that for instance in the file open dialog)
6436 * SUCCESS : item index
6439 static INT
LISTVIEW_HitTest(const LISTVIEW_INFO
*infoPtr
, LPLVHITTESTINFO lpht
, BOOL subitem
, BOOL select
)
6441 WCHAR szDispText
[DISP_TEXT_SIZE
] = { '\0' };
6442 UINT uView
= infoPtr
->dwStyle
& LVS_TYPEMASK
;
6443 RECT rcBox
, rcBounds
, rcState
, rcIcon
, rcLabel
, rcSearch
;
6444 POINT Origin
, Position
, opt
;
6449 TRACE("(pt=%s, subitem=%d, select=%d)\n", wine_dbgstr_point(&lpht
->pt
), subitem
, select
);
6453 if (subitem
) lpht
->iSubItem
= 0;
6455 if (infoPtr
->rcList
.left
> lpht
->pt
.x
)
6456 lpht
->flags
|= LVHT_TOLEFT
;
6457 else if (infoPtr
->rcList
.right
< lpht
->pt
.x
)
6458 lpht
->flags
|= LVHT_TORIGHT
;
6460 if (infoPtr
->rcList
.top
> lpht
->pt
.y
)
6461 lpht
->flags
|= LVHT_ABOVE
;
6462 else if (infoPtr
->rcList
.bottom
< lpht
->pt
.y
)
6463 lpht
->flags
|= LVHT_BELOW
;
6465 TRACE("lpht->flags=0x%x\n", lpht
->flags
);
6466 if (lpht
->flags
) return -1;
6468 lpht
->flags
|= LVHT_NOWHERE
;
6470 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
6472 /* first deal with the large items */
6473 rcSearch
.left
= lpht
->pt
.x
;
6474 rcSearch
.top
= lpht
->pt
.y
;
6475 rcSearch
.right
= rcSearch
.left
+ 1;
6476 rcSearch
.bottom
= rcSearch
.top
+ 1;
6478 iterator_frameditems(&i
, infoPtr
, &rcSearch
);
6479 iterator_next(&i
); /* go to first item in the sequence */
6481 iterator_destroy(&i
);
6483 TRACE("lpht->iItem=%d\n", iItem
);
6484 if (iItem
== -1) return -1;
6486 lvItem
.mask
= LVIF_STATE
| LVIF_TEXT
;
6487 if (uView
== LVS_REPORT
) lvItem
.mask
|= LVIF_INDENT
;
6488 lvItem
.stateMask
= LVIS_STATEIMAGEMASK
;
6489 if (uView
== LVS_ICON
) lvItem
.stateMask
|= LVIS_FOCUSED
;
6490 lvItem
.iItem
= iItem
;
6491 lvItem
.iSubItem
= 0;
6492 lvItem
.pszText
= szDispText
;
6493 lvItem
.cchTextMax
= DISP_TEXT_SIZE
;
6494 if (!LISTVIEW_GetItemW(infoPtr
, &lvItem
)) return -1;
6495 if (!infoPtr
->bFocus
) lvItem
.state
&= ~LVIS_FOCUSED
;
6497 LISTVIEW_GetItemMetrics(infoPtr
, &lvItem
, &rcBox
, NULL
, &rcIcon
, &rcState
, &rcLabel
);
6498 LISTVIEW_GetItemOrigin(infoPtr
, iItem
, &Position
);
6499 opt
.x
= lpht
->pt
.x
- Position
.x
- Origin
.x
;
6500 opt
.y
= lpht
->pt
.y
- Position
.y
- Origin
.y
;
6502 if (uView
== LVS_REPORT
)
6506 UnionRect(&rcBounds
, &rcIcon
, &rcLabel
);
6507 UnionRect(&rcBounds
, &rcBounds
, &rcState
);
6509 TRACE("rcBounds=%s\n", wine_dbgstr_rect(&rcBounds
));
6510 if (!PtInRect(&rcBounds
, opt
)) return -1;
6512 if (PtInRect(&rcIcon
, opt
))
6513 lpht
->flags
|= LVHT_ONITEMICON
;
6514 else if (PtInRect(&rcLabel
, opt
))
6515 lpht
->flags
|= LVHT_ONITEMLABEL
;
6516 else if (infoPtr
->himlState
&& STATEIMAGEINDEX(lvItem
.state
) && PtInRect(&rcState
, opt
))
6517 lpht
->flags
|= LVHT_ONITEMSTATEICON
;
6518 if (lpht
->flags
& LVHT_ONITEM
)
6519 lpht
->flags
&= ~LVHT_NOWHERE
;
6521 TRACE("lpht->flags=0x%x\n", lpht
->flags
);
6522 if (uView
== LVS_REPORT
&& subitem
)
6526 rcBounds
.right
= rcBounds
.left
;
6527 for (j
= 0; j
< DPA_GetPtrCount(infoPtr
->hdpaColumns
); j
++)
6529 rcBounds
.left
= rcBounds
.right
;
6530 rcBounds
.right
+= LISTVIEW_GetColumnWidth(infoPtr
, j
);
6531 if (PtInRect(&rcBounds
, opt
))
6539 if (select
&& !(uView
== LVS_REPORT
&&
6540 ((infoPtr
->dwLvExStyle
& LVS_EX_FULLROWSELECT
) ||
6541 (infoPtr
->dwStyle
& LVS_OWNERDRAWFIXED
))))
6543 if (uView
== LVS_REPORT
)
6545 UnionRect(&rcBounds
, &rcIcon
, &rcLabel
);
6546 UnionRect(&rcBounds
, &rcBounds
, &rcState
);
6548 if (!PtInRect(&rcBounds
, opt
)) iItem
= -1;
6550 return lpht
->iItem
= iItem
;
6554 /* LISTVIEW_InsertCompare: callback routine for comparing pszText members of the LV_ITEMS
6555 in a LISTVIEW on insert. Passed to DPA_Sort in LISTVIEW_InsertItem.
6556 This function should only be used for inserting items into a sorted list (LVM_INSERTITEM)
6557 and not during the processing of a LVM_SORTITEMS message. Applications should provide
6558 their own sort proc. when sending LVM_SORTITEMS.
6561 (remarks on LVITEM: LVM_INSERTITEM will insert the new item in the proper sort postion...
6563 LVS_SORTXXX must be specified,
6564 LVS_OWNERDRAW is not set,
6565 <item>.pszText is not LPSTR_TEXTCALLBACK.
6567 (LVS_SORT* flags): "For the LVS_SORTASCENDING... styles, item indices
6568 are sorted based on item text..."
6570 static INT WINAPI
LISTVIEW_InsertCompare( LPVOID first
, LPVOID second
, LPARAM lParam
)
6572 ITEM_INFO
* lv_first
= DPA_GetPtr( first
, 0 );
6573 ITEM_INFO
* lv_second
= DPA_GetPtr( second
, 0 );
6574 INT cmpv
= textcmpWT(lv_first
->hdr
.pszText
, lv_second
->hdr
.pszText
, TRUE
);
6576 /* if we're sorting descending, negate the return value */
6577 return (((const LISTVIEW_INFO
*)lParam
)->dwStyle
& LVS_SORTDESCENDING
) ? -cmpv
: cmpv
;
6582 * Inserts a new item in the listview control.
6585 * [I] infoPtr : valid pointer to the listview structure
6586 * [I] lpLVItem : item information
6587 * [I] isW : TRUE if lpLVItem is Unicode, FALSE if it's ANSI
6590 * SUCCESS : new item index
6593 static INT
LISTVIEW_InsertItemT(LISTVIEW_INFO
*infoPtr
, const LVITEMW
*lpLVItem
, BOOL isW
)
6595 UINT uView
= infoPtr
->dwStyle
& LVS_TYPEMASK
;
6600 BOOL is_sorted
, has_changed
;
6602 HWND hwndSelf
= infoPtr
->hwndSelf
;
6604 TRACE("(lpLVItem=%s, isW=%d)\n", debuglvitem_t(lpLVItem
, isW
), isW
);
6606 if (infoPtr
->dwStyle
& LVS_OWNERDATA
) return infoPtr
->nItemCount
++;
6608 /* make sure it's an item, and not a subitem; cannot insert a subitem */
6609 if (!lpLVItem
|| lpLVItem
->iSubItem
) return -1;
6611 if (!is_assignable_item(lpLVItem
, infoPtr
->dwStyle
)) return -1;
6613 if (!(lpItem
= Alloc(sizeof(ITEM_INFO
)))) return -1;
6615 /* insert item in listview control data structure */
6616 if ( !(hdpaSubItems
= DPA_Create(8)) ) goto fail
;
6617 if ( !DPA_SetPtr(hdpaSubItems
, 0, lpItem
) ) assert (FALSE
);
6619 is_sorted
= (infoPtr
->dwStyle
& (LVS_SORTASCENDING
| LVS_SORTDESCENDING
)) &&
6620 !(infoPtr
->dwStyle
& LVS_OWNERDRAWFIXED
) && (LPSTR_TEXTCALLBACKW
!= lpLVItem
->pszText
);
6622 if (lpLVItem
->iItem
< 0 && !is_sorted
) return -1;
6624 nItem
= is_sorted
? infoPtr
->nItemCount
: min(lpLVItem
->iItem
, infoPtr
->nItemCount
);
6625 TRACE(" inserting at %d, sorted=%d, count=%d, iItem=%d\n", nItem
, is_sorted
, infoPtr
->nItemCount
, lpLVItem
->iItem
);
6626 nItem
= DPA_InsertPtr( infoPtr
->hdpaItems
, nItem
, hdpaSubItems
);
6627 if (nItem
== -1) goto fail
;
6628 infoPtr
->nItemCount
++;
6630 /* shift indices first so they don't get tangled */
6631 LISTVIEW_ShiftIndices(infoPtr
, nItem
, 1);
6633 /* set the item attributes */
6634 if (lpLVItem
->mask
& (LVIF_GROUPID
|LVIF_COLUMNS
))
6636 /* full size structure expected - _WIN32IE >= 0x560 */
6639 else if (lpLVItem
->mask
& LVIF_INDENT
)
6641 /* indent member expected - _WIN32IE >= 0x300 */
6642 memcpy(&item
, lpLVItem
, offsetof( LVITEMW
, iGroupId
));
6646 /* minimal structure expected */
6647 memcpy(&item
, lpLVItem
, offsetof( LVITEMW
, iIndent
));
6650 if (infoPtr
->dwLvExStyle
& LVS_EX_CHECKBOXES
)
6652 item
.mask
|= LVIF_STATE
;
6653 item
.stateMask
|= LVIS_STATEIMAGEMASK
;
6654 item
.state
&= ~LVIS_STATEIMAGEMASK
;
6655 item
.state
|= INDEXTOSTATEIMAGEMASK(1);
6657 if (!set_main_item(infoPtr
, &item
, TRUE
, isW
, &has_changed
)) goto undo
;
6659 /* if we're sorted, sort the list, and update the index */
6662 DPA_Sort( infoPtr
->hdpaItems
, LISTVIEW_InsertCompare
, (LPARAM
)infoPtr
);
6663 nItem
= DPA_GetPtrIndex( infoPtr
->hdpaItems
, hdpaSubItems
);
6664 assert(nItem
!= -1);
6667 /* make room for the position, if we are in the right mode */
6668 if ((uView
== LVS_SMALLICON
) || (uView
== LVS_ICON
))
6670 if (DPA_InsertPtr(infoPtr
->hdpaPosX
, nItem
, 0) == -1)
6672 if (DPA_InsertPtr(infoPtr
->hdpaPosY
, nItem
, 0) == -1)
6674 DPA_DeletePtr(infoPtr
->hdpaPosX
, nItem
);
6679 /* send LVN_INSERTITEM notification */
6680 ZeroMemory(&nmlv
, sizeof(NMLISTVIEW
));
6682 nmlv
.lParam
= lpItem
->lParam
;
6683 notify_listview(infoPtr
, LVN_INSERTITEM
, &nmlv
);
6684 if (!IsWindow(hwndSelf
))
6687 /* align items (set position of each item) */
6688 if ((uView
== LVS_SMALLICON
|| uView
== LVS_ICON
))
6692 if (infoPtr
->dwStyle
& LVS_ALIGNLEFT
)
6693 LISTVIEW_NextIconPosLeft(infoPtr
, &pt
);
6695 LISTVIEW_NextIconPosTop(infoPtr
, &pt
);
6697 LISTVIEW_MoveIconTo(infoPtr
, nItem
, &pt
, TRUE
);
6700 /* now is the invalidation fun */
6701 LISTVIEW_ScrollOnInsert(infoPtr
, nItem
, 1);
6705 LISTVIEW_ShiftIndices(infoPtr
, nItem
, -1);
6706 DPA_DeletePtr(infoPtr
->hdpaItems
, nItem
);
6707 infoPtr
->nItemCount
--;
6709 DPA_DeletePtr(hdpaSubItems
, 0);
6710 DPA_Destroy (hdpaSubItems
);
6717 * Redraws a range of items.
6720 * [I] infoPtr : valid pointer to the listview structure
6721 * [I] nFirst : first item
6722 * [I] nLast : last item
6728 static BOOL
LISTVIEW_RedrawItems(const LISTVIEW_INFO
*infoPtr
, INT nFirst
, INT nLast
)
6732 if (nLast
< nFirst
|| min(nFirst
, nLast
) < 0 ||
6733 max(nFirst
, nLast
) >= infoPtr
->nItemCount
)
6736 for (i
= nFirst
; i
<= nLast
; i
++)
6737 LISTVIEW_InvalidateItem(infoPtr
, i
);
6744 * Scroll the content of a listview.
6747 * [I] infoPtr : valid pointer to the listview structure
6748 * [I] dx : horizontal scroll amount in pixels
6749 * [I] dy : vertical scroll amount in pixels
6756 * If the control is in report mode (LVS_REPORT) the control can
6757 * be scrolled only in line increments. "dy" will be rounded to the
6758 * nearest number of pixels that are a whole line. Ex: if line height
6759 * is 16 and an 8 is passed, the list will be scrolled by 16. If a 7
6760 * is passed, then the scroll will be 0. (per MSDN 7/2002)
6762 * For: (per experimentation with native control and CSpy ListView)
6763 * LVS_ICON dy=1 = 1 pixel (vertical only)
6765 * LVS_SMALLICON dy=1 = 1 pixel (vertical only)
6767 * LVS_LIST dx=1 = 1 column (horizontal only)
6768 * but will only scroll 1 column per message
6769 * no matter what the value.
6770 * dy must be 0 or FALSE returned.
6771 * LVS_REPORT dx=1 = 1 pixel
6775 static BOOL
LISTVIEW_Scroll(LISTVIEW_INFO
*infoPtr
, INT dx
, INT dy
)
6777 switch(infoPtr
->dwStyle
& LVS_TYPEMASK
) {
6779 dy
+= (dy
< 0 ? -1 : 1) * infoPtr
->nItemHeight
/2;
6780 dy
/= infoPtr
->nItemHeight
;
6783 if (dy
!= 0) return FALSE
;
6790 if (dx
!= 0) LISTVIEW_HScroll(infoPtr
, SB_INTERNAL
, dx
, 0);
6791 if (dy
!= 0) LISTVIEW_VScroll(infoPtr
, SB_INTERNAL
, dy
, 0);
6798 * Sets the background color.
6801 * [I] infoPtr : valid pointer to the listview structure
6802 * [I] clrBk : background color
6808 static BOOL
LISTVIEW_SetBkColor(LISTVIEW_INFO
*infoPtr
, COLORREF clrBk
)
6810 TRACE("(clrBk=%x)\n", clrBk
);
6812 if(infoPtr
->clrBk
!= clrBk
) {
6813 if (infoPtr
->clrBk
!= CLR_NONE
) DeleteObject(infoPtr
->hBkBrush
);
6814 infoPtr
->clrBk
= clrBk
;
6815 if (clrBk
== CLR_NONE
)
6816 infoPtr
->hBkBrush
= (HBRUSH
)GetClassLongPtrW(infoPtr
->hwndSelf
, GCLP_HBRBACKGROUND
);
6818 infoPtr
->hBkBrush
= CreateSolidBrush(clrBk
);
6819 LISTVIEW_InvalidateList(infoPtr
);
6825 /* LISTVIEW_SetBkImage */
6827 /*** Helper for {Insert,Set}ColumnT *only* */
6828 static void column_fill_hditem(const LISTVIEW_INFO
*infoPtr
, HDITEMW
*lphdi
, INT nColumn
,
6829 const LVCOLUMNW
*lpColumn
, BOOL isW
)
6831 if (lpColumn
->mask
& LVCF_FMT
)
6833 /* format member is valid */
6834 lphdi
->mask
|= HDI_FORMAT
;
6836 /* set text alignment (leftmost column must be left-aligned) */
6837 if (nColumn
== 0 || (lpColumn
->fmt
& LVCFMT_JUSTIFYMASK
) == LVCFMT_LEFT
)
6838 lphdi
->fmt
|= HDF_LEFT
;
6839 else if ((lpColumn
->fmt
& LVCFMT_JUSTIFYMASK
) == LVCFMT_RIGHT
)
6840 lphdi
->fmt
|= HDF_RIGHT
;
6841 else if ((lpColumn
->fmt
& LVCFMT_JUSTIFYMASK
) == LVCFMT_CENTER
)
6842 lphdi
->fmt
|= HDF_CENTER
;
6844 if (lpColumn
->fmt
& LVCFMT_BITMAP_ON_RIGHT
)
6845 lphdi
->fmt
|= HDF_BITMAP_ON_RIGHT
;
6847 if (lpColumn
->fmt
& LVCFMT_COL_HAS_IMAGES
)
6849 lphdi
->fmt
|= HDF_IMAGE
;
6850 lphdi
->iImage
= I_IMAGECALLBACK
;
6854 if (lpColumn
->mask
& LVCF_WIDTH
)
6856 lphdi
->mask
|= HDI_WIDTH
;
6857 if(lpColumn
->cx
== LVSCW_AUTOSIZE_USEHEADER
)
6859 /* make it fill the remainder of the controls width */
6863 for(item_index
= 0; item_index
< (nColumn
- 1); item_index
++)
6865 LISTVIEW_GetHeaderRect(infoPtr
, item_index
, &rcHeader
);
6866 lphdi
->cxy
+= rcHeader
.right
- rcHeader
.left
;
6869 /* retrieve the layout of the header */
6870 GetClientRect(infoPtr
->hwndSelf
, &rcHeader
);
6871 TRACE("start cxy=%d rcHeader=%s\n", lphdi
->cxy
, wine_dbgstr_rect(&rcHeader
));
6873 lphdi
->cxy
= (rcHeader
.right
- rcHeader
.left
) - lphdi
->cxy
;
6876 lphdi
->cxy
= lpColumn
->cx
;
6879 if (lpColumn
->mask
& LVCF_TEXT
)
6881 lphdi
->mask
|= HDI_TEXT
| HDI_FORMAT
;
6882 lphdi
->fmt
|= HDF_STRING
;
6883 lphdi
->pszText
= lpColumn
->pszText
;
6884 lphdi
->cchTextMax
= textlenT(lpColumn
->pszText
, isW
);
6887 if (lpColumn
->mask
& LVCF_IMAGE
)
6889 lphdi
->mask
|= HDI_IMAGE
;
6890 lphdi
->iImage
= lpColumn
->iImage
;
6893 if (lpColumn
->mask
& LVCF_ORDER
)
6895 lphdi
->mask
|= HDI_ORDER
;
6896 lphdi
->iOrder
= lpColumn
->iOrder
;
6903 * Inserts a new column.
6906 * [I] infoPtr : valid pointer to the listview structure
6907 * [I] nColumn : column index
6908 * [I] lpColumn : column information
6909 * [I] isW : TRUE if lpColumn is Unicode, FALSE otherwise
6912 * SUCCESS : new column index
6915 static INT
LISTVIEW_InsertColumnT(LISTVIEW_INFO
*infoPtr
, INT nColumn
,
6916 const LVCOLUMNW
*lpColumn
, BOOL isW
)
6918 COLUMN_INFO
*lpColumnInfo
;
6921 UINT uView
= infoPtr
->dwStyle
& LVS_TYPEMASK
;
6923 TRACE("(nColumn=%d, lpColumn=%s, isW=%d)\n", nColumn
, debuglvcolumn_t(lpColumn
, isW
), isW
);
6925 if (!lpColumn
|| nColumn
< 0) return -1;
6926 nColumn
= min(nColumn
, DPA_GetPtrCount(infoPtr
->hdpaColumns
));
6928 ZeroMemory(&hdi
, sizeof(HDITEMW
));
6929 column_fill_hditem(infoPtr
, &hdi
, nColumn
, lpColumn
, isW
);
6932 * A mask not including LVCF_WIDTH turns into a mask of width, width 10
6933 * (can be seen in SPY) otherwise column never gets added.
6935 if (!(lpColumn
->mask
& LVCF_WIDTH
)) {
6936 hdi
.mask
|= HDI_WIDTH
;
6941 * when the iSubItem is available Windows copies it to the header lParam. It seems
6942 * to happen only in LVM_INSERTCOLUMN - not in LVM_SETCOLUMN
6944 if (lpColumn
->mask
& LVCF_SUBITEM
)
6946 hdi
.mask
|= HDI_LPARAM
;
6947 hdi
.lParam
= lpColumn
->iSubItem
;
6950 /* create header if not present */
6951 LISTVIEW_CreateHeader(infoPtr
);
6952 if (!(LVS_NOCOLUMNHEADER
& infoPtr
->dwStyle
) &&
6953 (LVS_REPORT
== uView
) && (WS_VISIBLE
& infoPtr
->dwStyle
))
6955 ShowWindow(infoPtr
->hwndHeader
, SW_SHOWNORMAL
);
6958 /* insert item in header control */
6959 nNewColumn
= SendMessageW(infoPtr
->hwndHeader
,
6960 isW
? HDM_INSERTITEMW
: HDM_INSERTITEMA
,
6961 (WPARAM
)nColumn
, (LPARAM
)&hdi
);
6962 if (nNewColumn
== -1) return -1;
6963 if (nNewColumn
!= nColumn
) ERR("nColumn=%d, nNewColumn=%d\n", nColumn
, nNewColumn
);
6965 /* create our own column info */
6966 if (!(lpColumnInfo
= Alloc(sizeof(COLUMN_INFO
)))) goto fail
;
6967 if (DPA_InsertPtr(infoPtr
->hdpaColumns
, nNewColumn
, lpColumnInfo
) == -1) goto fail
;
6969 if (lpColumn
->mask
& LVCF_FMT
) lpColumnInfo
->fmt
= lpColumn
->fmt
;
6970 if (!Header_GetItemRect(infoPtr
->hwndHeader
, nNewColumn
, &lpColumnInfo
->rcHeader
)) goto fail
;
6972 /* now we have to actually adjust the data */
6973 if (!(infoPtr
->dwStyle
& LVS_OWNERDATA
) && infoPtr
->nItemCount
> 0)
6975 SUBITEM_INFO
*lpSubItem
;
6979 for (nItem
= 0; nItem
< infoPtr
->nItemCount
; nItem
++)
6981 hdpaSubItems
= DPA_GetPtr(infoPtr
->hdpaItems
, nItem
);
6982 for (i
= 1; i
< DPA_GetPtrCount(hdpaSubItems
); i
++)
6984 lpSubItem
= DPA_GetPtr(hdpaSubItems
, i
);
6985 if (lpSubItem
->iSubItem
>= nNewColumn
)
6986 lpSubItem
->iSubItem
++;
6991 /* make space for the new column */
6992 LISTVIEW_ScrollColumns(infoPtr
, nNewColumn
+ 1, lpColumnInfo
->rcHeader
.right
- lpColumnInfo
->rcHeader
.left
);
6993 LISTVIEW_UpdateItemSize(infoPtr
);
6998 if (nNewColumn
!= -1) SendMessageW(infoPtr
->hwndHeader
, HDM_DELETEITEM
, nNewColumn
, 0);
7001 DPA_DeletePtr(infoPtr
->hdpaColumns
, nNewColumn
);
7009 * Sets the attributes of a header item.
7012 * [I] infoPtr : valid pointer to the listview structure
7013 * [I] nColumn : column index
7014 * [I] lpColumn : column attributes
7015 * [I] isW: if TRUE, then lpColumn is a LPLVCOLUMNW, else it is a LPLVCOLUMNA
7021 static BOOL
LISTVIEW_SetColumnT(const LISTVIEW_INFO
*infoPtr
, INT nColumn
,
7022 const LVCOLUMNW
*lpColumn
, BOOL isW
)
7024 HDITEMW hdi
, hdiget
;
7027 TRACE("(nColumn=%d, lpColumn=%s, isW=%d)\n", nColumn
, debuglvcolumn_t(lpColumn
, isW
), isW
);
7029 if (!lpColumn
|| nColumn
< 0 || nColumn
>= DPA_GetPtrCount(infoPtr
->hdpaColumns
)) return FALSE
;
7031 ZeroMemory(&hdi
, sizeof(HDITEMW
));
7032 if (lpColumn
->mask
& LVCF_FMT
)
7034 hdi
.mask
|= HDI_FORMAT
;
7035 hdiget
.mask
= HDI_FORMAT
;
7036 if (Header_GetItemW(infoPtr
->hwndHeader
, nColumn
, &hdiget
))
7037 hdi
.fmt
= hdiget
.fmt
& HDF_STRING
;
7039 column_fill_hditem(infoPtr
, &hdi
, nColumn
, lpColumn
, isW
);
7041 /* set header item attributes */
7042 bResult
= SendMessageW(infoPtr
->hwndHeader
, isW
? HDM_SETITEMW
: HDM_SETITEMA
, (WPARAM
)nColumn
, (LPARAM
)&hdi
);
7043 if (!bResult
) return FALSE
;
7045 if (lpColumn
->mask
& LVCF_FMT
)
7047 COLUMN_INFO
*lpColumnInfo
= LISTVIEW_GetColumnInfo(infoPtr
, nColumn
);
7048 int oldFmt
= lpColumnInfo
->fmt
;
7050 lpColumnInfo
->fmt
= lpColumn
->fmt
;
7051 if ((oldFmt
^ lpColumn
->fmt
) & (LVCFMT_JUSTIFYMASK
| LVCFMT_IMAGE
))
7053 UINT uView
= infoPtr
->dwStyle
& LVS_TYPEMASK
;
7054 if (uView
== LVS_REPORT
) LISTVIEW_InvalidateColumn(infoPtr
, nColumn
);
7063 * Sets the column order array
7066 * [I] infoPtr : valid pointer to the listview structure
7067 * [I] iCount : number of elements in column order array
7068 * [I] lpiArray : pointer to column order array
7074 static BOOL
LISTVIEW_SetColumnOrderArray(const LISTVIEW_INFO
*infoPtr
, INT iCount
, const INT
*lpiArray
)
7076 FIXME("iCount %d lpiArray %p\n", iCount
, lpiArray
);
7087 * Sets the width of a column
7090 * [I] infoPtr : valid pointer to the listview structure
7091 * [I] nColumn : column index
7092 * [I] cx : column width
7098 static BOOL
LISTVIEW_SetColumnWidth(LISTVIEW_INFO
*infoPtr
, INT nColumn
, INT cx
)
7100 UINT uView
= infoPtr
->dwStyle
& LVS_TYPEMASK
;
7101 WCHAR szDispText
[DISP_TEXT_SIZE
] = { 0 };
7105 TRACE("(nColumn=%d, cx=%d\n", nColumn
, cx
);
7107 /* set column width only if in report or list mode */
7108 if (uView
!= LVS_REPORT
&& uView
!= LVS_LIST
) return FALSE
;
7110 /* take care of invalid cx values */
7111 if(uView
== LVS_REPORT
&& cx
< -2) cx
= LVSCW_AUTOSIZE
;
7112 else if (uView
== LVS_LIST
&& cx
< 1) return FALSE
;
7114 /* resize all columns if in LVS_LIST mode */
7115 if(uView
== LVS_LIST
)
7117 infoPtr
->nItemWidth
= cx
;
7118 LISTVIEW_InvalidateList(infoPtr
);
7122 if (nColumn
< 0 || nColumn
>= DPA_GetPtrCount(infoPtr
->hdpaColumns
)) return FALSE
;
7124 if (cx
== LVSCW_AUTOSIZE
|| (cx
== LVSCW_AUTOSIZE_USEHEADER
&& nColumn
< DPA_GetPtrCount(infoPtr
->hdpaColumns
) -1))
7129 lvItem
.mask
= LVIF_TEXT
;
7131 lvItem
.iSubItem
= nColumn
;
7132 lvItem
.pszText
= szDispText
;
7133 lvItem
.cchTextMax
= DISP_TEXT_SIZE
;
7134 for (; lvItem
.iItem
< infoPtr
->nItemCount
; lvItem
.iItem
++)
7136 if (!LISTVIEW_GetItemW(infoPtr
, &lvItem
)) continue;
7137 nLabelWidth
= LISTVIEW_GetStringWidthT(infoPtr
, lvItem
.pszText
, TRUE
);
7138 if (max_cx
< nLabelWidth
) max_cx
= nLabelWidth
;
7140 if (infoPtr
->himlSmall
&& (nColumn
== 0 || (LISTVIEW_GetColumnInfo(infoPtr
, nColumn
)->fmt
& LVCFMT_IMAGE
)))
7141 max_cx
+= infoPtr
->iconSize
.cx
;
7142 max_cx
+= TRAILING_LABEL_PADDING
;
7145 /* autosize based on listview items width */
7146 if(cx
== LVSCW_AUTOSIZE
)
7148 else if(cx
== LVSCW_AUTOSIZE_USEHEADER
)
7150 /* if iCol is the last column make it fill the remainder of the controls width */
7151 if(nColumn
== DPA_GetPtrCount(infoPtr
->hdpaColumns
) - 1)
7156 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
7157 LISTVIEW_GetHeaderRect(infoPtr
, nColumn
, &rcHeader
);
7159 cx
= infoPtr
->rcList
.right
- Origin
.x
- rcHeader
.left
;
7163 /* Despite what the MS docs say, if this is not the last
7164 column, then MS resizes the column to the width of the
7165 largest text string in the column, including headers
7166 and items. This is different from LVSCW_AUTOSIZE in that
7167 LVSCW_AUTOSIZE ignores the header string length. */
7170 /* retrieve header text */
7171 hdi
.mask
= HDI_TEXT
;
7172 hdi
.cchTextMax
= DISP_TEXT_SIZE
;
7173 hdi
.pszText
= szDispText
;
7174 if (Header_GetItemW(infoPtr
->hwndHeader
, nColumn
, &hdi
))
7176 HDC hdc
= GetDC(infoPtr
->hwndSelf
);
7177 HFONT old_font
= SelectObject(hdc
, (HFONT
)SendMessageW(infoPtr
->hwndHeader
, WM_GETFONT
, 0, 0));
7180 if (GetTextExtentPoint32W(hdc
, hdi
.pszText
, lstrlenW(hdi
.pszText
), &size
))
7181 cx
= size
.cx
+ TRAILING_HEADER_PADDING
;
7182 /* FIXME: Take into account the header image, if one is present */
7183 SelectObject(hdc
, old_font
);
7184 ReleaseDC(infoPtr
->hwndSelf
, hdc
);
7186 cx
= max (cx
, max_cx
);
7190 if (cx
< 0) return FALSE
;
7192 /* call header to update the column change */
7193 hdi
.mask
= HDI_WIDTH
;
7195 TRACE("hdi.cxy=%d\n", hdi
.cxy
);
7196 return Header_SetItemW(infoPtr
->hwndHeader
, nColumn
, &hdi
);
7200 * Creates the checkbox imagelist. Helper for LISTVIEW_SetExtendedListViewStyle
7203 static HIMAGELIST
LISTVIEW_CreateCheckBoxIL(const LISTVIEW_INFO
*infoPtr
)
7206 HBITMAP hbm_im
, hbm_mask
, hbm_orig
;
7208 HBRUSH hbr_white
= GetStockObject(WHITE_BRUSH
);
7209 HBRUSH hbr_black
= GetStockObject(BLACK_BRUSH
);
7212 himl
= ImageList_Create(GetSystemMetrics(SM_CXSMICON
), GetSystemMetrics(SM_CYSMICON
),
7213 ILC_COLOR
| ILC_MASK
, 2, 2);
7214 hdc_wnd
= GetDC(infoPtr
->hwndSelf
);
7215 hdc
= CreateCompatibleDC(hdc_wnd
);
7216 hbm_im
= CreateCompatibleBitmap(hdc_wnd
, GetSystemMetrics(SM_CXSMICON
), GetSystemMetrics(SM_CYSMICON
));
7217 hbm_mask
= CreateBitmap(GetSystemMetrics(SM_CXSMICON
), GetSystemMetrics(SM_CYSMICON
), 1, 1, NULL
);
7218 ReleaseDC(infoPtr
->hwndSelf
, hdc_wnd
);
7220 rc
.left
= rc
.top
= 0;
7221 rc
.right
= GetSystemMetrics(SM_CXSMICON
);
7222 rc
.bottom
= GetSystemMetrics(SM_CYSMICON
);
7224 hbm_orig
= SelectObject(hdc
, hbm_mask
);
7225 FillRect(hdc
, &rc
, hbr_white
);
7226 InflateRect(&rc
, -2, -2);
7227 FillRect(hdc
, &rc
, hbr_black
);
7229 SelectObject(hdc
, hbm_im
);
7230 DrawFrameControl(hdc
, &rc
, DFC_BUTTON
, DFCS_BUTTONCHECK
| DFCS_MONO
);
7231 SelectObject(hdc
, hbm_orig
);
7232 ImageList_Add(himl
, hbm_im
, hbm_mask
);
7234 SelectObject(hdc
, hbm_im
);
7235 DrawFrameControl(hdc
, &rc
, DFC_BUTTON
, DFCS_BUTTONCHECK
| DFCS_MONO
| DFCS_CHECKED
);
7236 SelectObject(hdc
, hbm_orig
);
7237 ImageList_Add(himl
, hbm_im
, hbm_mask
);
7239 DeleteObject(hbm_mask
);
7240 DeleteObject(hbm_im
);
7248 * Sets the extended listview style.
7251 * [I] infoPtr : valid pointer to the listview structure
7253 * [I] dwStyle : style
7256 * SUCCESS : previous style
7259 static DWORD
LISTVIEW_SetExtendedListViewStyle(LISTVIEW_INFO
*infoPtr
, DWORD dwMask
, DWORD dwExStyle
)
7261 DWORD dwOldExStyle
= infoPtr
->dwLvExStyle
;
7265 infoPtr
->dwLvExStyle
= (dwOldExStyle
& ~dwMask
) | (dwExStyle
& dwMask
);
7267 infoPtr
->dwLvExStyle
= dwExStyle
;
7269 if((infoPtr
->dwLvExStyle
^ dwOldExStyle
) & LVS_EX_CHECKBOXES
)
7271 HIMAGELIST himl
= 0;
7272 if(infoPtr
->dwLvExStyle
& LVS_EX_CHECKBOXES
)
7275 item
.mask
= LVIF_STATE
;
7276 item
.stateMask
= LVIS_STATEIMAGEMASK
;
7277 item
.state
= INDEXTOSTATEIMAGEMASK(1);
7278 LISTVIEW_SetItemState(infoPtr
, -1, &item
);
7280 himl
= LISTVIEW_CreateCheckBoxIL(infoPtr
);
7282 LISTVIEW_SetImageList(infoPtr
, LVSIL_STATE
, himl
);
7285 if((infoPtr
->dwLvExStyle
^ dwOldExStyle
) & LVS_EX_HEADERDRAGDROP
)
7289 /* if not already created */
7290 LISTVIEW_CreateHeader(infoPtr
);
7292 dwStyle
= GetWindowLongW(infoPtr
->hwndHeader
, GWL_STYLE
);
7293 if (infoPtr
->dwLvExStyle
& LVS_EX_HEADERDRAGDROP
)
7294 dwStyle
|= HDS_DRAGDROP
;
7296 dwStyle
&= ~HDS_DRAGDROP
;
7297 SetWindowLongW(infoPtr
->hwndHeader
, GWL_STYLE
, dwStyle
);
7300 /* GRIDLINES adds decoration at top so changes sizes */
7301 if((infoPtr
->dwLvExStyle
^ dwOldExStyle
) & LVS_EX_GRIDLINES
)
7303 LISTVIEW_UpdateSize(infoPtr
);
7307 LISTVIEW_InvalidateList(infoPtr
);
7308 return dwOldExStyle
;
7313 * Sets the new hot cursor used during hot tracking and hover selection.
7316 * [I] infoPtr : valid pointer to the listview structure
7317 * [I] hCursor : the new hot cursor handle
7320 * Returns the previous hot cursor
7322 static HCURSOR
LISTVIEW_SetHotCursor(LISTVIEW_INFO
*infoPtr
, HCURSOR hCursor
)
7324 HCURSOR oldCursor
= infoPtr
->hHotCursor
;
7326 infoPtr
->hHotCursor
= hCursor
;
7334 * Sets the hot item index.
7337 * [I] infoPtr : valid pointer to the listview structure
7338 * [I] iIndex : index
7341 * SUCCESS : previous hot item index
7342 * FAILURE : -1 (no hot item)
7344 static INT
LISTVIEW_SetHotItem(LISTVIEW_INFO
*infoPtr
, INT iIndex
)
7346 INT iOldIndex
= infoPtr
->nHotItem
;
7348 infoPtr
->nHotItem
= iIndex
;
7356 * Sets the amount of time the cursor must hover over an item before it is selected.
7359 * [I] infoPtr : valid pointer to the listview structure
7360 * [I] dwHoverTime : hover time, if -1 the hover time is set to the default
7363 * Returns the previous hover time
7365 static DWORD
LISTVIEW_SetHoverTime(LISTVIEW_INFO
*infoPtr
, DWORD dwHoverTime
)
7367 DWORD oldHoverTime
= infoPtr
->dwHoverTime
;
7369 infoPtr
->dwHoverTime
= dwHoverTime
;
7371 return oldHoverTime
;
7376 * Sets spacing for icons of LVS_ICON style.
7379 * [I] infoPtr : valid pointer to the listview structure
7380 * [I] cx : horizontal spacing (-1 = system spacing, 0 = autosize)
7381 * [I] cy : vertical spacing (-1 = system spacing, 0 = autosize)
7384 * MAKELONG(oldcx, oldcy)
7386 static DWORD
LISTVIEW_SetIconSpacing(LISTVIEW_INFO
*infoPtr
, INT cx
, INT cy
)
7388 DWORD oldspacing
= MAKELONG(infoPtr
->iconSpacing
.cx
, infoPtr
->iconSpacing
.cy
);
7389 UINT uView
= infoPtr
->dwStyle
& LVS_TYPEMASK
;
7391 TRACE("requested=(%d,%d)\n", cx
, cy
);
7393 /* this is supported only for LVS_ICON style */
7394 if (uView
!= LVS_ICON
) return oldspacing
;
7396 /* set to defaults, if instructed to */
7397 if (cx
== -1) cx
= GetSystemMetrics(SM_CXICONSPACING
);
7398 if (cy
== -1) cy
= GetSystemMetrics(SM_CYICONSPACING
);
7400 /* if 0 then compute width
7401 * FIXME: Should scan each item and determine max width of
7402 * icon or label, then make that the width */
7404 cx
= infoPtr
->iconSpacing
.cx
;
7406 /* if 0 then compute height */
7408 cy
= infoPtr
->iconSize
.cy
+ 2 * infoPtr
->ntmHeight
+
7409 ICON_BOTTOM_PADDING
+ ICON_TOP_PADDING
+ LABEL_VERT_PADDING
;
7412 infoPtr
->iconSpacing
.cx
= cx
;
7413 infoPtr
->iconSpacing
.cy
= cy
;
7415 TRACE("old=(%d,%d), new=(%d,%d), iconSize=(%d,%d), ntmH=%d\n",
7416 LOWORD(oldspacing
), HIWORD(oldspacing
), cx
, cy
,
7417 infoPtr
->iconSize
.cx
, infoPtr
->iconSize
.cy
,
7418 infoPtr
->ntmHeight
);
7420 /* these depend on the iconSpacing */
7421 LISTVIEW_UpdateItemSize(infoPtr
);
7426 static inline void set_icon_size(SIZE
*size
, HIMAGELIST himl
, BOOL small
)
7430 if (himl
&& ImageList_GetIconSize(himl
, &cx
, &cy
))
7437 size
->cx
= GetSystemMetrics(small
? SM_CXSMICON
: SM_CXICON
);
7438 size
->cy
= GetSystemMetrics(small
? SM_CYSMICON
: SM_CYICON
);
7447 * [I] infoPtr : valid pointer to the listview structure
7448 * [I] nType : image list type
7449 * [I] himl : image list handle
7452 * SUCCESS : old image list
7455 static HIMAGELIST
LISTVIEW_SetImageList(LISTVIEW_INFO
*infoPtr
, INT nType
, HIMAGELIST himl
)
7457 UINT uView
= infoPtr
->dwStyle
& LVS_TYPEMASK
;
7458 INT oldHeight
= infoPtr
->nItemHeight
;
7459 HIMAGELIST himlOld
= 0;
7461 TRACE("(nType=%d, himl=%p\n", nType
, himl
);
7466 himlOld
= infoPtr
->himlNormal
;
7467 infoPtr
->himlNormal
= himl
;
7468 if (uView
== LVS_ICON
) set_icon_size(&infoPtr
->iconSize
, himl
, FALSE
);
7469 LISTVIEW_SetIconSpacing(infoPtr
, 0, 0);
7473 himlOld
= infoPtr
->himlSmall
;
7474 infoPtr
->himlSmall
= himl
;
7475 if (uView
!= LVS_ICON
) set_icon_size(&infoPtr
->iconSize
, himl
, TRUE
);
7479 himlOld
= infoPtr
->himlState
;
7480 infoPtr
->himlState
= himl
;
7481 set_icon_size(&infoPtr
->iconStateSize
, himl
, TRUE
);
7482 ImageList_SetBkColor(infoPtr
->himlState
, CLR_NONE
);
7486 ERR("Unknown icon type=%d\n", nType
);
7490 infoPtr
->nItemHeight
= LISTVIEW_CalculateItemHeight(infoPtr
);
7491 if (infoPtr
->nItemHeight
!= oldHeight
)
7492 LISTVIEW_UpdateScroll(infoPtr
);
7499 * Preallocates memory (does *not* set the actual count of items !)
7502 * [I] infoPtr : valid pointer to the listview structure
7503 * [I] nItems : item count (projected number of items to allocate)
7504 * [I] dwFlags : update flags
7510 static BOOL
LISTVIEW_SetItemCount(LISTVIEW_INFO
*infoPtr
, INT nItems
, DWORD dwFlags
)
7512 TRACE("(nItems=%d, dwFlags=%x)\n", nItems
, dwFlags
);
7514 if (infoPtr
->dwStyle
& LVS_OWNERDATA
)
7516 UINT uView
= infoPtr
->dwStyle
& LVS_TYPEMASK
;
7517 INT nOldCount
= infoPtr
->nItemCount
;
7519 if (nItems
< nOldCount
)
7521 RANGE range
= { nItems
, nOldCount
};
7522 ranges_del(infoPtr
->selectionRanges
, range
);
7523 if (infoPtr
->nFocusedItem
>= nItems
)
7525 LISTVIEW_SetItemFocus(infoPtr
, -1);
7526 SetRectEmpty(&infoPtr
->rcFocus
);
7530 infoPtr
->nItemCount
= nItems
;
7531 LISTVIEW_UpdateScroll(infoPtr
);
7533 /* the flags are valid only in ownerdata report and list modes */
7534 if (uView
== LVS_ICON
|| uView
== LVS_SMALLICON
) dwFlags
= 0;
7536 if (!(dwFlags
& LVSICF_NOSCROLL
) && infoPtr
->nFocusedItem
!= -1)
7537 LISTVIEW_EnsureVisible(infoPtr
, infoPtr
->nFocusedItem
, FALSE
);
7539 if (!(dwFlags
& LVSICF_NOINVALIDATEALL
))
7540 LISTVIEW_InvalidateList(infoPtr
);
7547 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
7548 nFrom
= min(nOldCount
, nItems
);
7549 nTo
= max(nOldCount
, nItems
);
7551 if (uView
== LVS_REPORT
)
7554 rcErase
.top
= nFrom
* infoPtr
->nItemHeight
;
7555 rcErase
.right
= infoPtr
->nItemWidth
;
7556 rcErase
.bottom
= nTo
* infoPtr
->nItemHeight
;
7557 OffsetRect(&rcErase
, Origin
.x
, Origin
.y
);
7558 if (IntersectRect(&rcErase
, &rcErase
, &infoPtr
->rcList
))
7559 LISTVIEW_InvalidateRect(infoPtr
, &rcErase
);
7563 INT nPerCol
= LISTVIEW_GetCountPerColumn(infoPtr
);
7565 rcErase
.left
= (nFrom
/ nPerCol
) * infoPtr
->nItemWidth
;
7566 rcErase
.top
= (nFrom
% nPerCol
) * infoPtr
->nItemHeight
;
7567 rcErase
.right
= rcErase
.left
+ infoPtr
->nItemWidth
;
7568 rcErase
.bottom
= nPerCol
* infoPtr
->nItemHeight
;
7569 OffsetRect(&rcErase
, Origin
.x
, Origin
.y
);
7570 if (IntersectRect(&rcErase
, &rcErase
, &infoPtr
->rcList
))
7571 LISTVIEW_InvalidateRect(infoPtr
, &rcErase
);
7573 rcErase
.left
= (nFrom
/ nPerCol
+ 1) * infoPtr
->nItemWidth
;
7575 rcErase
.right
= (nTo
/ nPerCol
+ 1) * infoPtr
->nItemWidth
;
7576 rcErase
.bottom
= nPerCol
* infoPtr
->nItemHeight
;
7577 OffsetRect(&rcErase
, Origin
.x
, Origin
.y
);
7578 if (IntersectRect(&rcErase
, &rcErase
, &infoPtr
->rcList
))
7579 LISTVIEW_InvalidateRect(infoPtr
, &rcErase
);
7585 /* According to MSDN for non-LVS_OWNERDATA this is just
7586 * a performance issue. The control allocates its internal
7587 * data structures for the number of items specified. It
7588 * cuts down on the number of memory allocations. Therefore
7589 * we will just issue a WARN here
7591 WARN("for non-ownerdata performance option not implemented.\n");
7599 * Sets the position of an item.
7602 * [I] infoPtr : valid pointer to the listview structure
7603 * [I] nItem : item index
7604 * [I] pt : coordinate
7610 static BOOL
LISTVIEW_SetItemPosition(LISTVIEW_INFO
*infoPtr
, INT nItem
, POINT pt
)
7612 UINT uView
= infoPtr
->dwStyle
& LVS_TYPEMASK
;
7615 TRACE("(nItem=%d, &pt=%s\n", nItem
, wine_dbgstr_point(&pt
));
7617 if (nItem
< 0 || nItem
>= infoPtr
->nItemCount
||
7618 !(uView
== LVS_ICON
|| uView
== LVS_SMALLICON
)) return FALSE
;
7620 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
7622 /* This point value seems to be an undocumented feature.
7623 * The best guess is that it means either at the origin,
7624 * or at true beginning of the list. I will assume the origin. */
7625 if ((pt
.x
== -1) && (pt
.y
== -1))
7628 if (uView
== LVS_ICON
)
7630 pt
.x
-= (infoPtr
->nItemWidth
- infoPtr
->iconSize
.cx
) / 2;
7631 pt
.y
-= ICON_TOP_PADDING
;
7636 infoPtr
->bAutoarrange
= FALSE
;
7638 return LISTVIEW_MoveIconTo(infoPtr
, nItem
, &pt
, FALSE
);
7643 * Sets the state of one or many items.
7646 * [I] infoPtr : valid pointer to the listview structure
7647 * [I] nItem : item index
7648 * [I] lpLVItem : item or subitem info
7654 static BOOL
LISTVIEW_SetItemState(LISTVIEW_INFO
*infoPtr
, INT nItem
, const LVITEMW
*lpLVItem
)
7656 BOOL bResult
= TRUE
;
7659 lvItem
.iItem
= nItem
;
7660 lvItem
.iSubItem
= 0;
7661 lvItem
.mask
= LVIF_STATE
;
7662 lvItem
.state
= lpLVItem
->state
;
7663 lvItem
.stateMask
= lpLVItem
->stateMask
;
7664 TRACE("lvItem=%s\n", debuglvitem_t(&lvItem
, TRUE
));
7668 /* apply to all items */
7669 for (lvItem
.iItem
= 0; lvItem
.iItem
< infoPtr
->nItemCount
; lvItem
.iItem
++)
7670 if (!LISTVIEW_SetItemT(infoPtr
, &lvItem
, TRUE
)) bResult
= FALSE
;
7673 bResult
= LISTVIEW_SetItemT(infoPtr
, &lvItem
, TRUE
);
7676 * Update selection mark
7678 * Investigation on windows 2k showed that selection mark was updated
7679 * whenever a new selection was made, but if the selected item was
7680 * unselected it was not updated.
7682 * we are probably still not 100% accurate, but this at least sets the
7683 * proper selection mark when it is needed
7686 if (bResult
&& (lvItem
.state
& lvItem
.stateMask
& LVIS_SELECTED
) &&
7687 (infoPtr
->nSelectionMark
== -1))
7690 for (i
= 0; i
< infoPtr
->nItemCount
; i
++)
7692 if (infoPtr
->uCallbackMask
& LVIS_SELECTED
)
7694 if (LISTVIEW_GetItemState(infoPtr
, i
, LVIS_SELECTED
))
7696 infoPtr
->nSelectionMark
= i
;
7700 else if (ranges_contain(infoPtr
->selectionRanges
, i
))
7702 infoPtr
->nSelectionMark
= i
;
7713 * Sets the text of an item or subitem.
7716 * [I] hwnd : window handle
7717 * [I] nItem : item index
7718 * [I] lpLVItem : item or subitem info
7719 * [I] isW : TRUE if input is Unicode
7725 static BOOL
LISTVIEW_SetItemTextT(LISTVIEW_INFO
*infoPtr
, INT nItem
, const LVITEMW
*lpLVItem
, BOOL isW
)
7729 if (nItem
< 0 && nItem
>= infoPtr
->nItemCount
) return FALSE
;
7731 lvItem
.iItem
= nItem
;
7732 lvItem
.iSubItem
= lpLVItem
->iSubItem
;
7733 lvItem
.mask
= LVIF_TEXT
;
7734 lvItem
.pszText
= lpLVItem
->pszText
;
7735 lvItem
.cchTextMax
= lpLVItem
->cchTextMax
;
7737 TRACE("(nItem=%d, lpLVItem=%s, isW=%d)\n", nItem
, debuglvitem_t(&lvItem
, isW
), isW
);
7739 return LISTVIEW_SetItemT(infoPtr
, &lvItem
, isW
);
7744 * Set item index that marks the start of a multiple selection.
7747 * [I] infoPtr : valid pointer to the listview structure
7748 * [I] nIndex : index
7751 * Index number or -1 if there is no selection mark.
7753 static INT
LISTVIEW_SetSelectionMark(LISTVIEW_INFO
*infoPtr
, INT nIndex
)
7755 INT nOldIndex
= infoPtr
->nSelectionMark
;
7757 TRACE("(nIndex=%d)\n", nIndex
);
7759 infoPtr
->nSelectionMark
= nIndex
;
7766 * Sets the text background color.
7769 * [I] infoPtr : valid pointer to the listview structure
7770 * [I] clrTextBk : text background color
7776 static BOOL
LISTVIEW_SetTextBkColor(LISTVIEW_INFO
*infoPtr
, COLORREF clrTextBk
)
7778 TRACE("(clrTextBk=%x)\n", clrTextBk
);
7780 if (infoPtr
->clrTextBk
!= clrTextBk
)
7782 infoPtr
->clrTextBk
= clrTextBk
;
7783 LISTVIEW_InvalidateList(infoPtr
);
7791 * Sets the text foreground color.
7794 * [I] infoPtr : valid pointer to the listview structure
7795 * [I] clrText : text color
7801 static BOOL
LISTVIEW_SetTextColor (LISTVIEW_INFO
*infoPtr
, COLORREF clrText
)
7803 TRACE("(clrText=%x)\n", clrText
);
7805 if (infoPtr
->clrText
!= clrText
)
7807 infoPtr
->clrText
= clrText
;
7808 LISTVIEW_InvalidateList(infoPtr
);
7816 * Determines which listview item is located at the specified position.
7819 * [I] infoPtr : valid pointer to the listview structure
7820 * [I] hwndNewToolTip : handle to new ToolTip
7825 static HWND
LISTVIEW_SetToolTips( LISTVIEW_INFO
*infoPtr
, HWND hwndNewToolTip
)
7827 HWND hwndOldToolTip
= infoPtr
->hwndToolTip
;
7828 infoPtr
->hwndToolTip
= hwndNewToolTip
;
7829 return hwndOldToolTip
;
7834 * sets the Unicode character format flag for the control
7836 * [I] infoPtr :valid pointer to the listview structure
7837 * [I] fUnicode :true to switch to UNICODE false to switch to ANSI
7840 * Old Unicode Format
7842 static BOOL
LISTVIEW_SetUnicodeFormat( LISTVIEW_INFO
*infoPtr
, BOOL fUnicode
)
7844 BOOL rc
= infoPtr
->notifyFormat
;
7845 infoPtr
->notifyFormat
= (fUnicode
)?NFR_UNICODE
:NFR_ANSI
;
7849 /* LISTVIEW_SetWorkAreas */
7853 * Callback internally used by LISTVIEW_SortItems() in response of LVM_SORTITEMS
7856 * [I] first : pointer to first ITEM_INFO to compare
7857 * [I] second : pointer to second ITEM_INFO to compare
7858 * [I] lParam : HWND of control
7861 * if first comes before second : negative
7862 * if first comes after second : positive
7863 * if first and second are equivalent : zero
7865 static INT WINAPI
LISTVIEW_CallBackCompare(LPVOID first
, LPVOID second
, LPARAM lParam
)
7867 LISTVIEW_INFO
*infoPtr
= (LISTVIEW_INFO
*)lParam
;
7868 ITEM_INFO
* lv_first
= DPA_GetPtr( first
, 0 );
7869 ITEM_INFO
* lv_second
= DPA_GetPtr( second
, 0 );
7871 /* Forward the call to the client defined callback */
7872 return (infoPtr
->pfnCompare
)( lv_first
->lParam
, lv_second
->lParam
, infoPtr
->lParamSort
);
7877 * Callback internally used by LISTVIEW_SortItems() in response of LVM_SORTITEMSEX
7880 * [I] first : pointer to first ITEM_INFO to compare
7881 * [I] second : pointer to second ITEM_INFO to compare
7882 * [I] lParam : HWND of control
7885 * if first comes before second : negative
7886 * if first comes after second : positive
7887 * if first and second are equivalent : zero
7889 static INT WINAPI
LISTVIEW_CallBackCompareEx(LPVOID first
, LPVOID second
, LPARAM lParam
)
7891 LISTVIEW_INFO
*infoPtr
= (LISTVIEW_INFO
*)lParam
;
7892 INT first_idx
= DPA_GetPtrIndex( infoPtr
->hdpaItems
, first
);
7893 INT second_idx
= DPA_GetPtrIndex( infoPtr
->hdpaItems
, second
);
7895 /* Forward the call to the client defined callback */
7896 return (infoPtr
->pfnCompare
)( first_idx
, second_idx
, infoPtr
->lParamSort
);
7901 * Sorts the listview items.
7904 * [I] infoPtr : valid pointer to the listview structure
7905 * [I] pfnCompare : application-defined value
7906 * [I] lParamSort : pointer to comparison callback
7907 * [I] IsEx : TRUE when LVM_SORTITEMSEX used
7913 static BOOL
LISTVIEW_SortItems(LISTVIEW_INFO
*infoPtr
, PFNLVCOMPARE pfnCompare
,
7914 LPARAM lParamSort
, BOOL IsEx
)
7916 UINT uView
= infoPtr
->dwStyle
& LVS_TYPEMASK
;
7919 LPVOID selectionMarkItem
= NULL
;
7920 LPVOID focusedItem
= NULL
;
7923 TRACE("(pfnCompare=%p, lParamSort=%lx)\n", pfnCompare
, lParamSort
);
7925 if (infoPtr
->dwStyle
& LVS_OWNERDATA
) return FALSE
;
7927 if (!pfnCompare
) return FALSE
;
7928 if (!infoPtr
->hdpaItems
) return FALSE
;
7930 /* if there are 0 or 1 items, there is no need to sort */
7931 if (infoPtr
->nItemCount
< 2) return TRUE
;
7933 /* clear selection */
7934 ranges_clear(infoPtr
->selectionRanges
);
7936 /* save selection mark and focused item */
7937 if (infoPtr
->nSelectionMark
>= 0)
7938 selectionMarkItem
= DPA_GetPtr(infoPtr
->hdpaItems
, infoPtr
->nSelectionMark
);
7939 if (infoPtr
->nFocusedItem
>= 0)
7940 focusedItem
= DPA_GetPtr(infoPtr
->hdpaItems
, infoPtr
->nFocusedItem
);
7942 infoPtr
->pfnCompare
= pfnCompare
;
7943 infoPtr
->lParamSort
= lParamSort
;
7945 DPA_Sort(infoPtr
->hdpaItems
, LISTVIEW_CallBackCompareEx
, (LPARAM
)infoPtr
);
7947 DPA_Sort(infoPtr
->hdpaItems
, LISTVIEW_CallBackCompare
, (LPARAM
)infoPtr
);
7949 /* restore selection ranges */
7950 for (i
=0; i
< infoPtr
->nItemCount
; i
++)
7952 hdpaSubItems
= DPA_GetPtr(infoPtr
->hdpaItems
, i
);
7953 lpItem
= DPA_GetPtr(hdpaSubItems
, 0);
7955 if (lpItem
->state
& LVIS_SELECTED
)
7956 ranges_additem(infoPtr
->selectionRanges
, i
);
7958 /* restore selection mark and focused item */
7959 infoPtr
->nSelectionMark
= DPA_GetPtrIndex(infoPtr
->hdpaItems
, selectionMarkItem
);
7960 infoPtr
->nFocusedItem
= DPA_GetPtrIndex(infoPtr
->hdpaItems
, focusedItem
);
7962 /* I believe nHotItem should be left alone, see LISTVIEW_ShiftIndices */
7964 /* refresh the display */
7965 if (uView
!= LVS_ICON
&& uView
!= LVS_SMALLICON
)
7966 LISTVIEW_InvalidateList(infoPtr
);
7973 * Update theme handle after a theme change.
7976 * [I] infoPtr : valid pointer to the listview structure
7980 * FAILURE : something else
7982 static LRESULT
LISTVIEW_ThemeChanged(const LISTVIEW_INFO
*infoPtr
)
7984 HTHEME theme
= GetWindowTheme(infoPtr
->hwndSelf
);
7985 CloseThemeData(theme
);
7986 OpenThemeData(infoPtr
->hwndSelf
, themeClass
);
7992 * Updates an items or rearranges the listview control.
7995 * [I] infoPtr : valid pointer to the listview structure
7996 * [I] nItem : item index
8002 static BOOL
LISTVIEW_Update(LISTVIEW_INFO
*infoPtr
, INT nItem
)
8004 TRACE("(nItem=%d)\n", nItem
);
8006 if (nItem
< 0 || nItem
>= infoPtr
->nItemCount
) return FALSE
;
8008 /* rearrange with default alignment style */
8009 if (is_autoarrange(infoPtr
))
8010 LISTVIEW_Arrange(infoPtr
, LVA_DEFAULT
);
8012 LISTVIEW_InvalidateItem(infoPtr
, nItem
);
8019 * Draw the track line at the place defined in the infoPtr structure.
8020 * The line is drawn with a XOR pen so drawing the line for the second time
8021 * in the same place erases the line.
8024 * [I] infoPtr : valid pointer to the listview structure
8030 static BOOL
LISTVIEW_DrawTrackLine(const LISTVIEW_INFO
*infoPtr
)
8036 if (infoPtr
->xTrackLine
== -1)
8039 if (!(hdc
= GetDC(infoPtr
->hwndSelf
)))
8041 hOldPen
= SelectObject(hdc
, GetStockObject(BLACK_PEN
));
8042 oldROP
= SetROP2(hdc
, R2_XORPEN
);
8043 MoveToEx(hdc
, infoPtr
->xTrackLine
, infoPtr
->rcList
.top
, NULL
);
8044 LineTo(hdc
, infoPtr
->xTrackLine
, infoPtr
->rcList
.bottom
);
8045 SetROP2(hdc
, oldROP
);
8046 SelectObject(hdc
, hOldPen
);
8047 ReleaseDC(infoPtr
->hwndSelf
, hdc
);
8053 * Called when an edit control should be displayed. This function is called after
8054 * we are sure that there was a single click - not a double click (this is a TIMERPROC).
8057 * [I] hwnd : Handle to the listview
8058 * [I] uMsg : WM_TIMER (ignored)
8059 * [I] idEvent : The timer ID interpreted as a pointer to a DELAYED_EDIT_ITEM struct
8060 * [I] dwTimer : The elapsed time (ignored)
8065 static VOID CALLBACK
LISTVIEW_DelayedEditItem(HWND hwnd
, UINT uMsg
, UINT_PTR idEvent
, DWORD dwTime
)
8067 DELAYED_ITEM_EDIT
*editItem
= (DELAYED_ITEM_EDIT
*)idEvent
;
8068 LISTVIEW_INFO
*infoPtr
= (LISTVIEW_INFO
*)GetWindowLongPtrW(hwnd
, 0);
8070 KillTimer(hwnd
, idEvent
);
8071 editItem
->fEnabled
= FALSE
;
8072 /* check if the item is still selected */
8073 if (infoPtr
->bFocus
&& LISTVIEW_GetItemState(infoPtr
, editItem
->iItem
, LVIS_SELECTED
))
8074 LISTVIEW_EditLabelT(infoPtr
, editItem
->iItem
, TRUE
);
8079 * Creates the listview control - the WM_NCCREATE phase.
8082 * [I] hwnd : window handle
8083 * [I] lpcs : the create parameters
8089 static LRESULT
LISTVIEW_NCCreate(HWND hwnd
, const CREATESTRUCTW
*lpcs
)
8091 LISTVIEW_INFO
*infoPtr
;
8094 TRACE("(lpcs=%p)\n", lpcs
);
8096 /* initialize info pointer */
8097 infoPtr
= Alloc(sizeof(LISTVIEW_INFO
));
8098 if (!infoPtr
) return FALSE
;
8100 SetWindowLongPtrW(hwnd
, 0, (DWORD_PTR
)infoPtr
);
8102 infoPtr
->hwndSelf
= hwnd
;
8103 infoPtr
->dwStyle
= lpcs
->style
; /* Note: may be changed in WM_CREATE */
8104 /* determine the type of structures to use */
8105 infoPtr
->hwndNotify
= lpcs
->hwndParent
;
8106 /* infoPtr->notifyFormat will be filled in WM_CREATE */
8108 /* initialize color information */
8109 infoPtr
->clrBk
= CLR_NONE
;
8110 infoPtr
->clrText
= CLR_DEFAULT
;
8111 infoPtr
->clrTextBk
= CLR_DEFAULT
;
8112 LISTVIEW_SetBkColor(infoPtr
, comctl32_color
.clrWindow
);
8114 /* set default values */
8115 infoPtr
->nFocusedItem
= -1;
8116 infoPtr
->nSelectionMark
= -1;
8117 infoPtr
->nHotItem
= -1;
8118 infoPtr
->bRedraw
= TRUE
;
8119 infoPtr
->bNoItemMetrics
= TRUE
;
8120 infoPtr
->bDoChangeNotify
= TRUE
;
8121 infoPtr
->iconSpacing
.cx
= GetSystemMetrics(SM_CXICONSPACING
);
8122 infoPtr
->iconSpacing
.cy
= GetSystemMetrics(SM_CYICONSPACING
);
8123 infoPtr
->nEditLabelItem
= -1;
8124 infoPtr
->dwHoverTime
= -1; /* default system hover time */
8125 infoPtr
->nMeasureItemHeight
= 0;
8126 infoPtr
->xTrackLine
= -1; /* no track line */
8127 infoPtr
->itemEdit
.fEnabled
= FALSE
;
8129 /* get default font (icon title) */
8130 SystemParametersInfoW(SPI_GETICONTITLELOGFONT
, 0, &logFont
, 0);
8131 infoPtr
->hDefaultFont
= CreateFontIndirectW(&logFont
);
8132 infoPtr
->hFont
= infoPtr
->hDefaultFont
;
8133 LISTVIEW_SaveTextMetrics(infoPtr
);
8135 /* allocate memory for the data structure */
8136 if (!(infoPtr
->selectionRanges
= ranges_create(10))) goto fail
;
8137 if (!(infoPtr
->hdpaItems
= DPA_Create(10))) goto fail
;
8138 if (!(infoPtr
->hdpaPosX
= DPA_Create(10))) goto fail
;
8139 if (!(infoPtr
->hdpaPosY
= DPA_Create(10))) goto fail
;
8140 if (!(infoPtr
->hdpaColumns
= DPA_Create(10))) goto fail
;
8144 DestroyWindow(infoPtr
->hwndHeader
);
8145 ranges_destroy(infoPtr
->selectionRanges
);
8146 DPA_Destroy(infoPtr
->hdpaItems
);
8147 DPA_Destroy(infoPtr
->hdpaPosX
);
8148 DPA_Destroy(infoPtr
->hdpaPosY
);
8149 DPA_Destroy(infoPtr
->hdpaColumns
);
8156 * Creates the listview control - the WM_CREATE phase. Most of the data is
8157 * already set up in LISTVIEW_NCCreate
8160 * [I] hwnd : window handle
8161 * [I] lpcs : the create parameters
8167 static LRESULT
LISTVIEW_Create(HWND hwnd
, const CREATESTRUCTW
*lpcs
)
8169 LISTVIEW_INFO
*infoPtr
= (LISTVIEW_INFO
*)GetWindowLongPtrW(hwnd
, 0);
8170 UINT uView
= lpcs
->style
& LVS_TYPEMASK
;
8172 TRACE("(lpcs=%p)\n", lpcs
);
8174 infoPtr
->dwStyle
= lpcs
->style
;
8175 infoPtr
->notifyFormat
= SendMessageW(infoPtr
->hwndNotify
, WM_NOTIFYFORMAT
,
8176 (WPARAM
)infoPtr
->hwndSelf
, (LPARAM
)NF_QUERY
);
8178 if ((uView
== LVS_REPORT
) && (lpcs
->style
& WS_VISIBLE
))
8180 if (LISTVIEW_CreateHeader(infoPtr
) < 0) return -1;
8183 infoPtr
->hwndHeader
= 0;
8185 /* init item size to avoid division by 0 */
8186 LISTVIEW_UpdateItemSize (infoPtr
);
8188 if (uView
== LVS_REPORT
)
8190 if (!(LVS_NOCOLUMNHEADER
& lpcs
->style
) && (WS_VISIBLE
& lpcs
->style
))
8192 ShowWindow(infoPtr
->hwndHeader
, SW_SHOWNORMAL
);
8194 LISTVIEW_UpdateScroll(infoPtr
);
8197 OpenThemeData(hwnd
, themeClass
);
8199 /* initialize the icon sizes */
8200 set_icon_size(&infoPtr
->iconSize
, infoPtr
->himlNormal
, uView
!= LVS_ICON
);
8201 set_icon_size(&infoPtr
->iconStateSize
, infoPtr
->himlState
, TRUE
);
8207 * Destroys the listview control.
8210 * [I] infoPtr : valid pointer to the listview structure
8216 static LRESULT
LISTVIEW_Destroy(const LISTVIEW_INFO
*infoPtr
)
8218 HTHEME theme
= GetWindowTheme(infoPtr
->hwndSelf
);
8219 CloseThemeData(theme
);
8225 * Enables the listview control.
8228 * [I] infoPtr : valid pointer to the listview structure
8229 * [I] bEnable : specifies whether to enable or disable the window
8235 static BOOL
LISTVIEW_Enable(const LISTVIEW_INFO
*infoPtr
, BOOL bEnable
)
8237 if (infoPtr
->dwStyle
& LVS_OWNERDRAWFIXED
)
8238 InvalidateRect(infoPtr
->hwndSelf
, NULL
, TRUE
);
8244 * Erases the background of the listview control.
8247 * [I] infoPtr : valid pointer to the listview structure
8248 * [I] hdc : device context handle
8254 static inline BOOL
LISTVIEW_EraseBkgnd(const LISTVIEW_INFO
*infoPtr
, HDC hdc
)
8258 TRACE("(hdc=%p)\n", hdc
);
8260 if (!GetClipBox(hdc
, &rc
)) return FALSE
;
8262 /* for double buffered controls we need to do this during refresh */
8263 if (infoPtr
->dwLvExStyle
& LVS_EX_DOUBLEBUFFER
) return FALSE
;
8265 return LISTVIEW_FillBkgnd(infoPtr
, hdc
, &rc
);
8271 * Helper function for LISTVIEW_[HV]Scroll *only*.
8272 * Performs vertical/horizontal scrolling by a give amount.
8275 * [I] infoPtr : valid pointer to the listview structure
8276 * [I] dx : amount of horizontal scroll
8277 * [I] dy : amount of vertical scroll
8279 static void scroll_list(LISTVIEW_INFO
*infoPtr
, INT dx
, INT dy
)
8281 /* now we can scroll the list */
8282 ScrollWindowEx(infoPtr
->hwndSelf
, dx
, dy
, &infoPtr
->rcList
,
8283 &infoPtr
->rcList
, 0, 0, SW_ERASE
| SW_INVALIDATE
);
8284 /* if we have focus, adjust rect */
8285 OffsetRect(&infoPtr
->rcFocus
, dx
, dy
);
8286 UpdateWindow(infoPtr
->hwndSelf
);
8291 * Performs vertical scrolling.
8294 * [I] infoPtr : valid pointer to the listview structure
8295 * [I] nScrollCode : scroll code
8296 * [I] nScrollDiff : units to scroll in SB_INTERNAL mode, 0 otherwise
8297 * [I] hScrollWnd : scrollbar control window handle
8303 * SB_LINEUP/SB_LINEDOWN:
8304 * for LVS_ICON, LVS_SMALLICON is 37 by experiment
8305 * for LVS_REPORT is 1 line
8306 * for LVS_LIST cannot occur
8309 static LRESULT
LISTVIEW_VScroll(LISTVIEW_INFO
*infoPtr
, INT nScrollCode
,
8310 INT nScrollDiff
, HWND hScrollWnd
)
8312 UINT uView
= infoPtr
->dwStyle
& LVS_TYPEMASK
;
8313 INT nOldScrollPos
, nNewScrollPos
;
8314 SCROLLINFO scrollInfo
;
8317 TRACE("(nScrollCode=%d(%s), nScrollDiff=%d)\n", nScrollCode
,
8318 debugscrollcode(nScrollCode
), nScrollDiff
);
8320 if (infoPtr
->hwndEdit
) SendMessageW(infoPtr
->hwndEdit
, WM_KILLFOCUS
, 0, 0);
8322 scrollInfo
.cbSize
= sizeof(SCROLLINFO
);
8323 scrollInfo
.fMask
= SIF_PAGE
| SIF_POS
| SIF_RANGE
| SIF_TRACKPOS
;
8325 is_an_icon
= ((uView
== LVS_ICON
) || (uView
== LVS_SMALLICON
));
8327 if (!GetScrollInfo(infoPtr
->hwndSelf
, SB_VERT
, &scrollInfo
)) return 1;
8329 nOldScrollPos
= scrollInfo
.nPos
;
8330 switch (nScrollCode
)
8336 nScrollDiff
= (is_an_icon
) ? -LISTVIEW_SCROLL_ICON_LINE_SIZE
: -1;
8340 nScrollDiff
= (is_an_icon
) ? LISTVIEW_SCROLL_ICON_LINE_SIZE
: 1;
8344 nScrollDiff
= -scrollInfo
.nPage
;
8348 nScrollDiff
= scrollInfo
.nPage
;
8351 case SB_THUMBPOSITION
:
8353 nScrollDiff
= scrollInfo
.nTrackPos
- scrollInfo
.nPos
;
8360 /* quit right away if pos isn't changing */
8361 if (nScrollDiff
== 0) return 0;
8363 /* calculate new position, and handle overflows */
8364 nNewScrollPos
= scrollInfo
.nPos
+ nScrollDiff
;
8365 if (nScrollDiff
> 0) {
8366 if (nNewScrollPos
< nOldScrollPos
||
8367 nNewScrollPos
> scrollInfo
.nMax
)
8368 nNewScrollPos
= scrollInfo
.nMax
;
8370 if (nNewScrollPos
> nOldScrollPos
||
8371 nNewScrollPos
< scrollInfo
.nMin
)
8372 nNewScrollPos
= scrollInfo
.nMin
;
8375 /* set the new position, and reread in case it changed */
8376 scrollInfo
.fMask
= SIF_POS
;
8377 scrollInfo
.nPos
= nNewScrollPos
;
8378 nNewScrollPos
= SetScrollInfo(infoPtr
->hwndSelf
, SB_VERT
, &scrollInfo
, TRUE
);
8380 /* carry on only if it really changed */
8381 if (nNewScrollPos
== nOldScrollPos
) return 0;
8383 /* now adjust to client coordinates */
8384 nScrollDiff
= nOldScrollPos
- nNewScrollPos
;
8385 if (uView
== LVS_REPORT
) nScrollDiff
*= infoPtr
->nItemHeight
;
8387 /* and scroll the window */
8388 scroll_list(infoPtr
, 0, nScrollDiff
);
8395 * Performs horizontal scrolling.
8398 * [I] infoPtr : valid pointer to the listview structure
8399 * [I] nScrollCode : scroll code
8400 * [I] nScrollDiff : units to scroll in SB_INTERNAL mode, 0 otherwise
8401 * [I] hScrollWnd : scrollbar control window handle
8407 * SB_LINELEFT/SB_LINERIGHT:
8408 * for LVS_ICON, LVS_SMALLICON 1 pixel
8409 * for LVS_REPORT is 1 pixel
8410 * for LVS_LIST is 1 column --> which is a 1 because the
8411 * scroll is based on columns not pixels
8414 static LRESULT
LISTVIEW_HScroll(LISTVIEW_INFO
*infoPtr
, INT nScrollCode
,
8415 INT nScrollDiff
, HWND hScrollWnd
)
8417 UINT uView
= infoPtr
->dwStyle
& LVS_TYPEMASK
;
8418 INT nOldScrollPos
, nNewScrollPos
;
8419 SCROLLINFO scrollInfo
;
8421 TRACE("(nScrollCode=%d(%s), nScrollDiff=%d)\n", nScrollCode
,
8422 debugscrollcode(nScrollCode
), nScrollDiff
);
8424 if (infoPtr
->hwndEdit
) SendMessageW(infoPtr
->hwndEdit
, WM_KILLFOCUS
, 0, 0);
8426 scrollInfo
.cbSize
= sizeof(SCROLLINFO
);
8427 scrollInfo
.fMask
= SIF_PAGE
| SIF_POS
| SIF_RANGE
| SIF_TRACKPOS
;
8429 if (!GetScrollInfo(infoPtr
->hwndSelf
, SB_HORZ
, &scrollInfo
)) return 1;
8431 nOldScrollPos
= scrollInfo
.nPos
;
8433 switch (nScrollCode
)
8447 nScrollDiff
= -scrollInfo
.nPage
;
8451 nScrollDiff
= scrollInfo
.nPage
;
8454 case SB_THUMBPOSITION
:
8456 nScrollDiff
= scrollInfo
.nTrackPos
- scrollInfo
.nPos
;
8463 /* quit right away if pos isn't changing */
8464 if (nScrollDiff
== 0) return 0;
8466 /* calculate new position, and handle overflows */
8467 nNewScrollPos
= scrollInfo
.nPos
+ nScrollDiff
;
8468 if (nScrollDiff
> 0) {
8469 if (nNewScrollPos
< nOldScrollPos
||
8470 nNewScrollPos
> scrollInfo
.nMax
)
8471 nNewScrollPos
= scrollInfo
.nMax
;
8473 if (nNewScrollPos
> nOldScrollPos
||
8474 nNewScrollPos
< scrollInfo
.nMin
)
8475 nNewScrollPos
= scrollInfo
.nMin
;
8478 /* set the new position, and reread in case it changed */
8479 scrollInfo
.fMask
= SIF_POS
;
8480 scrollInfo
.nPos
= nNewScrollPos
;
8481 nNewScrollPos
= SetScrollInfo(infoPtr
->hwndSelf
, SB_HORZ
, &scrollInfo
, TRUE
);
8483 /* carry on only if it really changed */
8484 if (nNewScrollPos
== nOldScrollPos
) return 0;
8486 if(uView
== LVS_REPORT
)
8487 LISTVIEW_UpdateHeaderSize(infoPtr
, nNewScrollPos
);
8489 /* now adjust to client coordinates */
8490 nScrollDiff
= nOldScrollPos
- nNewScrollPos
;
8491 if (uView
== LVS_LIST
) nScrollDiff
*= infoPtr
->nItemWidth
;
8493 /* and scroll the window */
8494 scroll_list(infoPtr
, nScrollDiff
, 0);
8499 static LRESULT
LISTVIEW_MouseWheel(LISTVIEW_INFO
*infoPtr
, INT wheelDelta
)
8501 UINT uView
= infoPtr
->dwStyle
& LVS_TYPEMASK
;
8502 INT gcWheelDelta
= 0;
8503 INT pulScrollLines
= 3;
8504 SCROLLINFO scrollInfo
;
8506 TRACE("(wheelDelta=%d)\n", wheelDelta
);
8508 SystemParametersInfoW(SPI_GETWHEELSCROLLLINES
,0, &pulScrollLines
, 0);
8509 gcWheelDelta
-= wheelDelta
;
8511 scrollInfo
.cbSize
= sizeof(SCROLLINFO
);
8512 scrollInfo
.fMask
= SIF_POS
;
8519 * listview should be scrolled by a multiple of 37 dependently on its dimension or its visible item number
8520 * should be fixed in the future.
8522 LISTVIEW_VScroll(infoPtr
, SB_INTERNAL
, (gcWheelDelta
< 0) ?
8523 -LISTVIEW_SCROLL_ICON_LINE_SIZE
: LISTVIEW_SCROLL_ICON_LINE_SIZE
, 0);
8527 if (abs(gcWheelDelta
) >= WHEEL_DELTA
&& pulScrollLines
)
8529 int cLineScroll
= min(LISTVIEW_GetCountPerColumn(infoPtr
), pulScrollLines
);
8530 cLineScroll
*= (gcWheelDelta
/ WHEEL_DELTA
);
8531 LISTVIEW_VScroll(infoPtr
, SB_INTERNAL
, cLineScroll
, 0);
8536 LISTVIEW_HScroll(infoPtr
, (gcWheelDelta
< 0) ? SB_LINELEFT
: SB_LINERIGHT
, 0, 0);
8547 * [I] infoPtr : valid pointer to the listview structure
8548 * [I] nVirtualKey : virtual key
8549 * [I] lKeyData : key data
8554 static LRESULT
LISTVIEW_KeyDown(LISTVIEW_INFO
*infoPtr
, INT nVirtualKey
, LONG lKeyData
)
8556 UINT uView
= infoPtr
->dwStyle
& LVS_TYPEMASK
;
8557 HWND hwndSelf
= infoPtr
->hwndSelf
;
8559 NMLVKEYDOWN nmKeyDown
;
8561 TRACE("(nVirtualKey=%d, lKeyData=%d)\n", nVirtualKey
, lKeyData
);
8563 /* send LVN_KEYDOWN notification */
8564 nmKeyDown
.wVKey
= nVirtualKey
;
8565 nmKeyDown
.flags
= 0;
8566 notify_hdr(infoPtr
, LVN_KEYDOWN
, &nmKeyDown
.hdr
);
8567 if (!IsWindow(hwndSelf
))
8570 switch (nVirtualKey
)
8573 nItem
= infoPtr
->nFocusedItem
;
8574 if (infoPtr
->dwLvExStyle
& LVS_EX_CHECKBOXES
)
8575 toggle_checkbox_state(infoPtr
, infoPtr
->nFocusedItem
);
8579 if ((infoPtr
->nItemCount
> 0) && (infoPtr
->nFocusedItem
!= -1))
8581 if (!notify(infoPtr
, NM_RETURN
)) return 0;
8582 if (!notify(infoPtr
, LVN_ITEMACTIVATE
)) return 0;
8587 if (infoPtr
->nItemCount
> 0)
8592 if (infoPtr
->nItemCount
> 0)
8593 nItem
= infoPtr
->nItemCount
- 1;
8597 nItem
= ListView_GetNextItem(infoPtr
->hwndSelf
, infoPtr
->nFocusedItem
, LVNI_TOLEFT
);
8601 nItem
= ListView_GetNextItem(infoPtr
->hwndSelf
, infoPtr
->nFocusedItem
, LVNI_ABOVE
);
8605 nItem
= ListView_GetNextItem(infoPtr
->hwndSelf
, infoPtr
->nFocusedItem
, LVNI_TORIGHT
);
8609 nItem
= ListView_GetNextItem(infoPtr
->hwndSelf
, infoPtr
->nFocusedItem
, LVNI_BELOW
);
8613 if (uView
== LVS_REPORT
)
8615 INT topidx
= LISTVIEW_GetTopIndex(infoPtr
);
8616 if (infoPtr
->nFocusedItem
== topidx
)
8617 nItem
= topidx
- LISTVIEW_GetCountPerColumn(infoPtr
) + 1;
8622 nItem
= infoPtr
->nFocusedItem
- LISTVIEW_GetCountPerColumn(infoPtr
)
8623 * LISTVIEW_GetCountPerRow(infoPtr
);
8624 if(nItem
< 0) nItem
= 0;
8628 if (uView
== LVS_REPORT
)
8630 INT topidx
= LISTVIEW_GetTopIndex(infoPtr
);
8631 INT cnt
= LISTVIEW_GetCountPerColumn(infoPtr
);
8632 if (infoPtr
->nFocusedItem
== topidx
+ cnt
- 1)
8633 nItem
= infoPtr
->nFocusedItem
+ cnt
- 1;
8635 nItem
= topidx
+ cnt
- 1;
8638 nItem
= infoPtr
->nFocusedItem
+ LISTVIEW_GetCountPerColumn(infoPtr
)
8639 * LISTVIEW_GetCountPerRow(infoPtr
);
8640 if(nItem
>= infoPtr
->nItemCount
) nItem
= infoPtr
->nItemCount
- 1;
8644 if ((nItem
!= -1) && (nItem
!= infoPtr
->nFocusedItem
|| nVirtualKey
== VK_SPACE
))
8645 LISTVIEW_KeySelection(infoPtr
, nItem
, nVirtualKey
== VK_SPACE
);
8655 * [I] infoPtr : valid pointer to the listview structure
8660 static LRESULT
LISTVIEW_KillFocus(LISTVIEW_INFO
*infoPtr
)
8664 /* if we did not have the focus, there's nothing to do */
8665 if (!infoPtr
->bFocus
) return 0;
8667 /* send NM_KILLFOCUS notification */
8668 if (!notify(infoPtr
, NM_KILLFOCUS
)) return 0;
8670 /* if we have a focus rectangle, get rid of it */
8671 LISTVIEW_ShowFocusRect(infoPtr
, FALSE
);
8673 /* set window focus flag */
8674 infoPtr
->bFocus
= FALSE
;
8676 /* invalidate the selected items before resetting focus flag */
8677 LISTVIEW_InvalidateSelectedItems(infoPtr
);
8684 * Processes double click messages (left mouse button).
8687 * [I] infoPtr : valid pointer to the listview structure
8688 * [I] wKey : key flag
8689 * [I] x,y : mouse coordinate
8694 static LRESULT
LISTVIEW_LButtonDblClk(LISTVIEW_INFO
*infoPtr
, WORD wKey
, INT x
, INT y
)
8696 LVHITTESTINFO htInfo
;
8698 TRACE("(key=%hu, X=%hu, Y=%hu)\n", wKey
, x
, y
);
8700 /* Cancel the item edition if any */
8701 if (infoPtr
->itemEdit
.fEnabled
)
8703 KillTimer(infoPtr
->hwndSelf
, (UINT_PTR
)&infoPtr
->itemEdit
);
8704 infoPtr
->itemEdit
.fEnabled
= FALSE
;
8707 /* send NM_RELEASEDCAPTURE notification */
8708 if (!notify(infoPtr
, NM_RELEASEDCAPTURE
)) return 0;
8713 /* send NM_DBLCLK notification */
8714 LISTVIEW_HitTest(infoPtr
, &htInfo
, TRUE
, FALSE
);
8715 if (!notify_click(infoPtr
, NM_DBLCLK
, &htInfo
)) return 0;
8717 /* To send the LVN_ITEMACTIVATE, it must be on an Item */
8718 if(htInfo
.iItem
!= -1) notify_itemactivate(infoPtr
,&htInfo
);
8725 * Processes mouse down messages (left mouse button).
8728 * infoPtr [I ] valid pointer to the listview structure
8729 * wKey [I ] key flag
8730 * x,y [I ] mouse coordinate
8735 static LRESULT
LISTVIEW_LButtonDown(LISTVIEW_INFO
*infoPtr
, WORD wKey
, INT x
, INT y
)
8737 LVHITTESTINFO lvHitTestInfo
;
8738 static BOOL bGroupSelect
= TRUE
;
8739 POINT pt
= { x
, y
};
8742 TRACE("(key=%hu, X=%hu, Y=%hu)\n", wKey
, x
, y
);
8744 /* send NM_RELEASEDCAPTURE notification */
8745 if (!notify(infoPtr
, NM_RELEASEDCAPTURE
)) return 0;
8747 /* set left button down flag and record the click position */
8748 infoPtr
->bLButtonDown
= TRUE
;
8749 infoPtr
->ptClickPos
= pt
;
8750 infoPtr
->bDragging
= FALSE
;
8752 lvHitTestInfo
.pt
.x
= x
;
8753 lvHitTestInfo
.pt
.y
= y
;
8755 nItem
= LISTVIEW_HitTest(infoPtr
, &lvHitTestInfo
, TRUE
, TRUE
);
8756 TRACE("at %s, nItem=%d\n", wine_dbgstr_point(&pt
), nItem
);
8757 if ((nItem
>= 0) && (nItem
< infoPtr
->nItemCount
))
8759 if ((infoPtr
->dwLvExStyle
& LVS_EX_CHECKBOXES
) && (lvHitTestInfo
.flags
& LVHT_ONITEMSTATEICON
))
8761 toggle_checkbox_state(infoPtr
, nItem
);
8765 if (infoPtr
->dwStyle
& LVS_SINGLESEL
)
8767 if (LISTVIEW_GetItemState(infoPtr
, nItem
, LVIS_SELECTED
))
8768 infoPtr
->nEditLabelItem
= nItem
;
8770 LISTVIEW_SetSelection(infoPtr
, nItem
);
8774 if ((wKey
& MK_CONTROL
) && (wKey
& MK_SHIFT
))
8778 if (!LISTVIEW_AddGroupSelection(infoPtr
, nItem
)) return 0;
8779 LISTVIEW_SetItemFocus(infoPtr
, nItem
);
8780 infoPtr
->nSelectionMark
= nItem
;
8786 item
.state
= LVIS_SELECTED
| LVIS_FOCUSED
;
8787 item
.stateMask
= LVIS_SELECTED
| LVIS_FOCUSED
;
8789 LISTVIEW_SetItemState(infoPtr
,nItem
,&item
);
8790 infoPtr
->nSelectionMark
= nItem
;
8793 else if (wKey
& MK_CONTROL
)
8797 bGroupSelect
= (LISTVIEW_GetItemState(infoPtr
, nItem
, LVIS_SELECTED
) == 0);
8799 item
.state
= (bGroupSelect
? LVIS_SELECTED
: 0) | LVIS_FOCUSED
;
8800 item
.stateMask
= LVIS_SELECTED
| LVIS_FOCUSED
;
8801 LISTVIEW_SetItemState(infoPtr
, nItem
, &item
);
8802 infoPtr
->nSelectionMark
= nItem
;
8804 else if (wKey
& MK_SHIFT
)
8806 LISTVIEW_SetGroupSelection(infoPtr
, nItem
);
8810 if (LISTVIEW_GetItemState(infoPtr
, nItem
, LVIS_SELECTED
))
8811 infoPtr
->nEditLabelItem
= nItem
;
8813 /* set selection (clears other pre-existing selections) */
8814 LISTVIEW_SetSelection(infoPtr
, nItem
);
8818 if (infoPtr
->dwLvExStyle
& LVS_EX_ONECLICKACTIVATE
)
8819 if(lvHitTestInfo
.iItem
!= -1) notify_itemactivate(infoPtr
,&lvHitTestInfo
);
8823 /* remove all selections */
8824 LISTVIEW_DeselectAll(infoPtr
);
8833 * Processes mouse up messages (left mouse button).
8836 * infoPtr [I ] valid pointer to the listview structure
8837 * wKey [I ] key flag
8838 * x,y [I ] mouse coordinate
8843 static LRESULT
LISTVIEW_LButtonUp(LISTVIEW_INFO
*infoPtr
, WORD wKey
, INT x
, INT y
)
8845 LVHITTESTINFO lvHitTestInfo
;
8847 TRACE("(key=%hu, X=%hu, Y=%hu)\n", wKey
, x
, y
);
8849 if (!infoPtr
->bLButtonDown
) return 0;
8851 lvHitTestInfo
.pt
.x
= x
;
8852 lvHitTestInfo
.pt
.y
= y
;
8854 /* send NM_CLICK notification */
8855 LISTVIEW_HitTest(infoPtr
, &lvHitTestInfo
, TRUE
, FALSE
);
8856 if (!notify_click(infoPtr
, NM_CLICK
, &lvHitTestInfo
)) return 0;
8858 /* set left button flag */
8859 infoPtr
->bLButtonDown
= FALSE
;
8861 if (infoPtr
->bDragging
)
8863 infoPtr
->bDragging
= FALSE
;
8867 /* if we clicked on a selected item, edit the label */
8868 if(lvHitTestInfo
.iItem
== infoPtr
->nEditLabelItem
&& (lvHitTestInfo
.flags
& LVHT_ONITEMLABEL
))
8870 /* we want to make sure the user doesn't want to do a double click. So we will
8871 * delay the edit. WM_LBUTTONDBLCLICK will cancel the timer
8873 infoPtr
->itemEdit
.fEnabled
= TRUE
;
8874 infoPtr
->itemEdit
.iItem
= lvHitTestInfo
.iItem
;
8875 SetTimer(infoPtr
->hwndSelf
,
8876 (UINT_PTR
)&infoPtr
->itemEdit
,
8877 GetDoubleClickTime(),
8878 LISTVIEW_DelayedEditItem
);
8881 if (!infoPtr
->bFocus
)
8882 SetFocus(infoPtr
->hwndSelf
);
8889 * Destroys the listview control (called after WM_DESTROY).
8892 * [I] infoPtr : valid pointer to the listview structure
8897 static LRESULT
LISTVIEW_NCDestroy(LISTVIEW_INFO
*infoPtr
)
8901 /* delete all items */
8902 LISTVIEW_DeleteAllItems(infoPtr
, TRUE
);
8904 /* destroy data structure */
8905 DPA_Destroy(infoPtr
->hdpaItems
);
8906 DPA_Destroy(infoPtr
->hdpaPosX
);
8907 DPA_Destroy(infoPtr
->hdpaPosY
);
8908 DPA_Destroy(infoPtr
->hdpaColumns
);
8909 ranges_destroy(infoPtr
->selectionRanges
);
8911 /* destroy image lists */
8912 if (!(infoPtr
->dwStyle
& LVS_SHAREIMAGELISTS
))
8914 if (infoPtr
->himlNormal
)
8915 ImageList_Destroy(infoPtr
->himlNormal
);
8916 if (infoPtr
->himlSmall
)
8917 ImageList_Destroy(infoPtr
->himlSmall
);
8918 if (infoPtr
->himlState
)
8919 ImageList_Destroy(infoPtr
->himlState
);
8922 /* destroy font, bkgnd brush */
8924 if (infoPtr
->hDefaultFont
) DeleteObject(infoPtr
->hDefaultFont
);
8925 if (infoPtr
->clrBk
!= CLR_NONE
) DeleteObject(infoPtr
->hBkBrush
);
8927 SetWindowLongPtrW(infoPtr
->hwndSelf
, 0, 0);
8929 /* free listview info pointer*/
8937 * Handles notifications from header.
8940 * [I] infoPtr : valid pointer to the listview structure
8941 * [I] nCtrlId : control identifier
8942 * [I] lpnmh : notification information
8947 static LRESULT
LISTVIEW_HeaderNotification(LISTVIEW_INFO
*infoPtr
, const NMHEADERW
*lpnmh
)
8949 UINT uView
= infoPtr
->dwStyle
& LVS_TYPEMASK
;
8950 HWND hwndSelf
= infoPtr
->hwndSelf
;
8952 TRACE("(lpnmh=%p)\n", lpnmh
);
8954 if (!lpnmh
|| lpnmh
->iItem
< 0 || lpnmh
->iItem
>= DPA_GetPtrCount(infoPtr
->hdpaColumns
)) return 0;
8956 switch (lpnmh
->hdr
.code
)
8961 COLUMN_INFO
*lpColumnInfo
;
8965 if (!lpnmh
->pitem
|| !(lpnmh
->pitem
->mask
& HDI_WIDTH
))
8968 /* remove the old line (if any) */
8969 LISTVIEW_DrawTrackLine(infoPtr
);
8971 /* compute & draw the new line */
8972 lpColumnInfo
= LISTVIEW_GetColumnInfo(infoPtr
, lpnmh
->iItem
);
8973 x
= lpColumnInfo
->rcHeader
.left
+ lpnmh
->pitem
->cxy
;
8974 LISTVIEW_GetOrigin(infoPtr
, &ptOrigin
);
8975 infoPtr
->xTrackLine
= x
+ ptOrigin
.x
;
8976 LISTVIEW_DrawTrackLine(infoPtr
);
8982 /* remove the track line (if any) */
8983 LISTVIEW_DrawTrackLine(infoPtr
);
8984 infoPtr
->xTrackLine
= -1;
8988 FIXME("Changing column order not implemented\n");
8991 case HDN_ITEMCHANGINGW
:
8992 case HDN_ITEMCHANGINGA
:
8993 return notify_forward_header(infoPtr
, lpnmh
);
8995 case HDN_ITEMCHANGEDW
:
8996 case HDN_ITEMCHANGEDA
:
8998 COLUMN_INFO
*lpColumnInfo
;
9001 notify_forward_header(infoPtr
, lpnmh
);
9002 if (!IsWindow(hwndSelf
))
9005 if (!lpnmh
->pitem
|| !(lpnmh
->pitem
->mask
& HDI_WIDTH
))
9009 hdi
.mask
= HDI_WIDTH
;
9010 if (!Header_GetItemW(infoPtr
->hwndHeader
, lpnmh
->iItem
, &hdi
)) return 0;
9014 cxy
= lpnmh
->pitem
->cxy
;
9016 /* determine how much we change since the last know position */
9017 lpColumnInfo
= LISTVIEW_GetColumnInfo(infoPtr
, lpnmh
->iItem
);
9018 dx
= cxy
- (lpColumnInfo
->rcHeader
.right
- lpColumnInfo
->rcHeader
.left
);
9021 lpColumnInfo
->rcHeader
.right
+= dx
;
9022 if (lpnmh
->iItem
+ 1 < DPA_GetPtrCount(infoPtr
->hdpaColumns
))
9023 LISTVIEW_ScrollColumns(infoPtr
, lpnmh
->iItem
+ 1, dx
);
9026 /* only needs to update the scrolls */
9027 infoPtr
->nItemWidth
+= dx
;
9028 LISTVIEW_UpdateScroll(infoPtr
);
9030 LISTVIEW_UpdateItemSize(infoPtr
);
9031 if (uView
== LVS_REPORT
&& is_redrawing(infoPtr
))
9034 RECT rcCol
= lpColumnInfo
->rcHeader
;
9036 LISTVIEW_GetOrigin(infoPtr
, &ptOrigin
);
9037 OffsetRect(&rcCol
, ptOrigin
.x
, 0);
9039 rcCol
.top
= infoPtr
->rcList
.top
;
9040 rcCol
.bottom
= infoPtr
->rcList
.bottom
;
9042 /* resizing left-aligned columns leaves most of the left side untouched */
9043 if ((lpColumnInfo
->fmt
& LVCFMT_JUSTIFYMASK
) == LVCFMT_LEFT
)
9045 INT nMaxDirty
= infoPtr
->nEllipsisWidth
+ infoPtr
->ntmMaxCharWidth
;
9048 rcCol
.left
= max (rcCol
.left
, rcCol
.right
- nMaxDirty
);
9051 /* when shrinking the last column clear the now unused field */
9052 if (lpnmh
->iItem
== DPA_GetPtrCount(infoPtr
->hdpaColumns
) - 1 && dx
< 0)
9055 LISTVIEW_InvalidateRect(infoPtr
, &rcCol
);
9061 case HDN_ITEMCLICKW
:
9062 case HDN_ITEMCLICKA
:
9064 /* Handle sorting by Header Column */
9067 ZeroMemory(&nmlv
, sizeof(NMLISTVIEW
));
9069 nmlv
.iSubItem
= lpnmh
->iItem
;
9070 notify_listview(infoPtr
, LVN_COLUMNCLICK
, &nmlv
);
9071 notify_forward_header(infoPtr
, lpnmh
);
9075 case HDN_DIVIDERDBLCLICKW
:
9076 case HDN_DIVIDERDBLCLICKA
:
9077 LISTVIEW_SetColumnWidth(infoPtr
, lpnmh
->iItem
, LVSCW_AUTOSIZE
);
9086 * Paint non-client area of control.
9089 * [I] infoPtr : valid pointer to the listview structureof the sender
9090 * [I] region : update region
9093 * TRUE - frame was painted
9094 * FALSE - call default window proc
9096 static BOOL
LISTVIEW_NCPaint(const LISTVIEW_INFO
*infoPtr
, HRGN region
)
9098 HTHEME theme
= GetWindowTheme (infoPtr
->hwndSelf
);
9102 int cxEdge
= GetSystemMetrics (SM_CXEDGE
),
9103 cyEdge
= GetSystemMetrics (SM_CYEDGE
);
9105 if (!theme
) return FALSE
;
9107 GetWindowRect(infoPtr
->hwndSelf
, &r
);
9109 cliprgn
= CreateRectRgn (r
.left
+ cxEdge
, r
.top
+ cyEdge
,
9110 r
.right
- cxEdge
, r
.bottom
- cyEdge
);
9111 if (region
!= (HRGN
)1)
9112 CombineRgn (cliprgn
, cliprgn
, region
, RGN_AND
);
9113 OffsetRect(&r
, -r
.left
, -r
.top
);
9115 dc
= GetDCEx(infoPtr
->hwndSelf
, region
, DCX_WINDOW
|DCX_INTERSECTRGN
);
9116 OffsetRect(&r
, -r
.left
, -r
.top
);
9118 if (IsThemeBackgroundPartiallyTransparent (theme
, 0, 0))
9119 DrawThemeParentBackground(infoPtr
->hwndSelf
, dc
, &r
);
9120 DrawThemeBackground (theme
, dc
, 0, 0, &r
, 0);
9121 ReleaseDC(infoPtr
->hwndSelf
, dc
);
9123 /* Call default proc to get the scrollbars etc. painted */
9124 DefWindowProcW (infoPtr
->hwndSelf
, WM_NCPAINT
, (WPARAM
)cliprgn
, 0);
9131 * Determines the type of structure to use.
9134 * [I] infoPtr : valid pointer to the listview structureof the sender
9135 * [I] hwndFrom : listview window handle
9136 * [I] nCommand : command specifying the nature of the WM_NOTIFYFORMAT
9141 static LRESULT
LISTVIEW_NotifyFormat(LISTVIEW_INFO
*infoPtr
, HWND hwndFrom
, INT nCommand
)
9143 TRACE("(hwndFrom=%p, nCommand=%d)\n", hwndFrom
, nCommand
);
9145 if (nCommand
== NF_REQUERY
)
9146 infoPtr
->notifyFormat
= SendMessageW(hwndFrom
, WM_NOTIFYFORMAT
, (WPARAM
)infoPtr
->hwndSelf
, NF_QUERY
);
9148 return infoPtr
->notifyFormat
;
9153 * Paints/Repaints the listview control.
9156 * [I] infoPtr : valid pointer to the listview structure
9157 * [I] hdc : device context handle
9162 static LRESULT
LISTVIEW_Paint(LISTVIEW_INFO
*infoPtr
, HDC hdc
)
9164 TRACE("(hdc=%p)\n", hdc
);
9166 if (infoPtr
->bNoItemMetrics
&& infoPtr
->nItemCount
)
9168 UINT uView
= infoPtr
->dwStyle
& LVS_TYPEMASK
;
9170 infoPtr
->bNoItemMetrics
= FALSE
;
9171 LISTVIEW_UpdateItemSize(infoPtr
);
9172 if (uView
== LVS_ICON
|| uView
== LVS_SMALLICON
)
9173 LISTVIEW_Arrange(infoPtr
, LVA_DEFAULT
);
9174 LISTVIEW_UpdateScroll(infoPtr
);
9177 if (infoPtr
->hwndHeader
) UpdateWindow(infoPtr
->hwndHeader
);
9180 LISTVIEW_Refresh(infoPtr
, hdc
, NULL
);
9185 hdc
= BeginPaint(infoPtr
->hwndSelf
, &ps
);
9187 LISTVIEW_Refresh(infoPtr
, hdc
, ps
.fErase
? &ps
.rcPaint
: NULL
);
9188 EndPaint(infoPtr
->hwndSelf
, &ps
);
9197 * Paints/Repaints the listview control.
9200 * [I] infoPtr : valid pointer to the listview structure
9201 * [I] hdc : device context handle
9202 * [I] options : drawing options
9207 static LRESULT
LISTVIEW_PrintClient(LISTVIEW_INFO
*infoPtr
, HDC hdc
, DWORD options
)
9209 FIXME("Partial Stub: (hdc=%p options=0x%08x)\n", hdc
, options
);
9211 if ((options
& PRF_CHECKVISIBLE
) && !IsWindowVisible(infoPtr
->hwndSelf
))
9214 if (options
& PRF_ERASEBKGND
)
9215 LISTVIEW_EraseBkgnd(infoPtr
, hdc
);
9217 if (options
& PRF_CLIENT
)
9218 LISTVIEW_Paint(infoPtr
, hdc
);
9226 * Processes double click messages (right mouse button).
9229 * [I] infoPtr : valid pointer to the listview structure
9230 * [I] wKey : key flag
9231 * [I] x,y : mouse coordinate
9236 static LRESULT
LISTVIEW_RButtonDblClk(const LISTVIEW_INFO
*infoPtr
, WORD wKey
, INT x
, INT y
)
9238 LVHITTESTINFO lvHitTestInfo
;
9240 TRACE("(key=%hu,X=%hu,Y=%hu)\n", wKey
, x
, y
);
9242 /* send NM_RELEASEDCAPTURE notification */
9243 if (!notify(infoPtr
, NM_RELEASEDCAPTURE
)) return 0;
9245 /* send NM_RDBLCLK notification */
9246 lvHitTestInfo
.pt
.x
= x
;
9247 lvHitTestInfo
.pt
.y
= y
;
9248 LISTVIEW_HitTest(infoPtr
, &lvHitTestInfo
, TRUE
, FALSE
);
9249 notify_click(infoPtr
, NM_RDBLCLK
, &lvHitTestInfo
);
9256 * Processes mouse down messages (right mouse button).
9259 * [I] infoPtr : valid pointer to the listview structure
9260 * [I] wKey : key flag
9261 * [I] x,y : mouse coordinate
9266 static LRESULT
LISTVIEW_RButtonDown(LISTVIEW_INFO
*infoPtr
, WORD wKey
, INT x
, INT y
)
9268 LVHITTESTINFO lvHitTestInfo
;
9271 TRACE("(key=%hu,X=%hu,Y=%hu)\n", wKey
, x
, y
);
9273 /* send NM_RELEASEDCAPTURE notification */
9274 if (!notify(infoPtr
, NM_RELEASEDCAPTURE
)) return 0;
9276 /* make sure the listview control window has the focus */
9277 if (!infoPtr
->bFocus
) SetFocus(infoPtr
->hwndSelf
);
9279 /* set right button down flag */
9280 infoPtr
->bRButtonDown
= TRUE
;
9282 /* determine the index of the selected item */
9283 lvHitTestInfo
.pt
.x
= x
;
9284 lvHitTestInfo
.pt
.y
= y
;
9285 nItem
= LISTVIEW_HitTest(infoPtr
, &lvHitTestInfo
, TRUE
, TRUE
);
9287 if ((nItem
>= 0) && (nItem
< infoPtr
->nItemCount
))
9289 LISTVIEW_SetItemFocus(infoPtr
, nItem
);
9290 if (!((wKey
& MK_SHIFT
) || (wKey
& MK_CONTROL
)) &&
9291 !LISTVIEW_GetItemState(infoPtr
, nItem
, LVIS_SELECTED
))
9292 LISTVIEW_SetSelection(infoPtr
, nItem
);
9296 LISTVIEW_DeselectAll(infoPtr
);
9304 * Processes mouse up messages (right mouse button).
9307 * [I] infoPtr : valid pointer to the listview structure
9308 * [I] wKey : key flag
9309 * [I] x,y : mouse coordinate
9314 static LRESULT
LISTVIEW_RButtonUp(LISTVIEW_INFO
*infoPtr
, WORD wKey
, INT x
, INT y
)
9316 LVHITTESTINFO lvHitTestInfo
;
9319 TRACE("(key=%hu,X=%hu,Y=%hu)\n", wKey
, x
, y
);
9321 if (!infoPtr
->bRButtonDown
) return 0;
9323 /* set button flag */
9324 infoPtr
->bRButtonDown
= FALSE
;
9326 /* Send NM_RCLICK notification */
9327 lvHitTestInfo
.pt
.x
= x
;
9328 lvHitTestInfo
.pt
.y
= y
;
9329 LISTVIEW_HitTest(infoPtr
, &lvHitTestInfo
, TRUE
, FALSE
);
9330 if (!notify_click(infoPtr
, NM_RCLICK
, &lvHitTestInfo
)) return 0;
9332 /* Change to screen coordinate for WM_CONTEXTMENU */
9333 pt
= lvHitTestInfo
.pt
;
9334 ClientToScreen(infoPtr
->hwndSelf
, &pt
);
9336 /* Send a WM_CONTEXTMENU message in response to the RBUTTONUP */
9337 SendMessageW(infoPtr
->hwndSelf
, WM_CONTEXTMENU
,
9338 (WPARAM
)infoPtr
->hwndSelf
, MAKELPARAM(pt
.x
, pt
.y
));
9349 * [I] infoPtr : valid pointer to the listview structure
9350 * [I] hwnd : window handle of window containing the cursor
9351 * [I] nHittest : hit-test code
9352 * [I] wMouseMsg : ideintifier of the mouse message
9355 * TRUE if cursor is set
9358 static BOOL
LISTVIEW_SetCursor(const LISTVIEW_INFO
*infoPtr
, HWND hwnd
, UINT nHittest
, UINT wMouseMsg
)
9360 LVHITTESTINFO lvHitTestInfo
;
9362 if(!(LISTVIEW_isHotTracking(infoPtr
))) return FALSE
;
9364 if(!infoPtr
->hHotCursor
) return FALSE
;
9366 GetCursorPos(&lvHitTestInfo
.pt
);
9367 if (LISTVIEW_HitTest(infoPtr
, &lvHitTestInfo
, FALSE
, FALSE
) < 0) return FALSE
;
9369 SetCursor(infoPtr
->hHotCursor
);
9379 * [I] infoPtr : valid pointer to the listview structure
9380 * [I] hwndLoseFocus : handle of previously focused window
9385 static LRESULT
LISTVIEW_SetFocus(LISTVIEW_INFO
*infoPtr
, HWND hwndLoseFocus
)
9387 TRACE("(hwndLoseFocus=%p)\n", hwndLoseFocus
);
9389 /* if we have the focus already, there's nothing to do */
9390 if (infoPtr
->bFocus
) return 0;
9392 /* send NM_SETFOCUS notification */
9393 if (!notify(infoPtr
, NM_SETFOCUS
)) return 0;
9395 /* set window focus flag */
9396 infoPtr
->bFocus
= TRUE
;
9398 /* put the focus rect back on */
9399 LISTVIEW_ShowFocusRect(infoPtr
, TRUE
);
9401 /* redraw all visible selected items */
9402 LISTVIEW_InvalidateSelectedItems(infoPtr
);
9412 * [I] infoPtr : valid pointer to the listview structure
9413 * [I] fRedraw : font handle
9414 * [I] fRedraw : redraw flag
9419 static LRESULT
LISTVIEW_SetFont(LISTVIEW_INFO
*infoPtr
, HFONT hFont
, WORD fRedraw
)
9421 HFONT oldFont
= infoPtr
->hFont
;
9423 TRACE("(hfont=%p,redraw=%hu)\n", hFont
, fRedraw
);
9425 infoPtr
->hFont
= hFont
? hFont
: infoPtr
->hDefaultFont
;
9426 if (infoPtr
->hFont
== oldFont
) return 0;
9428 LISTVIEW_SaveTextMetrics(infoPtr
);
9430 if ((infoPtr
->dwStyle
& LVS_TYPEMASK
) == LVS_REPORT
)
9432 SendMessageW(infoPtr
->hwndHeader
, WM_SETFONT
, (WPARAM
)hFont
, MAKELPARAM(fRedraw
, 0));
9433 LISTVIEW_UpdateSize(infoPtr
);
9434 LISTVIEW_UpdateScroll(infoPtr
);
9437 if (fRedraw
) LISTVIEW_InvalidateList(infoPtr
);
9444 * Message handling for WM_SETREDRAW.
9445 * For the Listview, it invalidates the entire window (the doc specifies otherwise)
9448 * [I] infoPtr : valid pointer to the listview structure
9449 * [I] bRedraw: state of redraw flag
9452 * DefWinProc return value
9454 static LRESULT
LISTVIEW_SetRedraw(LISTVIEW_INFO
*infoPtr
, BOOL bRedraw
)
9456 TRACE("infoPtr->bRedraw=%d, bRedraw=%d\n", infoPtr
->bRedraw
, bRedraw
);
9458 /* we cannot use straight equality here because _any_ non-zero value is TRUE */
9459 if ((infoPtr
->bRedraw
&& bRedraw
) || (!infoPtr
->bRedraw
&& !bRedraw
)) return 0;
9461 infoPtr
->bRedraw
= bRedraw
;
9463 if(!bRedraw
) return 0;
9465 if (is_autoarrange(infoPtr
))
9466 LISTVIEW_Arrange(infoPtr
, LVA_DEFAULT
);
9467 LISTVIEW_UpdateScroll(infoPtr
);
9469 /* despite what the WM_SETREDRAW docs says, apps expect us
9470 * to invalidate the listview here... stupid! */
9471 LISTVIEW_InvalidateList(infoPtr
);
9478 * Resizes the listview control. This function processes WM_SIZE
9479 * messages. At this time, the width and height are not used.
9482 * [I] infoPtr : valid pointer to the listview structure
9483 * [I] Width : new width
9484 * [I] Height : new height
9489 static LRESULT
LISTVIEW_Size(LISTVIEW_INFO
*infoPtr
, int Width
, int Height
)
9491 RECT rcOld
= infoPtr
->rcList
;
9493 TRACE("(width=%d, height=%d)\n", Width
, Height
);
9495 LISTVIEW_UpdateSize(infoPtr
);
9496 if (EqualRect(&rcOld
, &infoPtr
->rcList
)) return 0;
9498 /* do not bother with display related stuff if we're not redrawing */
9499 if (!is_redrawing(infoPtr
)) return 0;
9501 if (is_autoarrange(infoPtr
))
9502 LISTVIEW_Arrange(infoPtr
, LVA_DEFAULT
);
9504 LISTVIEW_UpdateScroll(infoPtr
);
9506 /* refresh all only for lists whose height changed significantly */
9507 if ((infoPtr
->dwStyle
& LVS_TYPEMASK
) == LVS_LIST
&&
9508 (rcOld
.bottom
- rcOld
.top
) / infoPtr
->nItemHeight
!=
9509 (infoPtr
->rcList
.bottom
- infoPtr
->rcList
.top
) / infoPtr
->nItemHeight
)
9510 LISTVIEW_InvalidateList(infoPtr
);
9517 * Sets the size information.
9520 * [I] infoPtr : valid pointer to the listview structure
9525 static void LISTVIEW_UpdateSize(LISTVIEW_INFO
*infoPtr
)
9527 UINT uView
= infoPtr
->dwStyle
& LVS_TYPEMASK
;
9529 TRACE("uView=%d, rcList(old)=%s\n", uView
, wine_dbgstr_rect(&infoPtr
->rcList
));
9531 GetClientRect(infoPtr
->hwndSelf
, &infoPtr
->rcList
);
9533 if (uView
== LVS_LIST
)
9535 /* Apparently the "LIST" style is supposed to have the same
9536 * number of items in a column even if there is no scroll bar.
9537 * Since if a scroll bar already exists then the bottom is already
9538 * reduced, only reduce if the scroll bar does not currently exist.
9539 * The "2" is there to mimic the native control. I think it may be
9540 * related to either padding or edges. (GLA 7/2002)
9542 if (!(GetWindowLongW(infoPtr
->hwndSelf
, GWL_STYLE
) & WS_HSCROLL
))
9543 infoPtr
->rcList
.bottom
-= GetSystemMetrics(SM_CYHSCROLL
);
9544 infoPtr
->rcList
.bottom
= max (infoPtr
->rcList
.bottom
- 2, 0);
9546 else if (uView
== LVS_REPORT
)
9551 hl
.prc
= &infoPtr
->rcList
;
9553 SendMessageW( infoPtr
->hwndHeader
, HDM_LAYOUT
, 0, (LPARAM
)&hl
);
9554 TRACE(" wp.flags=0x%08x, wp=%d,%d (%dx%d)\n", wp
.flags
, wp
.x
, wp
.y
, wp
.cx
, wp
.cy
);
9555 SetWindowPos(wp
.hwnd
, wp
.hwndInsertAfter
, wp
.x
, wp
.y
, wp
.cx
, wp
.cy
,
9556 wp
.flags
| ((infoPtr
->dwStyle
& LVS_NOCOLUMNHEADER
)
9557 ? SWP_HIDEWINDOW
: SWP_SHOWWINDOW
));
9558 TRACE(" after SWP wp=%d,%d (%dx%d)\n", wp
.x
, wp
.y
, wp
.cx
, wp
.cy
);
9560 infoPtr
->rcList
.top
= max(wp
.cy
, 0);
9561 infoPtr
->rcList
.top
+= (infoPtr
->dwLvExStyle
& LVS_EX_GRIDLINES
) ? 2 : 0;
9564 TRACE(" rcList=%s\n", wine_dbgstr_rect(&infoPtr
->rcList
));
9569 * Processes WM_STYLECHANGED messages.
9572 * [I] infoPtr : valid pointer to the listview structure
9573 * [I] wStyleType : window style type (normal or extended)
9574 * [I] lpss : window style information
9579 static INT
LISTVIEW_StyleChanged(LISTVIEW_INFO
*infoPtr
, WPARAM wStyleType
,
9580 const STYLESTRUCT
*lpss
)
9582 UINT uNewView
= lpss
->styleNew
& LVS_TYPEMASK
;
9583 UINT uOldView
= lpss
->styleOld
& LVS_TYPEMASK
;
9586 TRACE("(styletype=%lx, styleOld=0x%08x, styleNew=0x%08x)\n",
9587 wStyleType
, lpss
->styleOld
, lpss
->styleNew
);
9589 if (wStyleType
!= GWL_STYLE
) return 0;
9591 /* FIXME: if LVS_NOSORTHEADER changed, update header */
9592 /* or LVS_SORT{AS,DES}CENDING */
9594 infoPtr
->dwStyle
= lpss
->styleNew
;
9596 if (((lpss
->styleOld
& WS_HSCROLL
) != 0)&&
9597 ((lpss
->styleNew
& WS_HSCROLL
) == 0))
9598 ShowScrollBar(infoPtr
->hwndSelf
, SB_HORZ
, FALSE
);
9600 if (((lpss
->styleOld
& WS_VSCROLL
) != 0)&&
9601 ((lpss
->styleNew
& WS_VSCROLL
) == 0))
9602 ShowScrollBar(infoPtr
->hwndSelf
, SB_VERT
, FALSE
);
9604 if (uNewView
!= uOldView
)
9606 SIZE oldIconSize
= infoPtr
->iconSize
;
9609 SendMessageW(infoPtr
->hwndEdit
, WM_KILLFOCUS
, 0, 0);
9610 ShowWindow(infoPtr
->hwndHeader
, SW_HIDE
);
9612 ShowScrollBar(infoPtr
->hwndSelf
, SB_BOTH
, FALSE
);
9613 SetRectEmpty(&infoPtr
->rcFocus
);
9615 himl
= (uNewView
== LVS_ICON
? infoPtr
->himlNormal
: infoPtr
->himlSmall
);
9616 set_icon_size(&infoPtr
->iconSize
, himl
, uNewView
!= LVS_ICON
);
9618 if (uNewView
== LVS_ICON
)
9620 if ((infoPtr
->iconSize
.cx
!= oldIconSize
.cx
) || (infoPtr
->iconSize
.cy
!= oldIconSize
.cy
))
9622 TRACE("icon old size=(%d,%d), new size=(%d,%d)\n",
9623 oldIconSize
.cx
, oldIconSize
.cy
, infoPtr
->iconSize
.cx
, infoPtr
->iconSize
.cy
);
9624 LISTVIEW_SetIconSpacing(infoPtr
, 0, 0);
9627 else if (uNewView
== LVS_REPORT
)
9632 LISTVIEW_CreateHeader( infoPtr
);
9634 hl
.prc
= &infoPtr
->rcList
;
9636 SendMessageW( infoPtr
->hwndHeader
, HDM_LAYOUT
, 0, (LPARAM
)&hl
);
9637 SetWindowPos(infoPtr
->hwndHeader
, infoPtr
->hwndSelf
, wp
.x
, wp
.y
, wp
.cx
, wp
.cy
,
9638 wp
.flags
| ((infoPtr
->dwStyle
& LVS_NOCOLUMNHEADER
)
9639 ? SWP_HIDEWINDOW
: SWP_SHOWWINDOW
));
9642 LISTVIEW_UpdateItemSize(infoPtr
);
9645 if (uNewView
== LVS_REPORT
)
9647 if ((lpss
->styleOld
^ lpss
->styleNew
) & LVS_NOCOLUMNHEADER
)
9649 if (lpss
->styleNew
& LVS_NOCOLUMNHEADER
)
9651 /* Turn off the header control */
9652 style
= GetWindowLongW(infoPtr
->hwndHeader
, GWL_STYLE
);
9653 TRACE("Hide header control, was 0x%08x\n", style
);
9654 SetWindowLongW(infoPtr
->hwndHeader
, GWL_STYLE
, style
| HDS_HIDDEN
);
9656 /* Turn on the header control */
9657 if ((style
= GetWindowLongW(infoPtr
->hwndHeader
, GWL_STYLE
)) & HDS_HIDDEN
)
9659 TRACE("Show header control, was 0x%08x\n", style
);
9660 SetWindowLongW(infoPtr
->hwndHeader
, GWL_STYLE
, (style
& ~HDS_HIDDEN
) | WS_VISIBLE
);
9666 if ( (uNewView
== LVS_ICON
|| uNewView
== LVS_SMALLICON
) &&
9667 (uNewView
!= uOldView
|| ((lpss
->styleNew
^ lpss
->styleOld
) & LVS_ALIGNMASK
)) )
9668 LISTVIEW_Arrange(infoPtr
, LVA_DEFAULT
);
9670 /* update the size of the client area */
9671 LISTVIEW_UpdateSize(infoPtr
);
9673 /* add scrollbars if needed */
9674 LISTVIEW_UpdateScroll(infoPtr
);
9676 /* invalidate client area + erase background */
9677 LISTVIEW_InvalidateList(infoPtr
);
9684 * Processes WM_STYLECHANGING messages.
9687 * [I] infoPtr : valid pointer to the listview structure
9688 * [I] wStyleType : window style type (normal or extended)
9689 * [I0] lpss : window style information
9694 static INT
LISTVIEW_StyleChanging(LISTVIEW_INFO
*infoPtr
, WPARAM wStyleType
,
9697 TRACE("(styletype=%lx, styleOld=0x%08x, styleNew=0x%08x)\n",
9698 wStyleType
, lpss
->styleOld
, lpss
->styleNew
);
9700 /* don't forward LVS_OWNERDATA only if not already set to */
9701 if ((lpss
->styleNew
^ lpss
->styleOld
) & LVS_OWNERDATA
)
9703 if (lpss
->styleOld
& LVS_OWNERDATA
)
9704 lpss
->styleNew
|= LVS_OWNERDATA
;
9706 lpss
->styleNew
&= ~LVS_OWNERDATA
;
9714 * Processes WM_SHOWWINDOW messages.
9717 * [I] infoPtr : valid pointer to the listview structure
9718 * [I] bShown : window is being shown (FALSE when hidden)
9719 * [I] iStatus : window show status
9724 static LRESULT
LISTVIEW_ShowWindow(LISTVIEW_INFO
*infoPtr
, BOOL bShown
, INT iStatus
)
9726 UINT uView
= infoPtr
->dwStyle
& LVS_TYPEMASK
;
9728 /* header delayed creation */
9729 if ((uView
== LVS_REPORT
) && bShown
)
9731 LISTVIEW_CreateHeader(infoPtr
);
9733 if (!(LVS_NOCOLUMNHEADER
& infoPtr
->dwStyle
))
9734 ShowWindow(infoPtr
->hwndHeader
, SW_SHOWNORMAL
);
9742 * Window procedure of the listview control.
9745 static LRESULT WINAPI
9746 LISTVIEW_WindowProc(HWND hwnd
, UINT uMsg
, WPARAM wParam
, LPARAM lParam
)
9748 LISTVIEW_INFO
*infoPtr
= (LISTVIEW_INFO
*)GetWindowLongPtrW(hwnd
, 0);
9750 TRACE("(uMsg=%x wParam=%lx lParam=%lx)\n", uMsg
, wParam
, lParam
);
9752 if (!infoPtr
&& (uMsg
!= WM_NCCREATE
))
9753 return DefWindowProcW(hwnd
, uMsg
, wParam
, lParam
);
9757 case LVM_APPROXIMATEVIEWRECT
:
9758 return LISTVIEW_ApproximateViewRect(infoPtr
, (INT
)wParam
,
9759 LOWORD(lParam
), HIWORD(lParam
));
9761 return LISTVIEW_Arrange(infoPtr
, (INT
)wParam
);
9763 /* case LVM_CANCELEDITLABEL: */
9765 case LVM_CREATEDRAGIMAGE
:
9766 return (LRESULT
)LISTVIEW_CreateDragImage(infoPtr
, (INT
)wParam
, (LPPOINT
)lParam
);
9768 case LVM_DELETEALLITEMS
:
9769 return LISTVIEW_DeleteAllItems(infoPtr
, FALSE
);
9771 case LVM_DELETECOLUMN
:
9772 return LISTVIEW_DeleteColumn(infoPtr
, (INT
)wParam
);
9774 case LVM_DELETEITEM
:
9775 return LISTVIEW_DeleteItem(infoPtr
, (INT
)wParam
);
9777 case LVM_EDITLABELW
:
9778 return (LRESULT
)LISTVIEW_EditLabelT(infoPtr
, (INT
)wParam
, TRUE
);
9780 case LVM_EDITLABELA
:
9781 return (LRESULT
)LISTVIEW_EditLabelT(infoPtr
, (INT
)wParam
, FALSE
);
9783 /* case LVM_ENABLEGROUPVIEW: */
9785 case LVM_ENSUREVISIBLE
:
9786 return LISTVIEW_EnsureVisible(infoPtr
, (INT
)wParam
, (BOOL
)lParam
);
9789 return LISTVIEW_FindItemW(infoPtr
, (INT
)wParam
, (LPLVFINDINFOW
)lParam
);
9792 return LISTVIEW_FindItemA(infoPtr
, (INT
)wParam
, (LPLVFINDINFOA
)lParam
);
9794 case LVM_GETBKCOLOR
:
9795 return infoPtr
->clrBk
;
9797 /* case LVM_GETBKIMAGE: */
9799 case LVM_GETCALLBACKMASK
:
9800 return infoPtr
->uCallbackMask
;
9802 case LVM_GETCOLUMNA
:
9803 return LISTVIEW_GetColumnT(infoPtr
, (INT
)wParam
, (LPLVCOLUMNW
)lParam
, FALSE
);
9805 case LVM_GETCOLUMNW
:
9806 return LISTVIEW_GetColumnT(infoPtr
, (INT
)wParam
, (LPLVCOLUMNW
)lParam
, TRUE
);
9808 case LVM_GETCOLUMNORDERARRAY
:
9809 return LISTVIEW_GetColumnOrderArray(infoPtr
, (INT
)wParam
, (LPINT
)lParam
);
9811 case LVM_GETCOLUMNWIDTH
:
9812 return LISTVIEW_GetColumnWidth(infoPtr
, (INT
)wParam
);
9814 case LVM_GETCOUNTPERPAGE
:
9815 return LISTVIEW_GetCountPerPage(infoPtr
);
9817 case LVM_GETEDITCONTROL
:
9818 return (LRESULT
)infoPtr
->hwndEdit
;
9820 case LVM_GETEXTENDEDLISTVIEWSTYLE
:
9821 return infoPtr
->dwLvExStyle
;
9823 /* case LVM_GETGROUPINFO: */
9825 /* case LVM_GETGROUPMETRICS: */
9828 return (LRESULT
)infoPtr
->hwndHeader
;
9830 case LVM_GETHOTCURSOR
:
9831 return (LRESULT
)infoPtr
->hHotCursor
;
9833 case LVM_GETHOTITEM
:
9834 return infoPtr
->nHotItem
;
9836 case LVM_GETHOVERTIME
:
9837 return infoPtr
->dwHoverTime
;
9839 case LVM_GETIMAGELIST
:
9840 return (LRESULT
)LISTVIEW_GetImageList(infoPtr
, (INT
)wParam
);
9842 /* case LVM_GETINSERTMARK: */
9844 /* case LVM_GETINSERTMARKCOLOR: */
9846 /* case LVM_GETINSERTMARKRECT: */
9848 case LVM_GETISEARCHSTRINGA
:
9849 case LVM_GETISEARCHSTRINGW
:
9850 FIXME("LVM_GETISEARCHSTRING: unimplemented\n");
9854 return LISTVIEW_GetItemExtT(infoPtr
, (LPLVITEMW
)lParam
, FALSE
);
9857 return LISTVIEW_GetItemExtT(infoPtr
, (LPLVITEMW
)lParam
, TRUE
);
9859 case LVM_GETITEMCOUNT
:
9860 return infoPtr
->nItemCount
;
9862 case LVM_GETITEMPOSITION
:
9863 return LISTVIEW_GetItemPosition(infoPtr
, (INT
)wParam
, (LPPOINT
)lParam
);
9865 case LVM_GETITEMRECT
:
9866 return LISTVIEW_GetItemRect(infoPtr
, (INT
)wParam
, (LPRECT
)lParam
);
9868 case LVM_GETITEMSPACING
:
9869 return LISTVIEW_GetItemSpacing(infoPtr
, (BOOL
)wParam
);
9871 case LVM_GETITEMSTATE
:
9872 return LISTVIEW_GetItemState(infoPtr
, (INT
)wParam
, (UINT
)lParam
);
9874 case LVM_GETITEMTEXTA
:
9875 return LISTVIEW_GetItemTextT(infoPtr
, (INT
)wParam
, (LPLVITEMW
)lParam
, FALSE
);
9877 case LVM_GETITEMTEXTW
:
9878 return LISTVIEW_GetItemTextT(infoPtr
, (INT
)wParam
, (LPLVITEMW
)lParam
, TRUE
);
9880 case LVM_GETNEXTITEM
:
9881 return LISTVIEW_GetNextItem(infoPtr
, (INT
)wParam
, LOWORD(lParam
));
9883 case LVM_GETNUMBEROFWORKAREAS
:
9884 FIXME("LVM_GETNUMBEROFWORKAREAS: unimplemented\n");
9888 if (!lParam
) return FALSE
;
9889 if ((infoPtr
->dwStyle
& LVS_TYPEMASK
) == LVS_REPORT
||
9890 (infoPtr
->dwStyle
& LVS_TYPEMASK
) == LVS_LIST
) return FALSE
;
9891 LISTVIEW_GetOrigin(infoPtr
, (LPPOINT
)lParam
);
9894 /* case LVM_GETOUTLINECOLOR: */
9896 /* case LVM_GETSELECTEDCOLUMN: */
9898 case LVM_GETSELECTEDCOUNT
:
9899 return LISTVIEW_GetSelectedCount(infoPtr
);
9901 case LVM_GETSELECTIONMARK
:
9902 return infoPtr
->nSelectionMark
;
9904 case LVM_GETSTRINGWIDTHA
:
9905 return LISTVIEW_GetStringWidthT(infoPtr
, (LPCWSTR
)lParam
, FALSE
);
9907 case LVM_GETSTRINGWIDTHW
:
9908 return LISTVIEW_GetStringWidthT(infoPtr
, (LPCWSTR
)lParam
, TRUE
);
9910 case LVM_GETSUBITEMRECT
:
9911 return LISTVIEW_GetSubItemRect(infoPtr
, (UINT
)wParam
, (LPRECT
)lParam
);
9913 case LVM_GETTEXTBKCOLOR
:
9914 return infoPtr
->clrTextBk
;
9916 case LVM_GETTEXTCOLOR
:
9917 return infoPtr
->clrText
;
9919 /* case LVM_GETTILEINFO: */
9921 /* case LVM_GETTILEVIEWINFO: */
9923 case LVM_GETTOOLTIPS
:
9924 if( !infoPtr
->hwndToolTip
)
9925 infoPtr
->hwndToolTip
= COMCTL32_CreateToolTip( hwnd
);
9926 return (LRESULT
)infoPtr
->hwndToolTip
;
9928 case LVM_GETTOPINDEX
:
9929 return LISTVIEW_GetTopIndex(infoPtr
);
9931 case LVM_GETUNICODEFORMAT
:
9932 return (infoPtr
->notifyFormat
== NFR_UNICODE
);
9934 /* case LVM_GETVIEW: */
9936 case LVM_GETVIEWRECT
:
9937 return LISTVIEW_GetViewRect(infoPtr
, (LPRECT
)lParam
);
9939 case LVM_GETWORKAREAS
:
9940 FIXME("LVM_GETWORKAREAS: unimplemented\n");
9943 /* case LVM_HASGROUP: */
9946 return LISTVIEW_HitTest(infoPtr
, (LPLVHITTESTINFO
)lParam
, FALSE
, FALSE
);
9948 case LVM_INSERTCOLUMNA
:
9949 return LISTVIEW_InsertColumnT(infoPtr
, (INT
)wParam
, (LPLVCOLUMNW
)lParam
, FALSE
);
9951 case LVM_INSERTCOLUMNW
:
9952 return LISTVIEW_InsertColumnT(infoPtr
, (INT
)wParam
, (LPLVCOLUMNW
)lParam
, TRUE
);
9954 /* case LVM_INSERTGROUP: */
9956 /* case LVM_INSERTGROUPSORTED: */
9958 case LVM_INSERTITEMA
:
9959 return LISTVIEW_InsertItemT(infoPtr
, (LPLVITEMW
)lParam
, FALSE
);
9961 case LVM_INSERTITEMW
:
9962 return LISTVIEW_InsertItemT(infoPtr
, (LPLVITEMW
)lParam
, TRUE
);
9964 /* case LVM_INSERTMARKHITTEST: */
9966 /* case LVM_ISGROUPVIEWENABLED: */
9968 /* case LVM_MAPIDTOINDEX: */
9970 /* case LVM_MAPINDEXTOID: */
9972 /* case LVM_MOVEGROUP: */
9974 /* case LVM_MOVEITEMTOGROUP: */
9976 case LVM_REDRAWITEMS
:
9977 return LISTVIEW_RedrawItems(infoPtr
, (INT
)wParam
, (INT
)lParam
);
9979 /* case LVM_REMOVEALLGROUPS: */
9981 /* case LVM_REMOVEGROUP: */
9984 return LISTVIEW_Scroll(infoPtr
, (INT
)wParam
, (INT
)lParam
);
9986 case LVM_SETBKCOLOR
:
9987 return LISTVIEW_SetBkColor(infoPtr
, (COLORREF
)lParam
);
9989 /* case LVM_SETBKIMAGE: */
9991 case LVM_SETCALLBACKMASK
:
9992 infoPtr
->uCallbackMask
= (UINT
)wParam
;
9995 case LVM_SETCOLUMNA
:
9996 return LISTVIEW_SetColumnT(infoPtr
, (INT
)wParam
, (LPLVCOLUMNW
)lParam
, FALSE
);
9998 case LVM_SETCOLUMNW
:
9999 return LISTVIEW_SetColumnT(infoPtr
, (INT
)wParam
, (LPLVCOLUMNW
)lParam
, TRUE
);
10001 case LVM_SETCOLUMNORDERARRAY
:
10002 return LISTVIEW_SetColumnOrderArray(infoPtr
, (INT
)wParam
, (LPINT
)lParam
);
10004 case LVM_SETCOLUMNWIDTH
:
10005 return LISTVIEW_SetColumnWidth(infoPtr
, (INT
)wParam
, (short)LOWORD(lParam
));
10007 case LVM_SETEXTENDEDLISTVIEWSTYLE
:
10008 return LISTVIEW_SetExtendedListViewStyle(infoPtr
, (DWORD
)wParam
, (DWORD
)lParam
);
10010 /* case LVM_SETGROUPINFO: */
10012 /* case LVM_SETGROUPMETRICS: */
10014 case LVM_SETHOTCURSOR
:
10015 return (LRESULT
)LISTVIEW_SetHotCursor(infoPtr
, (HCURSOR
)lParam
);
10017 case LVM_SETHOTITEM
:
10018 return LISTVIEW_SetHotItem(infoPtr
, (INT
)wParam
);
10020 case LVM_SETHOVERTIME
:
10021 return LISTVIEW_SetHoverTime(infoPtr
, (DWORD
)wParam
);
10023 case LVM_SETICONSPACING
:
10024 return LISTVIEW_SetIconSpacing(infoPtr
, (short)LOWORD(lParam
), (short)HIWORD(lParam
));
10026 case LVM_SETIMAGELIST
:
10027 return (LRESULT
)LISTVIEW_SetImageList(infoPtr
, (INT
)wParam
, (HIMAGELIST
)lParam
);
10029 /* case LVM_SETINFOTIP: */
10031 /* case LVM_SETINSERTMARK: */
10033 /* case LVM_SETINSERTMARKCOLOR: */
10038 if (infoPtr
->dwStyle
& LVS_OWNERDATA
) return FALSE
;
10039 return LISTVIEW_SetItemT(infoPtr
, (LPLVITEMW
)lParam
, (uMsg
== LVM_SETITEMW
));
10042 case LVM_SETITEMCOUNT
:
10043 return LISTVIEW_SetItemCount(infoPtr
, (INT
)wParam
, (DWORD
)lParam
);
10045 case LVM_SETITEMPOSITION
:
10048 pt
.x
= (short)LOWORD(lParam
);
10049 pt
.y
= (short)HIWORD(lParam
);
10050 return LISTVIEW_SetItemPosition(infoPtr
, (INT
)wParam
, pt
);
10053 case LVM_SETITEMPOSITION32
:
10054 if (lParam
== 0) return FALSE
;
10055 return LISTVIEW_SetItemPosition(infoPtr
, (INT
)wParam
, *((POINT
*)lParam
));
10057 case LVM_SETITEMSTATE
:
10058 return LISTVIEW_SetItemState(infoPtr
, (INT
)wParam
, (LPLVITEMW
)lParam
);
10060 case LVM_SETITEMTEXTA
:
10061 return LISTVIEW_SetItemTextT(infoPtr
, (INT
)wParam
, (LPLVITEMW
)lParam
, FALSE
);
10063 case LVM_SETITEMTEXTW
:
10064 return LISTVIEW_SetItemTextT(infoPtr
, (INT
)wParam
, (LPLVITEMW
)lParam
, TRUE
);
10066 /* case LVM_SETOUTLINECOLOR: */
10068 /* case LVM_SETSELECTEDCOLUMN: */
10070 case LVM_SETSELECTIONMARK
:
10071 return LISTVIEW_SetSelectionMark(infoPtr
, (INT
)lParam
);
10073 case LVM_SETTEXTBKCOLOR
:
10074 return LISTVIEW_SetTextBkColor(infoPtr
, (COLORREF
)lParam
);
10076 case LVM_SETTEXTCOLOR
:
10077 return LISTVIEW_SetTextColor(infoPtr
, (COLORREF
)lParam
);
10079 /* case LVM_SETTILEINFO: */
10081 /* case LVM_SETTILEVIEWINFO: */
10083 /* case LVM_SETTILEWIDTH: */
10085 case LVM_SETTOOLTIPS
:
10086 return (LRESULT
)LISTVIEW_SetToolTips(infoPtr
, (HWND
)lParam
);
10088 case LVM_SETUNICODEFORMAT
:
10089 return LISTVIEW_SetUnicodeFormat(infoPtr
, wParam
);
10091 /* case LVM_SETVIEW: */
10093 /* case LVM_SETWORKAREAS: */
10095 /* case LVM_SORTGROUPS: */
10097 case LVM_SORTITEMS
:
10098 return LISTVIEW_SortItems(infoPtr
, (PFNLVCOMPARE
)lParam
, (LPARAM
)wParam
, FALSE
);
10100 case LVM_SORTITEMSEX
:
10101 return LISTVIEW_SortItems(infoPtr
, (PFNLVCOMPARE
)lParam
, (LPARAM
)wParam
, TRUE
);
10103 case LVM_SUBITEMHITTEST
:
10104 return LISTVIEW_HitTest(infoPtr
, (LPLVHITTESTINFO
)lParam
, TRUE
, FALSE
);
10107 return LISTVIEW_Update(infoPtr
, (INT
)wParam
);
10110 return LISTVIEW_ProcessLetterKeys( infoPtr
, wParam
, lParam
);
10113 return LISTVIEW_Command(infoPtr
, wParam
, lParam
);
10116 return LISTVIEW_NCCreate(hwnd
, (LPCREATESTRUCTW
)lParam
);
10119 return LISTVIEW_Create(hwnd
, (LPCREATESTRUCTW
)lParam
);
10122 return LISTVIEW_Destroy(infoPtr
);
10125 return LISTVIEW_Enable(infoPtr
, (BOOL
)wParam
);
10127 case WM_ERASEBKGND
:
10128 return LISTVIEW_EraseBkgnd(infoPtr
, (HDC
)wParam
);
10130 case WM_GETDLGCODE
:
10131 return DLGC_WANTCHARS
| DLGC_WANTARROWS
;
10134 return (LRESULT
)infoPtr
->hFont
;
10137 return LISTVIEW_HScroll(infoPtr
, (INT
)LOWORD(wParam
), 0, (HWND
)lParam
);
10140 return LISTVIEW_KeyDown(infoPtr
, (INT
)wParam
, (LONG
)lParam
);
10143 return LISTVIEW_KillFocus(infoPtr
);
10145 case WM_LBUTTONDBLCLK
:
10146 return LISTVIEW_LButtonDblClk(infoPtr
, (WORD
)wParam
, (SHORT
)LOWORD(lParam
), (SHORT
)HIWORD(lParam
));
10148 case WM_LBUTTONDOWN
:
10149 return LISTVIEW_LButtonDown(infoPtr
, (WORD
)wParam
, (SHORT
)LOWORD(lParam
), (SHORT
)HIWORD(lParam
));
10152 return LISTVIEW_LButtonUp(infoPtr
, (WORD
)wParam
, (SHORT
)LOWORD(lParam
), (SHORT
)HIWORD(lParam
));
10155 return LISTVIEW_MouseMove (infoPtr
, (WORD
)wParam
, (SHORT
)LOWORD(lParam
), (SHORT
)HIWORD(lParam
));
10157 case WM_MOUSEHOVER
:
10158 return LISTVIEW_MouseHover(infoPtr
, (WORD
)wParam
, (SHORT
)LOWORD(lParam
), (SHORT
)HIWORD(lParam
));
10161 return LISTVIEW_NCDestroy(infoPtr
);
10164 if (LISTVIEW_NCPaint(infoPtr
, (HRGN
)wParam
))
10169 if (lParam
&& ((LPNMHDR
)lParam
)->hwndFrom
== infoPtr
->hwndHeader
)
10170 return LISTVIEW_HeaderNotification(infoPtr
, (LPNMHEADERW
)lParam
);
10173 case WM_NOTIFYFORMAT
:
10174 return LISTVIEW_NotifyFormat(infoPtr
, (HWND
)wParam
, (INT
)lParam
);
10176 case WM_PRINTCLIENT
:
10177 return LISTVIEW_PrintClient(infoPtr
, (HDC
)wParam
, (DWORD
)lParam
);
10180 return LISTVIEW_Paint(infoPtr
, (HDC
)wParam
);
10182 case WM_RBUTTONDBLCLK
:
10183 return LISTVIEW_RButtonDblClk(infoPtr
, (WORD
)wParam
, (SHORT
)LOWORD(lParam
), (SHORT
)HIWORD(lParam
));
10185 case WM_RBUTTONDOWN
:
10186 return LISTVIEW_RButtonDown(infoPtr
, (WORD
)wParam
, (SHORT
)LOWORD(lParam
), (SHORT
)HIWORD(lParam
));
10189 return LISTVIEW_RButtonUp(infoPtr
, (WORD
)wParam
, (SHORT
)LOWORD(lParam
), (SHORT
)HIWORD(lParam
));
10192 if(LISTVIEW_SetCursor(infoPtr
, (HWND
)wParam
, LOWORD(lParam
), HIWORD(lParam
)))
10197 return LISTVIEW_SetFocus(infoPtr
, (HWND
)wParam
);
10200 return LISTVIEW_SetFont(infoPtr
, (HFONT
)wParam
, (WORD
)lParam
);
10203 return LISTVIEW_SetRedraw(infoPtr
, (BOOL
)wParam
);
10205 case WM_SHOWWINDOW
:
10206 LISTVIEW_ShowWindow(infoPtr
, (BOOL
)wParam
, (INT
)lParam
);
10207 return DefWindowProcW(hwnd
, uMsg
, wParam
, lParam
);
10210 return LISTVIEW_Size(infoPtr
, (short)LOWORD(lParam
), (short)HIWORD(lParam
));
10212 case WM_STYLECHANGED
:
10213 return LISTVIEW_StyleChanged(infoPtr
, wParam
, (LPSTYLESTRUCT
)lParam
);
10215 case WM_STYLECHANGING
:
10216 return LISTVIEW_StyleChanging(infoPtr
, wParam
, (LPSTYLESTRUCT
)lParam
);
10218 case WM_SYSCOLORCHANGE
:
10219 COMCTL32_RefreshSysColors();
10222 /* case WM_TIMER: */
10223 case WM_THEMECHANGED
:
10224 return LISTVIEW_ThemeChanged(infoPtr
);
10227 return LISTVIEW_VScroll(infoPtr
, (INT
)LOWORD(wParam
), 0, (HWND
)lParam
);
10229 case WM_MOUSEWHEEL
:
10230 if (wParam
& (MK_SHIFT
| MK_CONTROL
))
10231 return DefWindowProcW(hwnd
, uMsg
, wParam
, lParam
);
10232 return LISTVIEW_MouseWheel(infoPtr
, (short int)HIWORD(wParam
));
10234 case WM_WINDOWPOSCHANGED
:
10235 if (!(((WINDOWPOS
*)lParam
)->flags
& SWP_NOSIZE
))
10237 UINT uView
= infoPtr
->dwStyle
& LVS_TYPEMASK
;
10238 SetWindowPos(infoPtr
->hwndSelf
, 0, 0, 0, 0, 0, SWP_FRAMECHANGED
| SWP_NOACTIVATE
|
10239 SWP_NOZORDER
| SWP_NOMOVE
| SWP_NOSIZE
);
10241 if ((infoPtr
->dwStyle
& LVS_OWNERDRAWFIXED
) && (uView
== LVS_REPORT
))
10243 MEASUREITEMSTRUCT mis
;
10244 mis
.CtlType
= ODT_LISTVIEW
;
10245 mis
.CtlID
= GetWindowLongPtrW(infoPtr
->hwndSelf
, GWLP_ID
);
10249 mis
.itemHeight
= infoPtr
->nItemHeight
;
10250 SendMessageW(infoPtr
->hwndNotify
, WM_MEASUREITEM
, mis
.CtlID
, (LPARAM
)&mis
);
10251 if (infoPtr
->nItemHeight
!= max(mis
.itemHeight
, 1))
10252 infoPtr
->nMeasureItemHeight
= infoPtr
->nItemHeight
= max(mis
.itemHeight
, 1);
10255 LISTVIEW_UpdateSize(infoPtr
);
10256 LISTVIEW_UpdateScroll(infoPtr
);
10258 return DefWindowProcW(hwnd
, uMsg
, wParam
, lParam
);
10260 /* case WM_WININICHANGE: */
10263 if ((uMsg
>= WM_USER
) && (uMsg
< WM_APP
) && !COMCTL32_IsReflectedMessage(uMsg
))
10264 ERR("unknown msg %04x wp=%08lx lp=%08lx\n", uMsg
, wParam
, lParam
);
10267 /* call default window procedure */
10268 return DefWindowProcW(hwnd
, uMsg
, wParam
, lParam
);
10275 * Registers the window class.
10283 void LISTVIEW_Register(void)
10285 WNDCLASSW wndClass
;
10287 ZeroMemory(&wndClass
, sizeof(WNDCLASSW
));
10288 wndClass
.style
= CS_GLOBALCLASS
| CS_DBLCLKS
;
10289 wndClass
.lpfnWndProc
= LISTVIEW_WindowProc
;
10290 wndClass
.cbClsExtra
= 0;
10291 wndClass
.cbWndExtra
= sizeof(LISTVIEW_INFO
*);
10292 wndClass
.hCursor
= LoadCursorW(0, (LPWSTR
)IDC_ARROW
);
10293 wndClass
.hbrBackground
= (HBRUSH
)(COLOR_WINDOW
+ 1);
10294 wndClass
.lpszClassName
= WC_LISTVIEWW
;
10295 RegisterClassW(&wndClass
);
10300 * Unregisters the window class.
10308 void LISTVIEW_Unregister(void)
10310 UnregisterClassW(WC_LISTVIEWW
, NULL
);
10315 * Handle any WM_COMMAND messages
10318 * [I] infoPtr : valid pointer to the listview structure
10319 * [I] wParam : the first message parameter
10320 * [I] lParam : the second message parameter
10325 static LRESULT
LISTVIEW_Command(const LISTVIEW_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
10327 switch (HIWORD(wParam
))
10332 * Adjust the edit window size
10334 WCHAR buffer
[1024];
10335 HDC hdc
= GetDC(infoPtr
->hwndEdit
);
10336 HFONT hFont
, hOldFont
= 0;
10340 if (!infoPtr
->hwndEdit
|| !hdc
) return 0;
10341 GetWindowTextW(infoPtr
->hwndEdit
, buffer
, sizeof(buffer
)/sizeof(buffer
[0]));
10342 GetWindowRect(infoPtr
->hwndEdit
, &rect
);
10344 /* Select font to get the right dimension of the string */
10345 hFont
= (HFONT
)SendMessageW(infoPtr
->hwndEdit
, WM_GETFONT
, 0, 0);
10348 hOldFont
= SelectObject(hdc
, hFont
);
10351 if (GetTextExtentPoint32W(hdc
, buffer
, lstrlenW(buffer
), &sz
))
10353 TEXTMETRICW textMetric
;
10355 /* Add Extra spacing for the next character */
10356 GetTextMetricsW(hdc
, &textMetric
);
10357 sz
.cx
+= (textMetric
.tmMaxCharWidth
* 2);
10365 rect
.bottom
- rect
.top
,
10366 SWP_DRAWFRAME
|SWP_NOMOVE
);
10369 SelectObject(hdc
, hOldFont
);
10371 ReleaseDC(infoPtr
->hwndEdit
, hdc
);
10377 return SendMessageW (infoPtr
->hwndNotify
, WM_COMMAND
, wParam
, lParam
);
10386 * Subclassed edit control windproc function
10389 * [I] hwnd : the edit window handle
10390 * [I] uMsg : the message that is to be processed
10391 * [I] wParam : first message parameter
10392 * [I] lParam : second message parameter
10393 * [I] isW : TRUE if input is Unicode
10398 static LRESULT
EditLblWndProcT(HWND hwnd
, UINT uMsg
, WPARAM wParam
, LPARAM lParam
, BOOL isW
)
10400 LISTVIEW_INFO
*infoPtr
= (LISTVIEW_INFO
*)GetWindowLongPtrW(GetParent(hwnd
), 0);
10401 BOOL cancel
= FALSE
;
10403 TRACE("(hwnd=%p, uMsg=%x, wParam=%lx, lParam=%lx, isW=%d)\n",
10404 hwnd
, uMsg
, wParam
, lParam
, isW
);
10408 case WM_GETDLGCODE
:
10409 return DLGC_WANTARROWS
| DLGC_WANTALLKEYS
;
10416 WNDPROC editProc
= infoPtr
->EditWndProc
;
10417 infoPtr
->EditWndProc
= 0;
10418 SetWindowLongPtrW(hwnd
, GWLP_WNDPROC
, (DWORD_PTR
)editProc
);
10419 return CallWindowProcT(editProc
, hwnd
, uMsg
, wParam
, lParam
, isW
);
10423 if (VK_ESCAPE
== (INT
)wParam
)
10428 else if (VK_RETURN
== (INT
)wParam
)
10432 return CallWindowProcT(infoPtr
->EditWndProc
, hwnd
, uMsg
, wParam
, lParam
, isW
);
10435 /* kill the edit */
10436 if (infoPtr
->hwndEdit
)
10438 LPWSTR buffer
= NULL
;
10440 infoPtr
->hwndEdit
= 0;
10443 DWORD len
= isW
? GetWindowTextLengthW(hwnd
) : GetWindowTextLengthA(hwnd
);
10447 if ( (buffer
= Alloc((len
+1) * (isW
? sizeof(WCHAR
) : sizeof(CHAR
)))) )
10449 if (isW
) GetWindowTextW(hwnd
, buffer
, len
+1);
10450 else GetWindowTextA(hwnd
, (CHAR
*)buffer
, len
+1);
10454 LISTVIEW_EndEditLabelT(infoPtr
, buffer
, isW
);
10459 SendMessageW(hwnd
, WM_CLOSE
, 0, 0);
10465 * Subclassed edit control Unicode windproc function
10468 * [I] hwnd : the edit window handle
10469 * [I] uMsg : the message that is to be processed
10470 * [I] wParam : first message parameter
10471 * [I] lParam : second message parameter
10475 static LRESULT CALLBACK
EditLblWndProcW(HWND hwnd
, UINT uMsg
, WPARAM wParam
, LPARAM lParam
)
10477 return EditLblWndProcT(hwnd
, uMsg
, wParam
, lParam
, TRUE
);
10482 * Subclassed edit control ANSI windproc function
10485 * [I] hwnd : the edit window handle
10486 * [I] uMsg : the message that is to be processed
10487 * [I] wParam : first message parameter
10488 * [I] lParam : second message parameter
10492 static LRESULT CALLBACK
EditLblWndProcA(HWND hwnd
, UINT uMsg
, WPARAM wParam
, LPARAM lParam
)
10494 return EditLblWndProcT(hwnd
, uMsg
, wParam
, lParam
, FALSE
);
10499 * Creates a subclassed edit control
10502 * [I] infoPtr : valid pointer to the listview structure
10503 * [I] text : initial text for the edit
10504 * [I] style : the window style
10505 * [I] isW : TRUE if input is Unicode
10509 static HWND
CreateEditLabelT(LISTVIEW_INFO
*infoPtr
, LPCWSTR text
, DWORD style
,
10510 INT x
, INT y
, INT width
, INT height
, BOOL isW
)
10512 WCHAR editName
[5] = { 'E', 'd', 'i', 't', '\0' };
10517 TEXTMETRICW textMetric
;
10518 HINSTANCE hinst
= (HINSTANCE
)GetWindowLongPtrW(infoPtr
->hwndSelf
, GWLP_HINSTANCE
);
10520 TRACE("(text=%s, ..., isW=%d)\n", debugtext_t(text
, isW
), isW
);
10522 style
|= WS_CHILDWINDOW
|WS_CLIPSIBLINGS
|ES_LEFT
|ES_AUTOHSCROLL
|WS_BORDER
;
10523 hdc
= GetDC(infoPtr
->hwndSelf
);
10525 /* Select the font to get appropriate metric dimensions */
10526 if(infoPtr
->hFont
!= 0)
10527 hOldFont
= SelectObject(hdc
, infoPtr
->hFont
);
10529 /*Get String Length in pixels */
10530 GetTextExtentPoint32W(hdc
, text
, lstrlenW(text
), &sz
);
10532 /*Add Extra spacing for the next character */
10533 GetTextMetricsW(hdc
, &textMetric
);
10534 sz
.cx
+= (textMetric
.tmMaxCharWidth
* 2);
10536 if(infoPtr
->hFont
!= 0)
10537 SelectObject(hdc
, hOldFont
);
10539 ReleaseDC(infoPtr
->hwndSelf
, hdc
);
10541 hedit
= CreateWindowW(editName
, text
, style
, x
, y
, sz
.cx
, height
, infoPtr
->hwndSelf
, 0, hinst
, 0);
10543 hedit
= CreateWindowA("Edit", (LPCSTR
)text
, style
, x
, y
, sz
.cx
, height
, infoPtr
->hwndSelf
, 0, hinst
, 0);
10545 if (!hedit
) return 0;
10547 infoPtr
->EditWndProc
= (WNDPROC
)
10548 (isW
? SetWindowLongPtrW(hedit
, GWLP_WNDPROC
, (DWORD_PTR
)EditLblWndProcW
) :
10549 SetWindowLongPtrA(hedit
, GWLP_WNDPROC
, (DWORD_PTR
)EditLblWndProcA
) );
10551 SendMessageW(hedit
, WM_SETFONT
, (WPARAM
)infoPtr
->hFont
, FALSE
);