4 * Copyright 1998, 1999 Eric Kohl
5 * Copyright 1999 Luc Tourangeau
6 * Copyright 2000 Jason Mawdsley
7 * Copyright 2001 CodeWeavers Inc.
8 * Copyright 2002 Dimitrie O. Paun
9 * Copyright 2009-2012 Nikolay Sivov
10 * Copyright 2009 Owen Rudge for CodeWeavers
12 * This library is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU Lesser General Public
14 * License as published by the Free Software Foundation; either
15 * version 2.1 of the License, or (at your option) any later version.
17 * This library is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * Lesser General Public License for more details.
22 * You should have received a copy of the GNU Lesser General Public
23 * License along with this library; if not, write to the Free Software
24 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
28 * This code was audited for completeness against the documented features
29 * of Comctl32.dll version 6.0 on May. 20, 2005, by James Hawkins.
31 * Unless otherwise noted, we believe this code to be complete, as per
32 * the specification mentioned above.
33 * If you discover missing features, or bugs, please note them below.
37 * Default Message Processing
38 * -- WM_CREATE: create the icon and small icon image lists at this point only if
39 * the LVS_SHAREIMAGELISTS style is not specified.
40 * -- WM_WINDOWPOSCHANGED: arrange the list items if the current view is icon
41 * or small icon and the LVS_AUTOARRANGE style is specified.
46 * -- Hot item handling, mouse hovering
47 * -- Workareas support
52 * -- Expand large item in ICON mode when the cursor is flying over the icon or text.
53 * -- Support CustomDraw options for _WIN32_IE >= 0x560 (see NMLVCUSTOMDRAW docs).
54 * -- LVA_SNAPTOGRID not implemented
55 * -- LISTVIEW_ApproximateViewRect partially implemented
56 * -- LISTVIEW_SetColumnWidth ignores header images & bitmap
57 * -- LISTVIEW_SetIconSpacing is incomplete
58 * -- LISTVIEW_StyleChanged doesn't handle some changes too well
61 * -- LISTVIEW_GetNextItem needs to be rewritten. It is currently
62 * linear in the number of items in the list, and this is
63 * unacceptable for large lists.
64 * -- if list is sorted by item text LISTVIEW_InsertItemT could use
65 * binary search to calculate item index (e.g. DPA_Search()).
66 * This requires sorted state to be reliably tracked in item modifiers.
67 * -- we should keep an ordered array of coordinates in iconic mode
68 * this would allow to frame items (iterator_frameditems),
69 * and find nearest item (LVFI_NEARESTXY) a lot more efficiently
76 * -- LVIS_ACTIVATING (not currently supported by comctl32.dll version 6.0)
82 * -- LVS_NOSCROLL (see Q137520)
86 * -- LVS_EX_BORDERSELECT
90 * -- LVS_EX_MULTIWORKAREAS
92 * -- LVS_EX_SIMPLESELECT
93 * -- LVS_EX_TWOCLICKACTIVATE
94 * -- LVS_EX_UNDERLINECOLD
95 * -- LVS_EX_UNDERLINEHOT
98 * -- LVN_BEGINSCROLL, LVN_ENDSCROLL
105 * -- LVM_ENABLEGROUPVIEW
106 * -- LVM_GETBKIMAGE, LVM_SETBKIMAGE
107 * -- LVM_GETGROUPINFO, LVM_SETGROUPINFO
108 * -- LVM_GETGROUPMETRICS, LVM_SETGROUPMETRICS
109 * -- LVM_GETINSERTMARK, LVM_SETINSERTMARK
110 * -- LVM_GETINSERTMARKCOLOR, LVM_SETINSERTMARKCOLOR
111 * -- LVM_GETINSERTMARKRECT
112 * -- LVM_GETNUMBEROFWORKAREAS
113 * -- LVM_GETOUTLINECOLOR, LVM_SETOUTLINECOLOR
114 * -- LVM_GETSELECTEDCOLUMN, LVM_SETSELECTEDCOLUMN
115 * -- LVM_GETISEARCHSTRINGW, LVM_GETISEARCHSTRINGA
116 * -- LVM_GETTILEINFO, LVM_SETTILEINFO
117 * -- LVM_GETTILEVIEWINFO, LVM_SETTILEVIEWINFO
118 * -- LVM_GETWORKAREAS, LVM_SETWORKAREAS
119 * -- LVM_HASGROUP, LVM_INSERTGROUP, LVM_REMOVEGROUP, LVM_REMOVEALLGROUPS
120 * -- LVM_INSERTGROUPSORTED
121 * -- LVM_INSERTMARKHITTEST
122 * -- LVM_ISGROUPVIEWENABLED
124 * -- LVM_MOVEITEMTOGROUP
126 * -- LVM_SETTILEWIDTH
130 * -- ListView_GetHoverTime, ListView_SetHoverTime
131 * -- ListView_GetISearchString
132 * -- ListView_GetNumberOfWorkAreas
133 * -- ListView_GetWorkAreas, ListView_SetWorkAreas
138 * Known differences in message stream from native control (not known if
139 * these differences cause problems):
140 * LVM_INSERTITEM issues LVM_SETITEMSTATE and LVM_SETITEM in certain cases.
141 * LVM_SETITEM does not always issue LVN_ITEMCHANGING/LVN_ITEMCHANGED.
142 * WM_CREATE does not issue WM_QUERYUISTATE and associated registry
143 * processing for "USEDOUBLECLICKTIME".
147 #include "wine/port.h"
162 #include "commctrl.h"
163 #include "comctl32.h"
166 #include "wine/debug.h"
167 #include "wine/unicode.h"
169 WINE_DEFAULT_DEBUG_CHANNEL(listview
);
171 typedef struct tagCOLUMN_INFO
173 RECT rcHeader
; /* tracks the header's rectangle */
174 INT fmt
; /* same as LVCOLUMN.fmt */
178 typedef struct tagITEMHDR
182 } ITEMHDR
, *LPITEMHDR
;
184 typedef struct tagSUBITEM_INFO
190 typedef struct tagITEM_ID ITEM_ID
;
192 typedef struct tagITEM_INFO
203 UINT id
; /* item id */
204 HDPA item
; /* link to item data */
207 typedef struct tagRANGE
213 typedef struct tagRANGES
218 typedef struct tagITERATOR
227 typedef struct tagDELAYED_ITEM_EDIT
233 typedef struct tagLISTVIEW_INFO
237 RECT rcList
; /* This rectangle is really the window
238 * client rectangle possibly reduced by the
239 * horizontal scroll bar and/or header - see
240 * LISTVIEW_UpdateSize. This rectangle offset
241 * by the LISTVIEW_GetOrigin value is in
242 * client coordinates */
244 /* notification window */
247 BOOL bDoChangeNotify
; /* send change notification messages? */
254 INT nItemCount
; /* the number of items in the list */
255 HDPA hdpaItems
; /* array ITEM_INFO pointers */
256 HDPA hdpaItemIds
; /* array of ITEM_ID pointers */
257 HDPA hdpaPosX
; /* maintains the (X, Y) coordinates of the */
258 HDPA hdpaPosY
; /* items in LVS_ICON, and LVS_SMALLICON modes */
259 RANGES selectionRanges
;
260 INT nSelectionMark
; /* item to start next multiselection from */
262 BOOL bAutoarrange
; /* Autoarrange flag when NOT in LVS_AUTOARRANGE */
265 HDPA hdpaColumns
; /* array of COLUMN_INFO pointers */
266 BOOL colRectsDirty
; /* trigger column rectangles requery from header */
269 BOOL bNoItemMetrics
; /* flags if item metrics are not yet computed */
274 PFNLVCOMPARE pfnCompare
; /* sorting callback pointer */
278 DWORD dwStyle
; /* the cached window GWL_STYLE */
279 DWORD dwLvExStyle
; /* extended listview style */
280 DWORD uView
; /* current view available through LVM_[G,S]ETVIEW */
286 DELAYED_ITEM_EDIT itemEdit
; /* Pointer to this structure will be the timer ID */
289 HIMAGELIST himlNormal
;
290 HIMAGELIST himlSmall
;
291 HIMAGELIST himlState
;
295 POINT currIconPos
; /* this is the position next icon will be placed */
299 INT xTrackLine
; /* The x coefficient of the track line or -1 if none */
301 /* marquee selection */
302 BOOL bMarqueeSelect
; /* marquee selection/highlight underway */
304 RECT marqueeRect
; /* absolute coordinates of marquee selection */
305 RECT marqueeDrawRect
; /* relative coordinates for drawing marquee */
306 POINT marqueeOrigin
; /* absolute coordinates of marquee click origin */
309 BOOL bFocus
; /* control has focus */
311 RECT rcFocus
; /* focus bounds */
322 INT ntmHeight
; /* Some cached metrics of the font used */
323 INT ntmMaxCharWidth
; /* by the listview to draw items */
326 /* mouse operation */
330 POINT ptClickPos
; /* point where the user clicked */
331 INT nLButtonDownItem
; /* tracks item to reset multiselection on WM_LBUTTONUP */
335 /* keyboard operation */
336 DWORD lastKeyPressTimestamp
;
338 INT nSearchParamLength
;
339 WCHAR szSearchParam
[ MAX_PATH
];
342 DWORD cditemmode
; /* Keep the custom draw flags for an item/row */
343 BOOL bIsDrawing
; /* Drawing in progress */
344 INT nMeasureItemHeight
; /* WM_MEASUREITEM result */
345 BOOL bRedraw
; /* WM_SETREDRAW switch */
348 DWORD iVersion
; /* CCM_[G,S]ETVERSION */
354 /* How many we debug buffer to allocate */
355 #define DEBUG_BUFFERS 20
356 /* The size of a single debug buffer */
357 #define DEBUG_BUFFER_SIZE 256
359 /* Internal interface to LISTVIEW_HScroll and LISTVIEW_VScroll */
360 #define SB_INTERNAL -1
362 /* maximum size of a label */
363 #define DISP_TEXT_SIZE 260
365 /* padding for items in list and small icon display modes */
366 #define WIDTH_PADDING 12
368 /* padding for items in list, report and small icon display modes */
369 #define HEIGHT_PADDING 1
371 /* offset of items in report display mode */
372 #define REPORT_MARGINX 2
374 /* padding for icon in large icon display mode
375 * ICON_TOP_PADDING_NOTHITABLE - space between top of box and area
376 * that HITTEST will see.
377 * ICON_TOP_PADDING_HITABLE - spacing between above and icon.
378 * ICON_TOP_PADDING - sum of the two above.
379 * ICON_BOTTOM_PADDING - between bottom of icon and top of text
380 * LABEL_HOR_PADDING - between text and sides of box
381 * LABEL_VERT_PADDING - between bottom of text and end of box
383 * ICON_LR_PADDING - additional width above icon size.
384 * ICON_LR_HALF - half of the above value
386 #define ICON_TOP_PADDING_NOTHITABLE 2
387 #define ICON_TOP_PADDING_HITABLE 2
388 #define ICON_TOP_PADDING (ICON_TOP_PADDING_NOTHITABLE + ICON_TOP_PADDING_HITABLE)
389 #define ICON_BOTTOM_PADDING 4
390 #define LABEL_HOR_PADDING 5
391 #define LABEL_VERT_PADDING 7
392 #define ICON_LR_PADDING 16
393 #define ICON_LR_HALF (ICON_LR_PADDING/2)
395 /* default label width for items in list and small icon display modes */
396 #define DEFAULT_LABEL_WIDTH 40
397 /* maximum select rectangle width for empty text item in LV_VIEW_DETAILS */
398 #define MAX_EMPTYTEXT_SELECT_WIDTH 80
400 /* default column width for items in list display mode */
401 #define DEFAULT_COLUMN_WIDTH 128
403 /* Size of "line" scroll for V & H scrolls */
404 #define LISTVIEW_SCROLL_ICON_LINE_SIZE 37
406 /* Padding between image and label */
407 #define IMAGE_PADDING 2
409 /* Padding behind the label */
410 #define TRAILING_LABEL_PADDING 12
411 #define TRAILING_HEADER_PADDING 11
413 /* Border for the icon caption */
414 #define CAPTION_BORDER 2
416 /* Standard DrawText flags */
417 #define LV_ML_DT_FLAGS (DT_TOP | DT_NOPREFIX | DT_EDITCONTROL | DT_CENTER | DT_WORDBREAK | DT_WORD_ELLIPSIS | DT_END_ELLIPSIS)
418 #define LV_FL_DT_FLAGS (DT_TOP | DT_NOPREFIX | DT_EDITCONTROL | DT_CENTER | DT_WORDBREAK | DT_NOCLIP)
419 #define LV_SL_DT_FLAGS (DT_VCENTER | DT_NOPREFIX | DT_EDITCONTROL | DT_SINGLELINE | DT_WORD_ELLIPSIS | DT_END_ELLIPSIS)
421 /* Image index from state */
422 #define STATEIMAGEINDEX(x) (((x) & LVIS_STATEIMAGEMASK) >> 12)
424 /* The time in milliseconds to reset the search in the list */
425 #define KEY_DELAY 450
427 /* Dump the LISTVIEW_INFO structure to the debug channel */
428 #define LISTVIEW_DUMP(iP) do { \
429 TRACE("hwndSelf=%p, clrBk=0x%06x, clrText=0x%06x, clrTextBk=0x%06x, ItemHeight=%d, ItemWidth=%d, Style=0x%08x\n", \
430 iP->hwndSelf, iP->clrBk, iP->clrText, iP->clrTextBk, \
431 iP->nItemHeight, iP->nItemWidth, iP->dwStyle); \
432 TRACE("hwndSelf=%p, himlNor=%p, himlSml=%p, himlState=%p, Focused=%d, Hot=%d, exStyle=0x%08x, Focus=%d\n", \
433 iP->hwndSelf, iP->himlNormal, iP->himlSmall, iP->himlState, \
434 iP->nFocusedItem, iP->nHotItem, iP->dwLvExStyle, iP->bFocus ); \
435 TRACE("hwndSelf=%p, ntmH=%d, icSz.cx=%d, icSz.cy=%d, icSp.cx=%d, icSp.cy=%d, notifyFmt=%d\n", \
436 iP->hwndSelf, iP->ntmHeight, iP->iconSize.cx, iP->iconSize.cy, \
437 iP->iconSpacing.cx, iP->iconSpacing.cy, iP->notifyFormat); \
438 TRACE("hwndSelf=%p, rcList=%s\n", iP->hwndSelf, wine_dbgstr_rect(&iP->rcList)); \
441 static const WCHAR themeClass
[] = {'L','i','s','t','V','i','e','w',0};
444 * forward declarations
446 static BOOL
LISTVIEW_GetItemT(const LISTVIEW_INFO
*, LPLVITEMW
, BOOL
);
447 static void LISTVIEW_GetItemBox(const LISTVIEW_INFO
*, INT
, LPRECT
);
448 static void LISTVIEW_GetItemOrigin(const LISTVIEW_INFO
*, INT
, LPPOINT
);
449 static BOOL
LISTVIEW_GetItemPosition(const LISTVIEW_INFO
*, INT
, LPPOINT
);
450 static BOOL
LISTVIEW_GetItemRect(const LISTVIEW_INFO
*, INT
, LPRECT
);
451 static void LISTVIEW_GetOrigin(const LISTVIEW_INFO
*, LPPOINT
);
452 static BOOL
LISTVIEW_GetViewRect(const LISTVIEW_INFO
*, LPRECT
);
453 static void LISTVIEW_UpdateSize(LISTVIEW_INFO
*);
454 static LRESULT
LISTVIEW_Command(LISTVIEW_INFO
*, WPARAM
, LPARAM
);
455 static INT
LISTVIEW_GetStringWidthT(const LISTVIEW_INFO
*, LPCWSTR
, BOOL
);
456 static BOOL
LISTVIEW_KeySelection(LISTVIEW_INFO
*, INT
, BOOL
);
457 static UINT
LISTVIEW_GetItemState(const LISTVIEW_INFO
*, INT
, UINT
);
458 static BOOL
LISTVIEW_SetItemState(LISTVIEW_INFO
*, INT
, const LVITEMW
*);
459 static LRESULT
LISTVIEW_VScroll(LISTVIEW_INFO
*, INT
, INT
);
460 static LRESULT
LISTVIEW_HScroll(LISTVIEW_INFO
*, INT
, INT
);
461 static BOOL
LISTVIEW_EnsureVisible(LISTVIEW_INFO
*, INT
, BOOL
);
462 static HIMAGELIST
LISTVIEW_SetImageList(LISTVIEW_INFO
*, INT
, HIMAGELIST
);
463 static INT
LISTVIEW_HitTest(const LISTVIEW_INFO
*, LPLVHITTESTINFO
, BOOL
, BOOL
);
464 static BOOL
LISTVIEW_EndEditLabelT(LISTVIEW_INFO
*, BOOL
, BOOL
);
465 static BOOL
LISTVIEW_Scroll(LISTVIEW_INFO
*, INT
, INT
);
467 /******** Text handling functions *************************************/
469 /* A text pointer is either NULL, LPSTR_TEXTCALLBACK, or points to a
470 * text string. The string may be ANSI or Unicode, in which case
471 * the boolean isW tells us the type of the string.
473 * The name of the function tell what type of strings it expects:
474 * W: Unicode, T: ANSI/Unicode - function of isW
477 static inline BOOL
is_text(LPCWSTR text
)
479 return text
!= NULL
&& text
!= LPSTR_TEXTCALLBACKW
;
482 static inline int textlenT(LPCWSTR text
, BOOL isW
)
484 return !is_text(text
) ? 0 :
485 isW
? lstrlenW(text
) : lstrlenA((LPCSTR
)text
);
488 static inline void textcpynT(LPWSTR dest
, BOOL isDestW
, LPCWSTR src
, BOOL isSrcW
, INT max
)
491 if (isSrcW
) lstrcpynW(dest
, src
, max
);
492 else MultiByteToWideChar(CP_ACP
, 0, (LPCSTR
)src
, -1, dest
, max
);
494 if (isSrcW
) WideCharToMultiByte(CP_ACP
, 0, src
, -1, (LPSTR
)dest
, max
, NULL
, NULL
);
495 else lstrcpynA((LPSTR
)dest
, (LPCSTR
)src
, max
);
498 static inline LPWSTR
textdupTtoW(LPCWSTR text
, BOOL isW
)
500 LPWSTR wstr
= (LPWSTR
)text
;
502 if (!isW
&& is_text(text
))
504 INT len
= MultiByteToWideChar(CP_ACP
, 0, (LPCSTR
)text
, -1, NULL
, 0);
505 wstr
= Alloc(len
* sizeof(WCHAR
));
506 if (wstr
) MultiByteToWideChar(CP_ACP
, 0, (LPCSTR
)text
, -1, wstr
, len
);
508 TRACE(" wstr=%s\n", text
== LPSTR_TEXTCALLBACKW
? "(callback)" : debugstr_w(wstr
));
512 static inline void textfreeT(LPWSTR wstr
, BOOL isW
)
514 if (!isW
&& is_text(wstr
)) Free (wstr
);
518 * dest is a pointer to a Unicode string
519 * src is a pointer to a string (Unicode if isW, ANSI if !isW)
521 static BOOL
textsetptrT(LPWSTR
*dest
, LPCWSTR src
, BOOL isW
)
525 if (src
== LPSTR_TEXTCALLBACKW
)
527 if (is_text(*dest
)) Free(*dest
);
528 *dest
= LPSTR_TEXTCALLBACKW
;
532 LPWSTR pszText
= textdupTtoW(src
, isW
);
533 if (*dest
== LPSTR_TEXTCALLBACKW
) *dest
= NULL
;
534 bResult
= Str_SetPtrW(dest
, pszText
);
535 textfreeT(pszText
, isW
);
541 * compares a Unicode to a Unicode/ANSI text string
543 static inline int textcmpWT(LPCWSTR aw
, LPCWSTR bt
, BOOL isW
)
545 if (!aw
) return bt
? -1 : 0;
547 if (aw
== LPSTR_TEXTCALLBACKW
)
548 return bt
== LPSTR_TEXTCALLBACKW
? 1 : -1;
549 if (bt
!= LPSTR_TEXTCALLBACKW
)
551 LPWSTR bw
= textdupTtoW(bt
, isW
);
552 int r
= bw
? lstrcmpW(aw
, bw
) : 1;
560 static inline int lstrncmpiW(LPCWSTR s1
, LPCWSTR s2
, int n
)
562 n
= min(min(n
, lstrlenW(s1
)), lstrlenW(s2
));
563 return CompareStringW(LOCALE_USER_DEFAULT
, NORM_IGNORECASE
, s1
, n
, s2
, n
) - CSTR_EQUAL
;
566 /******** Debugging functions *****************************************/
568 static inline LPCSTR
debugtext_t(LPCWSTR text
, BOOL isW
)
570 if (text
== LPSTR_TEXTCALLBACKW
) return "(callback)";
571 return isW
? debugstr_w(text
) : debugstr_a((LPCSTR
)text
);
574 static inline LPCSTR
debugtext_tn(LPCWSTR text
, BOOL isW
, INT n
)
576 if (text
== LPSTR_TEXTCALLBACKW
) return "(callback)";
577 n
= min(textlenT(text
, isW
), n
);
578 return isW
? debugstr_wn(text
, n
) : debugstr_an((LPCSTR
)text
, n
);
581 static char* debug_getbuf(void)
583 static int index
= 0;
584 static char buffers
[DEBUG_BUFFERS
][DEBUG_BUFFER_SIZE
];
585 return buffers
[index
++ % DEBUG_BUFFERS
];
588 static inline const char* debugrange(const RANGE
*lprng
)
590 if (!lprng
) return "(null)";
591 return wine_dbg_sprintf("[%d, %d]", lprng
->lower
, lprng
->upper
);
594 static const char* debugscrollinfo(const SCROLLINFO
*pScrollInfo
)
596 char* buf
= debug_getbuf(), *text
= buf
;
597 int len
, size
= DEBUG_BUFFER_SIZE
;
599 if (pScrollInfo
== NULL
) return "(null)";
600 len
= snprintf(buf
, size
, "{cbSize=%d, ", pScrollInfo
->cbSize
);
601 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
602 if (pScrollInfo
->fMask
& SIF_RANGE
)
603 len
= snprintf(buf
, size
, "nMin=%d, nMax=%d, ", pScrollInfo
->nMin
, pScrollInfo
->nMax
);
605 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
606 if (pScrollInfo
->fMask
& SIF_PAGE
)
607 len
= snprintf(buf
, size
, "nPage=%u, ", pScrollInfo
->nPage
);
609 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
610 if (pScrollInfo
->fMask
& SIF_POS
)
611 len
= snprintf(buf
, size
, "nPos=%d, ", pScrollInfo
->nPos
);
613 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
614 if (pScrollInfo
->fMask
& SIF_TRACKPOS
)
615 len
= snprintf(buf
, size
, "nTrackPos=%d, ", pScrollInfo
->nTrackPos
);
617 if (len
== -1) goto end
; buf
+= len
;
620 buf
= text
+ strlen(text
);
622 if (buf
- text
> 2) { buf
[-2] = '}'; buf
[-1] = 0; }
626 static const char* debugnmlistview(const NMLISTVIEW
*plvnm
)
628 if (!plvnm
) return "(null)";
629 return wine_dbg_sprintf("iItem=%d, iSubItem=%d, uNewState=0x%x,"
630 " uOldState=0x%x, uChanged=0x%x, ptAction=%s, lParam=%ld",
631 plvnm
->iItem
, plvnm
->iSubItem
, plvnm
->uNewState
, plvnm
->uOldState
,
632 plvnm
->uChanged
, wine_dbgstr_point(&plvnm
->ptAction
), plvnm
->lParam
);
635 static const char* debuglvitem_t(const LVITEMW
*lpLVItem
, BOOL isW
)
637 char* buf
= debug_getbuf(), *text
= buf
;
638 int len
, size
= DEBUG_BUFFER_SIZE
;
640 if (lpLVItem
== NULL
) return "(null)";
641 len
= snprintf(buf
, size
, "{iItem=%d, iSubItem=%d, ", lpLVItem
->iItem
, lpLVItem
->iSubItem
);
642 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
643 if (lpLVItem
->mask
& LVIF_STATE
)
644 len
= snprintf(buf
, size
, "state=%x, stateMask=%x, ", lpLVItem
->state
, lpLVItem
->stateMask
);
646 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
647 if (lpLVItem
->mask
& LVIF_TEXT
)
648 len
= snprintf(buf
, size
, "pszText=%s, cchTextMax=%d, ", debugtext_tn(lpLVItem
->pszText
, isW
, 80), lpLVItem
->cchTextMax
);
650 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
651 if (lpLVItem
->mask
& LVIF_IMAGE
)
652 len
= snprintf(buf
, size
, "iImage=%d, ", lpLVItem
->iImage
);
654 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
655 if (lpLVItem
->mask
& LVIF_PARAM
)
656 len
= snprintf(buf
, size
, "lParam=%lx, ", lpLVItem
->lParam
);
658 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
659 if (lpLVItem
->mask
& LVIF_INDENT
)
660 len
= snprintf(buf
, size
, "iIndent=%d, ", lpLVItem
->iIndent
);
662 if (len
== -1) goto end
; buf
+= len
;
665 buf
= text
+ strlen(text
);
667 if (buf
- text
> 2) { buf
[-2] = '}'; buf
[-1] = 0; }
671 static const char* debuglvcolumn_t(const LVCOLUMNW
*lpColumn
, BOOL isW
)
673 char* buf
= debug_getbuf(), *text
= buf
;
674 int len
, size
= DEBUG_BUFFER_SIZE
;
676 if (lpColumn
== NULL
) return "(null)";
677 len
= snprintf(buf
, size
, "{");
678 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
679 if (lpColumn
->mask
& LVCF_SUBITEM
)
680 len
= snprintf(buf
, size
, "iSubItem=%d, ", lpColumn
->iSubItem
);
682 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
683 if (lpColumn
->mask
& LVCF_FMT
)
684 len
= snprintf(buf
, size
, "fmt=%x, ", lpColumn
->fmt
);
686 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
687 if (lpColumn
->mask
& LVCF_WIDTH
)
688 len
= snprintf(buf
, size
, "cx=%d, ", lpColumn
->cx
);
690 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
691 if (lpColumn
->mask
& LVCF_TEXT
)
692 len
= snprintf(buf
, size
, "pszText=%s, cchTextMax=%d, ", debugtext_tn(lpColumn
->pszText
, isW
, 80), lpColumn
->cchTextMax
);
694 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
695 if (lpColumn
->mask
& LVCF_IMAGE
)
696 len
= snprintf(buf
, size
, "iImage=%d, ", lpColumn
->iImage
);
698 if (len
== -1) goto end
; buf
+= len
; size
-= len
;
699 if (lpColumn
->mask
& LVCF_ORDER
)
700 len
= snprintf(buf
, size
, "iOrder=%d, ", lpColumn
->iOrder
);
702 if (len
== -1) goto end
; buf
+= len
;
705 buf
= text
+ strlen(text
);
707 if (buf
- text
> 2) { buf
[-2] = '}'; buf
[-1] = 0; }
711 static const char* debuglvhittestinfo(const LVHITTESTINFO
*lpht
)
713 if (!lpht
) return "(null)";
715 return wine_dbg_sprintf("{pt=%s, flags=0x%x, iItem=%d, iSubItem=%d}",
716 wine_dbgstr_point(&lpht
->pt
), lpht
->flags
, lpht
->iItem
, lpht
->iSubItem
);
719 /* Return the corresponding text for a given scroll value */
720 static inline LPCSTR
debugscrollcode(int nScrollCode
)
724 case SB_LINELEFT
: return "SB_LINELEFT";
725 case SB_LINERIGHT
: return "SB_LINERIGHT";
726 case SB_PAGELEFT
: return "SB_PAGELEFT";
727 case SB_PAGERIGHT
: return "SB_PAGERIGHT";
728 case SB_THUMBPOSITION
: return "SB_THUMBPOSITION";
729 case SB_THUMBTRACK
: return "SB_THUMBTRACK";
730 case SB_ENDSCROLL
: return "SB_ENDSCROLL";
731 case SB_INTERNAL
: return "SB_INTERNAL";
732 default: return "unknown";
737 /******** Notification functions ************************************/
739 static int get_ansi_notification(UINT unicodeNotificationCode
)
741 switch (unicodeNotificationCode
)
743 case LVN_BEGINLABELEDITA
:
744 case LVN_BEGINLABELEDITW
: return LVN_BEGINLABELEDITA
;
745 case LVN_ENDLABELEDITA
:
746 case LVN_ENDLABELEDITW
: return LVN_ENDLABELEDITA
;
747 case LVN_GETDISPINFOA
:
748 case LVN_GETDISPINFOW
: return LVN_GETDISPINFOA
;
749 case LVN_SETDISPINFOA
:
750 case LVN_SETDISPINFOW
: return LVN_SETDISPINFOA
;
751 case LVN_ODFINDITEMA
:
752 case LVN_ODFINDITEMW
: return LVN_ODFINDITEMA
;
753 case LVN_GETINFOTIPA
:
754 case LVN_GETINFOTIPW
: return LVN_GETINFOTIPA
;
755 /* header forwards */
757 case HDN_TRACKW
: return HDN_TRACKA
;
759 case HDN_ENDTRACKW
: return HDN_ENDTRACKA
;
760 case HDN_BEGINDRAG
: return HDN_BEGINDRAG
;
761 case HDN_ENDDRAG
: return HDN_ENDDRAG
;
762 case HDN_ITEMCHANGINGA
:
763 case HDN_ITEMCHANGINGW
: return HDN_ITEMCHANGINGA
;
764 case HDN_ITEMCHANGEDA
:
765 case HDN_ITEMCHANGEDW
: return HDN_ITEMCHANGEDA
;
767 case HDN_ITEMCLICKW
: return HDN_ITEMCLICKA
;
768 case HDN_DIVIDERDBLCLICKA
:
769 case HDN_DIVIDERDBLCLICKW
: return HDN_DIVIDERDBLCLICKA
;
772 FIXME("unknown notification %x\n", unicodeNotificationCode
);
773 return unicodeNotificationCode
;
776 /* forwards header notifications to listview parent */
777 static LRESULT
notify_forward_header(const LISTVIEW_INFO
*infoPtr
, const NMHEADERW
*lpnmh
)
781 HD_TEXTFILTERA textfilter
;
782 LPSTR text
= NULL
, filter
= NULL
;
785 /* on unicode format exit earlier */
786 if (infoPtr
->notifyFormat
== NFR_UNICODE
)
787 return SendMessageW(infoPtr
->hwndNotify
, WM_NOTIFY
, lpnmh
->hdr
.idFrom
,
790 /* header always supplies unicode notifications,
791 all we have to do is to convert strings to ANSI */
792 nmhA
= *(const NMHEADERA
*)lpnmh
;
795 hditema
= *(HDITEMA
*)lpnmh
->pitem
;
796 nmhA
.pitem
= &hditema
;
797 /* convert item text */
798 if (lpnmh
->pitem
->mask
& HDI_TEXT
)
800 hditema
.pszText
= NULL
;
801 Str_SetPtrWtoA(&hditema
.pszText
, lpnmh
->pitem
->pszText
);
802 text
= hditema
.pszText
;
804 /* convert filter text */
805 if ((lpnmh
->pitem
->mask
& HDI_FILTER
) && (lpnmh
->pitem
->type
== HDFT_ISSTRING
) &&
806 lpnmh
->pitem
->pvFilter
)
808 hditema
.pvFilter
= &textfilter
;
809 textfilter
= *(HD_TEXTFILTERA
*)(lpnmh
->pitem
->pvFilter
);
810 textfilter
.pszText
= NULL
;
811 Str_SetPtrWtoA(&textfilter
.pszText
, ((HD_TEXTFILTERW
*)lpnmh
->pitem
->pvFilter
)->pszText
);
812 filter
= textfilter
.pszText
;
815 nmhA
.hdr
.code
= get_ansi_notification(lpnmh
->hdr
.code
);
817 ret
= SendMessageW(infoPtr
->hwndNotify
, WM_NOTIFY
, nmhA
.hdr
.idFrom
,
827 static LRESULT
notify_hdr(const LISTVIEW_INFO
*infoPtr
, INT code
, LPNMHDR pnmh
)
831 TRACE("(code=%d)\n", code
);
833 pnmh
->hwndFrom
= infoPtr
->hwndSelf
;
834 pnmh
->idFrom
= GetWindowLongPtrW(infoPtr
->hwndSelf
, GWLP_ID
);
836 result
= SendMessageW(infoPtr
->hwndNotify
, WM_NOTIFY
, pnmh
->idFrom
, (LPARAM
)pnmh
);
838 TRACE(" <= %ld\n", result
);
843 static inline BOOL
notify(const LISTVIEW_INFO
*infoPtr
, INT code
)
846 HWND hwnd
= infoPtr
->hwndSelf
;
847 notify_hdr(infoPtr
, code
, &nmh
);
848 return IsWindow(hwnd
);
851 static inline void notify_itemactivate(const LISTVIEW_INFO
*infoPtr
, const LVHITTESTINFO
*htInfo
)
862 item
.mask
= LVIF_PARAM
|LVIF_STATE
;
863 item
.iItem
= htInfo
->iItem
;
865 item
.stateMask
= (UINT
)-1;
866 if (LISTVIEW_GetItemT(infoPtr
, &item
, TRUE
)) {
867 nmia
.lParam
= item
.lParam
;
868 nmia
.uOldState
= item
.state
;
869 nmia
.uNewState
= item
.state
| LVIS_ACTIVATING
;
870 nmia
.uChanged
= LVIF_STATE
;
873 nmia
.iItem
= htInfo
->iItem
;
874 nmia
.iSubItem
= htInfo
->iSubItem
;
875 nmia
.ptAction
= htInfo
->pt
;
877 if (GetKeyState(VK_SHIFT
) & 0x8000) nmia
.uKeyFlags
|= LVKF_SHIFT
;
878 if (GetKeyState(VK_CONTROL
) & 0x8000) nmia
.uKeyFlags
|= LVKF_CONTROL
;
879 if (GetKeyState(VK_MENU
) & 0x8000) nmia
.uKeyFlags
|= LVKF_ALT
;
881 notify_hdr(infoPtr
, LVN_ITEMACTIVATE
, (LPNMHDR
)&nmia
);
884 static inline LRESULT
notify_listview(const LISTVIEW_INFO
*infoPtr
, INT code
, LPNMLISTVIEW plvnm
)
886 TRACE("(code=%d, plvnm=%s)\n", code
, debugnmlistview(plvnm
));
887 return notify_hdr(infoPtr
, code
, (LPNMHDR
)plvnm
);
890 static BOOL
notify_click(const LISTVIEW_INFO
*infoPtr
, INT code
, const LVHITTESTINFO
*lvht
)
894 HWND hwnd
= infoPtr
->hwndSelf
;
896 TRACE("code=%d, lvht=%s\n", code
, debuglvhittestinfo(lvht
));
897 ZeroMemory(&nmia
, sizeof(nmia
));
898 nmia
.iItem
= lvht
->iItem
;
899 nmia
.iSubItem
= lvht
->iSubItem
;
900 nmia
.ptAction
= lvht
->pt
;
901 item
.mask
= LVIF_PARAM
;
902 item
.iItem
= lvht
->iItem
;
904 if (LISTVIEW_GetItemT(infoPtr
, &item
, TRUE
)) nmia
.lParam
= item
.lParam
;
905 notify_hdr(infoPtr
, code
, (LPNMHDR
)&nmia
);
906 return IsWindow(hwnd
);
909 static BOOL
notify_deleteitem(const LISTVIEW_INFO
*infoPtr
, INT nItem
)
913 HWND hwnd
= infoPtr
->hwndSelf
;
915 ZeroMemory(&nmlv
, sizeof (NMLISTVIEW
));
917 item
.mask
= LVIF_PARAM
;
920 if (LISTVIEW_GetItemT(infoPtr
, &item
, TRUE
)) nmlv
.lParam
= item
.lParam
;
921 notify_listview(infoPtr
, LVN_DELETEITEM
, &nmlv
);
922 return IsWindow(hwnd
);
926 Send notification. depends on dispinfoW having same
927 structure as dispinfoA.
928 infoPtr : listview struct
929 code : *Unicode* notification code
930 pdi : dispinfo structure (can be unicode or ansi)
931 isW : TRUE if dispinfo is Unicode
933 static BOOL
notify_dispinfoT(const LISTVIEW_INFO
*infoPtr
, UINT code
, LPNMLVDISPINFOW pdi
, BOOL isW
)
935 INT length
= 0, ret_length
;
936 LPWSTR buffer
= NULL
, ret_text
;
937 BOOL return_ansi
= FALSE
;
938 BOOL return_unicode
= FALSE
;
941 if ((pdi
->item
.mask
& LVIF_TEXT
) && is_text(pdi
->item
.pszText
))
943 return_unicode
= ( isW
&& infoPtr
->notifyFormat
== NFR_ANSI
);
944 return_ansi
= (!isW
&& infoPtr
->notifyFormat
== NFR_UNICODE
);
947 ret_length
= pdi
->item
.cchTextMax
;
948 ret_text
= pdi
->item
.pszText
;
950 if (return_unicode
|| return_ansi
)
952 if (code
!= LVN_GETDISPINFOW
)
954 length
= return_ansi
?
955 MultiByteToWideChar(CP_ACP
, 0, (LPCSTR
)pdi
->item
.pszText
, -1, NULL
, 0):
956 WideCharToMultiByte(CP_ACP
, 0, pdi
->item
.pszText
, -1, NULL
, 0, NULL
, NULL
);
960 length
= pdi
->item
.cchTextMax
;
961 *pdi
->item
.pszText
= 0; /* make sure we don't process garbage */
964 buffer
= Alloc( (return_ansi
? sizeof(WCHAR
) : sizeof(CHAR
)) * length
);
965 if (!buffer
) return FALSE
;
968 MultiByteToWideChar(CP_ACP
, 0, (LPCSTR
)pdi
->item
.pszText
, -1,
971 WideCharToMultiByte(CP_ACP
, 0, pdi
->item
.pszText
, -1, (LPSTR
) buffer
,
974 pdi
->item
.pszText
= buffer
;
975 pdi
->item
.cchTextMax
= length
;
978 if (infoPtr
->notifyFormat
== NFR_ANSI
)
979 code
= get_ansi_notification(code
);
981 TRACE(" pdi->item=%s\n", debuglvitem_t(&pdi
->item
, infoPtr
->notifyFormat
!= NFR_ANSI
));
982 ret
= notify_hdr(infoPtr
, code
, &pdi
->hdr
);
983 TRACE(" resulting code=%d\n", pdi
->hdr
.code
);
985 if (return_ansi
|| return_unicode
)
987 if (return_ansi
&& (pdi
->hdr
.code
== LVN_GETDISPINFOA
))
989 strcpy((char*)ret_text
, (char*)pdi
->item
.pszText
);
991 else if (return_unicode
&& (pdi
->hdr
.code
== LVN_GETDISPINFOW
))
993 strcpyW(ret_text
, pdi
->item
.pszText
);
995 else if (return_ansi
) /* note : pointer can be changed by app ! */
997 WideCharToMultiByte(CP_ACP
, 0, pdi
->item
.pszText
, -1, (LPSTR
) ret_text
,
998 ret_length
, NULL
, NULL
);
1001 MultiByteToWideChar(CP_ACP
, 0, (LPSTR
) pdi
->item
.pszText
, -1,
1002 ret_text
, ret_length
);
1004 pdi
->item
.pszText
= ret_text
; /* restores our buffer */
1005 pdi
->item
.cchTextMax
= ret_length
;
1011 /* if dipsinfo holder changed notification code then convert */
1012 if (!isW
&& (pdi
->hdr
.code
== LVN_GETDISPINFOW
) && (pdi
->item
.mask
& LVIF_TEXT
))
1014 length
= WideCharToMultiByte(CP_ACP
, 0, pdi
->item
.pszText
, -1, NULL
, 0, NULL
, NULL
);
1016 buffer
= Alloc(length
* sizeof(CHAR
));
1017 if (!buffer
) return FALSE
;
1019 WideCharToMultiByte(CP_ACP
, 0, pdi
->item
.pszText
, -1, (LPSTR
) buffer
,
1020 ret_length
, NULL
, NULL
);
1022 strcpy((LPSTR
)pdi
->item
.pszText
, (LPSTR
)buffer
);
1029 static void customdraw_fill(NMLVCUSTOMDRAW
*lpnmlvcd
, const LISTVIEW_INFO
*infoPtr
, HDC hdc
,
1030 const RECT
*rcBounds
, const LVITEMW
*lplvItem
)
1032 ZeroMemory(lpnmlvcd
, sizeof(NMLVCUSTOMDRAW
));
1033 lpnmlvcd
->nmcd
.hdc
= hdc
;
1034 lpnmlvcd
->nmcd
.rc
= *rcBounds
;
1035 lpnmlvcd
->clrTextBk
= infoPtr
->clrTextBk
;
1036 lpnmlvcd
->clrText
= infoPtr
->clrText
;
1037 if (!lplvItem
) return;
1038 lpnmlvcd
->nmcd
.dwItemSpec
= lplvItem
->iItem
+ 1;
1039 lpnmlvcd
->iSubItem
= lplvItem
->iSubItem
;
1040 if (lplvItem
->state
& LVIS_SELECTED
) lpnmlvcd
->nmcd
.uItemState
|= CDIS_SELECTED
;
1041 if (lplvItem
->state
& LVIS_FOCUSED
) lpnmlvcd
->nmcd
.uItemState
|= CDIS_FOCUS
;
1042 if (lplvItem
->iItem
== infoPtr
->nHotItem
) lpnmlvcd
->nmcd
.uItemState
|= CDIS_HOT
;
1043 lpnmlvcd
->nmcd
.lItemlParam
= lplvItem
->lParam
;
1046 static inline DWORD
notify_customdraw (const LISTVIEW_INFO
*infoPtr
, DWORD dwDrawStage
, NMLVCUSTOMDRAW
*lpnmlvcd
)
1048 BOOL isForItem
= (lpnmlvcd
->nmcd
.dwItemSpec
!= 0);
1051 lpnmlvcd
->nmcd
.dwDrawStage
= dwDrawStage
;
1052 if (isForItem
) lpnmlvcd
->nmcd
.dwDrawStage
|= CDDS_ITEM
;
1053 if (lpnmlvcd
->iSubItem
) lpnmlvcd
->nmcd
.dwDrawStage
|= CDDS_SUBITEM
;
1054 if (isForItem
) lpnmlvcd
->nmcd
.dwItemSpec
--;
1055 result
= notify_hdr(infoPtr
, NM_CUSTOMDRAW
, &lpnmlvcd
->nmcd
.hdr
);
1056 if (isForItem
) lpnmlvcd
->nmcd
.dwItemSpec
++;
1060 static void prepaint_setup (const LISTVIEW_INFO
*infoPtr
, HDC hdc
, NMLVCUSTOMDRAW
*lpnmlvcd
, BOOL SubItem
)
1062 if (lpnmlvcd
->clrTextBk
== CLR_DEFAULT
)
1063 lpnmlvcd
->clrTextBk
= comctl32_color
.clrWindow
;
1064 if (lpnmlvcd
->clrText
== CLR_DEFAULT
)
1065 lpnmlvcd
->clrText
= comctl32_color
.clrWindowText
;
1067 /* apparently, for selected items, we have to override the returned values */
1070 if (lpnmlvcd
->nmcd
.uItemState
& CDIS_SELECTED
)
1072 if (infoPtr
->bFocus
)
1074 lpnmlvcd
->clrTextBk
= comctl32_color
.clrHighlight
;
1075 lpnmlvcd
->clrText
= comctl32_color
.clrHighlightText
;
1077 else if (infoPtr
->dwStyle
& LVS_SHOWSELALWAYS
)
1079 lpnmlvcd
->clrTextBk
= comctl32_color
.clr3dFace
;
1080 lpnmlvcd
->clrText
= comctl32_color
.clrBtnText
;
1085 /* Set the text attributes */
1086 if (lpnmlvcd
->clrTextBk
!= CLR_NONE
)
1088 SetBkMode(hdc
, OPAQUE
);
1089 SetBkColor(hdc
,lpnmlvcd
->clrTextBk
);
1092 SetBkMode(hdc
, TRANSPARENT
);
1093 SetTextColor(hdc
, lpnmlvcd
->clrText
);
1096 static inline DWORD
notify_postpaint (const LISTVIEW_INFO
*infoPtr
, NMLVCUSTOMDRAW
*lpnmlvcd
)
1098 return notify_customdraw(infoPtr
, CDDS_POSTPAINT
, lpnmlvcd
);
1101 /* returns TRUE when repaint needed, FALSE otherwise */
1102 static BOOL
notify_measureitem(LISTVIEW_INFO
*infoPtr
)
1104 MEASUREITEMSTRUCT mis
;
1105 mis
.CtlType
= ODT_LISTVIEW
;
1106 mis
.CtlID
= GetWindowLongPtrW(infoPtr
->hwndSelf
, GWLP_ID
);
1110 mis
.itemHeight
= infoPtr
->nItemHeight
;
1111 SendMessageW(infoPtr
->hwndNotify
, WM_MEASUREITEM
, mis
.CtlID
, (LPARAM
)&mis
);
1112 if (infoPtr
->nItemHeight
!= max(mis
.itemHeight
, 1))
1114 infoPtr
->nMeasureItemHeight
= infoPtr
->nItemHeight
= max(mis
.itemHeight
, 1);
1120 /******** Item iterator functions **********************************/
1122 static RANGES
ranges_create(int count
);
1123 static void ranges_destroy(RANGES ranges
);
1124 static BOOL
ranges_add(RANGES ranges
, RANGE range
);
1125 static BOOL
ranges_del(RANGES ranges
, RANGE range
);
1126 static void ranges_dump(RANGES ranges
);
1128 static inline BOOL
ranges_additem(RANGES ranges
, INT nItem
)
1130 RANGE range
= { nItem
, nItem
+ 1 };
1132 return ranges_add(ranges
, range
);
1135 static inline BOOL
ranges_delitem(RANGES ranges
, INT nItem
)
1137 RANGE range
= { nItem
, nItem
+ 1 };
1139 return ranges_del(ranges
, range
);
1143 * ITERATOR DOCUMENTATION
1145 * The iterator functions allow for easy, and convenient iteration
1146 * over items of interest in the list. Typically, you create a
1147 * iterator, use it, and destroy it, as such:
1150 * iterator_xxxitems(&i, ...);
1151 * while (iterator_{prev,next}(&i)
1153 * //code which uses i.nItem
1155 * iterator_destroy(&i);
1157 * where xxx is either: framed, or visible.
1158 * Note that it is important that the code destroys the iterator
1159 * after it's done with it, as the creation of the iterator may
1160 * allocate memory, which thus needs to be freed.
1162 * You can iterate both forwards, and backwards through the list,
1163 * by using iterator_next or iterator_prev respectively.
1165 * Lower numbered items are draw on top of higher number items in
1166 * LVS_ICON, and LVS_SMALLICON (which are the only modes where
1167 * items may overlap). So, to test items, you should use
1169 * which lists the items top to bottom (in Z-order).
1170 * For drawing items, you should use
1172 * which lists the items bottom to top (in Z-order).
1173 * If you keep iterating over the items after the end-of-items
1174 * marker (-1) is returned, the iterator will start from the
1175 * beginning. Typically, you don't need to test for -1,
1176 * because iterator_{next,prev} will return TRUE if more items
1177 * are to be iterated over, or FALSE otherwise.
1179 * Note: the iterator is defined to be bidirectional. That is,
1180 * any number of prev followed by any number of next, or
1181 * five versa, should leave the iterator at the same item:
1182 * prev * n, next * n = next * n, prev * n
1184 * The iterator has a notion of an out-of-order, special item,
1185 * which sits at the start of the list. This is used in
1186 * LVS_ICON, and LVS_SMALLICON mode to handle the focused item,
1187 * which needs to be first, as it may overlap other items.
1189 * The code is a bit messy because we have:
1190 * - a special item to deal with
1191 * - simple range, or composite range
1193 * If you find bugs, or want to add features, please make sure you
1194 * always check/modify *both* iterator_prev, and iterator_next.
1198 * This function iterates through the items in increasing order,
1199 * but prefixed by the special item, then -1. That is:
1200 * special, 1, 2, 3, ..., n, -1.
1201 * Each item is listed only once.
1203 static inline BOOL
iterator_next(ITERATOR
* i
)
1207 i
->nItem
= i
->nSpecial
;
1208 if (i
->nItem
!= -1) return TRUE
;
1210 if (i
->nItem
== i
->nSpecial
)
1212 if (i
->ranges
) i
->index
= 0;
1218 if (i
->nItem
== i
->nSpecial
) i
->nItem
++;
1219 if (i
->nItem
< i
->range
.upper
) return TRUE
;
1224 if (i
->index
< DPA_GetPtrCount(i
->ranges
->hdpa
))
1225 i
->range
= *(RANGE
*)DPA_GetPtr(i
->ranges
->hdpa
, i
->index
++);
1228 else if (i
->nItem
>= i
->range
.upper
) goto end
;
1230 i
->nItem
= i
->range
.lower
;
1231 if (i
->nItem
>= 0) goto testitem
;
1238 * This function iterates through the items in decreasing order,
1239 * followed by the special item, then -1. That is:
1240 * n, n-1, ..., 3, 2, 1, special, -1.
1241 * Each item is listed only once.
1243 static inline BOOL
iterator_prev(ITERATOR
* i
)
1250 if (i
->ranges
) i
->index
= DPA_GetPtrCount(i
->ranges
->hdpa
);
1253 if (i
->nItem
== i
->nSpecial
)
1261 if (i
->nItem
== i
->nSpecial
) i
->nItem
--;
1262 if (i
->nItem
>= i
->range
.lower
) return TRUE
;
1268 i
->range
= *(RANGE
*)DPA_GetPtr(i
->ranges
->hdpa
, --i
->index
);
1271 else if (!start
&& i
->nItem
< i
->range
.lower
) goto end
;
1273 i
->nItem
= i
->range
.upper
;
1274 if (i
->nItem
> 0) goto testitem
;
1276 return (i
->nItem
= i
->nSpecial
) != -1;
1279 static RANGE
iterator_range(const ITERATOR
*i
)
1283 if (!i
->ranges
) return i
->range
;
1285 if (DPA_GetPtrCount(i
->ranges
->hdpa
) > 0)
1287 range
.lower
= (*(RANGE
*)DPA_GetPtr(i
->ranges
->hdpa
, 0)).lower
;
1288 range
.upper
= (*(RANGE
*)DPA_GetPtr(i
->ranges
->hdpa
, DPA_GetPtrCount(i
->ranges
->hdpa
) - 1)).upper
;
1290 else range
.lower
= range
.upper
= 0;
1296 * Releases resources associated with this iterator.
1298 static inline void iterator_destroy(const ITERATOR
*i
)
1300 ranges_destroy(i
->ranges
);
1304 * Create an empty iterator.
1306 static inline BOOL
iterator_empty(ITERATOR
* i
)
1308 ZeroMemory(i
, sizeof(*i
));
1309 i
->nItem
= i
->nSpecial
= i
->range
.lower
= i
->range
.upper
= -1;
1314 * Create an iterator over a range.
1316 static inline BOOL
iterator_rangeitems(ITERATOR
* i
, RANGE range
)
1324 * Create an iterator over a bunch of ranges.
1325 * Please note that the iterator will take ownership of the ranges,
1326 * and will free them upon destruction.
1328 static inline BOOL
iterator_rangesitems(ITERATOR
* i
, RANGES ranges
)
1336 * Creates an iterator over the items which intersect frame.
1337 * Uses absolute coordinates rather than compensating for the current offset.
1339 static BOOL
iterator_frameditems_absolute(ITERATOR
* i
, const LISTVIEW_INFO
* infoPtr
, const RECT
*frame
)
1341 RECT rcItem
, rcTemp
;
1343 /* in case we fail, we want to return an empty iterator */
1344 if (!iterator_empty(i
)) return FALSE
;
1346 TRACE("(frame=%s)\n", wine_dbgstr_rect(frame
));
1348 if (infoPtr
->uView
== LV_VIEW_ICON
|| infoPtr
->uView
== LV_VIEW_SMALLICON
)
1352 if (infoPtr
->uView
== LV_VIEW_ICON
&& infoPtr
->nFocusedItem
!= -1)
1354 LISTVIEW_GetItemBox(infoPtr
, infoPtr
->nFocusedItem
, &rcItem
);
1355 if (IntersectRect(&rcTemp
, &rcItem
, frame
))
1356 i
->nSpecial
= infoPtr
->nFocusedItem
;
1358 if (!(iterator_rangesitems(i
, ranges_create(50)))) return FALSE
;
1359 /* to do better here, we need to have PosX, and PosY sorted */
1360 TRACE("building icon ranges:\n");
1361 for (nItem
= 0; nItem
< infoPtr
->nItemCount
; nItem
++)
1363 rcItem
.left
= (LONG_PTR
)DPA_GetPtr(infoPtr
->hdpaPosX
, nItem
);
1364 rcItem
.top
= (LONG_PTR
)DPA_GetPtr(infoPtr
->hdpaPosY
, nItem
);
1365 rcItem
.right
= rcItem
.left
+ infoPtr
->nItemWidth
;
1366 rcItem
.bottom
= rcItem
.top
+ infoPtr
->nItemHeight
;
1367 if (IntersectRect(&rcTemp
, &rcItem
, frame
))
1368 ranges_additem(i
->ranges
, nItem
);
1372 else if (infoPtr
->uView
== LV_VIEW_DETAILS
)
1376 if (frame
->left
>= infoPtr
->nItemWidth
) return TRUE
;
1377 if (frame
->top
>= infoPtr
->nItemHeight
* infoPtr
->nItemCount
) return TRUE
;
1379 range
.lower
= max(frame
->top
/ infoPtr
->nItemHeight
, 0);
1380 range
.upper
= min((frame
->bottom
- 1) / infoPtr
->nItemHeight
, infoPtr
->nItemCount
- 1) + 1;
1381 if (range
.upper
<= range
.lower
) return TRUE
;
1382 if (!iterator_rangeitems(i
, range
)) return FALSE
;
1383 TRACE(" report=%s\n", debugrange(&i
->range
));
1387 INT nPerCol
= max((infoPtr
->rcList
.bottom
- infoPtr
->rcList
.top
) / infoPtr
->nItemHeight
, 1);
1388 INT nFirstRow
= max(frame
->top
/ infoPtr
->nItemHeight
, 0);
1389 INT nLastRow
= min((frame
->bottom
- 1) / infoPtr
->nItemHeight
, nPerCol
- 1);
1396 if (infoPtr
->nItemWidth
)
1398 nFirstCol
= max(frame
->left
/ infoPtr
->nItemWidth
, 0);
1399 nLastCol
= min((frame
->right
- 1) / infoPtr
->nItemWidth
, (infoPtr
->nItemCount
+ nPerCol
- 1) / nPerCol
);
1403 nFirstCol
= max(frame
->left
, 0);
1404 nLastCol
= min(frame
->right
- 1, (infoPtr
->nItemCount
+ nPerCol
- 1) / nPerCol
);
1407 lower
= nFirstCol
* nPerCol
+ nFirstRow
;
1409 TRACE("nPerCol=%d, nFirstRow=%d, nLastRow=%d, nFirstCol=%d, nLastCol=%d, lower=%d\n",
1410 nPerCol
, nFirstRow
, nLastRow
, nFirstCol
, nLastCol
, lower
);
1412 if (nLastCol
< nFirstCol
|| nLastRow
< nFirstRow
) return TRUE
;
1414 if (!(iterator_rangesitems(i
, ranges_create(nLastCol
- nFirstCol
+ 1)))) return FALSE
;
1415 TRACE("building list ranges:\n");
1416 for (nCol
= nFirstCol
; nCol
<= nLastCol
; nCol
++)
1418 item_range
.lower
= nCol
* nPerCol
+ nFirstRow
;
1419 if(item_range
.lower
>= infoPtr
->nItemCount
) break;
1420 item_range
.upper
= min(nCol
* nPerCol
+ nLastRow
+ 1, infoPtr
->nItemCount
);
1421 TRACE(" list=%s\n", debugrange(&item_range
));
1422 ranges_add(i
->ranges
, item_range
);
1430 * Creates an iterator over the items which intersect lprc.
1432 static BOOL
iterator_frameditems(ITERATOR
* i
, const LISTVIEW_INFO
* infoPtr
, const RECT
*lprc
)
1437 TRACE("(lprc=%s)\n", wine_dbgstr_rect(lprc
));
1439 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
1440 OffsetRect(&frame
, -Origin
.x
, -Origin
.y
);
1442 return iterator_frameditems_absolute(i
, infoPtr
, &frame
);
1446 * Creates an iterator over the items which intersect the visible region of hdc.
1448 static BOOL
iterator_visibleitems(ITERATOR
*i
, const LISTVIEW_INFO
*infoPtr
, HDC hdc
)
1450 POINT Origin
, Position
;
1451 RECT rcItem
, rcClip
;
1454 rgntype
= GetClipBox(hdc
, &rcClip
);
1455 if (rgntype
== NULLREGION
) return iterator_empty(i
);
1456 if (!iterator_frameditems(i
, infoPtr
, &rcClip
)) return FALSE
;
1457 if (rgntype
== SIMPLEREGION
) return TRUE
;
1459 /* first deal with the special item */
1460 if (i
->nSpecial
!= -1)
1462 LISTVIEW_GetItemBox(infoPtr
, i
->nSpecial
, &rcItem
);
1463 if (!RectVisible(hdc
, &rcItem
)) i
->nSpecial
= -1;
1466 /* if we can't deal with the region, we'll just go with the simple range */
1467 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
1468 TRACE("building visible range:\n");
1469 if (!i
->ranges
&& i
->range
.lower
< i
->range
.upper
)
1471 if (!(i
->ranges
= ranges_create(50))) return TRUE
;
1472 if (!ranges_add(i
->ranges
, i
->range
))
1474 ranges_destroy(i
->ranges
);
1480 /* now delete the invisible items from the list */
1481 while(iterator_next(i
))
1483 LISTVIEW_GetItemOrigin(infoPtr
, i
->nItem
, &Position
);
1484 rcItem
.left
= (infoPtr
->uView
== LV_VIEW_DETAILS
) ? Origin
.x
: Position
.x
+ Origin
.x
;
1485 rcItem
.top
= Position
.y
+ Origin
.y
;
1486 rcItem
.right
= rcItem
.left
+ infoPtr
->nItemWidth
;
1487 rcItem
.bottom
= rcItem
.top
+ infoPtr
->nItemHeight
;
1488 if (!RectVisible(hdc
, &rcItem
))
1489 ranges_delitem(i
->ranges
, i
->nItem
);
1491 /* the iterator should restart on the next iterator_next */
1497 /* Remove common elements from two iterators */
1498 /* Passed iterators have to point on the first elements */
1499 static BOOL
iterator_remove_common_items(ITERATOR
*iter1
, ITERATOR
*iter2
)
1501 if(!iter1
->ranges
|| !iter2
->ranges
) {
1504 if(iter1
->ranges
|| iter2
->ranges
||
1505 (iter1
->range
.lower
<iter2
->range
.lower
&& iter1
->range
.upper
>iter2
->range
.upper
) ||
1506 (iter1
->range
.lower
>iter2
->range
.lower
&& iter1
->range
.upper
<iter2
->range
.upper
)) {
1507 ERR("result is not a one range iterator\n");
1511 if(iter1
->range
.lower
==-1 || iter2
->range
.lower
==-1)
1514 lower
= iter1
->range
.lower
;
1515 upper
= iter1
->range
.upper
;
1517 if(lower
< iter2
->range
.lower
)
1518 iter1
->range
.upper
= iter2
->range
.lower
;
1519 else if(upper
> iter2
->range
.upper
)
1520 iter1
->range
.lower
= iter2
->range
.upper
;
1522 iter1
->range
.lower
= iter1
->range
.upper
= -1;
1524 if(iter2
->range
.lower
< lower
)
1525 iter2
->range
.upper
= lower
;
1526 else if(iter2
->range
.upper
> upper
)
1527 iter2
->range
.lower
= upper
;
1529 iter2
->range
.lower
= iter2
->range
.upper
= -1;
1534 iterator_next(iter1
);
1535 iterator_next(iter2
);
1538 if(iter1
->nItem
==-1 || iter2
->nItem
==-1)
1541 if(iter1
->nItem
== iter2
->nItem
) {
1542 int delete = iter1
->nItem
;
1544 iterator_prev(iter1
);
1545 iterator_prev(iter2
);
1546 ranges_delitem(iter1
->ranges
, delete);
1547 ranges_delitem(iter2
->ranges
, delete);
1548 iterator_next(iter1
);
1549 iterator_next(iter2
);
1550 } else if(iter1
->nItem
> iter2
->nItem
)
1551 iterator_next(iter2
);
1553 iterator_next(iter1
);
1556 iter1
->nItem
= iter1
->range
.lower
= iter1
->range
.upper
= -1;
1557 iter2
->nItem
= iter2
->range
.lower
= iter2
->range
.upper
= -1;
1561 /******** Misc helper functions ************************************/
1563 static inline LRESULT
CallWindowProcT(WNDPROC proc
, HWND hwnd
, UINT uMsg
,
1564 WPARAM wParam
, LPARAM lParam
, BOOL isW
)
1566 if (isW
) return CallWindowProcW(proc
, hwnd
, uMsg
, wParam
, lParam
);
1567 else return CallWindowProcA(proc
, hwnd
, uMsg
, wParam
, lParam
);
1570 static inline BOOL
is_autoarrange(const LISTVIEW_INFO
*infoPtr
)
1572 return ((infoPtr
->dwStyle
& LVS_AUTOARRANGE
) || infoPtr
->bAutoarrange
) &&
1573 (infoPtr
->uView
== LV_VIEW_ICON
|| infoPtr
->uView
== LV_VIEW_SMALLICON
);
1576 static void toggle_checkbox_state(LISTVIEW_INFO
*infoPtr
, INT nItem
)
1578 DWORD state
= STATEIMAGEINDEX(LISTVIEW_GetItemState(infoPtr
, nItem
, LVIS_STATEIMAGEMASK
));
1579 if(state
== 1 || state
== 2)
1583 lvitem
.state
= INDEXTOSTATEIMAGEMASK(state
);
1584 lvitem
.stateMask
= LVIS_STATEIMAGEMASK
;
1585 LISTVIEW_SetItemState(infoPtr
, nItem
, &lvitem
);
1589 /* this should be called after window style got updated,
1590 it used to reset view state to match current window style */
1591 static inline void map_style_view(LISTVIEW_INFO
*infoPtr
)
1593 switch (infoPtr
->dwStyle
& LVS_TYPEMASK
)
1596 infoPtr
->uView
= LV_VIEW_ICON
;
1599 infoPtr
->uView
= LV_VIEW_DETAILS
;
1602 infoPtr
->uView
= LV_VIEW_SMALLICON
;
1605 infoPtr
->uView
= LV_VIEW_LIST
;
1609 /* computes next item id value */
1610 static DWORD
get_next_itemid(const LISTVIEW_INFO
*infoPtr
)
1612 INT count
= DPA_GetPtrCount(infoPtr
->hdpaItemIds
);
1616 ITEM_ID
*lpID
= DPA_GetPtr(infoPtr
->hdpaItemIds
, count
- 1);
1617 return lpID
->id
+ 1;
1622 /******** Internal API functions ************************************/
1624 static inline COLUMN_INFO
* LISTVIEW_GetColumnInfo(const LISTVIEW_INFO
*infoPtr
, INT nSubItem
)
1626 static COLUMN_INFO mainItem
;
1628 if (nSubItem
== 0 && DPA_GetPtrCount(infoPtr
->hdpaColumns
) == 0) return &mainItem
;
1629 assert (nSubItem
>= 0 && nSubItem
< DPA_GetPtrCount(infoPtr
->hdpaColumns
));
1631 /* update cached column rectangles */
1632 if (infoPtr
->colRectsDirty
)
1635 LISTVIEW_INFO
*Ptr
= (LISTVIEW_INFO
*)infoPtr
;
1638 for (i
= 0; i
< DPA_GetPtrCount(infoPtr
->hdpaColumns
); i
++) {
1639 info
= DPA_GetPtr(infoPtr
->hdpaColumns
, i
);
1640 SendMessageW(infoPtr
->hwndHeader
, HDM_GETITEMRECT
, i
, (LPARAM
)&info
->rcHeader
);
1642 Ptr
->colRectsDirty
= FALSE
;
1645 return DPA_GetPtr(infoPtr
->hdpaColumns
, nSubItem
);
1648 static INT
LISTVIEW_CreateHeader(LISTVIEW_INFO
*infoPtr
)
1650 DWORD dFlags
= WS_CHILD
| HDS_HORZ
| HDS_FULLDRAG
| HDS_DRAGDROP
;
1653 if (infoPtr
->hwndHeader
) return 0;
1655 TRACE("Creating header for list %p\n", infoPtr
->hwndSelf
);
1657 /* setup creation flags */
1658 dFlags
|= (LVS_NOSORTHEADER
& infoPtr
->dwStyle
) ? 0 : HDS_BUTTONS
;
1659 dFlags
|= (LVS_NOCOLUMNHEADER
& infoPtr
->dwStyle
) ? HDS_HIDDEN
: 0;
1661 hInst
= (HINSTANCE
)GetWindowLongPtrW(infoPtr
->hwndSelf
, GWLP_HINSTANCE
);
1664 infoPtr
->hwndHeader
= CreateWindowW(WC_HEADERW
, NULL
, dFlags
,
1665 0, 0, 0, 0, infoPtr
->hwndSelf
, NULL
, hInst
, NULL
);
1666 if (!infoPtr
->hwndHeader
) return -1;
1668 /* set header unicode format */
1669 SendMessageW(infoPtr
->hwndHeader
, HDM_SETUNICODEFORMAT
, TRUE
, 0);
1671 /* set header font */
1672 SendMessageW(infoPtr
->hwndHeader
, WM_SETFONT
, (WPARAM
)infoPtr
->hFont
, TRUE
);
1674 LISTVIEW_UpdateSize(infoPtr
);
1679 static inline void LISTVIEW_GetHeaderRect(const LISTVIEW_INFO
*infoPtr
, INT nSubItem
, LPRECT lprc
)
1681 *lprc
= LISTVIEW_GetColumnInfo(infoPtr
, nSubItem
)->rcHeader
;
1684 static inline BOOL
LISTVIEW_IsHeaderEnabled(const LISTVIEW_INFO
*infoPtr
)
1686 return (infoPtr
->uView
== LV_VIEW_DETAILS
||
1687 infoPtr
->dwLvExStyle
& LVS_EX_HEADERINALLVIEWS
) &&
1688 !(infoPtr
->dwStyle
& LVS_NOCOLUMNHEADER
);
1691 static inline BOOL
LISTVIEW_GetItemW(const LISTVIEW_INFO
*infoPtr
, LPLVITEMW lpLVItem
)
1693 return LISTVIEW_GetItemT(infoPtr
, lpLVItem
, TRUE
);
1696 /* used to handle collapse main item column case */
1697 static inline BOOL
LISTVIEW_DrawFocusRect(const LISTVIEW_INFO
*infoPtr
, HDC hdc
)
1699 return (infoPtr
->rcFocus
.left
< infoPtr
->rcFocus
.right
) ?
1700 DrawFocusRect(hdc
, &infoPtr
->rcFocus
) : FALSE
;
1703 /* Listview invalidation functions: use _only_ these functions to invalidate */
1705 static inline BOOL
is_redrawing(const LISTVIEW_INFO
*infoPtr
)
1707 return infoPtr
->bRedraw
;
1710 static inline void LISTVIEW_InvalidateRect(const LISTVIEW_INFO
*infoPtr
, const RECT
* rect
)
1712 if(!is_redrawing(infoPtr
)) return;
1713 TRACE(" invalidating rect=%s\n", wine_dbgstr_rect(rect
));
1714 InvalidateRect(infoPtr
->hwndSelf
, rect
, TRUE
);
1717 static inline void LISTVIEW_InvalidateItem(const LISTVIEW_INFO
*infoPtr
, INT nItem
)
1721 if(!is_redrawing(infoPtr
)) return;
1722 LISTVIEW_GetItemBox(infoPtr
, nItem
, &rcBox
);
1723 LISTVIEW_InvalidateRect(infoPtr
, &rcBox
);
1726 static inline void LISTVIEW_InvalidateSubItem(const LISTVIEW_INFO
*infoPtr
, INT nItem
, INT nSubItem
)
1728 POINT Origin
, Position
;
1731 if(!is_redrawing(infoPtr
)) return;
1732 assert (infoPtr
->uView
== LV_VIEW_DETAILS
);
1733 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
1734 LISTVIEW_GetItemOrigin(infoPtr
, nItem
, &Position
);
1735 LISTVIEW_GetHeaderRect(infoPtr
, nSubItem
, &rcBox
);
1737 rcBox
.bottom
= infoPtr
->nItemHeight
;
1738 OffsetRect(&rcBox
, Origin
.x
+ Position
.x
, Origin
.y
+ Position
.y
);
1739 LISTVIEW_InvalidateRect(infoPtr
, &rcBox
);
1742 static inline void LISTVIEW_InvalidateList(const LISTVIEW_INFO
*infoPtr
)
1744 LISTVIEW_InvalidateRect(infoPtr
, NULL
);
1747 static inline void LISTVIEW_InvalidateColumn(const LISTVIEW_INFO
*infoPtr
, INT nColumn
)
1751 if(!is_redrawing(infoPtr
)) return;
1752 LISTVIEW_GetHeaderRect(infoPtr
, nColumn
, &rcCol
);
1753 rcCol
.top
= infoPtr
->rcList
.top
;
1754 rcCol
.bottom
= infoPtr
->rcList
.bottom
;
1755 LISTVIEW_InvalidateRect(infoPtr
, &rcCol
);
1760 * Retrieves the number of items that can fit vertically in the client area.
1763 * [I] infoPtr : valid pointer to the listview structure
1766 * Number of items per row.
1768 static inline INT
LISTVIEW_GetCountPerRow(const LISTVIEW_INFO
*infoPtr
)
1770 INT nListWidth
= infoPtr
->rcList
.right
- infoPtr
->rcList
.left
;
1772 return max(nListWidth
/(infoPtr
->nItemWidth
? infoPtr
->nItemWidth
: 1), 1);
1777 * Retrieves the number of items that can fit horizontally in the client
1781 * [I] infoPtr : valid pointer to the listview structure
1784 * Number of items per column.
1786 static inline INT
LISTVIEW_GetCountPerColumn(const LISTVIEW_INFO
*infoPtr
)
1788 INT nListHeight
= infoPtr
->rcList
.bottom
- infoPtr
->rcList
.top
;
1790 return max(nListHeight
/ infoPtr
->nItemHeight
, 1);
1794 /*************************************************************************
1795 * LISTVIEW_ProcessLetterKeys
1797 * Processes keyboard messages generated by pressing the letter keys
1799 * What this does is perform a case insensitive search from the
1800 * current position with the following quirks:
1801 * - If two chars or more are pressed in quick succession we search
1802 * for the corresponding string (e.g. 'abc').
1803 * - If there is a delay we wipe away the current search string and
1804 * restart with just that char.
1805 * - If the user keeps pressing the same character, whether slowly or
1806 * fast, so that the search string is entirely composed of this
1807 * character ('aaaaa' for instance), then we search for first item
1808 * that starting with that character.
1809 * - If the user types the above character in quick succession, then
1810 * we must also search for the corresponding string ('aaaaa'), and
1811 * go to that string if there is a match.
1814 * [I] hwnd : handle to the window
1815 * [I] charCode : the character code, the actual character
1816 * [I] keyData : key data
1824 * - The current implementation has a list of characters it will
1825 * accept and it ignores everything else. In particular it will
1826 * ignore accentuated characters which seems to match what
1827 * Windows does. But I'm not sure it makes sense to follow
1829 * - We don't sound a beep when the search fails.
1833 * TREEVIEW_ProcessLetterKeys
1835 static INT
LISTVIEW_ProcessLetterKeys(LISTVIEW_INFO
*infoPtr
, WPARAM charCode
, LPARAM keyData
)
1837 WCHAR buffer
[MAX_PATH
];
1838 INT endidx
, startidx
;
1844 /* simple parameter checking */
1845 if (!charCode
|| !keyData
|| infoPtr
->nItemCount
== 0) return 0;
1847 /* only allow the valid WM_CHARs through */
1848 if (!isalnumW(charCode
) &&
1849 charCode
!= '.' && charCode
!= '`' && charCode
!= '!' &&
1850 charCode
!= '@' && charCode
!= '#' && charCode
!= '$' &&
1851 charCode
!= '%' && charCode
!= '^' && charCode
!= '&' &&
1852 charCode
!= '*' && charCode
!= '(' && charCode
!= ')' &&
1853 charCode
!= '-' && charCode
!= '_' && charCode
!= '+' &&
1854 charCode
!= '=' && charCode
!= '\\'&& charCode
!= ']' &&
1855 charCode
!= '}' && charCode
!= '[' && charCode
!= '{' &&
1856 charCode
!= '/' && charCode
!= '?' && charCode
!= '>' &&
1857 charCode
!= '<' && charCode
!= ',' && charCode
!= '~')
1860 /* update the search parameters */
1861 prevTime
= infoPtr
->lastKeyPressTimestamp
;
1862 infoPtr
->lastKeyPressTimestamp
= GetTickCount();
1863 diff
= infoPtr
->lastKeyPressTimestamp
- prevTime
;
1865 if (diff
>= 0 && diff
< KEY_DELAY
)
1867 if (infoPtr
->nSearchParamLength
< MAX_PATH
- 1)
1868 infoPtr
->szSearchParam
[infoPtr
->nSearchParamLength
++] = charCode
;
1870 if (infoPtr
->charCode
!= charCode
)
1871 infoPtr
->charCode
= charCode
= 0;
1875 infoPtr
->charCode
= charCode
;
1876 infoPtr
->szSearchParam
[0] = charCode
;
1877 infoPtr
->nSearchParamLength
= 1;
1880 /* and search from the current position */
1882 endidx
= infoPtr
->nItemCount
;
1884 /* should start from next after focused item, so next item that matches
1885 will be selected, if there isn't any and focused matches it will be selected
1886 on second search stage from beginning of the list */
1887 if (infoPtr
->nFocusedItem
>= 0 && infoPtr
->nItemCount
> 1)
1888 startidx
= infoPtr
->nFocusedItem
+ 1;
1892 /* let application handle this for virtual listview */
1893 if (infoPtr
->dwStyle
& LVS_OWNERDATA
)
1897 memset(&nmlv
.lvfi
, 0, sizeof(nmlv
.lvfi
));
1898 nmlv
.lvfi
.flags
= (LVFI_WRAP
| LVFI_PARTIAL
);
1899 nmlv
.lvfi
.psz
= infoPtr
->szSearchParam
;
1900 nmlv
.iStart
= startidx
;
1902 infoPtr
->szSearchParam
[infoPtr
->nSearchParamLength
] = 0;
1904 nItem
= notify_hdr(infoPtr
, LVN_ODFINDITEMW
, (LPNMHDR
)&nmlv
.hdr
);
1910 /* first search in [startidx, endidx), on failure continue in [0, startidx) */
1913 /* start from first item if not found with >= startidx */
1914 if (i
== infoPtr
->nItemCount
&& startidx
> 0)
1920 for (i
= startidx
; i
< endidx
; i
++)
1923 item
.mask
= LVIF_TEXT
;
1926 item
.pszText
= buffer
;
1927 item
.cchTextMax
= MAX_PATH
;
1928 if (!LISTVIEW_GetItemW(infoPtr
, &item
)) return 0;
1930 if (lstrncmpiW(item
.pszText
, infoPtr
->szSearchParam
, infoPtr
->nSearchParamLength
) == 0)
1935 else if (nItem
== -1 && lstrncmpiW(item
.pszText
, infoPtr
->szSearchParam
, 1) == 0)
1937 /* this would work but we must keep looking for a longer match */
1942 if ( nItem
!= -1 || /* found something */
1943 endidx
!= infoPtr
->nItemCount
|| /* second search done */
1944 (startidx
== 0 && endidx
== infoPtr
->nItemCount
) /* full range for first search */ )
1950 LISTVIEW_KeySelection(infoPtr
, nItem
, FALSE
);
1955 /*************************************************************************
1956 * LISTVIEW_UpdateHeaderSize [Internal]
1958 * Function to resize the header control
1961 * [I] hwnd : handle to a window
1962 * [I] nNewScrollPos : scroll pos to set
1967 static void LISTVIEW_UpdateHeaderSize(const LISTVIEW_INFO
*infoPtr
, INT nNewScrollPos
)
1972 TRACE("nNewScrollPos=%d\n", nNewScrollPos
);
1974 if (!infoPtr
->hwndHeader
) return;
1976 GetWindowRect(infoPtr
->hwndHeader
, &winRect
);
1977 point
[0].x
= winRect
.left
;
1978 point
[0].y
= winRect
.top
;
1979 point
[1].x
= winRect
.right
;
1980 point
[1].y
= winRect
.bottom
;
1982 MapWindowPoints(HWND_DESKTOP
, infoPtr
->hwndSelf
, point
, 2);
1983 point
[0].x
= -nNewScrollPos
;
1984 point
[1].x
+= nNewScrollPos
;
1986 SetWindowPos(infoPtr
->hwndHeader
,0,
1987 point
[0].x
,point
[0].y
,point
[1].x
,point
[1].y
,
1988 (infoPtr
->dwStyle
& LVS_NOCOLUMNHEADER
) ? SWP_HIDEWINDOW
: SWP_SHOWWINDOW
|
1989 SWP_NOZORDER
| SWP_NOACTIVATE
);
1994 * Update the scrollbars. This functions should be called whenever
1995 * the content, size or view changes.
1998 * [I] infoPtr : valid pointer to the listview structure
2003 static void LISTVIEW_UpdateScroll(const LISTVIEW_INFO
*infoPtr
)
2005 SCROLLINFO horzInfo
, vertInfo
;
2008 if ((infoPtr
->dwStyle
& LVS_NOSCROLL
) || !is_redrawing(infoPtr
)) return;
2010 ZeroMemory(&horzInfo
, sizeof(SCROLLINFO
));
2011 horzInfo
.cbSize
= sizeof(SCROLLINFO
);
2012 horzInfo
.nPage
= infoPtr
->rcList
.right
- infoPtr
->rcList
.left
;
2014 /* for now, we'll set info.nMax to the _count_, and adjust it later */
2015 if (infoPtr
->uView
== LV_VIEW_LIST
)
2017 INT nPerCol
= LISTVIEW_GetCountPerColumn(infoPtr
);
2018 horzInfo
.nMax
= (infoPtr
->nItemCount
+ nPerCol
- 1) / nPerCol
;
2020 /* scroll by at least one column per page */
2021 if(horzInfo
.nPage
< infoPtr
->nItemWidth
)
2022 horzInfo
.nPage
= infoPtr
->nItemWidth
;
2024 if (infoPtr
->nItemWidth
)
2025 horzInfo
.nPage
/= infoPtr
->nItemWidth
;
2027 else if (infoPtr
->uView
== LV_VIEW_DETAILS
)
2029 horzInfo
.nMax
= infoPtr
->nItemWidth
;
2031 else /* LV_VIEW_ICON, or LV_VIEW_SMALLICON */
2035 if (LISTVIEW_GetViewRect(infoPtr
, &rcView
)) horzInfo
.nMax
= rcView
.right
- rcView
.left
;
2038 if (LISTVIEW_IsHeaderEnabled(infoPtr
))
2040 if (DPA_GetPtrCount(infoPtr
->hdpaColumns
))
2045 index
= SendMessageW(infoPtr
->hwndHeader
, HDM_ORDERTOINDEX
,
2046 DPA_GetPtrCount(infoPtr
->hdpaColumns
) - 1, 0);
2048 LISTVIEW_GetHeaderRect(infoPtr
, index
, &rcHeader
);
2049 horzInfo
.nMax
= rcHeader
.right
;
2050 TRACE("horzInfo.nMax=%d\n", horzInfo
.nMax
);
2054 horzInfo
.fMask
= SIF_RANGE
| SIF_PAGE
;
2055 horzInfo
.nMax
= max(horzInfo
.nMax
- 1, 0);
2056 dx
= GetScrollPos(infoPtr
->hwndSelf
, SB_HORZ
);
2057 dx
-= SetScrollInfo(infoPtr
->hwndSelf
, SB_HORZ
, &horzInfo
, TRUE
);
2058 TRACE("horzInfo=%s\n", debugscrollinfo(&horzInfo
));
2060 /* Setting the horizontal scroll can change the listview size
2061 * (and potentially everything else) so we need to recompute
2062 * everything again for the vertical scroll
2065 ZeroMemory(&vertInfo
, sizeof(SCROLLINFO
));
2066 vertInfo
.cbSize
= sizeof(SCROLLINFO
);
2067 vertInfo
.nPage
= infoPtr
->rcList
.bottom
- infoPtr
->rcList
.top
;
2069 if (infoPtr
->uView
== LV_VIEW_DETAILS
)
2071 vertInfo
.nMax
= infoPtr
->nItemCount
;
2073 /* scroll by at least one page */
2074 if(vertInfo
.nPage
< infoPtr
->nItemHeight
)
2075 vertInfo
.nPage
= infoPtr
->nItemHeight
;
2077 if (infoPtr
->nItemHeight
> 0)
2078 vertInfo
.nPage
/= infoPtr
->nItemHeight
;
2080 else if (infoPtr
->uView
!= LV_VIEW_LIST
) /* LV_VIEW_ICON, or LV_VIEW_SMALLICON */
2084 if (LISTVIEW_GetViewRect(infoPtr
, &rcView
)) vertInfo
.nMax
= rcView
.bottom
- rcView
.top
;
2087 vertInfo
.fMask
= SIF_RANGE
| SIF_PAGE
;
2088 vertInfo
.nMax
= max(vertInfo
.nMax
- 1, 0);
2089 dy
= GetScrollPos(infoPtr
->hwndSelf
, SB_VERT
);
2090 dy
-= SetScrollInfo(infoPtr
->hwndSelf
, SB_VERT
, &vertInfo
, TRUE
);
2091 TRACE("vertInfo=%s\n", debugscrollinfo(&vertInfo
));
2093 /* Change of the range may have changed the scroll pos. If so move the content */
2094 if (dx
!= 0 || dy
!= 0)
2097 listRect
= infoPtr
->rcList
;
2098 ScrollWindowEx(infoPtr
->hwndSelf
, dx
, dy
, &listRect
, &listRect
, 0, 0,
2099 SW_ERASE
| SW_INVALIDATE
);
2102 /* Update the Header Control */
2103 if (infoPtr
->hwndHeader
)
2105 horzInfo
.fMask
= SIF_POS
;
2106 GetScrollInfo(infoPtr
->hwndSelf
, SB_HORZ
, &horzInfo
);
2107 LISTVIEW_UpdateHeaderSize(infoPtr
, horzInfo
.nPos
);
2114 * Shows/hides the focus rectangle.
2117 * [I] infoPtr : valid pointer to the listview structure
2118 * [I] fShow : TRUE to show the focus, FALSE to hide it.
2123 static void LISTVIEW_ShowFocusRect(const LISTVIEW_INFO
*infoPtr
, BOOL fShow
)
2127 TRACE("fShow=%d, nItem=%d\n", fShow
, infoPtr
->nFocusedItem
);
2129 if (infoPtr
->nFocusedItem
< 0) return;
2131 /* we need some gymnastics in ICON mode to handle large items */
2132 if (infoPtr
->uView
== LV_VIEW_ICON
)
2136 LISTVIEW_GetItemBox(infoPtr
, infoPtr
->nFocusedItem
, &rcBox
);
2137 if ((rcBox
.bottom
- rcBox
.top
) > infoPtr
->nItemHeight
)
2139 LISTVIEW_InvalidateRect(infoPtr
, &rcBox
);
2144 if (!(hdc
= GetDC(infoPtr
->hwndSelf
))) return;
2146 /* for some reason, owner draw should work only in report mode */
2147 if ((infoPtr
->dwStyle
& LVS_OWNERDRAWFIXED
) && (infoPtr
->uView
== LV_VIEW_DETAILS
))
2152 HFONT hFont
= infoPtr
->hFont
? infoPtr
->hFont
: infoPtr
->hDefaultFont
;
2153 HFONT hOldFont
= SelectObject(hdc
, hFont
);
2155 item
.iItem
= infoPtr
->nFocusedItem
;
2157 item
.mask
= LVIF_PARAM
;
2158 if (!LISTVIEW_GetItemW(infoPtr
, &item
)) goto done
;
2160 ZeroMemory(&dis
, sizeof(dis
));
2161 dis
.CtlType
= ODT_LISTVIEW
;
2162 dis
.CtlID
= (UINT
)GetWindowLongPtrW(infoPtr
->hwndSelf
, GWLP_ID
);
2163 dis
.itemID
= item
.iItem
;
2164 dis
.itemAction
= ODA_FOCUS
;
2165 if (fShow
) dis
.itemState
|= ODS_FOCUS
;
2166 dis
.hwndItem
= infoPtr
->hwndSelf
;
2168 LISTVIEW_GetItemBox(infoPtr
, dis
.itemID
, &dis
.rcItem
);
2169 dis
.itemData
= item
.lParam
;
2171 SendMessageW(infoPtr
->hwndNotify
, WM_DRAWITEM
, dis
.CtlID
, (LPARAM
)&dis
);
2173 SelectObject(hdc
, hOldFont
);
2177 LISTVIEW_DrawFocusRect(infoPtr
, hdc
);
2180 ReleaseDC(infoPtr
->hwndSelf
, hdc
);
2184 * Invalidates all visible selected items.
2186 static void LISTVIEW_InvalidateSelectedItems(const LISTVIEW_INFO
*infoPtr
)
2190 iterator_frameditems(&i
, infoPtr
, &infoPtr
->rcList
);
2191 while(iterator_next(&i
))
2193 if (LISTVIEW_GetItemState(infoPtr
, i
.nItem
, LVIS_SELECTED
))
2194 LISTVIEW_InvalidateItem(infoPtr
, i
.nItem
);
2196 iterator_destroy(&i
);
2201 * DESCRIPTION: [INTERNAL]
2202 * Computes an item's (left,top) corner, relative to rcView.
2203 * That is, the position has NOT been made relative to the Origin.
2204 * This is deliberate, to avoid computing the Origin over, and
2205 * over again, when this function is called in a loop. Instead,
2206 * one can factor the computation of the Origin before the loop,
2207 * and offset the value returned by this function, on every iteration.
2210 * [I] infoPtr : valid pointer to the listview structure
2211 * [I] nItem : item number
2212 * [O] lpptOrig : item top, left corner
2217 static void LISTVIEW_GetItemOrigin(const LISTVIEW_INFO
*infoPtr
, INT nItem
, LPPOINT lpptPosition
)
2219 assert(nItem
>= 0 && nItem
< infoPtr
->nItemCount
);
2221 if ((infoPtr
->uView
== LV_VIEW_SMALLICON
) || (infoPtr
->uView
== LV_VIEW_ICON
))
2223 lpptPosition
->x
= (LONG_PTR
)DPA_GetPtr(infoPtr
->hdpaPosX
, nItem
);
2224 lpptPosition
->y
= (LONG_PTR
)DPA_GetPtr(infoPtr
->hdpaPosY
, nItem
);
2226 else if (infoPtr
->uView
== LV_VIEW_LIST
)
2228 INT nCountPerColumn
= LISTVIEW_GetCountPerColumn(infoPtr
);
2229 lpptPosition
->x
= nItem
/ nCountPerColumn
* infoPtr
->nItemWidth
;
2230 lpptPosition
->y
= nItem
% nCountPerColumn
* infoPtr
->nItemHeight
;
2232 else /* LV_VIEW_DETAILS */
2234 lpptPosition
->x
= REPORT_MARGINX
;
2235 /* item is always at zero indexed column */
2236 if (DPA_GetPtrCount(infoPtr
->hdpaColumns
) > 0)
2237 lpptPosition
->x
+= LISTVIEW_GetColumnInfo(infoPtr
, 0)->rcHeader
.left
;
2238 lpptPosition
->y
= nItem
* infoPtr
->nItemHeight
;
2243 * DESCRIPTION: [INTERNAL]
2244 * Compute the rectangles of an item. This is to localize all
2245 * the computations in one place. If you are not interested in some
2246 * of these values, simply pass in a NULL -- the function is smart
2247 * enough to compute only what's necessary. The function computes
2248 * the standard rectangles (BOUNDS, ICON, LABEL) plus a non-standard
2249 * one, the BOX rectangle. This rectangle is very cheap to compute,
2250 * and is guaranteed to contain all the other rectangles. Computing
2251 * the ICON rect is also cheap, but all the others are potentially
2252 * expensive. This gives an easy and effective optimization when
2253 * searching (like point inclusion, or rectangle intersection):
2254 * first test against the BOX, and if TRUE, test against the desired
2256 * If the function does not have all the necessary information
2257 * to computed the requested rectangles, will crash with a
2258 * failed assertion. This is done so we catch all programming
2259 * errors, given that the function is called only from our code.
2261 * We have the following 'special' meanings for a few fields:
2262 * * If LVIS_FOCUSED is set, we assume the item has the focus
2263 * This is important in ICON mode, where it might get a larger
2264 * then usual rectangle
2266 * Please note that subitem support works only in REPORT mode.
2269 * [I] infoPtr : valid pointer to the listview structure
2270 * [I] lpLVItem : item to compute the measures for
2271 * [O] lprcBox : ptr to Box rectangle
2272 * Same as LVM_GETITEMRECT with LVIR_BOUNDS
2273 * [0] lprcSelectBox : ptr to select box rectangle
2274 * Same as LVM_GETITEMRECT with LVIR_SELECTEDBOUNDS
2275 * [O] lprcIcon : ptr to Icon rectangle
2276 * Same as LVM_GETITEMRECT with LVIR_ICON
2277 * [O] lprcStateIcon: ptr to State Icon rectangle
2278 * [O] lprcLabel : ptr to Label rectangle
2279 * Same as LVM_GETITEMRECT with LVIR_LABEL
2284 static void LISTVIEW_GetItemMetrics(const LISTVIEW_INFO
*infoPtr
, const LVITEMW
*lpLVItem
,
2285 LPRECT lprcBox
, LPRECT lprcSelectBox
,
2286 LPRECT lprcIcon
, LPRECT lprcStateIcon
, LPRECT lprcLabel
)
2288 BOOL doSelectBox
= FALSE
, doIcon
= FALSE
, doLabel
= FALSE
, oversizedBox
= FALSE
;
2289 RECT Box
, SelectBox
, Icon
, Label
;
2290 COLUMN_INFO
*lpColumnInfo
= NULL
;
2291 SIZE labelSize
= { 0, 0 };
2293 TRACE("(lpLVItem=%s)\n", debuglvitem_t(lpLVItem
, TRUE
));
2295 /* Be smart and try to figure out the minimum we have to do */
2296 if (lpLVItem
->iSubItem
) assert(infoPtr
->uView
== LV_VIEW_DETAILS
);
2297 if (infoPtr
->uView
== LV_VIEW_ICON
&& (lprcBox
|| lprcLabel
))
2299 assert((lpLVItem
->mask
& LVIF_STATE
) && (lpLVItem
->stateMask
& LVIS_FOCUSED
));
2300 if (lpLVItem
->state
& LVIS_FOCUSED
) oversizedBox
= doLabel
= TRUE
;
2302 if (lprcSelectBox
) doSelectBox
= TRUE
;
2303 if (lprcLabel
) doLabel
= TRUE
;
2304 if (doLabel
|| lprcIcon
|| lprcStateIcon
) doIcon
= TRUE
;
2311 /************************************************************/
2312 /* compute the box rectangle (it should be cheap to do) */
2313 /************************************************************/
2314 if (lpLVItem
->iSubItem
|| infoPtr
->uView
== LV_VIEW_DETAILS
)
2315 lpColumnInfo
= LISTVIEW_GetColumnInfo(infoPtr
, lpLVItem
->iSubItem
);
2317 if (lpLVItem
->iSubItem
)
2319 Box
= lpColumnInfo
->rcHeader
;
2324 Box
.right
= infoPtr
->nItemWidth
;
2327 Box
.bottom
= infoPtr
->nItemHeight
;
2329 /******************************************************************/
2330 /* compute ICON bounding box (ala LVM_GETITEMRECT) and STATEICON */
2331 /******************************************************************/
2334 LONG state_width
= 0;
2336 if (infoPtr
->himlState
&& lpLVItem
->iSubItem
== 0)
2337 state_width
= infoPtr
->iconStateSize
.cx
;
2339 if (infoPtr
->uView
== LV_VIEW_ICON
)
2341 Icon
.left
= Box
.left
+ state_width
;
2342 if (infoPtr
->himlNormal
)
2343 Icon
.left
+= (infoPtr
->nItemWidth
- infoPtr
->iconSize
.cx
- state_width
) / 2;
2344 Icon
.top
= Box
.top
+ ICON_TOP_PADDING
;
2345 Icon
.right
= Icon
.left
;
2346 Icon
.bottom
= Icon
.top
;
2347 if (infoPtr
->himlNormal
)
2349 Icon
.right
+= infoPtr
->iconSize
.cx
;
2350 Icon
.bottom
+= infoPtr
->iconSize
.cy
;
2353 else /* LV_VIEW_SMALLICON, LV_VIEW_LIST or LV_VIEW_DETAILS */
2355 Icon
.left
= Box
.left
+ state_width
;
2357 if (infoPtr
->uView
== LV_VIEW_DETAILS
&& lpLVItem
->iSubItem
== 0)
2359 /* we need the indent in report mode */
2360 assert(lpLVItem
->mask
& LVIF_INDENT
);
2361 Icon
.left
+= infoPtr
->iconSize
.cx
* lpLVItem
->iIndent
+ REPORT_MARGINX
;
2365 Icon
.right
= Icon
.left
;
2366 if (infoPtr
->himlSmall
&&
2367 (!lpColumnInfo
|| lpLVItem
->iSubItem
== 0 || (lpColumnInfo
->fmt
& LVCFMT_IMAGE
) ||
2368 ((infoPtr
->dwLvExStyle
& LVS_EX_SUBITEMIMAGES
) && lpLVItem
->iImage
!= I_IMAGECALLBACK
)))
2369 Icon
.right
+= infoPtr
->iconSize
.cx
;
2370 Icon
.bottom
= Icon
.top
+ infoPtr
->iconSize
.cy
;
2372 if(lprcIcon
) *lprcIcon
= Icon
;
2373 TRACE(" - icon=%s\n", wine_dbgstr_rect(&Icon
));
2375 /* TODO: is this correct? */
2378 lprcStateIcon
->left
= Icon
.left
- state_width
;
2379 lprcStateIcon
->right
= Icon
.left
;
2380 lprcStateIcon
->top
= Icon
.top
;
2381 lprcStateIcon
->bottom
= lprcStateIcon
->top
+ infoPtr
->iconSize
.cy
;
2382 TRACE(" - state icon=%s\n", wine_dbgstr_rect(lprcStateIcon
));
2385 else Icon
.right
= 0;
2387 /************************************************************/
2388 /* compute LABEL bounding box (ala LVM_GETITEMRECT) */
2389 /************************************************************/
2392 /* calculate how far to the right can the label stretch */
2393 Label
.right
= Box
.right
;
2394 if (infoPtr
->uView
== LV_VIEW_DETAILS
)
2396 if (lpLVItem
->iSubItem
== 0)
2398 /* we need a zero based rect here */
2399 Label
= lpColumnInfo
->rcHeader
;
2400 OffsetRect(&Label
, -Label
.left
, 0);
2404 if (lpLVItem
->iSubItem
|| ((infoPtr
->dwStyle
& LVS_OWNERDRAWFIXED
) && infoPtr
->uView
== LV_VIEW_DETAILS
))
2406 labelSize
.cx
= infoPtr
->nItemWidth
;
2407 labelSize
.cy
= infoPtr
->nItemHeight
;
2411 /* we need the text in non owner draw mode */
2412 assert(lpLVItem
->mask
& LVIF_TEXT
);
2413 if (is_text(lpLVItem
->pszText
))
2415 HFONT hFont
= infoPtr
->hFont
? infoPtr
->hFont
: infoPtr
->hDefaultFont
;
2416 HDC hdc
= GetDC(infoPtr
->hwndSelf
);
2417 HFONT hOldFont
= SelectObject(hdc
, hFont
);
2421 /* compute rough rectangle where the label will go */
2422 SetRectEmpty(&rcText
);
2423 rcText
.right
= infoPtr
->nItemWidth
- TRAILING_LABEL_PADDING
;
2424 rcText
.bottom
= infoPtr
->nItemHeight
;
2425 if (infoPtr
->uView
== LV_VIEW_ICON
)
2426 rcText
.bottom
-= ICON_TOP_PADDING
+ infoPtr
->iconSize
.cy
+ ICON_BOTTOM_PADDING
;
2428 /* now figure out the flags */
2429 if (infoPtr
->uView
== LV_VIEW_ICON
)
2430 uFormat
= oversizedBox
? LV_FL_DT_FLAGS
: LV_ML_DT_FLAGS
;
2432 uFormat
= LV_SL_DT_FLAGS
;
2434 DrawTextW (hdc
, lpLVItem
->pszText
, -1, &rcText
, uFormat
| DT_CALCRECT
);
2436 if (rcText
.right
!= rcText
.left
)
2437 labelSize
.cx
= min(rcText
.right
- rcText
.left
+ TRAILING_LABEL_PADDING
, infoPtr
->nItemWidth
);
2439 labelSize
.cy
= rcText
.bottom
- rcText
.top
;
2441 SelectObject(hdc
, hOldFont
);
2442 ReleaseDC(infoPtr
->hwndSelf
, hdc
);
2446 if (infoPtr
->uView
== LV_VIEW_ICON
)
2448 Label
.left
= Box
.left
+ (infoPtr
->nItemWidth
- labelSize
.cx
) / 2;
2449 Label
.top
= Box
.top
+ ICON_TOP_PADDING_HITABLE
+
2450 infoPtr
->iconSize
.cy
+ ICON_BOTTOM_PADDING
;
2451 Label
.right
= Label
.left
+ labelSize
.cx
;
2452 Label
.bottom
= Label
.top
+ infoPtr
->nItemHeight
;
2453 if (!oversizedBox
&& labelSize
.cy
> infoPtr
->ntmHeight
)
2455 labelSize
.cy
= min(Box
.bottom
- Label
.top
, labelSize
.cy
);
2456 labelSize
.cy
/= infoPtr
->ntmHeight
;
2457 labelSize
.cy
= max(labelSize
.cy
, 1);
2458 labelSize
.cy
*= infoPtr
->ntmHeight
;
2460 Label
.bottom
= Label
.top
+ labelSize
.cy
+ HEIGHT_PADDING
;
2462 else if (infoPtr
->uView
== LV_VIEW_DETAILS
)
2464 Label
.left
= Icon
.right
;
2465 Label
.top
= Box
.top
;
2466 Label
.right
= lpLVItem
->iSubItem
? lpColumnInfo
->rcHeader
.right
:
2467 lpColumnInfo
->rcHeader
.right
- lpColumnInfo
->rcHeader
.left
;
2468 Label
.bottom
= Label
.top
+ infoPtr
->nItemHeight
;
2470 else /* LV_VIEW_SMALLICON or LV_VIEW_LIST */
2472 Label
.left
= Icon
.right
;
2473 Label
.top
= Box
.top
;
2474 Label
.right
= min(Label
.left
+ labelSize
.cx
, Label
.right
);
2475 Label
.bottom
= Label
.top
+ infoPtr
->nItemHeight
;
2478 if (lprcLabel
) *lprcLabel
= Label
;
2479 TRACE(" - label=%s\n", wine_dbgstr_rect(&Label
));
2482 /************************************************************/
2483 /* compute SELECT bounding box */
2484 /************************************************************/
2487 if (infoPtr
->uView
== LV_VIEW_DETAILS
)
2489 SelectBox
.left
= Icon
.left
;
2490 SelectBox
.top
= Box
.top
;
2491 SelectBox
.bottom
= Box
.bottom
;
2494 SelectBox
.right
= min(Label
.left
+ labelSize
.cx
, Label
.right
);
2496 SelectBox
.right
= min(Label
.left
+ MAX_EMPTYTEXT_SELECT_WIDTH
, Label
.right
);
2500 UnionRect(&SelectBox
, &Icon
, &Label
);
2502 if (lprcSelectBox
) *lprcSelectBox
= SelectBox
;
2503 TRACE(" - select box=%s\n", wine_dbgstr_rect(&SelectBox
));
2506 /* Fix the Box if necessary */
2509 if (oversizedBox
) UnionRect(lprcBox
, &Box
, &Label
);
2510 else *lprcBox
= Box
;
2512 TRACE(" - box=%s\n", wine_dbgstr_rect(&Box
));
2516 * DESCRIPTION: [INTERNAL]
2519 * [I] infoPtr : valid pointer to the listview structure
2520 * [I] nItem : item number
2521 * [O] lprcBox : ptr to Box rectangle
2526 static void LISTVIEW_GetItemBox(const LISTVIEW_INFO
*infoPtr
, INT nItem
, LPRECT lprcBox
)
2528 WCHAR szDispText
[DISP_TEXT_SIZE
] = { '\0' };
2529 POINT Position
, Origin
;
2532 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
2533 LISTVIEW_GetItemOrigin(infoPtr
, nItem
, &Position
);
2535 /* Be smart and try to figure out the minimum we have to do */
2537 if (infoPtr
->uView
== LV_VIEW_ICON
&& infoPtr
->bFocus
&& LISTVIEW_GetItemState(infoPtr
, nItem
, LVIS_FOCUSED
))
2538 lvItem
.mask
|= LVIF_TEXT
;
2539 lvItem
.iItem
= nItem
;
2540 lvItem
.iSubItem
= 0;
2541 lvItem
.pszText
= szDispText
;
2542 lvItem
.cchTextMax
= DISP_TEXT_SIZE
;
2543 if (lvItem
.mask
) LISTVIEW_GetItemW(infoPtr
, &lvItem
);
2544 if (infoPtr
->uView
== LV_VIEW_ICON
)
2546 lvItem
.mask
|= LVIF_STATE
;
2547 lvItem
.stateMask
= LVIS_FOCUSED
;
2548 lvItem
.state
= (lvItem
.mask
& LVIF_TEXT
? LVIS_FOCUSED
: 0);
2550 LISTVIEW_GetItemMetrics(infoPtr
, &lvItem
, lprcBox
, 0, 0, 0, 0);
2552 if (infoPtr
->uView
== LV_VIEW_DETAILS
&& infoPtr
->dwLvExStyle
& LVS_EX_FULLROWSELECT
&&
2553 SendMessageW(infoPtr
->hwndHeader
, HDM_ORDERTOINDEX
, 0, 0))
2555 OffsetRect(lprcBox
, Origin
.x
, Position
.y
+ Origin
.y
);
2558 OffsetRect(lprcBox
, Position
.x
+ Origin
.x
, Position
.y
+ Origin
.y
);
2561 /* LISTVIEW_MapIdToIndex helper */
2562 static INT CALLBACK
MapIdSearchCompare(LPVOID p1
, LPVOID p2
, LPARAM lParam
)
2564 ITEM_ID
*id1
= (ITEM_ID
*)p1
;
2565 ITEM_ID
*id2
= (ITEM_ID
*)p2
;
2567 if (id1
->id
== id2
->id
) return 0;
2569 return (id1
->id
< id2
->id
) ? -1 : 1;
2574 * Returns the item index for id specified.
2577 * [I] infoPtr : valid pointer to the listview structure
2578 * [I] iID : item id to get index for
2581 * Item index, or -1 on failure.
2583 static INT
LISTVIEW_MapIdToIndex(const LISTVIEW_INFO
*infoPtr
, UINT iID
)
2588 TRACE("iID=%d\n", iID
);
2590 if (infoPtr
->dwStyle
& LVS_OWNERDATA
) return -1;
2591 if (infoPtr
->nItemCount
== 0) return -1;
2594 index
= DPA_Search(infoPtr
->hdpaItemIds
, &ID
, -1, MapIdSearchCompare
, 0, DPAS_SORTED
);
2598 ITEM_ID
*lpID
= DPA_GetPtr(infoPtr
->hdpaItemIds
, index
);
2599 return DPA_GetPtrIndex(infoPtr
->hdpaItems
, lpID
->item
);
2607 * Returns the item id for index given.
2610 * [I] infoPtr : valid pointer to the listview structure
2611 * [I] iItem : item index to get id for
2616 static DWORD
LISTVIEW_MapIndexToId(const LISTVIEW_INFO
*infoPtr
, INT iItem
)
2621 TRACE("iItem=%d\n", iItem
);
2623 if (infoPtr
->dwStyle
& LVS_OWNERDATA
) return -1;
2624 if (iItem
< 0 || iItem
>= infoPtr
->nItemCount
) return -1;
2626 hdpaSubItems
= DPA_GetPtr(infoPtr
->hdpaItems
, iItem
);
2627 lpItem
= DPA_GetPtr(hdpaSubItems
, 0);
2629 return lpItem
->id
->id
;
2634 * Returns the current icon position, and advances it along the top.
2635 * The returned position is not offset by Origin.
2638 * [I] infoPtr : valid pointer to the listview structure
2639 * [O] lpPos : will get the current icon position
2644 static void LISTVIEW_NextIconPosTop(LISTVIEW_INFO
*infoPtr
, LPPOINT lpPos
)
2646 INT nListWidth
= infoPtr
->rcList
.right
- infoPtr
->rcList
.left
;
2648 *lpPos
= infoPtr
->currIconPos
;
2650 infoPtr
->currIconPos
.x
+= infoPtr
->nItemWidth
;
2651 if (infoPtr
->currIconPos
.x
+ infoPtr
->nItemWidth
<= nListWidth
) return;
2653 infoPtr
->currIconPos
.x
= 0;
2654 infoPtr
->currIconPos
.y
+= infoPtr
->nItemHeight
;
2660 * Returns the current icon position, and advances it down the left edge.
2661 * The returned position is not offset by Origin.
2664 * [I] infoPtr : valid pointer to the listview structure
2665 * [O] lpPos : will get the current icon position
2670 static void LISTVIEW_NextIconPosLeft(LISTVIEW_INFO
*infoPtr
, LPPOINT lpPos
)
2672 INT nListHeight
= infoPtr
->rcList
.bottom
- infoPtr
->rcList
.top
;
2674 *lpPos
= infoPtr
->currIconPos
;
2676 infoPtr
->currIconPos
.y
+= infoPtr
->nItemHeight
;
2677 if (infoPtr
->currIconPos
.y
+ infoPtr
->nItemHeight
<= nListHeight
) return;
2679 infoPtr
->currIconPos
.x
+= infoPtr
->nItemWidth
;
2680 infoPtr
->currIconPos
.y
= 0;
2686 * Moves an icon to the specified position.
2687 * It takes care of invalidating the item, etc.
2690 * [I] infoPtr : valid pointer to the listview structure
2691 * [I] nItem : the item to move
2692 * [I] lpPos : the new icon position
2693 * [I] isNew : flags the item as being new
2699 static BOOL
LISTVIEW_MoveIconTo(const LISTVIEW_INFO
*infoPtr
, INT nItem
, const POINT
*lppt
, BOOL isNew
)
2705 old
.x
= (LONG_PTR
)DPA_GetPtr(infoPtr
->hdpaPosX
, nItem
);
2706 old
.y
= (LONG_PTR
)DPA_GetPtr(infoPtr
->hdpaPosY
, nItem
);
2708 if (lppt
->x
== old
.x
&& lppt
->y
== old
.y
) return TRUE
;
2709 LISTVIEW_InvalidateItem(infoPtr
, nItem
);
2712 /* Allocating a POINTER for every item is too resource intensive,
2713 * so we'll keep the (x,y) in different arrays */
2714 if (!DPA_SetPtr(infoPtr
->hdpaPosX
, nItem
, (void *)(LONG_PTR
)lppt
->x
)) return FALSE
;
2715 if (!DPA_SetPtr(infoPtr
->hdpaPosY
, nItem
, (void *)(LONG_PTR
)lppt
->y
)) return FALSE
;
2717 LISTVIEW_InvalidateItem(infoPtr
, nItem
);
2724 * Arranges listview items in icon display mode.
2727 * [I] infoPtr : valid pointer to the listview structure
2728 * [I] nAlignCode : alignment code
2734 static BOOL
LISTVIEW_Arrange(LISTVIEW_INFO
*infoPtr
, INT nAlignCode
)
2736 void (*next_pos
)(LISTVIEW_INFO
*, LPPOINT
);
2740 if (infoPtr
->uView
!= LV_VIEW_ICON
&& infoPtr
->uView
!= LV_VIEW_SMALLICON
) return FALSE
;
2742 TRACE("nAlignCode=%d\n", nAlignCode
);
2744 if (nAlignCode
== LVA_DEFAULT
)
2746 if (infoPtr
->dwStyle
& LVS_ALIGNLEFT
) nAlignCode
= LVA_ALIGNLEFT
;
2747 else nAlignCode
= LVA_ALIGNTOP
;
2752 case LVA_ALIGNLEFT
: next_pos
= LISTVIEW_NextIconPosLeft
; break;
2753 case LVA_ALIGNTOP
: next_pos
= LISTVIEW_NextIconPosTop
; break;
2754 case LVA_SNAPTOGRID
: next_pos
= LISTVIEW_NextIconPosTop
; break; /* FIXME */
2755 default: return FALSE
;
2758 infoPtr
->bAutoarrange
= TRUE
;
2759 infoPtr
->currIconPos
.x
= infoPtr
->currIconPos
.y
= 0;
2760 for (i
= 0; i
< infoPtr
->nItemCount
; i
++)
2762 next_pos(infoPtr
, &pos
);
2763 LISTVIEW_MoveIconTo(infoPtr
, i
, &pos
, FALSE
);
2771 * Retrieves the bounding rectangle of all the items, not offset by Origin.
2772 * For LVS_REPORT always returns empty rectangle.
2775 * [I] infoPtr : valid pointer to the listview structure
2776 * [O] lprcView : bounding rectangle
2782 static void LISTVIEW_GetAreaRect(const LISTVIEW_INFO
*infoPtr
, LPRECT lprcView
)
2786 SetRectEmpty(lprcView
);
2788 switch (infoPtr
->uView
)
2791 case LV_VIEW_SMALLICON
:
2792 for (i
= 0; i
< infoPtr
->nItemCount
; i
++)
2794 x
= (LONG_PTR
)DPA_GetPtr(infoPtr
->hdpaPosX
, i
);
2795 y
= (LONG_PTR
)DPA_GetPtr(infoPtr
->hdpaPosY
, i
);
2796 lprcView
->right
= max(lprcView
->right
, x
);
2797 lprcView
->bottom
= max(lprcView
->bottom
, y
);
2799 if (infoPtr
->nItemCount
> 0)
2801 lprcView
->right
+= infoPtr
->nItemWidth
;
2802 lprcView
->bottom
+= infoPtr
->nItemHeight
;
2807 y
= LISTVIEW_GetCountPerColumn(infoPtr
);
2808 x
= infoPtr
->nItemCount
/ y
;
2809 if (infoPtr
->nItemCount
% y
) x
++;
2810 lprcView
->right
= x
* infoPtr
->nItemWidth
;
2811 lprcView
->bottom
= y
* infoPtr
->nItemHeight
;
2818 * Retrieves the bounding rectangle of all the items.
2821 * [I] infoPtr : valid pointer to the listview structure
2822 * [O] lprcView : bounding rectangle
2828 static BOOL
LISTVIEW_GetViewRect(const LISTVIEW_INFO
*infoPtr
, LPRECT lprcView
)
2832 TRACE("(lprcView=%p)\n", lprcView
);
2834 if (!lprcView
) return FALSE
;
2836 LISTVIEW_GetAreaRect(infoPtr
, lprcView
);
2838 if (infoPtr
->uView
!= LV_VIEW_DETAILS
)
2840 LISTVIEW_GetOrigin(infoPtr
, &ptOrigin
);
2841 OffsetRect(lprcView
, ptOrigin
.x
, ptOrigin
.y
);
2844 TRACE("lprcView=%s\n", wine_dbgstr_rect(lprcView
));
2851 * Retrieves the subitem pointer associated with the subitem index.
2854 * [I] hdpaSubItems : DPA handle for a specific item
2855 * [I] nSubItem : index of subitem
2858 * SUCCESS : subitem pointer
2861 static SUBITEM_INFO
* LISTVIEW_GetSubItemPtr(HDPA hdpaSubItems
, INT nSubItem
)
2863 SUBITEM_INFO
*lpSubItem
;
2866 /* we should binary search here if need be */
2867 for (i
= 1; i
< DPA_GetPtrCount(hdpaSubItems
); i
++)
2869 lpSubItem
= DPA_GetPtr(hdpaSubItems
, i
);
2870 if (lpSubItem
->iSubItem
== nSubItem
)
2880 * Calculates the desired item width.
2883 * [I] infoPtr : valid pointer to the listview structure
2886 * The desired item width.
2888 static INT
LISTVIEW_CalculateItemWidth(const LISTVIEW_INFO
*infoPtr
)
2892 TRACE("uView=%d\n", infoPtr
->uView
);
2894 if (infoPtr
->uView
== LV_VIEW_ICON
)
2895 nItemWidth
= infoPtr
->iconSpacing
.cx
;
2896 else if (infoPtr
->uView
== LV_VIEW_DETAILS
)
2898 if (DPA_GetPtrCount(infoPtr
->hdpaColumns
) > 0)
2903 index
= SendMessageW(infoPtr
->hwndHeader
, HDM_ORDERTOINDEX
,
2904 DPA_GetPtrCount(infoPtr
->hdpaColumns
) - 1, 0);
2906 LISTVIEW_GetHeaderRect(infoPtr
, index
, &rcHeader
);
2907 nItemWidth
= rcHeader
.right
;
2910 else /* LV_VIEW_SMALLICON, or LV_VIEW_LIST */
2912 WCHAR szDispText
[DISP_TEXT_SIZE
] = { '\0' };
2916 lvItem
.mask
= LVIF_TEXT
;
2917 lvItem
.iSubItem
= 0;
2919 for (i
= 0; i
< infoPtr
->nItemCount
; i
++)
2922 lvItem
.pszText
= szDispText
;
2923 lvItem
.cchTextMax
= DISP_TEXT_SIZE
;
2924 if (LISTVIEW_GetItemW(infoPtr
, &lvItem
))
2925 nItemWidth
= max(LISTVIEW_GetStringWidthT(infoPtr
, lvItem
.pszText
, TRUE
),
2929 if (infoPtr
->himlSmall
) nItemWidth
+= infoPtr
->iconSize
.cx
;
2930 if (infoPtr
->himlState
) nItemWidth
+= infoPtr
->iconStateSize
.cx
;
2932 nItemWidth
= max(DEFAULT_COLUMN_WIDTH
, nItemWidth
+ WIDTH_PADDING
);
2940 * Calculates the desired item height.
2943 * [I] infoPtr : valid pointer to the listview structure
2946 * The desired item height.
2948 static INT
LISTVIEW_CalculateItemHeight(const LISTVIEW_INFO
*infoPtr
)
2952 TRACE("uView=%d\n", infoPtr
->uView
);
2954 if (infoPtr
->uView
== LV_VIEW_ICON
)
2955 nItemHeight
= infoPtr
->iconSpacing
.cy
;
2958 nItemHeight
= infoPtr
->ntmHeight
;
2959 if (infoPtr
->uView
== LV_VIEW_DETAILS
&& infoPtr
->dwLvExStyle
& LVS_EX_GRIDLINES
)
2961 if (infoPtr
->himlState
)
2962 nItemHeight
= max(nItemHeight
, infoPtr
->iconStateSize
.cy
);
2963 if (infoPtr
->himlSmall
)
2964 nItemHeight
= max(nItemHeight
, infoPtr
->iconSize
.cy
);
2965 if (infoPtr
->himlState
|| infoPtr
->himlSmall
)
2966 nItemHeight
+= HEIGHT_PADDING
;
2967 if (infoPtr
->nMeasureItemHeight
> 0)
2968 nItemHeight
= infoPtr
->nMeasureItemHeight
;
2971 return max(nItemHeight
, 1);
2976 * Updates the width, and height of an item.
2979 * [I] infoPtr : valid pointer to the listview structure
2984 static inline void LISTVIEW_UpdateItemSize(LISTVIEW_INFO
*infoPtr
)
2986 infoPtr
->nItemWidth
= LISTVIEW_CalculateItemWidth(infoPtr
);
2987 infoPtr
->nItemHeight
= LISTVIEW_CalculateItemHeight(infoPtr
);
2993 * Retrieves and saves important text metrics info for the current
2997 * [I] infoPtr : valid pointer to the listview structure
3000 static void LISTVIEW_SaveTextMetrics(LISTVIEW_INFO
*infoPtr
)
3002 HDC hdc
= GetDC(infoPtr
->hwndSelf
);
3003 HFONT hFont
= infoPtr
->hFont
? infoPtr
->hFont
: infoPtr
->hDefaultFont
;
3004 HFONT hOldFont
= SelectObject(hdc
, hFont
);
3008 if (GetTextMetricsW(hdc
, &tm
))
3010 infoPtr
->ntmHeight
= tm
.tmHeight
;
3011 infoPtr
->ntmMaxCharWidth
= tm
.tmMaxCharWidth
;
3014 if (GetTextExtentPoint32A(hdc
, "...", 3, &sz
))
3015 infoPtr
->nEllipsisWidth
= sz
.cx
;
3017 SelectObject(hdc
, hOldFont
);
3018 ReleaseDC(infoPtr
->hwndSelf
, hdc
);
3020 TRACE("tmHeight=%d\n", infoPtr
->ntmHeight
);
3025 * A compare function for ranges
3028 * [I] range1 : pointer to range 1;
3029 * [I] range2 : pointer to range 2;
3033 * > 0 : if range 1 > range 2
3034 * < 0 : if range 2 > range 1
3035 * = 0 : if range intersects range 2
3037 static INT CALLBACK
ranges_cmp(LPVOID range1
, LPVOID range2
, LPARAM flags
)
3041 if (((RANGE
*)range1
)->upper
<= ((RANGE
*)range2
)->lower
)
3043 else if (((RANGE
*)range2
)->upper
<= ((RANGE
*)range1
)->lower
)
3048 TRACE("range1=%s, range2=%s, cmp=%d\n", debugrange(range1
), debugrange(range2
), cmp
);
3053 #define ranges_check(ranges, desc) if (TRACE_ON(listview)) ranges_assert(ranges, desc, __FILE__, __LINE__)
3055 static void ranges_assert(RANGES ranges
, LPCSTR desc
, const char *file
, int line
)
3060 TRACE("*** Checking %s:%d:%s ***\n", file
, line
, desc
);
3062 assert (DPA_GetPtrCount(ranges
->hdpa
) >= 0);
3063 ranges_dump(ranges
);
3064 if (DPA_GetPtrCount(ranges
->hdpa
) > 0)
3066 prev
= DPA_GetPtr(ranges
->hdpa
, 0);
3067 assert (prev
->lower
>= 0 && prev
->lower
< prev
->upper
);
3068 for (i
= 1; i
< DPA_GetPtrCount(ranges
->hdpa
); i
++)
3070 curr
= DPA_GetPtr(ranges
->hdpa
, i
);
3071 assert (prev
->upper
<= curr
->lower
);
3072 assert (curr
->lower
< curr
->upper
);
3076 TRACE("--- Done checking---\n");
3079 static RANGES
ranges_create(int count
)
3081 RANGES ranges
= Alloc(sizeof(struct tagRANGES
));
3082 if (!ranges
) return NULL
;
3083 ranges
->hdpa
= DPA_Create(count
);
3084 if (ranges
->hdpa
) return ranges
;
3089 static void ranges_clear(RANGES ranges
)
3093 for(i
= 0; i
< DPA_GetPtrCount(ranges
->hdpa
); i
++)
3094 Free(DPA_GetPtr(ranges
->hdpa
, i
));
3095 DPA_DeleteAllPtrs(ranges
->hdpa
);
3099 static void ranges_destroy(RANGES ranges
)
3101 if (!ranges
) return;
3102 ranges_clear(ranges
);
3103 DPA_Destroy(ranges
->hdpa
);
3107 static RANGES
ranges_clone(RANGES ranges
)
3112 if (!(clone
= ranges_create(DPA_GetPtrCount(ranges
->hdpa
)))) goto fail
;
3114 for (i
= 0; i
< DPA_GetPtrCount(ranges
->hdpa
); i
++)
3116 RANGE
*newrng
= Alloc(sizeof(RANGE
));
3117 if (!newrng
) goto fail
;
3118 *newrng
= *((RANGE
*)DPA_GetPtr(ranges
->hdpa
, i
));
3119 DPA_SetPtr(clone
->hdpa
, i
, newrng
);
3124 TRACE ("clone failed\n");
3125 ranges_destroy(clone
);
3129 static RANGES
ranges_diff(RANGES ranges
, RANGES sub
)
3133 for (i
= 0; i
< DPA_GetPtrCount(sub
->hdpa
); i
++)
3134 ranges_del(ranges
, *((RANGE
*)DPA_GetPtr(sub
->hdpa
, i
)));
3139 static void ranges_dump(RANGES ranges
)
3143 for (i
= 0; i
< DPA_GetPtrCount(ranges
->hdpa
); i
++)
3144 TRACE(" %s\n", debugrange(DPA_GetPtr(ranges
->hdpa
, i
)));
3147 static inline BOOL
ranges_contain(RANGES ranges
, INT nItem
)
3149 RANGE srchrng
= { nItem
, nItem
+ 1 };
3151 TRACE("(nItem=%d)\n", nItem
);
3152 ranges_check(ranges
, "before contain");
3153 return DPA_Search(ranges
->hdpa
, &srchrng
, 0, ranges_cmp
, 0, DPAS_SORTED
) != -1;
3156 static INT
ranges_itemcount(RANGES ranges
)
3160 for (i
= 0; i
< DPA_GetPtrCount(ranges
->hdpa
); i
++)
3162 RANGE
*sel
= DPA_GetPtr(ranges
->hdpa
, i
);
3163 count
+= sel
->upper
- sel
->lower
;
3169 static BOOL
ranges_shift(RANGES ranges
, INT nItem
, INT delta
, INT nUpper
)
3171 RANGE srchrng
= { nItem
, nItem
+ 1 }, *chkrng
;
3174 index
= DPA_Search(ranges
->hdpa
, &srchrng
, 0, ranges_cmp
, 0, DPAS_SORTED
| DPAS_INSERTAFTER
);
3175 if (index
== -1) return TRUE
;
3177 for (; index
< DPA_GetPtrCount(ranges
->hdpa
); index
++)
3179 chkrng
= DPA_GetPtr(ranges
->hdpa
, index
);
3180 if (chkrng
->lower
>= nItem
)
3181 chkrng
->lower
= max(min(chkrng
->lower
+ delta
, nUpper
- 1), 0);
3182 if (chkrng
->upper
> nItem
)
3183 chkrng
->upper
= max(min(chkrng
->upper
+ delta
, nUpper
), 0);
3188 static BOOL
ranges_add(RANGES ranges
, RANGE range
)
3193 TRACE("(%s)\n", debugrange(&range
));
3194 ranges_check(ranges
, "before add");
3196 /* try find overlapping regions first */
3197 srchrgn
.lower
= range
.lower
- 1;
3198 srchrgn
.upper
= range
.upper
+ 1;
3199 index
= DPA_Search(ranges
->hdpa
, &srchrgn
, 0, ranges_cmp
, 0, DPAS_SORTED
);
3205 TRACE("Adding new range\n");
3207 /* create the brand new range to insert */
3208 newrgn
= Alloc(sizeof(RANGE
));
3209 if(!newrgn
) goto fail
;
3212 /* figure out where to insert it */
3213 index
= DPA_Search(ranges
->hdpa
, newrgn
, 0, ranges_cmp
, 0, DPAS_SORTED
| DPAS_INSERTAFTER
);
3214 TRACE("index=%d\n", index
);
3215 if (index
== -1) index
= 0;
3217 /* and get it over with */
3218 if (DPA_InsertPtr(ranges
->hdpa
, index
, newrgn
) == -1)
3226 RANGE
*chkrgn
, *mrgrgn
;
3227 INT fromindex
, mergeindex
;
3229 chkrgn
= DPA_GetPtr(ranges
->hdpa
, index
);
3230 TRACE("Merge with %s @%d\n", debugrange(chkrgn
), index
);
3232 chkrgn
->lower
= min(range
.lower
, chkrgn
->lower
);
3233 chkrgn
->upper
= max(range
.upper
, chkrgn
->upper
);
3235 TRACE("New range %s @%d\n", debugrange(chkrgn
), index
);
3237 /* merge now common ranges */
3239 srchrgn
.lower
= chkrgn
->lower
- 1;
3240 srchrgn
.upper
= chkrgn
->upper
+ 1;
3244 mergeindex
= DPA_Search(ranges
->hdpa
, &srchrgn
, fromindex
, ranges_cmp
, 0, 0);
3245 if (mergeindex
== -1) break;
3246 if (mergeindex
== index
)
3248 fromindex
= index
+ 1;
3252 TRACE("Merge with index %i\n", mergeindex
);
3254 mrgrgn
= DPA_GetPtr(ranges
->hdpa
, mergeindex
);
3255 chkrgn
->lower
= min(chkrgn
->lower
, mrgrgn
->lower
);
3256 chkrgn
->upper
= max(chkrgn
->upper
, mrgrgn
->upper
);
3258 DPA_DeletePtr(ranges
->hdpa
, mergeindex
);
3259 if (mergeindex
< index
) index
--;
3263 ranges_check(ranges
, "after add");
3267 ranges_check(ranges
, "failed add");
3271 static BOOL
ranges_del(RANGES ranges
, RANGE range
)
3276 TRACE("(%s)\n", debugrange(&range
));
3277 ranges_check(ranges
, "before del");
3279 /* we don't use DPAS_SORTED here, since we need *
3280 * to find the first overlapping range */
3281 index
= DPA_Search(ranges
->hdpa
, &range
, 0, ranges_cmp
, 0, 0);
3284 chkrgn
= DPA_GetPtr(ranges
->hdpa
, index
);
3286 TRACE("Matches range %s @%d\n", debugrange(chkrgn
), index
);
3288 /* case 1: Same range */
3289 if ( (chkrgn
->upper
== range
.upper
) &&
3290 (chkrgn
->lower
== range
.lower
) )
3292 DPA_DeletePtr(ranges
->hdpa
, index
);
3296 /* case 2: engulf */
3297 else if ( (chkrgn
->upper
<= range
.upper
) &&
3298 (chkrgn
->lower
>= range
.lower
) )
3300 DPA_DeletePtr(ranges
->hdpa
, index
);
3303 /* case 3: overlap upper */
3304 else if ( (chkrgn
->upper
<= range
.upper
) &&
3305 (chkrgn
->lower
< range
.lower
) )
3307 chkrgn
->upper
= range
.lower
;
3309 /* case 4: overlap lower */
3310 else if ( (chkrgn
->upper
> range
.upper
) &&
3311 (chkrgn
->lower
>= range
.lower
) )
3313 chkrgn
->lower
= range
.upper
;
3316 /* case 5: fully internal */
3321 if (!(newrgn
= Alloc(sizeof(RANGE
)))) goto fail
;
3322 newrgn
->lower
= chkrgn
->lower
;
3323 newrgn
->upper
= range
.lower
;
3324 chkrgn
->lower
= range
.upper
;
3325 if (DPA_InsertPtr(ranges
->hdpa
, index
, newrgn
) == -1)
3333 index
= DPA_Search(ranges
->hdpa
, &range
, index
, ranges_cmp
, 0, 0);
3336 ranges_check(ranges
, "after del");
3340 ranges_check(ranges
, "failed del");
3346 * Removes all selection ranges
3349 * [I] infoPtr : valid pointer to the listview structure
3350 * [I] toSkip : item range to skip removing the selection
3356 static BOOL
LISTVIEW_DeselectAllSkipItems(LISTVIEW_INFO
*infoPtr
, RANGES toSkip
)
3365 lvItem
.stateMask
= LVIS_SELECTED
;
3367 /* need to clone the DPA because callbacks can change it */
3368 if (!(clone
= ranges_clone(infoPtr
->selectionRanges
))) return FALSE
;
3369 iterator_rangesitems(&i
, ranges_diff(clone
, toSkip
));
3370 while(iterator_next(&i
))
3371 LISTVIEW_SetItemState(infoPtr
, i
.nItem
, &lvItem
);
3372 /* note that the iterator destructor will free the cloned range */
3373 iterator_destroy(&i
);
3378 static inline BOOL
LISTVIEW_DeselectAllSkipItem(LISTVIEW_INFO
*infoPtr
, INT nItem
)
3382 if (!(toSkip
= ranges_create(1))) return FALSE
;
3383 if (nItem
!= -1) ranges_additem(toSkip
, nItem
);
3384 LISTVIEW_DeselectAllSkipItems(infoPtr
, toSkip
);
3385 ranges_destroy(toSkip
);
3389 static inline BOOL
LISTVIEW_DeselectAll(LISTVIEW_INFO
*infoPtr
)
3391 return LISTVIEW_DeselectAllSkipItem(infoPtr
, -1);
3396 * Retrieves the number of items that are marked as selected.
3399 * [I] infoPtr : valid pointer to the listview structure
3402 * Number of items selected.
3404 static INT
LISTVIEW_GetSelectedCount(const LISTVIEW_INFO
*infoPtr
)
3406 INT nSelectedCount
= 0;
3408 if (infoPtr
->uCallbackMask
& LVIS_SELECTED
)
3411 for (i
= 0; i
< infoPtr
->nItemCount
; i
++)
3413 if (LISTVIEW_GetItemState(infoPtr
, i
, LVIS_SELECTED
))
3418 nSelectedCount
= ranges_itemcount(infoPtr
->selectionRanges
);
3420 TRACE("nSelectedCount=%d\n", nSelectedCount
);
3421 return nSelectedCount
;
3426 * Manages the item focus.
3429 * [I] infoPtr : valid pointer to the listview structure
3430 * [I] nItem : item index
3433 * TRUE : focused item changed
3434 * FALSE : focused item has NOT changed
3436 static inline BOOL
LISTVIEW_SetItemFocus(LISTVIEW_INFO
*infoPtr
, INT nItem
)
3438 INT oldFocus
= infoPtr
->nFocusedItem
;
3441 if (nItem
== infoPtr
->nFocusedItem
) return FALSE
;
3443 lvItem
.state
= nItem
== -1 ? 0 : LVIS_FOCUSED
;
3444 lvItem
.stateMask
= LVIS_FOCUSED
;
3445 LISTVIEW_SetItemState(infoPtr
, nItem
== -1 ? infoPtr
->nFocusedItem
: nItem
, &lvItem
);
3447 return oldFocus
!= infoPtr
->nFocusedItem
;
3450 /* Helper function for LISTVIEW_ShiftIndices *only* */
3451 static INT
shift_item(const LISTVIEW_INFO
*infoPtr
, INT nShiftItem
, INT nItem
, INT direction
)
3453 if (nShiftItem
< nItem
) return nShiftItem
;
3455 if (nShiftItem
> nItem
) return nShiftItem
+ direction
;
3457 if (direction
> 0) return nShiftItem
+ direction
;
3459 return min(nShiftItem
, infoPtr
->nItemCount
- 1);
3464 * Updates the various indices after an item has been inserted or deleted.
3467 * [I] infoPtr : valid pointer to the listview structure
3468 * [I] nItem : item index
3469 * [I] direction : Direction of shift, +1 or -1.
3474 static void LISTVIEW_ShiftIndices(LISTVIEW_INFO
*infoPtr
, INT nItem
, INT direction
)
3479 /* temporarily disable change notification while shifting items */
3480 bOldChange
= infoPtr
->bDoChangeNotify
;
3481 infoPtr
->bDoChangeNotify
= FALSE
;
3483 TRACE("Shifting %iu, %i steps\n", nItem
, direction
);
3485 ranges_shift(infoPtr
->selectionRanges
, nItem
, direction
, infoPtr
->nItemCount
);
3487 assert(abs(direction
) == 1);
3489 infoPtr
->nSelectionMark
= shift_item(infoPtr
, infoPtr
->nSelectionMark
, nItem
, direction
);
3491 nNewFocus
= shift_item(infoPtr
, infoPtr
->nFocusedItem
, nItem
, direction
);
3492 if (nNewFocus
!= infoPtr
->nFocusedItem
)
3493 LISTVIEW_SetItemFocus(infoPtr
, nNewFocus
);
3495 /* But we are not supposed to modify nHotItem! */
3497 infoPtr
->bDoChangeNotify
= bOldChange
;
3503 * Adds a block of selections.
3506 * [I] infoPtr : valid pointer to the listview structure
3507 * [I] nItem : item index
3510 * Whether the window is still valid.
3512 static BOOL
LISTVIEW_AddGroupSelection(LISTVIEW_INFO
*infoPtr
, INT nItem
)
3514 INT nFirst
= min(infoPtr
->nSelectionMark
, nItem
);
3515 INT nLast
= max(infoPtr
->nSelectionMark
, nItem
);
3516 HWND hwndSelf
= infoPtr
->hwndSelf
;
3517 NMLVODSTATECHANGE nmlv
;
3522 /* Temporarily disable change notification
3523 * If the control is LVS_OWNERDATA, we need to send
3524 * only one LVN_ODSTATECHANGED notification.
3525 * See MSDN documentation for LVN_ITEMCHANGED.
3527 bOldChange
= infoPtr
->bDoChangeNotify
;
3528 if (infoPtr
->dwStyle
& LVS_OWNERDATA
) infoPtr
->bDoChangeNotify
= FALSE
;
3530 if (nFirst
== -1) nFirst
= nItem
;
3532 item
.state
= LVIS_SELECTED
;
3533 item
.stateMask
= LVIS_SELECTED
;
3535 for (i
= nFirst
; i
<= nLast
; i
++)
3536 LISTVIEW_SetItemState(infoPtr
,i
,&item
);
3538 ZeroMemory(&nmlv
, sizeof(nmlv
));
3539 nmlv
.iFrom
= nFirst
;
3542 nmlv
.uOldState
= item
.state
;
3544 notify_hdr(infoPtr
, LVN_ODSTATECHANGED
, (LPNMHDR
)&nmlv
);
3545 if (!IsWindow(hwndSelf
))
3547 infoPtr
->bDoChangeNotify
= bOldChange
;
3554 * Sets a single group selection.
3557 * [I] infoPtr : valid pointer to the listview structure
3558 * [I] nItem : item index
3563 static void LISTVIEW_SetGroupSelection(LISTVIEW_INFO
*infoPtr
, INT nItem
)
3570 if (!(selection
= ranges_create(100))) return;
3572 item
.state
= LVIS_SELECTED
;
3573 item
.stateMask
= LVIS_SELECTED
;
3575 if ((infoPtr
->uView
== LV_VIEW_LIST
) || (infoPtr
->uView
== LV_VIEW_DETAILS
))
3577 if (infoPtr
->nSelectionMark
== -1)
3579 infoPtr
->nSelectionMark
= nItem
;
3580 ranges_additem(selection
, nItem
);
3586 sel
.lower
= min(infoPtr
->nSelectionMark
, nItem
);
3587 sel
.upper
= max(infoPtr
->nSelectionMark
, nItem
) + 1;
3588 ranges_add(selection
, sel
);
3593 RECT rcItem
, rcSel
, rcSelMark
;
3596 rcItem
.left
= LVIR_BOUNDS
;
3597 if (!LISTVIEW_GetItemRect(infoPtr
, nItem
, &rcItem
)) return;
3598 rcSelMark
.left
= LVIR_BOUNDS
;
3599 if (!LISTVIEW_GetItemRect(infoPtr
, infoPtr
->nSelectionMark
, &rcSelMark
)) return;
3600 UnionRect(&rcSel
, &rcItem
, &rcSelMark
);
3601 iterator_frameditems(&i
, infoPtr
, &rcSel
);
3602 while(iterator_next(&i
))
3604 LISTVIEW_GetItemPosition(infoPtr
, i
.nItem
, &ptItem
);
3605 if (PtInRect(&rcSel
, ptItem
)) ranges_additem(selection
, i
.nItem
);
3607 iterator_destroy(&i
);
3610 /* disable per item notifications on LVS_OWNERDATA style
3611 FIXME: single LVN_ODSTATECHANGED should be used */
3612 bOldChange
= infoPtr
->bDoChangeNotify
;
3613 if (infoPtr
->dwStyle
& LVS_OWNERDATA
) infoPtr
->bDoChangeNotify
= FALSE
;
3615 LISTVIEW_DeselectAllSkipItems(infoPtr
, selection
);
3618 iterator_rangesitems(&i
, selection
);
3619 while(iterator_next(&i
))
3620 LISTVIEW_SetItemState(infoPtr
, i
.nItem
, &item
);
3621 /* this will also destroy the selection */
3622 iterator_destroy(&i
);
3624 infoPtr
->bDoChangeNotify
= bOldChange
;
3626 LISTVIEW_SetItemFocus(infoPtr
, nItem
);
3631 * Sets a single selection.
3634 * [I] infoPtr : valid pointer to the listview structure
3635 * [I] nItem : item index
3640 static void LISTVIEW_SetSelection(LISTVIEW_INFO
*infoPtr
, INT nItem
)
3644 TRACE("nItem=%d\n", nItem
);
3646 LISTVIEW_DeselectAllSkipItem(infoPtr
, nItem
);
3648 lvItem
.state
= LVIS_FOCUSED
| LVIS_SELECTED
;
3649 lvItem
.stateMask
= LVIS_FOCUSED
| LVIS_SELECTED
;
3650 LISTVIEW_SetItemState(infoPtr
, nItem
, &lvItem
);
3652 infoPtr
->nSelectionMark
= nItem
;
3657 * Set selection(s) with keyboard.
3660 * [I] infoPtr : valid pointer to the listview structure
3661 * [I] nItem : item index
3662 * [I] space : VK_SPACE code sent
3665 * SUCCESS : TRUE (needs to be repainted)
3666 * FAILURE : FALSE (nothing has changed)
3668 static BOOL
LISTVIEW_KeySelection(LISTVIEW_INFO
*infoPtr
, INT nItem
, BOOL space
)
3670 /* FIXME: pass in the state */
3671 WORD wShift
= HIWORD(GetKeyState(VK_SHIFT
));
3672 WORD wCtrl
= HIWORD(GetKeyState(VK_CONTROL
));
3673 BOOL bResult
= FALSE
;
3675 TRACE("nItem=%d, wShift=%d, wCtrl=%d\n", nItem
, wShift
, wCtrl
);
3676 if ((nItem
>= 0) && (nItem
< infoPtr
->nItemCount
))
3680 if (infoPtr
->dwStyle
& LVS_SINGLESEL
|| (wShift
== 0 && wCtrl
== 0))
3681 LISTVIEW_SetSelection(infoPtr
, nItem
);
3685 LISTVIEW_SetGroupSelection(infoPtr
, nItem
);
3689 lvItem
.state
= ~LISTVIEW_GetItemState(infoPtr
, nItem
, LVIS_SELECTED
);
3690 lvItem
.stateMask
= LVIS_SELECTED
;
3693 LISTVIEW_SetItemState(infoPtr
, nItem
, &lvItem
);
3694 if (lvItem
.state
& LVIS_SELECTED
)
3695 infoPtr
->nSelectionMark
= nItem
;
3697 bResult
= LISTVIEW_SetItemFocus(infoPtr
, nItem
);
3700 LISTVIEW_EnsureVisible(infoPtr
, nItem
, FALSE
);
3703 UpdateWindow(infoPtr
->hwndSelf
); /* update client area */
3707 static BOOL
LISTVIEW_GetItemAtPt(const LISTVIEW_INFO
*infoPtr
, LPLVITEMW lpLVItem
, POINT pt
)
3709 LVHITTESTINFO lvHitTestInfo
;
3711 ZeroMemory(&lvHitTestInfo
, sizeof(lvHitTestInfo
));
3712 lvHitTestInfo
.pt
.x
= pt
.x
;
3713 lvHitTestInfo
.pt
.y
= pt
.y
;
3715 LISTVIEW_HitTest(infoPtr
, &lvHitTestInfo
, TRUE
, FALSE
);
3717 lpLVItem
->mask
= LVIF_PARAM
;
3718 lpLVItem
->iItem
= lvHitTestInfo
.iItem
;
3719 lpLVItem
->iSubItem
= 0;
3721 return LISTVIEW_GetItemT(infoPtr
, lpLVItem
, TRUE
);
3724 static inline BOOL
LISTVIEW_IsHotTracking(const LISTVIEW_INFO
*infoPtr
)
3726 return ((infoPtr
->dwLvExStyle
& LVS_EX_TRACKSELECT
) ||
3727 (infoPtr
->dwLvExStyle
& LVS_EX_ONECLICKACTIVATE
) ||
3728 (infoPtr
->dwLvExStyle
& LVS_EX_TWOCLICKACTIVATE
));
3733 * Called when the mouse is being actively tracked and has hovered for a specified
3737 * [I] infoPtr : valid pointer to the listview structure
3738 * [I] fwKeys : key indicator
3739 * [I] x,y : mouse position
3742 * 0 if the message was processed, non-zero if there was an error
3745 * LVS_EX_TRACKSELECT: An item is automatically selected when the cursor remains
3746 * over the item for a certain period of time.
3749 static LRESULT
LISTVIEW_MouseHover(LISTVIEW_INFO
*infoPtr
, INT x
, INT y
)
3753 if (notify_hdr(infoPtr
, NM_HOVER
, &hdr
)) return 0;
3755 if (LISTVIEW_IsHotTracking(infoPtr
))
3763 if (LISTVIEW_GetItemAtPt(infoPtr
, &item
, pt
))
3764 LISTVIEW_SetSelection(infoPtr
, item
.iItem
);
3766 SetFocus(infoPtr
->hwndSelf
);
3772 #define SCROLL_LEFT 0x1
3773 #define SCROLL_RIGHT 0x2
3774 #define SCROLL_UP 0x4
3775 #define SCROLL_DOWN 0x8
3779 * Utility routine to draw and highlight items within a marquee selection rectangle.
3782 * [I] infoPtr : valid pointer to the listview structure
3783 * [I] coords_orig : original co-ordinates of the cursor
3784 * [I] coords_offs : offsetted coordinates of the cursor
3785 * [I] offset : offset amount
3786 * [I] scroll : Bitmask of which directions we should scroll, if at all
3791 static void LISTVIEW_MarqueeHighlight(LISTVIEW_INFO
*infoPtr
, const POINT
*coords_orig
,
3792 const POINT
*coords_offs
, const POINT
*offset
,
3795 BOOL controlDown
= FALSE
;
3797 ITERATOR old_elems
, new_elems
;
3800 if (coords_offs
->x
> infoPtr
->marqueeOrigin
.x
)
3802 rect
.left
= infoPtr
->marqueeOrigin
.x
;
3803 rect
.right
= coords_offs
->x
;
3807 rect
.left
= coords_offs
->x
;
3808 rect
.right
= infoPtr
->marqueeOrigin
.x
;
3811 if (coords_offs
->y
> infoPtr
->marqueeOrigin
.y
)
3813 rect
.top
= infoPtr
->marqueeOrigin
.y
;
3814 rect
.bottom
= coords_offs
->y
;
3818 rect
.top
= coords_offs
->y
;
3819 rect
.bottom
= infoPtr
->marqueeOrigin
.y
;
3822 /* Cancel out the old marquee rectangle and draw the new one */
3823 LISTVIEW_InvalidateRect(infoPtr
, &infoPtr
->marqueeDrawRect
);
3825 /* Scroll by the appropriate distance if applicable - speed up scrolling as
3826 the cursor is further away */
3828 if ((scroll
& SCROLL_LEFT
) && (coords_orig
->x
<= 0))
3829 LISTVIEW_Scroll(infoPtr
, coords_orig
->x
, 0);
3831 if ((scroll
& SCROLL_RIGHT
) && (coords_orig
->x
>= infoPtr
->rcList
.right
))
3832 LISTVIEW_Scroll(infoPtr
, (coords_orig
->x
- infoPtr
->rcList
.right
), 0);
3834 if ((scroll
& SCROLL_UP
) && (coords_orig
->y
<= 0))
3835 LISTVIEW_Scroll(infoPtr
, 0, coords_orig
->y
);
3837 if ((scroll
& SCROLL_DOWN
) && (coords_orig
->y
>= infoPtr
->rcList
.bottom
))
3838 LISTVIEW_Scroll(infoPtr
, 0, (coords_orig
->y
- infoPtr
->rcList
.bottom
));
3840 iterator_frameditems_absolute(&old_elems
, infoPtr
, &infoPtr
->marqueeRect
);
3842 CopyRect(&infoPtr
->marqueeRect
, &rect
);
3844 CopyRect(&infoPtr
->marqueeDrawRect
, &rect
);
3845 OffsetRect(&infoPtr
->marqueeDrawRect
, offset
->x
, offset
->y
);
3847 iterator_frameditems_absolute(&new_elems
, infoPtr
, &infoPtr
->marqueeRect
);
3848 iterator_remove_common_items(&old_elems
, &new_elems
);
3850 /* Iterate over no longer selected items */
3851 while (iterator_next(&old_elems
))
3853 if (old_elems
.nItem
> -1)
3855 if (LISTVIEW_GetItemState(infoPtr
, old_elems
.nItem
, LVIS_SELECTED
) == LVIS_SELECTED
)
3858 item
.state
= LVIS_SELECTED
;
3860 item
.stateMask
= LVIS_SELECTED
;
3862 LISTVIEW_SetItemState(infoPtr
, old_elems
.nItem
, &item
);
3865 iterator_destroy(&old_elems
);
3868 /* Iterate over newly selected items */
3869 if (GetKeyState(VK_CONTROL
) & 0x8000)
3872 while (iterator_next(&new_elems
))
3874 if (new_elems
.nItem
> -1)
3876 /* If CTRL is pressed, invert. If not, always select the item. */
3877 if ((controlDown
) && (LISTVIEW_GetItemState(infoPtr
, new_elems
.nItem
, LVIS_SELECTED
)))
3880 item
.state
= LVIS_SELECTED
;
3882 item
.stateMask
= LVIS_SELECTED
;
3884 LISTVIEW_SetItemState(infoPtr
, new_elems
.nItem
, &item
);
3887 iterator_destroy(&new_elems
);
3889 LISTVIEW_InvalidateRect(infoPtr
, &infoPtr
->marqueeDrawRect
);
3894 * Called when we are in a marquee selection that involves scrolling the listview (ie,
3895 * the cursor is outside the bounds of the client area). This is a TIMERPROC.
3898 * [I] hwnd : Handle to the listview
3899 * [I] uMsg : WM_TIMER (ignored)
3900 * [I] idEvent : The timer ID interpreted as a pointer to a LISTVIEW_INFO struct
3901 * [I] dwTimer : The elapsed time (ignored)
3906 static VOID CALLBACK
LISTVIEW_ScrollTimer(HWND hWnd
, UINT uMsg
, UINT_PTR idEvent
, DWORD dwTime
)
3908 LISTVIEW_INFO
*infoPtr
;
3909 SCROLLINFO scrollInfo
;
3915 infoPtr
= (LISTVIEW_INFO
*) idEvent
;
3920 /* Get the current cursor position and convert to client coordinates */
3921 GetCursorPos(&coords_orig
);
3922 ScreenToClient(hWnd
, &coords_orig
);
3924 /* Ensure coordinates are within client bounds */
3925 coords_offs
.x
= max(min(coords_orig
.x
, infoPtr
->rcList
.right
), 0);
3926 coords_offs
.y
= max(min(coords_orig
.y
, infoPtr
->rcList
.bottom
), 0);
3929 LISTVIEW_GetOrigin(infoPtr
, &offset
);
3931 /* Offset coordinates by the appropriate amount */
3932 coords_offs
.x
-= offset
.x
;
3933 coords_offs
.y
-= offset
.y
;
3935 scrollInfo
.cbSize
= sizeof(SCROLLINFO
);
3936 scrollInfo
.fMask
= SIF_ALL
;
3938 /* Work out in which directions we can scroll */
3939 if (GetScrollInfo(infoPtr
->hwndSelf
, SB_VERT
, &scrollInfo
))
3941 if (scrollInfo
.nPos
!= scrollInfo
.nMin
)
3942 scroll
|= SCROLL_UP
;
3944 if (((scrollInfo
.nPage
+ scrollInfo
.nPos
) - 1) != scrollInfo
.nMax
)
3945 scroll
|= SCROLL_DOWN
;
3948 if (GetScrollInfo(infoPtr
->hwndSelf
, SB_HORZ
, &scrollInfo
))
3950 if (scrollInfo
.nPos
!= scrollInfo
.nMin
)
3951 scroll
|= SCROLL_LEFT
;
3953 if (((scrollInfo
.nPage
+ scrollInfo
.nPos
) - 1) != scrollInfo
.nMax
)
3954 scroll
|= SCROLL_RIGHT
;
3957 if (((coords_orig
.x
<= 0) && (scroll
& SCROLL_LEFT
)) ||
3958 ((coords_orig
.y
<= 0) && (scroll
& SCROLL_UP
)) ||
3959 ((coords_orig
.x
>= infoPtr
->rcList
.right
) && (scroll
& SCROLL_RIGHT
)) ||
3960 ((coords_orig
.y
>= infoPtr
->rcList
.bottom
) && (scroll
& SCROLL_DOWN
)))
3962 LISTVIEW_MarqueeHighlight(infoPtr
, &coords_orig
, &coords_offs
, &offset
, scroll
);
3968 * Called whenever WM_MOUSEMOVE is received.
3971 * [I] infoPtr : valid pointer to the listview structure
3972 * [I] fwKeys : key indicator
3973 * [I] x,y : mouse position
3976 * 0 if the message is processed, non-zero if there was an error
3978 static LRESULT
LISTVIEW_MouseMove(LISTVIEW_INFO
*infoPtr
, WORD fwKeys
, INT x
, INT y
)
3980 if (!(fwKeys
& MK_LBUTTON
))
3981 infoPtr
->bLButtonDown
= FALSE
;
3983 if (infoPtr
->bLButtonDown
)
3987 LVHITTESTINFO lvHitTestInfo
;
3988 WORD wDragWidth
= GetSystemMetrics(SM_CXDRAG
);
3989 WORD wDragHeight
= GetSystemMetrics(SM_CYDRAG
);
3991 if (infoPtr
->bMarqueeSelect
)
4001 LISTVIEW_GetOrigin(infoPtr
, &offset
);
4003 /* Ensure coordinates are within client bounds */
4004 coords_offs
.x
= max(min(x
, infoPtr
->rcList
.right
), 0);
4005 coords_offs
.y
= max(min(y
, infoPtr
->rcList
.bottom
), 0);
4007 /* Offset coordinates by the appropriate amount */
4008 coords_offs
.x
-= offset
.x
;
4009 coords_offs
.y
-= offset
.y
;
4011 /* Enable the timer if we're going outside our bounds, in case the user doesn't
4012 move the mouse again */
4014 if ((x
<= 0) || (y
<= 0) || (x
>= infoPtr
->rcList
.right
) ||
4015 (y
>= infoPtr
->rcList
.bottom
))
4017 if (!infoPtr
->bScrolling
)
4019 infoPtr
->bScrolling
= TRUE
;
4020 SetTimer(infoPtr
->hwndSelf
, (UINT_PTR
) infoPtr
, 1, LISTVIEW_ScrollTimer
);
4025 infoPtr
->bScrolling
= FALSE
;
4026 KillTimer(infoPtr
->hwndSelf
, (UINT_PTR
) infoPtr
);
4029 LISTVIEW_MarqueeHighlight(infoPtr
, &coords_orig
, &coords_offs
, &offset
, 0);
4033 rect
.left
= infoPtr
->ptClickPos
.x
- wDragWidth
;
4034 rect
.right
= infoPtr
->ptClickPos
.x
+ wDragWidth
;
4035 rect
.top
= infoPtr
->ptClickPos
.y
- wDragHeight
;
4036 rect
.bottom
= infoPtr
->ptClickPos
.y
+ wDragHeight
;
4041 lvHitTestInfo
.pt
= tmp
;
4042 LISTVIEW_HitTest(infoPtr
, &lvHitTestInfo
, TRUE
, TRUE
);
4044 /* reset item marker */
4045 if (infoPtr
->nLButtonDownItem
!= lvHitTestInfo
.iItem
)
4046 infoPtr
->nLButtonDownItem
= -1;
4048 if (!PtInRect(&rect
, tmp
))
4050 /* this path covers the following:
4051 1. WM_LBUTTONDOWN over selected item (sets focus on it)
4052 2. change focus with keys
4053 3. move mouse over item from step 1 selects it and moves focus on it */
4054 if (infoPtr
->nLButtonDownItem
!= -1 &&
4055 !LISTVIEW_GetItemState(infoPtr
, infoPtr
->nLButtonDownItem
, LVIS_SELECTED
))
4059 lvItem
.state
= LVIS_FOCUSED
| LVIS_SELECTED
;
4060 lvItem
.stateMask
= LVIS_FOCUSED
| LVIS_SELECTED
;
4062 LISTVIEW_SetItemState(infoPtr
, infoPtr
->nLButtonDownItem
, &lvItem
);
4063 infoPtr
->nLButtonDownItem
= -1;
4066 if (!infoPtr
->bDragging
)
4068 lvHitTestInfo
.pt
= infoPtr
->ptClickPos
;
4069 LISTVIEW_HitTest(infoPtr
, &lvHitTestInfo
, TRUE
, TRUE
);
4071 /* If the click is outside the range of an item, begin a
4072 highlight. If not, begin an item drag. */
4073 if (lvHitTestInfo
.iItem
== -1)
4077 /* If we're allowing multiple selections, send notification.
4078 If return value is non-zero, cancel. */
4079 if (!(infoPtr
->dwStyle
& LVS_SINGLESEL
) && (notify_hdr(infoPtr
, LVN_MARQUEEBEGIN
, &hdr
) == 0))
4081 /* Store the absolute coordinates of the click */
4083 LISTVIEW_GetOrigin(infoPtr
, &offset
);
4085 infoPtr
->marqueeOrigin
.x
= infoPtr
->ptClickPos
.x
- offset
.x
;
4086 infoPtr
->marqueeOrigin
.y
= infoPtr
->ptClickPos
.y
- offset
.y
;
4088 /* Begin selection and capture mouse */
4089 infoPtr
->bMarqueeSelect
= TRUE
;
4090 SetCapture(infoPtr
->hwndSelf
);
4097 ZeroMemory(&nmlv
, sizeof(nmlv
));
4098 nmlv
.iItem
= lvHitTestInfo
.iItem
;
4099 nmlv
.ptAction
= infoPtr
->ptClickPos
;
4101 notify_listview(infoPtr
, LVN_BEGINDRAG
, &nmlv
);
4102 infoPtr
->bDragging
= TRUE
;
4110 /* see if we are supposed to be tracking mouse hovering */
4111 if (LISTVIEW_IsHotTracking(infoPtr
)) {
4112 TRACKMOUSEEVENT trackinfo
;
4114 trackinfo
.cbSize
= sizeof(TRACKMOUSEEVENT
);
4115 trackinfo
.dwFlags
= TME_QUERY
;
4117 /* see if we are already tracking this hwnd */
4118 _TrackMouseEvent(&trackinfo
);
4120 if(!(trackinfo
.dwFlags
& TME_HOVER
) || trackinfo
.hwndTrack
!= infoPtr
->hwndSelf
) {
4121 trackinfo
.dwFlags
= TME_HOVER
;
4122 trackinfo
.dwHoverTime
= infoPtr
->dwHoverTime
;
4123 trackinfo
.hwndTrack
= infoPtr
->hwndSelf
;
4125 /* call TRACKMOUSEEVENT so we receive WM_MOUSEHOVER messages */
4126 _TrackMouseEvent(&trackinfo
);
4135 * Tests whether the item is assignable to a list with style lStyle
4137 static inline BOOL
is_assignable_item(const LVITEMW
*lpLVItem
, LONG lStyle
)
4139 if ( (lpLVItem
->mask
& LVIF_TEXT
) &&
4140 (lpLVItem
->pszText
== LPSTR_TEXTCALLBACKW
) &&
4141 (lStyle
& (LVS_SORTASCENDING
| LVS_SORTDESCENDING
)) ) return FALSE
;
4149 * Helper for LISTVIEW_SetItemT *only*: sets item attributes.
4152 * [I] infoPtr : valid pointer to the listview structure
4153 * [I] lpLVItem : valid pointer to new item attributes
4154 * [I] isNew : the item being set is being inserted
4155 * [I] isW : TRUE if lpLVItem is Unicode, FALSE if it's ANSI
4156 * [O] bChanged : will be set to TRUE if the item really changed
4162 static BOOL
set_main_item(LISTVIEW_INFO
*infoPtr
, const LVITEMW
*lpLVItem
, BOOL isNew
, BOOL isW
, BOOL
*bChanged
)
4168 /* stateMask is ignored for LVM_INSERTITEM */
4169 UINT stateMask
= isNew
? ~0 : lpLVItem
->stateMask
;
4173 assert(lpLVItem
->iItem
>= 0 && lpLVItem
->iItem
< infoPtr
->nItemCount
);
4175 if (lpLVItem
->mask
== 0) return TRUE
;
4177 if (infoPtr
->dwStyle
& LVS_OWNERDATA
)
4179 /* a virtual listview only stores selection and focus */
4180 if (lpLVItem
->mask
& ~LVIF_STATE
)
4186 HDPA hdpaSubItems
= DPA_GetPtr(infoPtr
->hdpaItems
, lpLVItem
->iItem
);
4187 lpItem
= DPA_GetPtr(hdpaSubItems
, 0);
4191 /* we need to get the lParam and state of the item */
4192 item
.iItem
= lpLVItem
->iItem
;
4193 item
.iSubItem
= lpLVItem
->iSubItem
;
4194 item
.mask
= LVIF_STATE
| LVIF_PARAM
;
4195 item
.stateMask
= (infoPtr
->dwStyle
& LVS_OWNERDATA
) ? LVIS_FOCUSED
| LVIS_SELECTED
: ~0;
4199 if (!isNew
&& !LISTVIEW_GetItemW(infoPtr
, &item
)) return FALSE
;
4201 TRACE("oldState=%x, newState=%x\n", item
.state
, lpLVItem
->state
);
4202 /* determine what fields will change */
4203 if ((lpLVItem
->mask
& LVIF_STATE
) && ((item
.state
^ lpLVItem
->state
) & stateMask
& ~infoPtr
->uCallbackMask
))
4204 uChanged
|= LVIF_STATE
;
4206 if ((lpLVItem
->mask
& LVIF_IMAGE
) && (lpItem
->hdr
.iImage
!= lpLVItem
->iImage
))
4207 uChanged
|= LVIF_IMAGE
;
4209 if ((lpLVItem
->mask
& LVIF_PARAM
) && (lpItem
->lParam
!= lpLVItem
->lParam
))
4210 uChanged
|= LVIF_PARAM
;
4212 if ((lpLVItem
->mask
& LVIF_INDENT
) && (lpItem
->iIndent
!= lpLVItem
->iIndent
))
4213 uChanged
|= LVIF_INDENT
;
4215 if ((lpLVItem
->mask
& LVIF_TEXT
) && textcmpWT(lpItem
->hdr
.pszText
, lpLVItem
->pszText
, isW
))
4216 uChanged
|= LVIF_TEXT
;
4218 TRACE("uChanged=0x%x\n", uChanged
);
4219 if (!uChanged
) return TRUE
;
4222 ZeroMemory(&nmlv
, sizeof(NMLISTVIEW
));
4223 nmlv
.iItem
= lpLVItem
->iItem
;
4224 nmlv
.uNewState
= (item
.state
& ~stateMask
) | (lpLVItem
->state
& stateMask
);
4225 nmlv
.uOldState
= item
.state
;
4226 nmlv
.uChanged
= uChanged
;
4227 nmlv
.lParam
= item
.lParam
;
4229 /* send LVN_ITEMCHANGING notification, if the item is not being inserted */
4230 /* and we are _NOT_ virtual (LVS_OWNERDATA), and change notifications */
4232 if(lpItem
&& !isNew
&& infoPtr
->bDoChangeNotify
)
4234 HWND hwndSelf
= infoPtr
->hwndSelf
;
4236 if (notify_listview(infoPtr
, LVN_ITEMCHANGING
, &nmlv
))
4238 if (!IsWindow(hwndSelf
))
4242 /* copy information */
4243 if (lpLVItem
->mask
& LVIF_TEXT
)
4244 textsetptrT(&lpItem
->hdr
.pszText
, lpLVItem
->pszText
, isW
);
4246 if (lpLVItem
->mask
& LVIF_IMAGE
)
4247 lpItem
->hdr
.iImage
= lpLVItem
->iImage
;
4249 if (lpLVItem
->mask
& LVIF_PARAM
)
4250 lpItem
->lParam
= lpLVItem
->lParam
;
4252 if (lpLVItem
->mask
& LVIF_INDENT
)
4253 lpItem
->iIndent
= lpLVItem
->iIndent
;
4255 if (uChanged
& LVIF_STATE
)
4257 if (lpItem
&& (stateMask
& ~infoPtr
->uCallbackMask
))
4259 lpItem
->state
&= ~stateMask
;
4260 lpItem
->state
|= (lpLVItem
->state
& stateMask
);
4262 if (lpLVItem
->state
& stateMask
& ~infoPtr
->uCallbackMask
& LVIS_SELECTED
)
4264 if (infoPtr
->dwStyle
& LVS_SINGLESEL
) LISTVIEW_DeselectAllSkipItem(infoPtr
, lpLVItem
->iItem
);
4265 ranges_additem(infoPtr
->selectionRanges
, lpLVItem
->iItem
);
4267 else if (stateMask
& LVIS_SELECTED
)
4269 ranges_delitem(infoPtr
->selectionRanges
, lpLVItem
->iItem
);
4271 /* if we are asked to change focus, and we manage it, do it */
4272 if (stateMask
& ~infoPtr
->uCallbackMask
& LVIS_FOCUSED
)
4274 if (lpLVItem
->state
& LVIS_FOCUSED
)
4276 /* update selection mark */
4277 if (infoPtr
->nFocusedItem
== -1 && infoPtr
->nSelectionMark
== -1)
4278 infoPtr
->nSelectionMark
= lpLVItem
->iItem
;
4280 if (infoPtr
->nFocusedItem
!= -1)
4282 /* remove current focus */
4283 item
.mask
= LVIF_STATE
;
4285 item
.stateMask
= LVIS_FOCUSED
;
4287 /* recurse with redrawing an item */
4288 LISTVIEW_SetItemState(infoPtr
, infoPtr
->nFocusedItem
, &item
);
4291 infoPtr
->nFocusedItem
= lpLVItem
->iItem
;
4292 LISTVIEW_EnsureVisible(infoPtr
, lpLVItem
->iItem
, infoPtr
->uView
== LV_VIEW_LIST
);
4294 else if (infoPtr
->nFocusedItem
== lpLVItem
->iItem
)
4296 infoPtr
->nFocusedItem
= -1;
4301 /* if we're inserting the item, we're done */
4302 if (isNew
) return TRUE
;
4304 /* send LVN_ITEMCHANGED notification */
4305 if (lpLVItem
->mask
& LVIF_PARAM
) nmlv
.lParam
= lpLVItem
->lParam
;
4306 if (infoPtr
->bDoChangeNotify
) notify_listview(infoPtr
, LVN_ITEMCHANGED
, &nmlv
);
4313 * Helper for LISTVIEW_{Set,Insert}ItemT *only*: sets subitem attributes.
4316 * [I] infoPtr : valid pointer to the listview structure
4317 * [I] lpLVItem : valid pointer to new subitem attributes
4318 * [I] isW : TRUE if lpLVItem is Unicode, FALSE if it's ANSI
4319 * [O] bChanged : will be set to TRUE if the item really changed
4325 static BOOL
set_sub_item(const LISTVIEW_INFO
*infoPtr
, const LVITEMW
*lpLVItem
, BOOL isW
, BOOL
*bChanged
)
4328 SUBITEM_INFO
*lpSubItem
;
4330 /* we do not support subitems for virtual listviews */
4331 if (infoPtr
->dwStyle
& LVS_OWNERDATA
) return FALSE
;
4333 /* set subitem only if column is present */
4334 if (lpLVItem
->iSubItem
>= DPA_GetPtrCount(infoPtr
->hdpaColumns
)) return FALSE
;
4336 /* First do some sanity checks */
4337 /* The LVIF_STATE flag is valid for subitems, but does not appear to be
4338 particularly useful. We currently do not actually do anything with
4339 the flag on subitems.
4341 if (lpLVItem
->mask
& ~(LVIF_TEXT
| LVIF_IMAGE
| LVIF_STATE
| LVIF_DI_SETITEM
)) return FALSE
;
4342 if (!(lpLVItem
->mask
& (LVIF_TEXT
| LVIF_IMAGE
| LVIF_STATE
))) return TRUE
;
4344 /* get the subitem structure, and create it if not there */
4345 hdpaSubItems
= DPA_GetPtr(infoPtr
->hdpaItems
, lpLVItem
->iItem
);
4346 assert (hdpaSubItems
);
4348 lpSubItem
= LISTVIEW_GetSubItemPtr(hdpaSubItems
, lpLVItem
->iSubItem
);
4351 SUBITEM_INFO
*tmpSubItem
;
4354 lpSubItem
= Alloc(sizeof(SUBITEM_INFO
));
4355 if (!lpSubItem
) return FALSE
;
4356 /* we could binary search here, if need be...*/
4357 for (i
= 1; i
< DPA_GetPtrCount(hdpaSubItems
); i
++)
4359 tmpSubItem
= DPA_GetPtr(hdpaSubItems
, i
);
4360 if (tmpSubItem
->iSubItem
> lpLVItem
->iSubItem
) break;
4362 if (DPA_InsertPtr(hdpaSubItems
, i
, lpSubItem
) == -1)
4367 lpSubItem
->iSubItem
= lpLVItem
->iSubItem
;
4368 lpSubItem
->hdr
.iImage
= I_IMAGECALLBACK
;
4372 if ((lpLVItem
->mask
& LVIF_IMAGE
) && (lpSubItem
->hdr
.iImage
!= lpLVItem
->iImage
))
4374 lpSubItem
->hdr
.iImage
= lpLVItem
->iImage
;
4378 if ((lpLVItem
->mask
& LVIF_TEXT
) && textcmpWT(lpSubItem
->hdr
.pszText
, lpLVItem
->pszText
, isW
))
4380 textsetptrT(&lpSubItem
->hdr
.pszText
, lpLVItem
->pszText
, isW
);
4389 * Sets item attributes.
4392 * [I] infoPtr : valid pointer to the listview structure
4393 * [I] lpLVItem : new item attributes
4394 * [I] isW : TRUE if lpLVItem is Unicode, FALSE if it's ANSI
4400 static BOOL
LISTVIEW_SetItemT(LISTVIEW_INFO
*infoPtr
, LVITEMW
*lpLVItem
, BOOL isW
)
4402 HWND hwndSelf
= infoPtr
->hwndSelf
;
4403 LPWSTR pszText
= NULL
;
4404 BOOL bResult
, bChanged
= FALSE
;
4407 TRACE("(lpLVItem=%s, isW=%d)\n", debuglvitem_t(lpLVItem
, isW
), isW
);
4409 if (!lpLVItem
|| lpLVItem
->iItem
< 0 || lpLVItem
->iItem
>= infoPtr
->nItemCount
)
4412 /* Store old item area */
4413 LISTVIEW_GetItemBox(infoPtr
, lpLVItem
->iItem
, &oldItemArea
);
4415 /* For efficiency, we transform the lpLVItem->pszText to Unicode here */
4416 if ((lpLVItem
->mask
& LVIF_TEXT
) && is_text(lpLVItem
->pszText
))
4418 pszText
= lpLVItem
->pszText
;
4419 lpLVItem
->pszText
= textdupTtoW(lpLVItem
->pszText
, isW
);
4422 /* actually set the fields */
4423 if (!is_assignable_item(lpLVItem
, infoPtr
->dwStyle
)) return FALSE
;
4425 if (lpLVItem
->iSubItem
)
4426 bResult
= set_sub_item(infoPtr
, lpLVItem
, TRUE
, &bChanged
);
4428 bResult
= set_main_item(infoPtr
, lpLVItem
, FALSE
, TRUE
, &bChanged
);
4429 if (!IsWindow(hwndSelf
))
4432 /* redraw item, if necessary */
4433 if (bChanged
&& !infoPtr
->bIsDrawing
)
4435 /* this little optimization eliminates some nasty flicker */
4436 if ( infoPtr
->uView
== LV_VIEW_DETAILS
&& !(infoPtr
->dwStyle
& LVS_OWNERDRAWFIXED
) &&
4437 !(infoPtr
->dwLvExStyle
& LVS_EX_FULLROWSELECT
) &&
4438 lpLVItem
->iSubItem
> 0 && lpLVItem
->iSubItem
<= DPA_GetPtrCount(infoPtr
->hdpaColumns
) )
4439 LISTVIEW_InvalidateSubItem(infoPtr
, lpLVItem
->iItem
, lpLVItem
->iSubItem
);
4442 LISTVIEW_InvalidateRect(infoPtr
, &oldItemArea
);
4443 LISTVIEW_InvalidateItem(infoPtr
, lpLVItem
->iItem
);
4449 textfreeT(lpLVItem
->pszText
, isW
);
4450 lpLVItem
->pszText
= pszText
;
4458 * Retrieves the index of the item at coordinate (0, 0) of the client area.
4461 * [I] infoPtr : valid pointer to the listview structure
4466 static INT
LISTVIEW_GetTopIndex(const LISTVIEW_INFO
*infoPtr
)
4469 SCROLLINFO scrollInfo
;
4471 scrollInfo
.cbSize
= sizeof(SCROLLINFO
);
4472 scrollInfo
.fMask
= SIF_POS
;
4474 if (infoPtr
->uView
== LV_VIEW_LIST
)
4476 if (GetScrollInfo(infoPtr
->hwndSelf
, SB_HORZ
, &scrollInfo
))
4477 nItem
= scrollInfo
.nPos
* LISTVIEW_GetCountPerColumn(infoPtr
);
4479 else if (infoPtr
->uView
== LV_VIEW_DETAILS
)
4481 if (GetScrollInfo(infoPtr
->hwndSelf
, SB_VERT
, &scrollInfo
))
4482 nItem
= scrollInfo
.nPos
;
4486 if (GetScrollInfo(infoPtr
->hwndSelf
, SB_VERT
, &scrollInfo
))
4487 nItem
= LISTVIEW_GetCountPerRow(infoPtr
) * (scrollInfo
.nPos
/ infoPtr
->nItemHeight
);
4490 TRACE("nItem=%d\n", nItem
);
4498 * Erases the background of the given rectangle
4501 * [I] infoPtr : valid pointer to the listview structure
4502 * [I] hdc : device context handle
4503 * [I] lprcBox : clipping rectangle
4509 static inline BOOL
LISTVIEW_FillBkgnd(const LISTVIEW_INFO
*infoPtr
, HDC hdc
, const RECT
*lprcBox
)
4511 if (!infoPtr
->hBkBrush
) return FALSE
;
4513 TRACE("(hdc=%p, lprcBox=%s, hBkBrush=%p)\n", hdc
, wine_dbgstr_rect(lprcBox
), infoPtr
->hBkBrush
);
4515 return FillRect(hdc
, lprcBox
, infoPtr
->hBkBrush
);
4523 * [I] infoPtr : valid pointer to the listview structure
4524 * [I] hdc : device context handle
4525 * [I] nItem : item index
4526 * [I] nSubItem : subitem index
4527 * [I] pos : item position in client coordinates
4528 * [I] cdmode : custom draw mode
4534 static BOOL
LISTVIEW_DrawItem(LISTVIEW_INFO
*infoPtr
, HDC hdc
, INT nItem
, INT nSubItem
, POINT pos
, DWORD cdmode
)
4537 WCHAR szDispText
[DISP_TEXT_SIZE
] = { '\0' };
4538 static WCHAR szCallback
[] = { '(', 'c', 'a', 'l', 'l', 'b', 'a', 'c', 'k', ')', 0 };
4539 DWORD cdsubitemmode
= CDRF_DODEFAULT
;
4541 RECT rcSelect
, rcBox
, rcIcon
, rcLabel
, rcStateIcon
;
4542 NMLVCUSTOMDRAW nmlvcd
;
4547 TRACE("(hdc=%p, nItem=%d, nSubItem=%d, pos=%s)\n", hdc
, nItem
, nSubItem
, wine_dbgstr_point(&pos
));
4549 /* get information needed for drawing the item */
4550 lvItem
.mask
= LVIF_TEXT
| LVIF_IMAGE
| LVIF_PARAM
;
4551 if (nSubItem
== 0) lvItem
.mask
|= LVIF_STATE
;
4552 if (infoPtr
->uView
== LV_VIEW_DETAILS
) lvItem
.mask
|= LVIF_INDENT
;
4553 lvItem
.stateMask
= LVIS_SELECTED
| LVIS_FOCUSED
| LVIS_STATEIMAGEMASK
| LVIS_CUT
;
4554 lvItem
.iItem
= nItem
;
4555 lvItem
.iSubItem
= nSubItem
;
4558 lvItem
.cchTextMax
= DISP_TEXT_SIZE
;
4559 lvItem
.pszText
= szDispText
;
4560 if (!LISTVIEW_GetItemW(infoPtr
, &lvItem
)) return FALSE
;
4561 if (nSubItem
> 0 && (infoPtr
->dwLvExStyle
& LVS_EX_FULLROWSELECT
))
4562 lvItem
.state
= LISTVIEW_GetItemState(infoPtr
, nItem
, LVIS_SELECTED
);
4563 if (lvItem
.pszText
== LPSTR_TEXTCALLBACKW
) lvItem
.pszText
= szCallback
;
4564 TRACE(" lvItem=%s\n", debuglvitem_t(&lvItem
, TRUE
));
4566 /* now check if we need to update the focus rectangle */
4567 lprcFocus
= infoPtr
->bFocus
&& (lvItem
.state
& LVIS_FOCUSED
) ? &infoPtr
->rcFocus
: 0;
4569 if (!lprcFocus
) lvItem
.state
&= ~LVIS_FOCUSED
;
4570 LISTVIEW_GetItemMetrics(infoPtr
, &lvItem
, &rcBox
, &rcSelect
, &rcIcon
, &rcStateIcon
, &rcLabel
);
4571 OffsetRect(&rcBox
, pos
.x
, pos
.y
);
4572 OffsetRect(&rcSelect
, pos
.x
, pos
.y
);
4573 OffsetRect(&rcIcon
, pos
.x
, pos
.y
);
4574 OffsetRect(&rcStateIcon
, pos
.x
, pos
.y
);
4575 OffsetRect(&rcLabel
, pos
.x
, pos
.y
);
4576 TRACE(" rcBox=%s, rcSelect=%s, rcIcon=%s. rcLabel=%s\n",
4577 wine_dbgstr_rect(&rcBox
), wine_dbgstr_rect(&rcSelect
),
4578 wine_dbgstr_rect(&rcIcon
), wine_dbgstr_rect(&rcLabel
));
4580 /* fill in the custom draw structure */
4581 customdraw_fill(&nmlvcd
, infoPtr
, hdc
, &rcBox
, &lvItem
);
4583 hOldFont
= GetCurrentObject(hdc
, OBJ_FONT
);
4584 if (nSubItem
> 0) cdmode
= infoPtr
->cditemmode
;
4585 if (cdmode
& CDRF_SKIPDEFAULT
) goto postpaint
;
4586 if (cdmode
& CDRF_NOTIFYITEMDRAW
)
4587 cdsubitemmode
= notify_customdraw(infoPtr
, CDDS_PREPAINT
, &nmlvcd
);
4588 if (nSubItem
== 0) infoPtr
->cditemmode
= cdsubitemmode
;
4589 if (cdsubitemmode
& CDRF_SKIPDEFAULT
) goto postpaint
;
4590 /* we have to send a CDDS_SUBITEM customdraw explicitly for subitem 0 */
4591 if (nSubItem
== 0 && cdsubitemmode
== CDRF_NOTIFYITEMDRAW
)
4593 cdsubitemmode
= notify_customdraw(infoPtr
, CDDS_SUBITEM
| CDDS_ITEMPREPAINT
, &nmlvcd
);
4594 if (cdsubitemmode
& CDRF_SKIPDEFAULT
) goto postpaint
;
4596 if (nSubItem
== 0 || (cdmode
& CDRF_NOTIFYITEMDRAW
))
4597 prepaint_setup(infoPtr
, hdc
, &nmlvcd
, FALSE
);
4598 else if ((infoPtr
->dwLvExStyle
& LVS_EX_FULLROWSELECT
) == FALSE
)
4599 prepaint_setup(infoPtr
, hdc
, &nmlvcd
, TRUE
);
4601 /* in full row select, subitems, will just use main item's colors */
4602 if (nSubItem
&& infoPtr
->uView
== LV_VIEW_DETAILS
&& (infoPtr
->dwLvExStyle
& LVS_EX_FULLROWSELECT
))
4603 nmlvcd
.clrTextBk
= CLR_NONE
;
4605 /* FIXME: temporary hack */
4606 rcSelect
.left
= rcLabel
.left
;
4608 /* draw the selection background, if we're drawing the main item */
4611 /* in icon mode, the label rect is really what we want to draw the
4613 if (infoPtr
->uView
== LV_VIEW_ICON
)
4616 if (infoPtr
->uView
== LV_VIEW_DETAILS
&& (infoPtr
->dwLvExStyle
& LVS_EX_FULLROWSELECT
))
4618 /* we have to update left focus bound too if item isn't in leftmost column
4619 and reduce right box bound */
4620 if (DPA_GetPtrCount(infoPtr
->hdpaColumns
) > 0)
4624 if ((leftmost
= SendMessageW(infoPtr
->hwndHeader
, HDM_ORDERTOINDEX
, 0, 0)))
4626 INT Originx
= pos
.x
- LISTVIEW_GetColumnInfo(infoPtr
, 0)->rcHeader
.left
;
4627 INT index
= SendMessageW(infoPtr
->hwndHeader
, HDM_ORDERTOINDEX
,
4628 DPA_GetPtrCount(infoPtr
->hdpaColumns
) - 1, 0);
4630 rcBox
.right
= LISTVIEW_GetColumnInfo(infoPtr
, index
)->rcHeader
.right
+ Originx
;
4631 rcSelect
.left
= LISTVIEW_GetColumnInfo(infoPtr
, leftmost
)->rcHeader
.left
+ Originx
;
4635 rcSelect
.right
= rcBox
.right
;
4638 if (nmlvcd
.clrTextBk
!= CLR_NONE
)
4639 ExtTextOutW(hdc
, rcSelect
.left
, rcSelect
.top
, ETO_OPAQUE
, &rcSelect
, NULL
, 0, NULL
);
4640 /* store new focus rectangle */
4641 if (infoPtr
->nFocusedItem
== nItem
) infoPtr
->rcFocus
= rcSelect
;
4645 if (infoPtr
->himlState
&& STATEIMAGEINDEX(lvItem
.state
) && (nSubItem
== 0))
4647 UINT uStateImage
= STATEIMAGEINDEX(lvItem
.state
);
4650 TRACE("uStateImage=%d\n", uStateImage
);
4651 ImageList_Draw(infoPtr
->himlState
, uStateImage
- 1, hdc
,
4652 rcStateIcon
.left
, rcStateIcon
.top
, ILD_NORMAL
);
4657 himl
= (infoPtr
->uView
== LV_VIEW_ICON
? infoPtr
->himlNormal
: infoPtr
->himlSmall
);
4658 if (himl
&& lvItem
.iImage
>= 0 && !IsRectEmpty(&rcIcon
))
4662 TRACE("iImage=%d\n", lvItem
.iImage
);
4664 if (lvItem
.state
& (LVIS_SELECTED
| LVIS_CUT
) && infoPtr
->bFocus
)
4665 style
= ILD_SELECTED
;
4669 ImageList_DrawEx(himl
, lvItem
.iImage
, hdc
, rcIcon
.left
, rcIcon
.top
,
4670 rcIcon
.right
- rcIcon
.left
, rcIcon
.bottom
- rcIcon
.top
, infoPtr
->clrBk
,
4671 lvItem
.state
& LVIS_CUT
? RGB(255, 255, 255) : CLR_DEFAULT
,
4675 /* Don't bother painting item being edited */
4676 if (infoPtr
->hwndEdit
&& nItem
== infoPtr
->nEditLabelItem
&& nSubItem
== 0) goto postpaint
;
4678 /* figure out the text drawing flags */
4679 uFormat
= (infoPtr
->uView
== LV_VIEW_ICON
? (lprcFocus
? LV_FL_DT_FLAGS
: LV_ML_DT_FLAGS
) : LV_SL_DT_FLAGS
);
4680 if (infoPtr
->uView
== LV_VIEW_ICON
)
4681 uFormat
= (lprcFocus
? LV_FL_DT_FLAGS
: LV_ML_DT_FLAGS
);
4684 switch (LISTVIEW_GetColumnInfo(infoPtr
, nSubItem
)->fmt
& LVCFMT_JUSTIFYMASK
)
4686 case LVCFMT_RIGHT
: uFormat
|= DT_RIGHT
; break;
4687 case LVCFMT_CENTER
: uFormat
|= DT_CENTER
; break;
4688 default: uFormat
|= DT_LEFT
;
4691 if (!(uFormat
& (DT_RIGHT
| DT_CENTER
)))
4693 if (himl
&& lvItem
.iImage
>= 0 && !IsRectEmpty(&rcIcon
)) rcLabel
.left
+= IMAGE_PADDING
;
4694 else rcLabel
.left
+= LABEL_HOR_PADDING
;
4696 else if (uFormat
& DT_RIGHT
) rcLabel
.right
-= LABEL_HOR_PADDING
;
4698 /* for GRIDLINES reduce the bottom so the text formats correctly */
4699 if (infoPtr
->uView
== LV_VIEW_DETAILS
&& infoPtr
->dwLvExStyle
& LVS_EX_GRIDLINES
)
4702 DrawTextW(hdc
, lvItem
.pszText
, -1, &rcLabel
, uFormat
);
4705 if (cdsubitemmode
& CDRF_NOTIFYPOSTPAINT
)
4706 notify_postpaint(infoPtr
, &nmlvcd
);
4707 if (cdsubitemmode
& CDRF_NEWFONT
)
4708 SelectObject(hdc
, hOldFont
);
4714 * Draws listview items when in owner draw mode.
4717 * [I] infoPtr : valid pointer to the listview structure
4718 * [I] hdc : device context handle
4723 static void LISTVIEW_RefreshOwnerDraw(const LISTVIEW_INFO
*infoPtr
, ITERATOR
*i
, HDC hdc
, DWORD cdmode
)
4725 UINT uID
= (UINT
)GetWindowLongPtrW(infoPtr
->hwndSelf
, GWLP_ID
);
4726 DWORD cditemmode
= CDRF_DODEFAULT
;
4727 NMLVCUSTOMDRAW nmlvcd
;
4728 POINT Origin
, Position
;
4734 ZeroMemory(&dis
, sizeof(dis
));
4736 /* Get scroll info once before loop */
4737 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
4739 /* iterate through the invalidated rows */
4740 while(iterator_next(i
))
4742 item
.iItem
= i
->nItem
;
4744 item
.mask
= LVIF_PARAM
| LVIF_STATE
;
4745 item
.stateMask
= LVIS_SELECTED
| LVIS_FOCUSED
;
4746 if (!LISTVIEW_GetItemW(infoPtr
, &item
)) continue;
4748 dis
.CtlType
= ODT_LISTVIEW
;
4750 dis
.itemID
= item
.iItem
;
4751 dis
.itemAction
= ODA_DRAWENTIRE
;
4753 if (item
.state
& LVIS_SELECTED
) dis
.itemState
|= ODS_SELECTED
;
4754 if (infoPtr
->bFocus
&& (item
.state
& LVIS_FOCUSED
)) dis
.itemState
|= ODS_FOCUS
;
4755 dis
.hwndItem
= infoPtr
->hwndSelf
;
4757 LISTVIEW_GetItemOrigin(infoPtr
, dis
.itemID
, &Position
);
4758 dis
.rcItem
.left
= Position
.x
+ Origin
.x
;
4759 dis
.rcItem
.right
= dis
.rcItem
.left
+ infoPtr
->nItemWidth
;
4760 dis
.rcItem
.top
= Position
.y
+ Origin
.y
;
4761 dis
.rcItem
.bottom
= dis
.rcItem
.top
+ infoPtr
->nItemHeight
;
4762 dis
.itemData
= item
.lParam
;
4764 TRACE("item=%s, rcItem=%s\n", debuglvitem_t(&item
, TRUE
), wine_dbgstr_rect(&dis
.rcItem
));
4767 * Even if we do not send the CDRF_NOTIFYITEMDRAW we need to fill the nmlvcd
4768 * structure for the rest. of the paint cycle
4770 customdraw_fill(&nmlvcd
, infoPtr
, hdc
, &dis
.rcItem
, &item
);
4771 if (cdmode
& CDRF_NOTIFYITEMDRAW
)
4772 cditemmode
= notify_customdraw(infoPtr
, CDDS_PREPAINT
, &nmlvcd
);
4774 if (!(cditemmode
& CDRF_SKIPDEFAULT
))
4776 prepaint_setup (infoPtr
, hdc
, &nmlvcd
, FALSE
);
4777 SendMessageW(infoPtr
->hwndNotify
, WM_DRAWITEM
, dis
.CtlID
, (LPARAM
)&dis
);
4780 if (cditemmode
& CDRF_NOTIFYPOSTPAINT
)
4781 notify_postpaint(infoPtr
, &nmlvcd
);
4787 * Draws listview items when in report display mode.
4790 * [I] infoPtr : valid pointer to the listview structure
4791 * [I] hdc : device context handle
4792 * [I] cdmode : custom draw mode
4797 static void LISTVIEW_RefreshReport(LISTVIEW_INFO
*infoPtr
, ITERATOR
*i
, HDC hdc
, DWORD cdmode
)
4800 RECT rcClip
, rcItem
;
4801 POINT Origin
, Position
;
4808 /* figure out what to draw */
4809 rgntype
= GetClipBox(hdc
, &rcClip
);
4810 if (rgntype
== NULLREGION
) return;
4812 /* Get scroll info once before loop */
4813 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
4815 colRanges
= ranges_create(DPA_GetPtrCount(infoPtr
->hdpaColumns
));
4817 /* narrow down the columns we need to paint */
4818 for(col
= 0; col
< DPA_GetPtrCount(infoPtr
->hdpaColumns
); col
++)
4820 index
= SendMessageW(infoPtr
->hwndHeader
, HDM_ORDERTOINDEX
, col
, 0);
4822 LISTVIEW_GetHeaderRect(infoPtr
, index
, &rcItem
);
4823 if ((rcItem
.right
+ Origin
.x
>= rcClip
.left
) && (rcItem
.left
+ Origin
.x
< rcClip
.right
))
4824 ranges_additem(colRanges
, index
);
4826 iterator_rangesitems(&j
, colRanges
);
4828 /* in full row select, we _have_ to draw the main item */
4829 if (infoPtr
->dwLvExStyle
& LVS_EX_FULLROWSELECT
)
4832 /* iterate through the invalidated rows */
4833 while(iterator_next(i
))
4835 LISTVIEW_GetItemOrigin(infoPtr
, i
->nItem
, &Position
);
4836 Position
.y
+= Origin
.y
;
4838 /* iterate through the invalidated columns */
4839 while(iterator_next(&j
))
4841 LISTVIEW_GetHeaderRect(infoPtr
, j
.nItem
, &rcItem
);
4842 Position
.x
= (j
.nItem
== 0) ? rcItem
.left
+ Origin
.x
: Origin
.x
;
4844 if (rgntype
== COMPLEXREGION
&& !((infoPtr
->dwLvExStyle
& LVS_EX_FULLROWSELECT
) && j
.nItem
== 0))
4847 rcItem
.bottom
= infoPtr
->nItemHeight
;
4848 OffsetRect(&rcItem
, Origin
.x
, Position
.y
);
4849 if (!RectVisible(hdc
, &rcItem
)) continue;
4852 LISTVIEW_DrawItem(infoPtr
, hdc
, i
->nItem
, j
.nItem
, Position
, cdmode
);
4855 iterator_destroy(&j
);
4860 * Draws the gridlines if necessary when in report display mode.
4863 * [I] infoPtr : valid pointer to the listview structure
4864 * [I] hdc : device context handle
4869 static void LISTVIEW_RefreshReportGrid(LISTVIEW_INFO
*infoPtr
, HDC hdc
)
4875 RECT rcClip
, rcItem
= {0};
4883 /* figure out what to draw */
4884 rgntype
= GetClipBox(hdc
, &rcClip
);
4885 if (rgntype
== NULLREGION
) return;
4887 /* Get scroll info once before loop */
4888 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
4890 colRanges
= ranges_create(DPA_GetPtrCount(infoPtr
->hdpaColumns
));
4892 /* narrow down the columns we need to paint */
4893 for(col
= 0; col
< DPA_GetPtrCount(infoPtr
->hdpaColumns
); col
++)
4895 index
= SendMessageW(infoPtr
->hwndHeader
, HDM_ORDERTOINDEX
, col
, 0);
4897 LISTVIEW_GetHeaderRect(infoPtr
, index
, &rcItem
);
4898 if ((rcItem
.right
+ Origin
.x
>= rcClip
.left
) && (rcItem
.left
+ Origin
.x
< rcClip
.right
))
4899 ranges_additem(colRanges
, index
);
4902 /* is right most vertical line visible? */
4903 if (DPA_GetPtrCount(infoPtr
->hdpaColumns
) > 0)
4905 index
= SendMessageW(infoPtr
->hwndHeader
, HDM_ORDERTOINDEX
, DPA_GetPtrCount(infoPtr
->hdpaColumns
) - 1, 0);
4906 LISTVIEW_GetHeaderRect(infoPtr
, index
, &rcItem
);
4907 rmost
= (rcItem
.right
+ Origin
.x
< rcClip
.right
);
4910 if ((hPen
= CreatePen( PS_SOLID
, 1, comctl32_color
.clr3dFace
)))
4912 hOldPen
= SelectObject ( hdc
, hPen
);
4914 /* draw the vertical lines for the columns */
4915 iterator_rangesitems(&j
, colRanges
);
4916 while(iterator_next(&j
))
4918 LISTVIEW_GetHeaderRect(infoPtr
, j
.nItem
, &rcItem
);
4919 if (rcItem
.left
== 0) continue; /* skip leftmost column */
4920 rcItem
.left
+= Origin
.x
;
4921 rcItem
.right
+= Origin
.x
;
4922 rcItem
.top
= infoPtr
->rcList
.top
;
4923 rcItem
.bottom
= infoPtr
->rcList
.bottom
;
4924 TRACE("vert col=%d, rcItem=%s\n", j
.nItem
, wine_dbgstr_rect(&rcItem
));
4925 MoveToEx (hdc
, rcItem
.left
, rcItem
.top
, NULL
);
4926 LineTo (hdc
, rcItem
.left
, rcItem
.bottom
);
4928 iterator_destroy(&j
);
4929 /* draw rightmost grid line if visible */
4932 index
= SendMessageW(infoPtr
->hwndHeader
, HDM_ORDERTOINDEX
,
4933 DPA_GetPtrCount(infoPtr
->hdpaColumns
) - 1, 0);
4934 LISTVIEW_GetHeaderRect(infoPtr
, index
, &rcItem
);
4936 rcItem
.right
+= Origin
.x
;
4938 MoveToEx (hdc
, rcItem
.right
, infoPtr
->rcList
.top
, NULL
);
4939 LineTo (hdc
, rcItem
.right
, infoPtr
->rcList
.bottom
);
4942 /* draw the horizontal lines for the rows */
4943 itemheight
= LISTVIEW_CalculateItemHeight(infoPtr
);
4944 rcItem
.left
= infoPtr
->rcList
.left
;
4945 rcItem
.right
= infoPtr
->rcList
.right
;
4946 for(y
= Origin
.y
> 1 ? Origin
.y
- 1 : itemheight
- 1 + Origin
.y
% itemheight
; y
<=infoPtr
->rcList
.bottom
; y
+=itemheight
)
4948 rcItem
.bottom
= rcItem
.top
= y
;
4949 TRACE("horz rcItem=%s\n", wine_dbgstr_rect(&rcItem
));
4950 MoveToEx (hdc
, rcItem
.left
, rcItem
.top
, NULL
);
4951 LineTo (hdc
, rcItem
.right
, rcItem
.top
);
4954 SelectObject( hdc
, hOldPen
);
4955 DeleteObject( hPen
);
4958 ranges_destroy(colRanges
);
4963 * Draws listview items when in list display mode.
4966 * [I] infoPtr : valid pointer to the listview structure
4967 * [I] hdc : device context handle
4968 * [I] cdmode : custom draw mode
4973 static void LISTVIEW_RefreshList(LISTVIEW_INFO
*infoPtr
, ITERATOR
*i
, HDC hdc
, DWORD cdmode
)
4975 POINT Origin
, Position
;
4977 /* Get scroll info once before loop */
4978 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
4980 while(iterator_prev(i
))
4982 LISTVIEW_GetItemOrigin(infoPtr
, i
->nItem
, &Position
);
4983 Position
.x
+= Origin
.x
;
4984 Position
.y
+= Origin
.y
;
4986 LISTVIEW_DrawItem(infoPtr
, hdc
, i
->nItem
, 0, Position
, cdmode
);
4993 * Draws listview items.
4996 * [I] infoPtr : valid pointer to the listview structure
4997 * [I] hdc : device context handle
4998 * [I] prcErase : rect to be erased before refresh (may be NULL)
5003 static void LISTVIEW_Refresh(LISTVIEW_INFO
*infoPtr
, HDC hdc
, const RECT
*prcErase
)
5005 COLORREF oldTextColor
= 0, oldBkColor
= 0, oldClrTextBk
, oldClrText
;
5006 NMLVCUSTOMDRAW nmlvcd
;
5013 HBITMAP hbmp
= NULL
;
5016 LISTVIEW_DUMP(infoPtr
);
5018 if (infoPtr
->dwLvExStyle
& LVS_EX_DOUBLEBUFFER
) {
5019 TRACE("double buffering\n");
5021 hdc
= CreateCompatibleDC(hdcOrig
);
5023 ERR("Failed to create DC for backbuffer\n");
5026 hbmp
= CreateCompatibleBitmap(hdcOrig
, infoPtr
->rcList
.right
,
5027 infoPtr
->rcList
.bottom
);
5029 ERR("Failed to create bitmap for backbuffer\n");
5034 SelectObject(hdc
, hbmp
);
5035 SelectObject(hdc
, infoPtr
->hFont
);
5037 if(GetClipBox(hdcOrig
, &rcClient
))
5038 IntersectClipRect(hdc
, rcClient
.left
, rcClient
.top
, rcClient
.right
, rcClient
.bottom
);
5040 /* Save dc values we're gonna trash while drawing
5041 * FIXME: Should be done in LISTVIEW_DrawItem() */
5042 hOldFont
= SelectObject(hdc
, infoPtr
->hFont
);
5043 oldBkMode
= GetBkMode(hdc
);
5044 oldBkColor
= GetBkColor(hdc
);
5045 oldTextColor
= GetTextColor(hdc
);
5048 infoPtr
->bIsDrawing
= TRUE
;
5051 LISTVIEW_FillBkgnd(infoPtr
, hdc
, prcErase
);
5052 } else if (infoPtr
->dwLvExStyle
& LVS_EX_DOUBLEBUFFER
) {
5053 /* If no erasing was done (usually because RedrawWindow was called
5054 * with RDW_INVALIDATE only) we need to copy the old contents into
5055 * the backbuffer before continuing. */
5056 BitBlt(hdc
, infoPtr
->rcList
.left
, infoPtr
->rcList
.top
,
5057 infoPtr
->rcList
.right
- infoPtr
->rcList
.left
,
5058 infoPtr
->rcList
.bottom
- infoPtr
->rcList
.top
,
5059 hdcOrig
, infoPtr
->rcList
.left
, infoPtr
->rcList
.top
, SRCCOPY
);
5062 /* FIXME: Shouldn't need to do this */
5063 oldClrTextBk
= infoPtr
->clrTextBk
;
5064 oldClrText
= infoPtr
->clrText
;
5066 infoPtr
->cditemmode
= CDRF_DODEFAULT
;
5068 GetClientRect(infoPtr
->hwndSelf
, &rcClient
);
5069 customdraw_fill(&nmlvcd
, infoPtr
, hdc
, &rcClient
, 0);
5070 cdmode
= notify_customdraw(infoPtr
, CDDS_PREPAINT
, &nmlvcd
);
5071 if (cdmode
& CDRF_SKIPDEFAULT
) goto enddraw
;
5072 prepaint_setup(infoPtr
, hdc
, &nmlvcd
, FALSE
);
5074 /* Use these colors to draw the items */
5075 infoPtr
->clrTextBk
= nmlvcd
.clrTextBk
;
5076 infoPtr
->clrText
= nmlvcd
.clrText
;
5078 /* nothing to draw */
5079 if(infoPtr
->nItemCount
== 0) goto enddraw
;
5081 /* figure out what we need to draw */
5082 iterator_visibleitems(&i
, infoPtr
, hdc
);
5083 range
= iterator_range(&i
);
5085 /* send cache hint notification */
5086 if (infoPtr
->dwStyle
& LVS_OWNERDATA
)
5090 ZeroMemory(&nmlv
, sizeof(NMLVCACHEHINT
));
5091 nmlv
.iFrom
= range
.lower
;
5092 nmlv
.iTo
= range
.upper
- 1;
5093 notify_hdr(infoPtr
, LVN_ODCACHEHINT
, &nmlv
.hdr
);
5096 if ((infoPtr
->dwStyle
& LVS_OWNERDRAWFIXED
) && (infoPtr
->uView
== LV_VIEW_DETAILS
))
5097 LISTVIEW_RefreshOwnerDraw(infoPtr
, &i
, hdc
, cdmode
);
5100 if (infoPtr
->uView
== LV_VIEW_DETAILS
)
5101 LISTVIEW_RefreshReport(infoPtr
, &i
, hdc
, cdmode
);
5102 else /* LV_VIEW_LIST, LV_VIEW_ICON or LV_VIEW_SMALLICON */
5103 LISTVIEW_RefreshList(infoPtr
, &i
, hdc
, cdmode
);
5105 /* if we have a focus rect and it's visible, draw it */
5106 if (infoPtr
->bFocus
&& range
.lower
<= infoPtr
->nFocusedItem
&&
5107 (range
.upper
- 1) >= infoPtr
->nFocusedItem
)
5108 LISTVIEW_DrawFocusRect(infoPtr
, hdc
);
5110 iterator_destroy(&i
);
5113 /* For LVS_EX_GRIDLINES go and draw lines */
5114 /* This includes the case where there were *no* items */
5115 if ((infoPtr
->uView
== LV_VIEW_DETAILS
) && infoPtr
->dwLvExStyle
& LVS_EX_GRIDLINES
)
5116 LISTVIEW_RefreshReportGrid(infoPtr
, hdc
);
5118 /* Draw marquee rectangle if appropriate */
5119 if (infoPtr
->bMarqueeSelect
)
5120 DrawFocusRect(hdc
, &infoPtr
->marqueeDrawRect
);
5122 if (cdmode
& CDRF_NOTIFYPOSTPAINT
)
5123 notify_postpaint(infoPtr
, &nmlvcd
);
5125 infoPtr
->clrTextBk
= oldClrTextBk
;
5126 infoPtr
->clrText
= oldClrText
;
5129 BitBlt(hdcOrig
, infoPtr
->rcList
.left
, infoPtr
->rcList
.top
,
5130 infoPtr
->rcList
.right
- infoPtr
->rcList
.left
,
5131 infoPtr
->rcList
.bottom
- infoPtr
->rcList
.top
,
5132 hdc
, infoPtr
->rcList
.left
, infoPtr
->rcList
.top
, SRCCOPY
);
5137 SelectObject(hdc
, hOldFont
);
5138 SetBkMode(hdc
, oldBkMode
);
5139 SetBkColor(hdc
, oldBkColor
);
5140 SetTextColor(hdc
, oldTextColor
);
5143 infoPtr
->bIsDrawing
= FALSE
;
5149 * Calculates the approximate width and height of a given number of items.
5152 * [I] infoPtr : valid pointer to the listview structure
5153 * [I] nItemCount : number of items
5154 * [I] wWidth : width
5155 * [I] wHeight : height
5158 * Returns a DWORD. The width in the low word and the height in high word.
5160 static DWORD
LISTVIEW_ApproximateViewRect(const LISTVIEW_INFO
*infoPtr
, INT nItemCount
,
5161 WORD wWidth
, WORD wHeight
)
5163 DWORD dwViewRect
= 0;
5165 if (nItemCount
== -1)
5166 nItemCount
= infoPtr
->nItemCount
;
5168 if (infoPtr
->uView
== LV_VIEW_LIST
)
5170 INT nItemCountPerColumn
= 1;
5171 INT nColumnCount
= 0;
5173 if (wHeight
== 0xFFFF)
5175 /* use current height */
5176 wHeight
= infoPtr
->rcList
.bottom
- infoPtr
->rcList
.top
;
5179 if (wHeight
< infoPtr
->nItemHeight
)
5180 wHeight
= infoPtr
->nItemHeight
;
5184 if (infoPtr
->nItemHeight
> 0)
5186 nItemCountPerColumn
= wHeight
/ infoPtr
->nItemHeight
;
5187 if (nItemCountPerColumn
== 0)
5188 nItemCountPerColumn
= 1;
5190 if (nItemCount
% nItemCountPerColumn
!= 0)
5191 nColumnCount
= nItemCount
/ nItemCountPerColumn
;
5193 nColumnCount
= nItemCount
/ nItemCountPerColumn
+ 1;
5197 /* Microsoft padding magic */
5198 wHeight
= nItemCountPerColumn
* infoPtr
->nItemHeight
+ 2;
5199 wWidth
= nColumnCount
* infoPtr
->nItemWidth
+ 2;
5201 dwViewRect
= MAKELONG(wWidth
, wHeight
);
5203 else if (infoPtr
->uView
== LV_VIEW_DETAILS
)
5207 if (infoPtr
->nItemCount
> 0)
5209 LISTVIEW_GetItemBox(infoPtr
, 0, &rcBox
);
5210 wWidth
= rcBox
.right
- rcBox
.left
;
5211 wHeight
= (rcBox
.bottom
- rcBox
.top
) * nItemCount
;
5215 /* use current height and width */
5216 if (wHeight
== 0xffff)
5217 wHeight
= infoPtr
->rcList
.bottom
- infoPtr
->rcList
.top
;
5218 if (wWidth
== 0xffff)
5219 wWidth
= infoPtr
->rcList
.right
- infoPtr
->rcList
.left
;
5222 dwViewRect
= MAKELONG(wWidth
, wHeight
);
5224 else if (infoPtr
->uView
== LV_VIEW_ICON
)
5230 nItemWidth
= infoPtr
->iconSpacing
.cx
;
5231 nItemHeight
= infoPtr
->iconSpacing
.cy
;
5233 if (wWidth
== 0xffff)
5234 wWidth
= infoPtr
->rcList
.right
- infoPtr
->rcList
.left
;
5236 if (wWidth
< nItemWidth
)
5237 wWidth
= nItemWidth
;
5239 cols
= wWidth
/ nItemWidth
;
5240 if (cols
> nItemCount
)
5247 rows
= nItemCount
/ cols
;
5248 if (nItemCount
% cols
)
5254 wHeight
= (nItemHeight
* rows
)+2;
5255 wWidth
= (nItemWidth
* cols
)+2;
5257 dwViewRect
= MAKELONG(wWidth
, wHeight
);
5259 else if (infoPtr
->uView
== LV_VIEW_SMALLICON
)
5260 FIXME("uView == LV_VIEW_SMALLICON: not implemented\n");
5267 * Cancel edit label with saving item text.
5270 * [I] infoPtr : valid pointer to the listview structure
5273 * Always returns TRUE.
5275 static LRESULT
LISTVIEW_CancelEditLabel(LISTVIEW_INFO
*infoPtr
)
5277 if (infoPtr
->hwndEdit
)
5279 /* handle value will be lost after LISTVIEW_EndEditLabelT */
5280 HWND edit
= infoPtr
->hwndEdit
;
5282 LISTVIEW_EndEditLabelT(infoPtr
, TRUE
, IsWindowUnicode(infoPtr
->hwndEdit
));
5283 SendMessageW(edit
, WM_CLOSE
, 0, 0);
5291 * Create a drag image list for the specified item.
5294 * [I] infoPtr : valid pointer to the listview structure
5295 * [I] iItem : index of item
5296 * [O] lppt : Upper-left corner of the image
5299 * Returns a handle to the image list if successful, NULL otherwise.
5301 static HIMAGELIST
LISTVIEW_CreateDragImage(LISTVIEW_INFO
*infoPtr
, INT iItem
, LPPOINT lppt
)
5307 HBITMAP hbmp
, hOldbmp
;
5308 HIMAGELIST dragList
= 0;
5309 TRACE("iItem=%d Count=%d\n", iItem
, infoPtr
->nItemCount
);
5311 if (iItem
< 0 || iItem
>= infoPtr
->nItemCount
|| !lppt
)
5314 rcItem
.left
= LVIR_BOUNDS
;
5315 if (!LISTVIEW_GetItemRect(infoPtr
, iItem
, &rcItem
))
5318 lppt
->x
= rcItem
.left
;
5319 lppt
->y
= rcItem
.top
;
5321 size
.cx
= rcItem
.right
- rcItem
.left
;
5322 size
.cy
= rcItem
.bottom
- rcItem
.top
;
5324 hdcOrig
= GetDC(infoPtr
->hwndSelf
);
5325 hdc
= CreateCompatibleDC(hdcOrig
);
5326 hbmp
= CreateCompatibleBitmap(hdcOrig
, size
.cx
, size
.cy
);
5327 hOldbmp
= SelectObject(hdc
, hbmp
);
5329 rcItem
.left
= rcItem
.top
= 0;
5330 rcItem
.right
= size
.cx
;
5331 rcItem
.bottom
= size
.cy
;
5332 FillRect(hdc
, &rcItem
, infoPtr
->hBkBrush
);
5335 if (LISTVIEW_DrawItem(infoPtr
, hdc
, iItem
, 0, pos
, infoPtr
->cditemmode
))
5337 dragList
= ImageList_Create(size
.cx
, size
.cy
, ILC_COLOR
, 10, 10);
5338 SelectObject(hdc
, hOldbmp
);
5339 ImageList_Add(dragList
, hbmp
, 0);
5342 SelectObject(hdc
, hOldbmp
);
5346 ReleaseDC(infoPtr
->hwndSelf
, hdcOrig
);
5348 TRACE("ret=%p\n", dragList
);
5356 * Removes all listview items and subitems.
5359 * [I] infoPtr : valid pointer to the listview structure
5365 static BOOL
LISTVIEW_DeleteAllItems(LISTVIEW_INFO
*infoPtr
, BOOL destroy
)
5368 HDPA hdpaSubItems
= NULL
;
5377 /* we do it directly, to avoid notifications */
5378 ranges_clear(infoPtr
->selectionRanges
);
5379 infoPtr
->nSelectionMark
= -1;
5380 infoPtr
->nFocusedItem
= -1;
5381 SetRectEmpty(&infoPtr
->rcFocus
);
5382 /* But we are supposed to leave nHotItem as is! */
5385 /* send LVN_DELETEALLITEMS notification */
5386 ZeroMemory(&nmlv
, sizeof(NMLISTVIEW
));
5388 bSuppress
= notify_listview(infoPtr
, LVN_DELETEALLITEMS
, &nmlv
);
5390 for (i
= infoPtr
->nItemCount
- 1; i
>= 0; i
--)
5392 if (!(infoPtr
->dwStyle
& LVS_OWNERDATA
))
5394 /* send LVN_DELETEITEM notification, if not suppressed
5395 and if it is not a virtual listview */
5396 if (!bSuppress
) notify_deleteitem(infoPtr
, i
);
5397 hdpaSubItems
= DPA_GetPtr(infoPtr
->hdpaItems
, i
);
5398 lpItem
= DPA_GetPtr(hdpaSubItems
, 0);
5399 /* free id struct */
5400 j
= DPA_GetPtrIndex(infoPtr
->hdpaItemIds
, lpItem
->id
);
5401 lpID
= DPA_GetPtr(infoPtr
->hdpaItemIds
, j
);
5402 DPA_DeletePtr(infoPtr
->hdpaItemIds
, j
);
5404 /* both item and subitem start with ITEMHDR header */
5405 for (j
= 0; j
< DPA_GetPtrCount(hdpaSubItems
); j
++)
5407 hdrItem
= DPA_GetPtr(hdpaSubItems
, j
);
5408 if (is_text(hdrItem
->pszText
)) Free(hdrItem
->pszText
);
5411 DPA_Destroy(hdpaSubItems
);
5412 DPA_DeletePtr(infoPtr
->hdpaItems
, i
);
5414 DPA_DeletePtr(infoPtr
->hdpaPosX
, i
);
5415 DPA_DeletePtr(infoPtr
->hdpaPosY
, i
);
5416 infoPtr
->nItemCount
--;
5421 LISTVIEW_Arrange(infoPtr
, LVA_DEFAULT
);
5422 LISTVIEW_UpdateScroll(infoPtr
);
5424 LISTVIEW_InvalidateList(infoPtr
);
5431 * Scrolls, and updates the columns, when a column is changing width.
5434 * [I] infoPtr : valid pointer to the listview structure
5435 * [I] nColumn : column to scroll
5436 * [I] dx : amount of scroll, in pixels
5441 static void LISTVIEW_ScrollColumns(LISTVIEW_INFO
*infoPtr
, INT nColumn
, INT dx
)
5443 COLUMN_INFO
*lpColumnInfo
;
5449 if (nColumn
< 0 || DPA_GetPtrCount(infoPtr
->hdpaColumns
) < 1) return;
5450 lpColumnInfo
= LISTVIEW_GetColumnInfo(infoPtr
, min(nColumn
, DPA_GetPtrCount(infoPtr
->hdpaColumns
) - 1));
5451 rcCol
= lpColumnInfo
->rcHeader
;
5452 if (nColumn
>= DPA_GetPtrCount(infoPtr
->hdpaColumns
))
5453 rcCol
.left
= rcCol
.right
;
5455 /* adjust the other columns */
5456 hdi
.mask
= HDI_ORDER
;
5457 if (SendMessageW(infoPtr
->hwndHeader
, HDM_GETITEMW
, nColumn
, (LPARAM
)&hdi
))
5459 INT nOrder
= hdi
.iOrder
;
5460 for (nCol
= 0; nCol
< DPA_GetPtrCount(infoPtr
->hdpaColumns
); nCol
++)
5462 hdi
.mask
= HDI_ORDER
;
5463 SendMessageW(infoPtr
->hwndHeader
, HDM_GETITEMW
, nCol
, (LPARAM
)&hdi
);
5464 if (hdi
.iOrder
>= nOrder
) {
5465 lpColumnInfo
= LISTVIEW_GetColumnInfo(infoPtr
, nCol
);
5466 lpColumnInfo
->rcHeader
.left
+= dx
;
5467 lpColumnInfo
->rcHeader
.right
+= dx
;
5472 /* do not update screen if not in report mode */
5473 if (!is_redrawing(infoPtr
) || infoPtr
->uView
!= LV_VIEW_DETAILS
) return;
5475 /* Need to reset the item width when inserting a new column */
5476 infoPtr
->nItemWidth
+= dx
;
5478 LISTVIEW_UpdateScroll(infoPtr
);
5479 LISTVIEW_GetOrigin(infoPtr
, &ptOrigin
);
5481 /* scroll to cover the deleted column, and invalidate for redraw */
5482 rcOld
= infoPtr
->rcList
;
5483 rcOld
.left
= ptOrigin
.x
+ rcCol
.left
+ dx
;
5484 ScrollWindowEx(infoPtr
->hwndSelf
, dx
, 0, &rcOld
, &rcOld
, 0, 0, SW_ERASE
| SW_INVALIDATE
);
5489 * Removes a column from the listview control.
5492 * [I] infoPtr : valid pointer to the listview structure
5493 * [I] nColumn : column index
5499 static BOOL
LISTVIEW_DeleteColumn(LISTVIEW_INFO
*infoPtr
, INT nColumn
)
5503 TRACE("nColumn=%d\n", nColumn
);
5505 if (nColumn
< 0 || DPA_GetPtrCount(infoPtr
->hdpaColumns
) == 0
5506 || nColumn
>= DPA_GetPtrCount(infoPtr
->hdpaColumns
)) return FALSE
;
5508 /* While the MSDN specifically says that column zero should not be deleted,
5509 what actually happens is that the column itself is deleted but no items or subitems
5513 LISTVIEW_GetHeaderRect(infoPtr
, nColumn
, &rcCol
);
5515 if (!SendMessageW(infoPtr
->hwndHeader
, HDM_DELETEITEM
, nColumn
, 0))
5518 Free(DPA_GetPtr(infoPtr
->hdpaColumns
, nColumn
));
5519 DPA_DeletePtr(infoPtr
->hdpaColumns
, nColumn
);
5521 if (!(infoPtr
->dwStyle
& LVS_OWNERDATA
) && nColumn
)
5523 SUBITEM_INFO
*lpSubItem
, *lpDelItem
;
5525 INT nItem
, nSubItem
, i
;
5527 for (nItem
= 0; nItem
< infoPtr
->nItemCount
; nItem
++)
5529 hdpaSubItems
= DPA_GetPtr(infoPtr
->hdpaItems
, nItem
);
5532 for (i
= 1; i
< DPA_GetPtrCount(hdpaSubItems
); i
++)
5534 lpSubItem
= DPA_GetPtr(hdpaSubItems
, i
);
5535 if (lpSubItem
->iSubItem
== nColumn
)
5538 lpDelItem
= lpSubItem
;
5540 else if (lpSubItem
->iSubItem
> nColumn
)
5542 lpSubItem
->iSubItem
--;
5546 /* if we found our subitem, zap it */
5550 if (is_text(lpDelItem
->hdr
.pszText
))
5551 Free(lpDelItem
->hdr
.pszText
);
5556 /* free dpa memory */
5557 DPA_DeletePtr(hdpaSubItems
, nSubItem
);
5562 /* update the other column info */
5563 LISTVIEW_UpdateItemSize(infoPtr
);
5564 if(DPA_GetPtrCount(infoPtr
->hdpaColumns
) == 0)
5565 LISTVIEW_InvalidateList(infoPtr
);
5567 LISTVIEW_ScrollColumns(infoPtr
, nColumn
, -(rcCol
.right
- rcCol
.left
));
5574 * Invalidates the listview after an item's insertion or deletion.
5577 * [I] infoPtr : valid pointer to the listview structure
5578 * [I] nItem : item index
5579 * [I] dir : -1 if deleting, 1 if inserting
5584 static void LISTVIEW_ScrollOnInsert(LISTVIEW_INFO
*infoPtr
, INT nItem
, INT dir
)
5586 INT nPerCol
, nItemCol
, nItemRow
;
5590 /* if we don't refresh, what's the point of scrolling? */
5591 if (!is_redrawing(infoPtr
)) return;
5593 assert (abs(dir
) == 1);
5595 /* arrange icons if autoarrange is on */
5596 if (is_autoarrange(infoPtr
))
5598 BOOL arrange
= TRUE
;
5599 if (dir
< 0 && nItem
>= infoPtr
->nItemCount
) arrange
= FALSE
;
5600 if (dir
> 0 && nItem
== infoPtr
->nItemCount
- 1) arrange
= FALSE
;
5601 if (arrange
) LISTVIEW_Arrange(infoPtr
, LVA_DEFAULT
);
5604 /* scrollbars need updating */
5605 LISTVIEW_UpdateScroll(infoPtr
);
5607 /* figure out the item's position */
5608 if (infoPtr
->uView
== LV_VIEW_DETAILS
)
5609 nPerCol
= infoPtr
->nItemCount
+ 1;
5610 else if (infoPtr
->uView
== LV_VIEW_LIST
)
5611 nPerCol
= LISTVIEW_GetCountPerColumn(infoPtr
);
5612 else /* LV_VIEW_ICON, or LV_VIEW_SMALLICON */
5615 nItemCol
= nItem
/ nPerCol
;
5616 nItemRow
= nItem
% nPerCol
;
5617 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
5619 /* move the items below up a slot */
5620 rcScroll
.left
= nItemCol
* infoPtr
->nItemWidth
;
5621 rcScroll
.top
= nItemRow
* infoPtr
->nItemHeight
;
5622 rcScroll
.right
= rcScroll
.left
+ infoPtr
->nItemWidth
;
5623 rcScroll
.bottom
= nPerCol
* infoPtr
->nItemHeight
;
5624 OffsetRect(&rcScroll
, Origin
.x
, Origin
.y
);
5625 TRACE("rcScroll=%s, dx=%d\n", wine_dbgstr_rect(&rcScroll
), dir
* infoPtr
->nItemHeight
);
5626 if (IntersectRect(&rcScroll
, &rcScroll
, &infoPtr
->rcList
))
5628 TRACE("Scrolling rcScroll=%s, rcList=%s\n", wine_dbgstr_rect(&rcScroll
), wine_dbgstr_rect(&infoPtr
->rcList
));
5629 ScrollWindowEx(infoPtr
->hwndSelf
, 0, dir
* infoPtr
->nItemHeight
,
5630 &rcScroll
, &rcScroll
, 0, 0, SW_ERASE
| SW_INVALIDATE
);
5633 /* report has only that column, so we're done */
5634 if (infoPtr
->uView
== LV_VIEW_DETAILS
) return;
5636 /* now for LISTs, we have to deal with the columns to the right */
5637 rcScroll
.left
= (nItemCol
+ 1) * infoPtr
->nItemWidth
;
5639 rcScroll
.right
= (infoPtr
->nItemCount
/ nPerCol
+ 1) * infoPtr
->nItemWidth
;
5640 rcScroll
.bottom
= nPerCol
* infoPtr
->nItemHeight
;
5641 OffsetRect(&rcScroll
, Origin
.x
, Origin
.y
);
5642 if (IntersectRect(&rcScroll
, &rcScroll
, &infoPtr
->rcList
))
5643 ScrollWindowEx(infoPtr
->hwndSelf
, 0, dir
* infoPtr
->nItemHeight
,
5644 &rcScroll
, &rcScroll
, 0, 0, SW_ERASE
| SW_INVALIDATE
);
5649 * Removes an item from the listview control.
5652 * [I] infoPtr : valid pointer to the listview structure
5653 * [I] nItem : item index
5659 static BOOL
LISTVIEW_DeleteItem(LISTVIEW_INFO
*infoPtr
, INT nItem
)
5662 const BOOL is_icon
= (infoPtr
->uView
== LV_VIEW_SMALLICON
|| infoPtr
->uView
== LV_VIEW_ICON
);
5664 TRACE("(nItem=%d)\n", nItem
);
5666 if (nItem
< 0 || nItem
>= infoPtr
->nItemCount
) return FALSE
;
5668 /* remove selection, and focus */
5670 item
.stateMask
= LVIS_SELECTED
| LVIS_FOCUSED
;
5671 LISTVIEW_SetItemState(infoPtr
, nItem
, &item
);
5673 /* send LVN_DELETEITEM notification. */
5674 if (!notify_deleteitem(infoPtr
, nItem
)) return FALSE
;
5676 /* we need to do this here, because we'll be deleting stuff */
5678 LISTVIEW_InvalidateItem(infoPtr
, nItem
);
5680 if (!(infoPtr
->dwStyle
& LVS_OWNERDATA
))
5688 hdpaSubItems
= DPA_DeletePtr(infoPtr
->hdpaItems
, nItem
);
5689 lpItem
= DPA_GetPtr(hdpaSubItems
, 0);
5691 /* free id struct */
5692 i
= DPA_GetPtrIndex(infoPtr
->hdpaItemIds
, lpItem
->id
);
5693 lpID
= DPA_GetPtr(infoPtr
->hdpaItemIds
, i
);
5694 DPA_DeletePtr(infoPtr
->hdpaItemIds
, i
);
5696 for (i
= 0; i
< DPA_GetPtrCount(hdpaSubItems
); i
++)
5698 hdrItem
= DPA_GetPtr(hdpaSubItems
, i
);
5699 if (is_text(hdrItem
->pszText
)) Free(hdrItem
->pszText
);
5702 DPA_Destroy(hdpaSubItems
);
5707 DPA_DeletePtr(infoPtr
->hdpaPosX
, nItem
);
5708 DPA_DeletePtr(infoPtr
->hdpaPosY
, nItem
);
5711 infoPtr
->nItemCount
--;
5712 LISTVIEW_ShiftIndices(infoPtr
, nItem
, -1);
5714 /* now is the invalidation fun */
5716 LISTVIEW_ScrollOnInsert(infoPtr
, nItem
, -1);
5723 * Callback implementation for editlabel control
5726 * [I] infoPtr : valid pointer to the listview structure
5727 * [I] storeText : store edit box text as item text
5728 * [I] isW : TRUE if psxText is Unicode, FALSE if it's ANSI
5734 static BOOL
LISTVIEW_EndEditLabelT(LISTVIEW_INFO
*infoPtr
, BOOL storeText
, BOOL isW
)
5736 HWND hwndSelf
= infoPtr
->hwndSelf
;
5737 WCHAR szDispText
[DISP_TEXT_SIZE
] = { 0 };
5738 NMLVDISPINFOW dispInfo
;
5739 INT editedItem
= infoPtr
->nEditLabelItem
;
5741 WCHAR
*pszText
= NULL
;
5746 DWORD len
= isW
? GetWindowTextLengthW(infoPtr
->hwndEdit
) : GetWindowTextLengthA(infoPtr
->hwndEdit
);
5750 if ((pszText
= Alloc((len
+1) * (isW
? sizeof(WCHAR
) : sizeof(CHAR
)))))
5752 if (isW
) GetWindowTextW(infoPtr
->hwndEdit
, pszText
, len
+1);
5753 else GetWindowTextA(infoPtr
->hwndEdit
, (CHAR
*)pszText
, len
+1);
5758 TRACE("(pszText=%s, isW=%d)\n", debugtext_t(pszText
, isW
), isW
);
5760 ZeroMemory(&dispInfo
, sizeof(dispInfo
));
5761 dispInfo
.item
.mask
= LVIF_PARAM
| LVIF_STATE
| LVIF_TEXT
;
5762 dispInfo
.item
.iItem
= editedItem
;
5763 dispInfo
.item
.iSubItem
= 0;
5764 dispInfo
.item
.stateMask
= ~0;
5765 dispInfo
.item
.pszText
= szDispText
;
5766 dispInfo
.item
.cchTextMax
= DISP_TEXT_SIZE
;
5767 if (!LISTVIEW_GetItemT(infoPtr
, &dispInfo
.item
, isW
))
5774 same
= (lstrcmpW(dispInfo
.item
.pszText
, pszText
) == 0);
5777 LPWSTR tmp
= textdupTtoW(pszText
, FALSE
);
5778 same
= (lstrcmpW(dispInfo
.item
.pszText
, tmp
) == 0);
5779 textfreeT(tmp
, FALSE
);
5782 /* add the text from the edit in */
5783 dispInfo
.item
.mask
|= LVIF_TEXT
;
5784 dispInfo
.item
.pszText
= same
? NULL
: pszText
;
5785 dispInfo
.item
.cchTextMax
= textlenT(dispInfo
.item
.pszText
, isW
);
5787 /* Do we need to update the Item Text */
5788 res
= notify_dispinfoT(infoPtr
, LVN_ENDLABELEDITW
, &dispInfo
, isW
);
5790 infoPtr
->nEditLabelItem
= -1;
5791 infoPtr
->hwndEdit
= 0;
5793 if (!res
) goto cleanup
;
5795 if (!IsWindow(hwndSelf
))
5800 if (!pszText
) return TRUE
;
5807 if (!(infoPtr
->dwStyle
& LVS_OWNERDATA
))
5809 HDPA hdpaSubItems
= DPA_GetPtr(infoPtr
->hdpaItems
, editedItem
);
5810 ITEM_INFO
* lpItem
= DPA_GetPtr(hdpaSubItems
, 0);
5811 if (lpItem
&& lpItem
->hdr
.pszText
== LPSTR_TEXTCALLBACKW
)
5813 LISTVIEW_InvalidateItem(infoPtr
, editedItem
);
5819 ZeroMemory(&dispInfo
, sizeof(dispInfo
));
5820 dispInfo
.item
.mask
= LVIF_TEXT
;
5821 dispInfo
.item
.iItem
= editedItem
;
5822 dispInfo
.item
.iSubItem
= 0;
5823 dispInfo
.item
.pszText
= pszText
;
5824 dispInfo
.item
.cchTextMax
= textlenT(pszText
, isW
);
5825 res
= LISTVIEW_SetItemT(infoPtr
, &dispInfo
.item
, isW
);
5835 * Subclassed edit control windproc function
5838 * [I] hwnd : the edit window handle
5839 * [I] uMsg : the message that is to be processed
5840 * [I] wParam : first message parameter
5841 * [I] lParam : second message parameter
5842 * [I] isW : TRUE if input is Unicode
5847 static LRESULT
EditLblWndProcT(HWND hwnd
, UINT uMsg
, WPARAM wParam
, LPARAM lParam
, BOOL isW
)
5849 LISTVIEW_INFO
*infoPtr
= (LISTVIEW_INFO
*)GetWindowLongPtrW(GetParent(hwnd
), 0);
5852 TRACE("(hwnd=%p, uMsg=%x, wParam=%lx, lParam=%lx, isW=%d)\n",
5853 hwnd
, uMsg
, wParam
, lParam
, isW
);
5858 return DLGC_WANTARROWS
| DLGC_WANTALLKEYS
;
5862 WNDPROC editProc
= infoPtr
->EditWndProc
;
5863 infoPtr
->EditWndProc
= 0;
5864 SetWindowLongPtrW(hwnd
, GWLP_WNDPROC
, (DWORD_PTR
)editProc
);
5865 return CallWindowProcT(editProc
, hwnd
, uMsg
, wParam
, lParam
, isW
);
5869 if (VK_ESCAPE
== (INT
)wParam
)
5874 else if (VK_RETURN
== (INT
)wParam
)
5878 return CallWindowProcT(infoPtr
->EditWndProc
, hwnd
, uMsg
, wParam
, lParam
, isW
);
5882 if (infoPtr
->hwndEdit
)
5883 LISTVIEW_EndEditLabelT(infoPtr
, save
, isW
);
5885 SendMessageW(hwnd
, WM_CLOSE
, 0, 0);
5891 * Subclassed edit control Unicode windproc function
5894 * [I] hwnd : the edit window handle
5895 * [I] uMsg : the message that is to be processed
5896 * [I] wParam : first message parameter
5897 * [I] lParam : second message parameter
5901 static LRESULT CALLBACK
EditLblWndProcW(HWND hwnd
, UINT uMsg
, WPARAM wParam
, LPARAM lParam
)
5903 return EditLblWndProcT(hwnd
, uMsg
, wParam
, lParam
, TRUE
);
5908 * Subclassed edit control ANSI windproc function
5911 * [I] hwnd : the edit window handle
5912 * [I] uMsg : the message that is to be processed
5913 * [I] wParam : first message parameter
5914 * [I] lParam : second message parameter
5918 static LRESULT CALLBACK
EditLblWndProcA(HWND hwnd
, UINT uMsg
, WPARAM wParam
, LPARAM lParam
)
5920 return EditLblWndProcT(hwnd
, uMsg
, wParam
, lParam
, FALSE
);
5925 * Creates a subclassed edit control
5928 * [I] infoPtr : valid pointer to the listview structure
5929 * [I] text : initial text for the edit
5930 * [I] style : the window style
5931 * [I] isW : TRUE if input is Unicode
5935 static HWND
CreateEditLabelT(LISTVIEW_INFO
*infoPtr
, LPCWSTR text
, BOOL isW
)
5937 static const DWORD style
= WS_CHILDWINDOW
|WS_CLIPSIBLINGS
|ES_LEFT
|ES_AUTOHSCROLL
|WS_BORDER
|WS_VISIBLE
;
5938 HINSTANCE hinst
= (HINSTANCE
)GetWindowLongPtrW(infoPtr
->hwndSelf
, GWLP_HINSTANCE
);
5941 TRACE("(%p, text=%s, isW=%d)\n", infoPtr
, debugtext_t(text
, isW
), isW
);
5943 /* window will be resized and positioned after LVN_BEGINLABELEDIT */
5945 hedit
= CreateWindowW(WC_EDITW
, text
, style
, 0, 0, 0, 0, infoPtr
->hwndSelf
, 0, hinst
, 0);
5947 hedit
= CreateWindowA(WC_EDITA
, (LPCSTR
)text
, style
, 0, 0, 0, 0, infoPtr
->hwndSelf
, 0, hinst
, 0);
5949 if (!hedit
) return 0;
5951 infoPtr
->EditWndProc
= (WNDPROC
)
5952 (isW
? SetWindowLongPtrW(hedit
, GWLP_WNDPROC
, (DWORD_PTR
)EditLblWndProcW
) :
5953 SetWindowLongPtrA(hedit
, GWLP_WNDPROC
, (DWORD_PTR
)EditLblWndProcA
) );
5955 SendMessageW(hedit
, WM_SETFONT
, (WPARAM
)infoPtr
->hFont
, FALSE
);
5956 SendMessageW(hedit
, EM_SETLIMITTEXT
, DISP_TEXT_SIZE
-1, 0);
5963 * Begin in place editing of specified list view item
5966 * [I] infoPtr : valid pointer to the listview structure
5967 * [I] nItem : item index
5968 * [I] isW : TRUE if it's a Unicode req, FALSE if ASCII
5974 static HWND
LISTVIEW_EditLabelT(LISTVIEW_INFO
*infoPtr
, INT nItem
, BOOL isW
)
5976 WCHAR disptextW
[DISP_TEXT_SIZE
] = { 0 };
5977 HWND hwndSelf
= infoPtr
->hwndSelf
;
5978 NMLVDISPINFOW dispInfo
;
5979 HFONT hOldFont
= NULL
;
5985 TRACE("(nItem=%d, isW=%d)\n", nItem
, isW
);
5987 if (~infoPtr
->dwStyle
& LVS_EDITLABELS
) return 0;
5989 /* remove existing edit box */
5990 if (infoPtr
->hwndEdit
)
5992 SetFocus(infoPtr
->hwndSelf
);
5993 infoPtr
->hwndEdit
= 0;
5996 if (nItem
< 0 || nItem
>= infoPtr
->nItemCount
) return 0;
5998 infoPtr
->nEditLabelItem
= nItem
;
6000 LISTVIEW_SetSelection(infoPtr
, nItem
);
6001 LISTVIEW_SetItemFocus(infoPtr
, nItem
);
6002 LISTVIEW_InvalidateItem(infoPtr
, nItem
);
6004 rect
.left
= LVIR_LABEL
;
6005 if (!LISTVIEW_GetItemRect(infoPtr
, nItem
, &rect
)) return 0;
6007 ZeroMemory(&dispInfo
, sizeof(dispInfo
));
6008 dispInfo
.item
.mask
= LVIF_PARAM
| LVIF_STATE
| LVIF_TEXT
;
6009 dispInfo
.item
.iItem
= nItem
;
6010 dispInfo
.item
.iSubItem
= 0;
6011 dispInfo
.item
.stateMask
= ~0;
6012 dispInfo
.item
.pszText
= disptextW
;
6013 dispInfo
.item
.cchTextMax
= DISP_TEXT_SIZE
;
6014 if (!LISTVIEW_GetItemT(infoPtr
, &dispInfo
.item
, isW
)) return 0;
6016 infoPtr
->hwndEdit
= CreateEditLabelT(infoPtr
, dispInfo
.item
.pszText
, isW
);
6017 if (!infoPtr
->hwndEdit
) return 0;
6019 if (notify_dispinfoT(infoPtr
, LVN_BEGINLABELEDITW
, &dispInfo
, isW
))
6021 if (!IsWindow(hwndSelf
))
6023 SendMessageW(infoPtr
->hwndEdit
, WM_CLOSE
, 0, 0);
6024 infoPtr
->hwndEdit
= 0;
6028 TRACE("disp text=%s\n", debugtext_t(dispInfo
.item
.pszText
, isW
));
6030 /* position and display edit box */
6031 hdc
= GetDC(infoPtr
->hwndSelf
);
6033 /* select the font to get appropriate metric dimensions */
6035 hOldFont
= SelectObject(hdc
, infoPtr
->hFont
);
6037 /* use real edit box content, it could be altered during LVN_BEGINLABELEDIT notification */
6038 GetWindowTextW(infoPtr
->hwndEdit
, disptextW
, DISP_TEXT_SIZE
);
6039 TRACE("edit box text=%s\n", debugstr_w(disptextW
));
6041 /* get string length in pixels */
6042 GetTextExtentPoint32W(hdc
, disptextW
, lstrlenW(disptextW
), &sz
);
6044 /* add extra spacing for the next character */
6045 GetTextMetricsW(hdc
, &tm
);
6046 sz
.cx
+= tm
.tmMaxCharWidth
* 2;
6049 SelectObject(hdc
, hOldFont
);
6051 ReleaseDC(infoPtr
->hwndSelf
, hdc
);
6053 sz
.cy
= rect
.bottom
- rect
.top
+ 2;
6056 TRACE("moving edit=(%d,%d)-(%d,%d)\n", rect
.left
, rect
.top
, sz
.cx
, sz
.cy
);
6057 MoveWindow(infoPtr
->hwndEdit
, rect
.left
, rect
.top
, sz
.cx
, sz
.cy
, FALSE
);
6058 ShowWindow(infoPtr
->hwndEdit
, SW_NORMAL
);
6059 SetFocus(infoPtr
->hwndEdit
);
6060 SendMessageW(infoPtr
->hwndEdit
, EM_SETSEL
, 0, -1);
6061 return infoPtr
->hwndEdit
;
6067 * Ensures the specified item is visible, scrolling into view if necessary.
6070 * [I] infoPtr : valid pointer to the listview structure
6071 * [I] nItem : item index
6072 * [I] bPartial : partially or entirely visible
6078 static BOOL
LISTVIEW_EnsureVisible(LISTVIEW_INFO
*infoPtr
, INT nItem
, BOOL bPartial
)
6080 INT nScrollPosHeight
= 0;
6081 INT nScrollPosWidth
= 0;
6082 INT nHorzAdjust
= 0;
6083 INT nVertAdjust
= 0;
6086 RECT rcItem
, rcTemp
;
6088 rcItem
.left
= LVIR_BOUNDS
;
6089 if (!LISTVIEW_GetItemRect(infoPtr
, nItem
, &rcItem
)) return FALSE
;
6091 if (bPartial
&& IntersectRect(&rcTemp
, &infoPtr
->rcList
, &rcItem
)) return TRUE
;
6093 if (rcItem
.left
< infoPtr
->rcList
.left
|| rcItem
.right
> infoPtr
->rcList
.right
)
6095 /* scroll left/right, but in LV_VIEW_DETAILS mode */
6096 if (infoPtr
->uView
== LV_VIEW_LIST
)
6097 nScrollPosWidth
= infoPtr
->nItemWidth
;
6098 else if ((infoPtr
->uView
== LV_VIEW_SMALLICON
) || (infoPtr
->uView
== LV_VIEW_ICON
))
6099 nScrollPosWidth
= 1;
6101 if (rcItem
.left
< infoPtr
->rcList
.left
)
6104 if (infoPtr
->uView
!= LV_VIEW_DETAILS
) nHorzDiff
= rcItem
.left
- infoPtr
->rcList
.left
;
6109 if (infoPtr
->uView
!= LV_VIEW_DETAILS
) nHorzDiff
= rcItem
.right
- infoPtr
->rcList
.right
;
6113 if (rcItem
.top
< infoPtr
->rcList
.top
|| rcItem
.bottom
> infoPtr
->rcList
.bottom
)
6115 /* scroll up/down, but not in LVS_LIST mode */
6116 if (infoPtr
->uView
== LV_VIEW_DETAILS
)
6117 nScrollPosHeight
= infoPtr
->nItemHeight
;
6118 else if ((infoPtr
->uView
== LV_VIEW_ICON
) || (infoPtr
->uView
== LV_VIEW_SMALLICON
))
6119 nScrollPosHeight
= 1;
6121 if (rcItem
.top
< infoPtr
->rcList
.top
)
6124 if (infoPtr
->uView
!= LV_VIEW_LIST
) nVertDiff
= rcItem
.top
- infoPtr
->rcList
.top
;
6129 if (infoPtr
->uView
!= LV_VIEW_LIST
) nVertDiff
= rcItem
.bottom
- infoPtr
->rcList
.bottom
;
6133 if (!nScrollPosWidth
&& !nScrollPosHeight
) return TRUE
;
6135 if (nScrollPosWidth
)
6137 INT diff
= nHorzDiff
/ nScrollPosWidth
;
6138 if (nHorzDiff
% nScrollPosWidth
) diff
+= nHorzAdjust
;
6139 LISTVIEW_HScroll(infoPtr
, SB_INTERNAL
, diff
);
6142 if (nScrollPosHeight
)
6144 INT diff
= nVertDiff
/ nScrollPosHeight
;
6145 if (nVertDiff
% nScrollPosHeight
) diff
+= nVertAdjust
;
6146 LISTVIEW_VScroll(infoPtr
, SB_INTERNAL
, diff
);
6154 * Searches for an item with specific characteristics.
6157 * [I] hwnd : window handle
6158 * [I] nStart : base item index
6159 * [I] lpFindInfo : item information to look for
6162 * SUCCESS : index of item
6165 static INT
LISTVIEW_FindItemW(const LISTVIEW_INFO
*infoPtr
, INT nStart
,
6166 const LVFINDINFOW
*lpFindInfo
)
6168 WCHAR szDispText
[DISP_TEXT_SIZE
] = { '\0' };
6169 BOOL bWrap
= FALSE
, bNearest
= FALSE
;
6170 INT nItem
= nStart
+ 1, nLast
= infoPtr
->nItemCount
, nNearestItem
= -1;
6171 ULONG xdist
, ydist
, dist
, mindist
= 0x7fffffff;
6172 POINT Position
, Destination
;
6175 /* Search in virtual listviews should be done by application, not by
6176 listview control, so we just send LVN_ODFINDITEMW and return the result */
6177 if (infoPtr
->dwStyle
& LVS_OWNERDATA
)
6181 nmlv
.iStart
= nStart
;
6182 nmlv
.lvfi
= *lpFindInfo
;
6183 return notify_hdr(infoPtr
, LVN_ODFINDITEMW
, (LPNMHDR
)&nmlv
.hdr
);
6186 if (!lpFindInfo
|| nItem
< 0) return -1;
6189 if (lpFindInfo
->flags
& (LVFI_STRING
| LVFI_PARTIAL
) ||
6190 lpFindInfo
->flags
& LVFI_SUBSTRING
)
6192 lvItem
.mask
|= LVIF_TEXT
;
6193 lvItem
.pszText
= szDispText
;
6194 lvItem
.cchTextMax
= DISP_TEXT_SIZE
;
6197 if (lpFindInfo
->flags
& LVFI_WRAP
)
6200 if ((lpFindInfo
->flags
& LVFI_NEARESTXY
) &&
6201 (infoPtr
->uView
== LV_VIEW_ICON
|| infoPtr
->uView
== LV_VIEW_SMALLICON
))
6206 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
6207 Destination
.x
= lpFindInfo
->pt
.x
- Origin
.x
;
6208 Destination
.y
= lpFindInfo
->pt
.y
- Origin
.y
;
6209 switch(lpFindInfo
->vkDirection
)
6211 case VK_DOWN
: Destination
.y
+= infoPtr
->nItemHeight
; break;
6212 case VK_UP
: Destination
.y
-= infoPtr
->nItemHeight
; break;
6213 case VK_RIGHT
: Destination
.x
+= infoPtr
->nItemWidth
; break;
6214 case VK_LEFT
: Destination
.x
-= infoPtr
->nItemWidth
; break;
6215 case VK_HOME
: Destination
.x
= Destination
.y
= 0; break;
6216 case VK_NEXT
: Destination
.y
+= infoPtr
->rcList
.bottom
- infoPtr
->rcList
.top
; break;
6217 case VK_PRIOR
: Destination
.y
-= infoPtr
->rcList
.bottom
- infoPtr
->rcList
.top
; break;
6219 LISTVIEW_GetAreaRect(infoPtr
, &rcArea
);
6220 Destination
.x
= rcArea
.right
;
6221 Destination
.y
= rcArea
.bottom
;
6223 default: ERR("Unknown vkDirection=%d\n", lpFindInfo
->vkDirection
);
6227 else Destination
.x
= Destination
.y
= 0;
6229 /* if LVFI_PARAM is specified, all other flags are ignored */
6230 if (lpFindInfo
->flags
& LVFI_PARAM
)
6232 lvItem
.mask
|= LVIF_PARAM
;
6234 lvItem
.mask
&= ~LVIF_TEXT
;
6238 for (; nItem
< nLast
; nItem
++)
6240 lvItem
.iItem
= nItem
;
6241 lvItem
.iSubItem
= 0;
6242 if (!LISTVIEW_GetItemW(infoPtr
, &lvItem
)) continue;
6244 if (lvItem
.mask
& LVIF_PARAM
)
6246 if (lpFindInfo
->lParam
== lvItem
.lParam
)
6252 if (lvItem
.mask
& LVIF_TEXT
)
6254 if (lpFindInfo
->flags
& (LVFI_PARTIAL
| LVFI_SUBSTRING
))
6256 WCHAR
*p
= strstrW(lvItem
.pszText
, lpFindInfo
->psz
);
6257 if (!p
|| p
!= lvItem
.pszText
) continue;
6261 if (lstrcmpW(lvItem
.pszText
, lpFindInfo
->psz
) != 0) continue;
6265 if (!bNearest
) return nItem
;
6267 /* This is very inefficient. To do a good job here,
6268 * we need a sorted array of (x,y) item positions */
6269 LISTVIEW_GetItemOrigin(infoPtr
, nItem
, &Position
);
6271 /* compute the distance^2 to the destination */
6272 xdist
= Destination
.x
- Position
.x
;
6273 ydist
= Destination
.y
- Position
.y
;
6274 dist
= xdist
* xdist
+ ydist
* ydist
;
6276 /* remember the distance, and item if it's closer */
6280 nNearestItem
= nItem
;
6287 nLast
= min(nStart
+ 1, infoPtr
->nItemCount
);
6292 return nNearestItem
;
6297 * Searches for an item with specific characteristics.
6300 * [I] hwnd : window handle
6301 * [I] nStart : base item index
6302 * [I] lpFindInfo : item information to look for
6305 * SUCCESS : index of item
6308 static INT
LISTVIEW_FindItemA(const LISTVIEW_INFO
*infoPtr
, INT nStart
,
6309 const LVFINDINFOA
*lpFindInfo
)
6311 BOOL hasText
= lpFindInfo
->flags
& (LVFI_STRING
| LVFI_PARTIAL
) ||
6312 lpFindInfo
->flags
& LVFI_SUBSTRING
;
6317 memcpy(&fiw
, lpFindInfo
, sizeof(fiw
));
6318 if (hasText
) fiw
.psz
= strW
= textdupTtoW((LPCWSTR
)lpFindInfo
->psz
, FALSE
);
6319 res
= LISTVIEW_FindItemW(infoPtr
, nStart
, &fiw
);
6320 textfreeT(strW
, FALSE
);
6326 * Retrieves column attributes.
6329 * [I] infoPtr : valid pointer to the listview structure
6330 * [I] nColumn : column index
6331 * [IO] lpColumn : column information
6332 * [I] isW : if TRUE, then lpColumn is a LPLVCOLUMNW
6333 * otherwise it is in fact a LPLVCOLUMNA
6339 static BOOL
LISTVIEW_GetColumnT(const LISTVIEW_INFO
*infoPtr
, INT nColumn
, LPLVCOLUMNW lpColumn
, BOOL isW
)
6341 COLUMN_INFO
*lpColumnInfo
;
6344 if (!lpColumn
|| nColumn
< 0 || nColumn
>= DPA_GetPtrCount(infoPtr
->hdpaColumns
)) return FALSE
;
6345 lpColumnInfo
= LISTVIEW_GetColumnInfo(infoPtr
, nColumn
);
6347 /* initialize memory */
6348 ZeroMemory(&hdi
, sizeof(hdi
));
6350 if (lpColumn
->mask
& LVCF_TEXT
)
6352 hdi
.mask
|= HDI_TEXT
;
6353 hdi
.pszText
= lpColumn
->pszText
;
6354 hdi
.cchTextMax
= lpColumn
->cchTextMax
;
6357 if (lpColumn
->mask
& LVCF_IMAGE
)
6358 hdi
.mask
|= HDI_IMAGE
;
6360 if (lpColumn
->mask
& LVCF_ORDER
)
6361 hdi
.mask
|= HDI_ORDER
;
6363 if (lpColumn
->mask
& LVCF_SUBITEM
)
6364 hdi
.mask
|= HDI_LPARAM
;
6366 if (!SendMessageW(infoPtr
->hwndHeader
, isW
? HDM_GETITEMW
: HDM_GETITEMA
, nColumn
, (LPARAM
)&hdi
)) return FALSE
;
6368 if (lpColumn
->mask
& LVCF_FMT
)
6369 lpColumn
->fmt
= lpColumnInfo
->fmt
;
6371 if (lpColumn
->mask
& LVCF_WIDTH
)
6372 lpColumn
->cx
= lpColumnInfo
->rcHeader
.right
- lpColumnInfo
->rcHeader
.left
;
6374 if (lpColumn
->mask
& LVCF_IMAGE
)
6375 lpColumn
->iImage
= hdi
.iImage
;
6377 if (lpColumn
->mask
& LVCF_ORDER
)
6378 lpColumn
->iOrder
= hdi
.iOrder
;
6380 if (lpColumn
->mask
& LVCF_SUBITEM
)
6381 lpColumn
->iSubItem
= hdi
.lParam
;
6383 if (lpColumn
->mask
& LVCF_MINWIDTH
)
6384 lpColumn
->cxMin
= lpColumnInfo
->cxMin
;
6390 static BOOL
LISTVIEW_GetColumnOrderArray(const LISTVIEW_INFO
*infoPtr
, INT iCount
, LPINT lpiArray
)
6392 TRACE("iCount=%d, lpiArray=%p\n", iCount
, lpiArray
);
6397 return SendMessageW(infoPtr
->hwndHeader
, HDM_GETORDERARRAY
, iCount
, (LPARAM
)lpiArray
);
6402 * Retrieves the column width.
6405 * [I] infoPtr : valid pointer to the listview structure
6406 * [I] int : column index
6409 * SUCCESS : column width
6412 static INT
LISTVIEW_GetColumnWidth(const LISTVIEW_INFO
*infoPtr
, INT nColumn
)
6414 INT nColumnWidth
= 0;
6417 TRACE("nColumn=%d\n", nColumn
);
6419 /* we have a 'column' in LIST and REPORT mode only */
6420 switch(infoPtr
->uView
)
6423 nColumnWidth
= infoPtr
->nItemWidth
;
6425 case LV_VIEW_DETAILS
:
6426 /* We are not using LISTVIEW_GetHeaderRect as this data is updated only after a HDN_ITEMCHANGED.
6427 * There is an application that subclasses the listview, calls LVM_GETCOLUMNWIDTH in the
6428 * HDN_ITEMCHANGED handler and goes into infinite recursion if it receives old data.
6430 * TODO: should we do the same in LVM_GETCOLUMN?
6432 hdItem
.mask
= HDI_WIDTH
;
6433 if (!SendMessageW(infoPtr
->hwndHeader
, HDM_GETITEMW
, nColumn
, (LPARAM
)&hdItem
))
6435 WARN("(%p): HDM_GETITEMW failed for item %d\n", infoPtr
->hwndSelf
, nColumn
);
6438 nColumnWidth
= hdItem
.cxy
;
6442 TRACE("nColumnWidth=%d\n", nColumnWidth
);
6443 return nColumnWidth
;
6448 * In list or report display mode, retrieves the number of items that can fit
6449 * vertically in the visible area. In icon or small icon display mode,
6450 * retrieves the total number of visible items.
6453 * [I] infoPtr : valid pointer to the listview structure
6456 * Number of fully visible items.
6458 static INT
LISTVIEW_GetCountPerPage(const LISTVIEW_INFO
*infoPtr
)
6460 switch (infoPtr
->uView
)
6463 case LV_VIEW_SMALLICON
:
6464 return infoPtr
->nItemCount
;
6465 case LV_VIEW_DETAILS
:
6466 return LISTVIEW_GetCountPerColumn(infoPtr
);
6468 return LISTVIEW_GetCountPerRow(infoPtr
) * LISTVIEW_GetCountPerColumn(infoPtr
);
6476 * Retrieves an image list handle.
6479 * [I] infoPtr : valid pointer to the listview structure
6480 * [I] nImageList : image list identifier
6483 * SUCCESS : image list handle
6486 static HIMAGELIST
LISTVIEW_GetImageList(const LISTVIEW_INFO
*infoPtr
, INT nImageList
)
6490 case LVSIL_NORMAL
: return infoPtr
->himlNormal
;
6491 case LVSIL_SMALL
: return infoPtr
->himlSmall
;
6492 case LVSIL_STATE
: return infoPtr
->himlState
;
6493 case LVSIL_GROUPHEADER
:
6494 FIXME("LVSIL_GROUPHEADER not supported\n");
6497 WARN("got unknown imagelist index - %d\n", nImageList
);
6502 /* LISTVIEW_GetISearchString */
6506 * Retrieves item attributes.
6509 * [I] hwnd : window handle
6510 * [IO] lpLVItem : item info
6511 * [I] isW : if TRUE, then lpLVItem is a LPLVITEMW,
6512 * if FALSE, then lpLVItem is a LPLVITEMA.
6515 * This is the internal 'GetItem' interface -- it tries to
6516 * be smart and avoid text copies, if possible, by modifying
6517 * lpLVItem->pszText to point to the text string. Please note
6518 * that this is not always possible (e.g. OWNERDATA), so on
6519 * entry you *must* supply valid values for pszText, and cchTextMax.
6520 * The only difference to the documented interface is that upon
6521 * return, you should use *only* the lpLVItem->pszText, rather than
6522 * the buffer pointer you provided on input. Most code already does
6523 * that, so it's not a problem.
6524 * For the two cases when the text must be copied (that is,
6525 * for LVM_GETITEM, and LVM_GETITEMTEXT), use LISTVIEW_GetItemExtT.
6531 static BOOL
LISTVIEW_GetItemT(const LISTVIEW_INFO
*infoPtr
, LPLVITEMW lpLVItem
, BOOL isW
)
6533 ITEMHDR callbackHdr
= { LPSTR_TEXTCALLBACKW
, I_IMAGECALLBACK
};
6534 NMLVDISPINFOW dispInfo
;
6540 TRACE("(lpLVItem=%s, isW=%d)\n", debuglvitem_t(lpLVItem
, isW
), isW
);
6542 if (!lpLVItem
|| lpLVItem
->iItem
< 0 || lpLVItem
->iItem
>= infoPtr
->nItemCount
)
6545 if (lpLVItem
->mask
== 0) return TRUE
;
6546 TRACE("mask=%x\n", lpLVItem
->mask
);
6548 /* make a local copy */
6549 isubitem
= lpLVItem
->iSubItem
;
6551 /* a quick optimization if all we're asked is the focus state
6552 * these queries are worth optimising since they are common,
6553 * and can be answered in constant time, without the heavy accesses */
6554 if ( (lpLVItem
->mask
== LVIF_STATE
) && (lpLVItem
->stateMask
== LVIS_FOCUSED
) &&
6555 !(infoPtr
->uCallbackMask
& LVIS_FOCUSED
) )
6557 lpLVItem
->state
= 0;
6558 if (infoPtr
->nFocusedItem
== lpLVItem
->iItem
)
6559 lpLVItem
->state
|= LVIS_FOCUSED
;
6563 ZeroMemory(&dispInfo
, sizeof(dispInfo
));
6565 /* if the app stores all the data, handle it separately */
6566 if (infoPtr
->dwStyle
& LVS_OWNERDATA
)
6568 dispInfo
.item
.state
= 0;
6570 /* apparently, we should not callback for lParam in LVS_OWNERDATA */
6571 if ((lpLVItem
->mask
& ~(LVIF_STATE
| LVIF_PARAM
)) ||
6572 ((lpLVItem
->mask
& LVIF_STATE
) && (infoPtr
->uCallbackMask
& lpLVItem
->stateMask
)))
6574 UINT mask
= lpLVItem
->mask
;
6576 /* NOTE: copy only fields which we _know_ are initialized, some apps
6577 * depend on the uninitialized fields being 0 */
6578 dispInfo
.item
.mask
= lpLVItem
->mask
& ~LVIF_PARAM
;
6579 dispInfo
.item
.iItem
= lpLVItem
->iItem
;
6580 dispInfo
.item
.iSubItem
= isubitem
;
6581 if (lpLVItem
->mask
& LVIF_TEXT
)
6583 if (lpLVItem
->mask
& LVIF_NORECOMPUTE
)
6585 dispInfo
.item
.mask
&= ~(LVIF_TEXT
| LVIF_NORECOMPUTE
);
6588 dispInfo
.item
.pszText
= lpLVItem
->pszText
;
6589 dispInfo
.item
.cchTextMax
= lpLVItem
->cchTextMax
;
6592 if (lpLVItem
->mask
& LVIF_STATE
)
6593 dispInfo
.item
.stateMask
= lpLVItem
->stateMask
& infoPtr
->uCallbackMask
;
6594 /* could be zeroed on LVIF_NORECOMPUTE case */
6595 if (dispInfo
.item
.mask
)
6597 notify_dispinfoT(infoPtr
, LVN_GETDISPINFOW
, &dispInfo
, isW
);
6598 dispInfo
.item
.stateMask
= lpLVItem
->stateMask
;
6599 if (lpLVItem
->mask
& (LVIF_GROUPID
|LVIF_COLUMNS
))
6601 /* full size structure expected - _WIN32IE >= 0x560 */
6602 *lpLVItem
= dispInfo
.item
;
6604 else if (lpLVItem
->mask
& LVIF_INDENT
)
6606 /* indent member expected - _WIN32IE >= 0x300 */
6607 memcpy(lpLVItem
, &dispInfo
.item
, offsetof( LVITEMW
, iGroupId
));
6611 /* minimal structure expected */
6612 memcpy(lpLVItem
, &dispInfo
.item
, offsetof( LVITEMW
, iIndent
));
6614 lpLVItem
->mask
= mask
;
6615 TRACE(" getdispinfo(1):lpLVItem=%s\n", debuglvitem_t(lpLVItem
, isW
));
6619 /* make sure lParam is zeroed out */
6620 if (lpLVItem
->mask
& LVIF_PARAM
) lpLVItem
->lParam
= 0;
6622 /* callback marked pointer required here */
6623 if ((lpLVItem
->mask
& LVIF_TEXT
) && (lpLVItem
->mask
& LVIF_NORECOMPUTE
))
6624 lpLVItem
->pszText
= LPSTR_TEXTCALLBACKW
;
6626 /* we store only a little state, so if we're not asked, we're done */
6627 if (!(lpLVItem
->mask
& LVIF_STATE
) || isubitem
) return TRUE
;
6629 /* if focus is handled by us, report it */
6630 if ( lpLVItem
->stateMask
& ~infoPtr
->uCallbackMask
& LVIS_FOCUSED
)
6632 lpLVItem
->state
&= ~LVIS_FOCUSED
;
6633 if (infoPtr
->nFocusedItem
== lpLVItem
->iItem
)
6634 lpLVItem
->state
|= LVIS_FOCUSED
;
6637 /* and do the same for selection, if we handle it */
6638 if ( lpLVItem
->stateMask
& ~infoPtr
->uCallbackMask
& LVIS_SELECTED
)
6640 lpLVItem
->state
&= ~LVIS_SELECTED
;
6641 if (ranges_contain(infoPtr
->selectionRanges
, lpLVItem
->iItem
))
6642 lpLVItem
->state
|= LVIS_SELECTED
;
6648 /* find the item and subitem structures before we proceed */
6649 hdpaSubItems
= DPA_GetPtr(infoPtr
->hdpaItems
, lpLVItem
->iItem
);
6650 lpItem
= DPA_GetPtr(hdpaSubItems
, 0);
6655 SUBITEM_INFO
*lpSubItem
= LISTVIEW_GetSubItemPtr(hdpaSubItems
, isubitem
);
6656 pItemHdr
= lpSubItem
? &lpSubItem
->hdr
: &callbackHdr
;
6659 WARN(" iSubItem invalid (%08x), ignored.\n", isubitem
);
6664 pItemHdr
= &lpItem
->hdr
;
6666 /* Do we need to query the state from the app? */
6667 if ((lpLVItem
->mask
& LVIF_STATE
) && infoPtr
->uCallbackMask
&& isubitem
== 0)
6669 dispInfo
.item
.mask
|= LVIF_STATE
;
6670 dispInfo
.item
.stateMask
= infoPtr
->uCallbackMask
;
6673 /* Do we need to enquire about the image? */
6674 if ((lpLVItem
->mask
& LVIF_IMAGE
) && pItemHdr
->iImage
== I_IMAGECALLBACK
&&
6675 (isubitem
== 0 || (infoPtr
->dwLvExStyle
& LVS_EX_SUBITEMIMAGES
)))
6677 dispInfo
.item
.mask
|= LVIF_IMAGE
;
6678 dispInfo
.item
.iImage
= I_IMAGECALLBACK
;
6681 /* Only items support indentation */
6682 if ((lpLVItem
->mask
& LVIF_INDENT
) && lpItem
->iIndent
== I_INDENTCALLBACK
&&
6685 dispInfo
.item
.mask
|= LVIF_INDENT
;
6686 dispInfo
.item
.iIndent
= I_INDENTCALLBACK
;
6689 /* Apps depend on calling back for text if it is NULL or LPSTR_TEXTCALLBACKW */
6690 if ((lpLVItem
->mask
& LVIF_TEXT
) && !(lpLVItem
->mask
& LVIF_NORECOMPUTE
) &&
6691 !is_text(pItemHdr
->pszText
))
6693 dispInfo
.item
.mask
|= LVIF_TEXT
;
6694 dispInfo
.item
.pszText
= lpLVItem
->pszText
;
6695 dispInfo
.item
.cchTextMax
= lpLVItem
->cchTextMax
;
6696 if (dispInfo
.item
.pszText
&& dispInfo
.item
.cchTextMax
> 0)
6697 *dispInfo
.item
.pszText
= '\0';
6700 /* If we don't have all the requested info, query the application */
6701 if (dispInfo
.item
.mask
)
6703 dispInfo
.item
.iItem
= lpLVItem
->iItem
;
6704 dispInfo
.item
.iSubItem
= lpLVItem
->iSubItem
; /* yes: the original subitem */
6705 dispInfo
.item
.lParam
= lpItem
->lParam
;
6706 notify_dispinfoT(infoPtr
, LVN_GETDISPINFOW
, &dispInfo
, isW
);
6707 TRACE(" getdispinfo(2):item=%s\n", debuglvitem_t(&dispInfo
.item
, isW
));
6710 /* we should not store values for subitems */
6711 if (isubitem
) dispInfo
.item
.mask
&= ~LVIF_DI_SETITEM
;
6713 /* Now, handle the iImage field */
6714 if (dispInfo
.item
.mask
& LVIF_IMAGE
)
6716 lpLVItem
->iImage
= dispInfo
.item
.iImage
;
6717 if ((dispInfo
.item
.mask
& LVIF_DI_SETITEM
) && pItemHdr
->iImage
== I_IMAGECALLBACK
)
6718 pItemHdr
->iImage
= dispInfo
.item
.iImage
;
6720 else if (lpLVItem
->mask
& LVIF_IMAGE
)
6722 if(isubitem
== 0 || (infoPtr
->dwLvExStyle
& LVS_EX_SUBITEMIMAGES
))
6723 lpLVItem
->iImage
= pItemHdr
->iImage
;
6725 lpLVItem
->iImage
= 0;
6728 /* The pszText field */
6729 if (dispInfo
.item
.mask
& LVIF_TEXT
)
6731 if ((dispInfo
.item
.mask
& LVIF_DI_SETITEM
) && pItemHdr
->pszText
)
6732 textsetptrT(&pItemHdr
->pszText
, dispInfo
.item
.pszText
, isW
);
6734 lpLVItem
->pszText
= dispInfo
.item
.pszText
;
6736 else if (lpLVItem
->mask
& LVIF_TEXT
)
6738 /* if LVN_GETDISPINFO's disabled with LVIF_NORECOMPUTE return callback placeholder */
6739 if (isW
|| !is_text(pItemHdr
->pszText
)) lpLVItem
->pszText
= pItemHdr
->pszText
;
6740 else textcpynT(lpLVItem
->pszText
, isW
, pItemHdr
->pszText
, TRUE
, lpLVItem
->cchTextMax
);
6743 /* Next is the lParam field */
6744 if (dispInfo
.item
.mask
& LVIF_PARAM
)
6746 lpLVItem
->lParam
= dispInfo
.item
.lParam
;
6747 if ((dispInfo
.item
.mask
& LVIF_DI_SETITEM
))
6748 lpItem
->lParam
= dispInfo
.item
.lParam
;
6750 else if (lpLVItem
->mask
& LVIF_PARAM
)
6751 lpLVItem
->lParam
= lpItem
->lParam
;
6753 /* if this is a subitem, we're done */
6754 if (isubitem
) return TRUE
;
6756 /* ... the state field (this one is different due to uCallbackmask) */
6757 if (lpLVItem
->mask
& LVIF_STATE
)
6759 lpLVItem
->state
= lpItem
->state
& lpLVItem
->stateMask
;
6760 if (dispInfo
.item
.mask
& LVIF_STATE
)
6762 lpLVItem
->state
&= ~dispInfo
.item
.stateMask
;
6763 lpLVItem
->state
|= (dispInfo
.item
.state
& dispInfo
.item
.stateMask
);
6765 if ( lpLVItem
->stateMask
& ~infoPtr
->uCallbackMask
& LVIS_FOCUSED
)
6767 lpLVItem
->state
&= ~LVIS_FOCUSED
;
6768 if (infoPtr
->nFocusedItem
== lpLVItem
->iItem
)
6769 lpLVItem
->state
|= LVIS_FOCUSED
;
6771 if ( lpLVItem
->stateMask
& ~infoPtr
->uCallbackMask
& LVIS_SELECTED
)
6773 lpLVItem
->state
&= ~LVIS_SELECTED
;
6774 if (ranges_contain(infoPtr
->selectionRanges
, lpLVItem
->iItem
))
6775 lpLVItem
->state
|= LVIS_SELECTED
;
6779 /* and last, but not least, the indent field */
6780 if (dispInfo
.item
.mask
& LVIF_INDENT
)
6782 lpLVItem
->iIndent
= dispInfo
.item
.iIndent
;
6783 if ((dispInfo
.item
.mask
& LVIF_DI_SETITEM
) && lpItem
->iIndent
== I_INDENTCALLBACK
)
6784 lpItem
->iIndent
= dispInfo
.item
.iIndent
;
6786 else if (lpLVItem
->mask
& LVIF_INDENT
)
6788 lpLVItem
->iIndent
= lpItem
->iIndent
;
6796 * Retrieves item attributes.
6799 * [I] hwnd : window handle
6800 * [IO] lpLVItem : item info
6801 * [I] isW : if TRUE, then lpLVItem is a LPLVITEMW,
6802 * if FALSE, then lpLVItem is a LPLVITEMA.
6805 * This is the external 'GetItem' interface -- it properly copies
6806 * the text in the provided buffer.
6812 static BOOL
LISTVIEW_GetItemExtT(const LISTVIEW_INFO
*infoPtr
, LPLVITEMW lpLVItem
, BOOL isW
)
6817 if (!lpLVItem
|| lpLVItem
->iItem
< 0 || lpLVItem
->iItem
>= infoPtr
->nItemCount
)
6820 pszText
= lpLVItem
->pszText
;
6821 bResult
= LISTVIEW_GetItemT(infoPtr
, lpLVItem
, isW
);
6822 if (bResult
&& (lpLVItem
->mask
& LVIF_TEXT
) && lpLVItem
->pszText
!= pszText
)
6824 if (lpLVItem
->pszText
!= LPSTR_TEXTCALLBACKW
)
6825 textcpynT(pszText
, isW
, lpLVItem
->pszText
, isW
, lpLVItem
->cchTextMax
);
6827 pszText
= LPSTR_TEXTCALLBACKW
;
6829 lpLVItem
->pszText
= pszText
;
6837 * Retrieves the position (upper-left) of the listview control item.
6838 * Note that for LVS_ICON style, the upper-left is that of the icon
6839 * and not the bounding box.
6842 * [I] infoPtr : valid pointer to the listview structure
6843 * [I] nItem : item index
6844 * [O] lpptPosition : coordinate information
6850 static BOOL
LISTVIEW_GetItemPosition(const LISTVIEW_INFO
*infoPtr
, INT nItem
, LPPOINT lpptPosition
)
6854 TRACE("(nItem=%d, lpptPosition=%p)\n", nItem
, lpptPosition
);
6856 if (!lpptPosition
|| nItem
< 0 || nItem
>= infoPtr
->nItemCount
) return FALSE
;
6858 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
6859 LISTVIEW_GetItemOrigin(infoPtr
, nItem
, lpptPosition
);
6861 if (infoPtr
->uView
== LV_VIEW_ICON
)
6863 lpptPosition
->x
+= (infoPtr
->nItemWidth
- infoPtr
->iconSize
.cx
) / 2;
6864 lpptPosition
->y
+= ICON_TOP_PADDING
;
6866 lpptPosition
->x
+= Origin
.x
;
6867 lpptPosition
->y
+= Origin
.y
;
6869 TRACE (" lpptPosition=%s\n", wine_dbgstr_point(lpptPosition
));
6876 * Retrieves the bounding rectangle for a listview control item.
6879 * [I] infoPtr : valid pointer to the listview structure
6880 * [I] nItem : item index
6881 * [IO] lprc : bounding rectangle coordinates
6882 * lprc->left specifies the portion of the item for which the bounding
6883 * rectangle will be retrieved.
6885 * LVIR_BOUNDS Returns the bounding rectangle of the entire item,
6886 * including the icon and label.
6889 * * Experiment shows that native control returns:
6890 * * width = min (48, length of text line)
6891 * * .left = position.x - (width - iconsize.cx)/2
6892 * * .right = .left + width
6893 * * height = #lines of text * ntmHeight + icon height + 8
6894 * * .top = position.y - 2
6895 * * .bottom = .top + height
6896 * * separation between items .y = itemSpacing.cy - height
6897 * * .x = itemSpacing.cx - width
6898 * LVIR_ICON Returns the bounding rectangle of the icon or small icon.
6901 * * Experiment shows that native control returns:
6902 * * width = iconSize.cx + 16
6903 * * .left = position.x - (width - iconsize.cx)/2
6904 * * .right = .left + width
6905 * * height = iconSize.cy + 4
6906 * * .top = position.y - 2
6907 * * .bottom = .top + height
6908 * * separation between items .y = itemSpacing.cy - height
6909 * * .x = itemSpacing.cx - width
6910 * LVIR_LABEL Returns the bounding rectangle of the item text.
6913 * * Experiment shows that native control returns:
6914 * * width = text length
6915 * * .left = position.x - width/2
6916 * * .right = .left + width
6917 * * height = ntmH * linecount + 2
6918 * * .top = position.y + iconSize.cy + 6
6919 * * .bottom = .top + height
6920 * * separation between items .y = itemSpacing.cy - height
6921 * * .x = itemSpacing.cx - width
6922 * LVIR_SELECTBOUNDS Returns the union of the LVIR_ICON and LVIR_LABEL
6923 * rectangles, but excludes columns in report view.
6930 * Note that the bounding rectangle of the label in the LVS_ICON view depends
6931 * upon whether the window has the focus currently and on whether the item
6932 * is the one with the focus. Ensure that the control's record of which
6933 * item has the focus agrees with the items' records.
6935 static BOOL
LISTVIEW_GetItemRect(const LISTVIEW_INFO
*infoPtr
, INT nItem
, LPRECT lprc
)
6937 WCHAR szDispText
[DISP_TEXT_SIZE
] = { '\0' };
6938 BOOL doLabel
= TRUE
, oversizedBox
= FALSE
;
6939 POINT Position
, Origin
;
6943 TRACE("(hwnd=%p, nItem=%d, lprc=%p)\n", infoPtr
->hwndSelf
, nItem
, lprc
);
6945 if (!lprc
|| nItem
< 0 || nItem
>= infoPtr
->nItemCount
) return FALSE
;
6947 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
6948 LISTVIEW_GetItemOrigin(infoPtr
, nItem
, &Position
);
6950 /* Be smart and try to figure out the minimum we have to do */
6951 if (lprc
->left
== LVIR_ICON
) doLabel
= FALSE
;
6952 if (infoPtr
->uView
== LV_VIEW_DETAILS
&& lprc
->left
== LVIR_BOUNDS
) doLabel
= FALSE
;
6953 if (infoPtr
->uView
== LV_VIEW_ICON
&& lprc
->left
!= LVIR_ICON
&&
6954 infoPtr
->bFocus
&& LISTVIEW_GetItemState(infoPtr
, nItem
, LVIS_FOCUSED
))
6955 oversizedBox
= TRUE
;
6957 /* get what we need from the item before hand, so we make
6958 * only one request. This can speed up things, if data
6959 * is stored on the app side */
6961 if (infoPtr
->uView
== LV_VIEW_DETAILS
) lvItem
.mask
|= LVIF_INDENT
;
6962 if (doLabel
) lvItem
.mask
|= LVIF_TEXT
;
6963 lvItem
.iItem
= nItem
;
6964 lvItem
.iSubItem
= 0;
6965 lvItem
.pszText
= szDispText
;
6966 lvItem
.cchTextMax
= DISP_TEXT_SIZE
;
6967 if (lvItem
.mask
&& !LISTVIEW_GetItemW(infoPtr
, &lvItem
)) return FALSE
;
6968 /* we got the state already up, simulate it here, to avoid a reget */
6969 if (infoPtr
->uView
== LV_VIEW_ICON
&& (lprc
->left
!= LVIR_ICON
))
6971 lvItem
.mask
|= LVIF_STATE
;
6972 lvItem
.stateMask
= LVIS_FOCUSED
;
6973 lvItem
.state
= (oversizedBox
? LVIS_FOCUSED
: 0);
6976 if (infoPtr
->uView
== LV_VIEW_DETAILS
&& (infoPtr
->dwLvExStyle
& LVS_EX_FULLROWSELECT
) && lprc
->left
== LVIR_SELECTBOUNDS
)
6977 lprc
->left
= LVIR_BOUNDS
;
6983 LISTVIEW_GetItemMetrics(infoPtr
, &lvItem
, NULL
, NULL
, lprc
, NULL
, NULL
);
6987 LISTVIEW_GetItemMetrics(infoPtr
, &lvItem
, NULL
, NULL
, NULL
, NULL
, lprc
);
6991 LISTVIEW_GetItemMetrics(infoPtr
, &lvItem
, lprc
, NULL
, NULL
, NULL
, NULL
);
6994 case LVIR_SELECTBOUNDS
:
6995 LISTVIEW_GetItemMetrics(infoPtr
, &lvItem
, NULL
, lprc
, NULL
, NULL
, NULL
);
6999 WARN("Unknown value: %d\n", lprc
->left
);
7003 if (infoPtr
->uView
== LV_VIEW_DETAILS
)
7005 if (mode
!= LVIR_BOUNDS
)
7006 OffsetRect(lprc
, Origin
.x
+ LISTVIEW_GetColumnInfo(infoPtr
, 0)->rcHeader
.left
,
7007 Position
.y
+ Origin
.y
);
7009 OffsetRect(lprc
, Origin
.x
, Position
.y
+ Origin
.y
);
7012 OffsetRect(lprc
, Position
.x
+ Origin
.x
, Position
.y
+ Origin
.y
);
7014 TRACE(" rect=%s\n", wine_dbgstr_rect(lprc
));
7021 * Retrieves the spacing between listview control items.
7024 * [I] infoPtr : valid pointer to the listview structure
7025 * [IO] lprc : rectangle to receive the output
7026 * on input, lprc->top = nSubItem
7027 * lprc->left = LVIR_ICON | LVIR_BOUNDS | LVIR_LABEL
7029 * NOTE: for subItem = 0, we should return the bounds of the _entire_ item,
7030 * not only those of the first column.
7031 * Fortunately, LISTVIEW_GetItemMetrics does the right thing.
7037 static BOOL
LISTVIEW_GetSubItemRect(const LISTVIEW_INFO
*infoPtr
, INT nItem
, LPRECT lprc
)
7039 POINT Position
, Origin
;
7043 if (!lprc
) return FALSE
;
7045 nColumn
= lprc
->top
;
7047 TRACE("(nItem=%d, nSubItem=%d, type=%d)\n", nItem
, lprc
->top
, lprc
->left
);
7048 /* On WinNT, a subitem of '0' calls LISTVIEW_GetItemRect */
7050 return LISTVIEW_GetItemRect(infoPtr
, nItem
, lprc
);
7052 if (infoPtr
->uView
!= LV_VIEW_DETAILS
) return FALSE
;
7054 /* special case for header items */
7057 if (lprc
->left
!= LVIR_BOUNDS
)
7059 FIXME("Only LVIR_BOUNDS is implemented for header, got %d\n", lprc
->left
);
7063 if (infoPtr
->hwndHeader
)
7064 return SendMessageW(infoPtr
->hwndHeader
, HDM_GETITEMRECT
, lprc
->top
, (LPARAM
)lprc
);
7067 memset(lprc
, 0, sizeof(RECT
));
7072 if (!LISTVIEW_GetItemPosition(infoPtr
, nItem
, &Position
)) return FALSE
;
7073 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
7075 if (nColumn
< 0 || nColumn
>= DPA_GetPtrCount(infoPtr
->hdpaColumns
)) return FALSE
;
7078 lvItem
.iItem
= nItem
;
7079 lvItem
.iSubItem
= nColumn
;
7084 LISTVIEW_GetItemMetrics(infoPtr
, &lvItem
, NULL
, NULL
, lprc
, NULL
, NULL
);
7089 LISTVIEW_GetItemMetrics(infoPtr
, &lvItem
, lprc
, NULL
, NULL
, NULL
, NULL
);
7093 ERR("Unknown bounds=%d\n", lprc
->left
);
7097 OffsetRect(lprc
, Origin
.x
, Position
.y
);
7098 TRACE("return rect %s\n", wine_dbgstr_rect(lprc
));
7105 * Retrieves the spacing between listview control items.
7108 * [I] infoPtr : valid pointer to the listview structure
7109 * [I] bSmall : flag for small or large icon
7112 * Horizontal + vertical spacing
7114 static LONG
LISTVIEW_GetItemSpacing(const LISTVIEW_INFO
*infoPtr
, BOOL bSmall
)
7120 lResult
= MAKELONG(infoPtr
->iconSpacing
.cx
, infoPtr
->iconSpacing
.cy
);
7124 if (infoPtr
->uView
== LV_VIEW_ICON
)
7125 lResult
= MAKELONG(DEFAULT_COLUMN_WIDTH
, GetSystemMetrics(SM_CXSMICON
)+HEIGHT_PADDING
);
7127 lResult
= MAKELONG(infoPtr
->nItemWidth
, infoPtr
->nItemHeight
);
7134 * Retrieves the state of a listview control item.
7137 * [I] infoPtr : valid pointer to the listview structure
7138 * [I] nItem : item index
7139 * [I] uMask : state mask
7142 * State specified by the mask.
7144 static UINT
LISTVIEW_GetItemState(const LISTVIEW_INFO
*infoPtr
, INT nItem
, UINT uMask
)
7148 if (nItem
< 0 || nItem
>= infoPtr
->nItemCount
) return 0;
7150 lvItem
.iItem
= nItem
;
7151 lvItem
.iSubItem
= 0;
7152 lvItem
.mask
= LVIF_STATE
;
7153 lvItem
.stateMask
= uMask
;
7154 if (!LISTVIEW_GetItemW(infoPtr
, &lvItem
)) return 0;
7156 return lvItem
.state
& uMask
;
7161 * Retrieves the text of a listview control item or subitem.
7164 * [I] hwnd : window handle
7165 * [I] nItem : item index
7166 * [IO] lpLVItem : item information
7167 * [I] isW : TRUE if lpLVItem is Unicode
7170 * SUCCESS : string length
7173 static INT
LISTVIEW_GetItemTextT(const LISTVIEW_INFO
*infoPtr
, INT nItem
, LPLVITEMW lpLVItem
, BOOL isW
)
7175 if (!lpLVItem
|| nItem
< 0 || nItem
>= infoPtr
->nItemCount
) return 0;
7177 lpLVItem
->mask
= LVIF_TEXT
;
7178 lpLVItem
->iItem
= nItem
;
7179 if (!LISTVIEW_GetItemExtT(infoPtr
, lpLVItem
, isW
)) return 0;
7181 return textlenT(lpLVItem
->pszText
, isW
);
7186 * Searches for an item based on properties + relationships.
7189 * [I] infoPtr : valid pointer to the listview structure
7190 * [I] nItem : item index
7191 * [I] uFlags : relationship flag
7194 * SUCCESS : item index
7197 static INT
LISTVIEW_GetNextItem(const LISTVIEW_INFO
*infoPtr
, INT nItem
, UINT uFlags
)
7200 LVFINDINFOW lvFindInfo
;
7201 INT nCountPerColumn
;
7205 TRACE("nItem=%d, uFlags=%x, nItemCount=%d\n", nItem
, uFlags
, infoPtr
->nItemCount
);
7206 if (nItem
< -1 || nItem
>= infoPtr
->nItemCount
) return -1;
7208 ZeroMemory(&lvFindInfo
, sizeof(lvFindInfo
));
7210 if (uFlags
& LVNI_CUT
)
7213 if (uFlags
& LVNI_DROPHILITED
)
7214 uMask
|= LVIS_DROPHILITED
;
7216 if (uFlags
& LVNI_FOCUSED
)
7217 uMask
|= LVIS_FOCUSED
;
7219 if (uFlags
& LVNI_SELECTED
)
7220 uMask
|= LVIS_SELECTED
;
7222 /* if we're asked for the focused item, that's only one,
7223 * so it's worth optimizing */
7224 if (uFlags
& LVNI_FOCUSED
)
7226 if ((LISTVIEW_GetItemState(infoPtr
, infoPtr
->nFocusedItem
, uMask
) & uMask
) != uMask
) return -1;
7227 return (infoPtr
->nFocusedItem
== nItem
) ? -1 : infoPtr
->nFocusedItem
;
7230 if (uFlags
& LVNI_ABOVE
)
7232 if ((infoPtr
->uView
== LV_VIEW_LIST
) || (infoPtr
->uView
== LV_VIEW_DETAILS
))
7237 if ((LISTVIEW_GetItemState(infoPtr
, nItem
, uMask
) & uMask
) == uMask
)
7243 /* Special case for autoarrange - move 'til the top of a list */
7244 if (is_autoarrange(infoPtr
))
7246 nCountPerRow
= LISTVIEW_GetCountPerRow(infoPtr
);
7247 while (nItem
- nCountPerRow
>= 0)
7249 nItem
-= nCountPerRow
;
7250 if ((LISTVIEW_GetItemState(infoPtr
, nItem
, uMask
) & uMask
) == uMask
)
7255 lvFindInfo
.flags
= LVFI_NEARESTXY
;
7256 lvFindInfo
.vkDirection
= VK_UP
;
7257 LISTVIEW_GetItemPosition(infoPtr
, nItem
, &lvFindInfo
.pt
);
7258 while ((nItem
= LISTVIEW_FindItemW(infoPtr
, nItem
, &lvFindInfo
)) != -1)
7260 if ((LISTVIEW_GetItemState(infoPtr
, nItem
, uMask
) & uMask
) == uMask
)
7265 else if (uFlags
& LVNI_BELOW
)
7267 if ((infoPtr
->uView
== LV_VIEW_LIST
) || (infoPtr
->uView
== LV_VIEW_DETAILS
))
7269 while (nItem
< infoPtr
->nItemCount
)
7272 if ((LISTVIEW_GetItemState(infoPtr
, nItem
, uMask
) & uMask
) == uMask
)
7278 /* Special case for autoarrange - move 'til the bottom of a list */
7279 if (is_autoarrange(infoPtr
))
7281 nCountPerRow
= LISTVIEW_GetCountPerRow(infoPtr
);
7282 while (nItem
+ nCountPerRow
< infoPtr
->nItemCount
)
7284 nItem
+= nCountPerRow
;
7285 if ((LISTVIEW_GetItemState(infoPtr
, nItem
, uMask
) & uMask
) == uMask
)
7290 lvFindInfo
.flags
= LVFI_NEARESTXY
;
7291 lvFindInfo
.vkDirection
= VK_DOWN
;
7292 LISTVIEW_GetItemPosition(infoPtr
, nItem
, &lvFindInfo
.pt
);
7293 while ((nItem
= LISTVIEW_FindItemW(infoPtr
, nItem
, &lvFindInfo
)) != -1)
7295 if ((LISTVIEW_GetItemState(infoPtr
, nItem
, uMask
) & uMask
) == uMask
)
7300 else if (uFlags
& LVNI_TOLEFT
)
7302 if (infoPtr
->uView
== LV_VIEW_LIST
)
7304 nCountPerColumn
= LISTVIEW_GetCountPerColumn(infoPtr
);
7305 while (nItem
- nCountPerColumn
>= 0)
7307 nItem
-= nCountPerColumn
;
7308 if ((LISTVIEW_GetItemState(infoPtr
, nItem
, uMask
) & uMask
) == uMask
)
7312 else if ((infoPtr
->uView
== LV_VIEW_SMALLICON
) || (infoPtr
->uView
== LV_VIEW_ICON
))
7314 /* Special case for autoarrange - move 'til the beginning of a row */
7315 if (is_autoarrange(infoPtr
))
7317 nCountPerRow
= LISTVIEW_GetCountPerRow(infoPtr
);
7318 while (nItem
% nCountPerRow
> 0)
7321 if ((LISTVIEW_GetItemState(infoPtr
, nItem
, uMask
) & uMask
) == uMask
)
7326 lvFindInfo
.flags
= LVFI_NEARESTXY
;
7327 lvFindInfo
.vkDirection
= VK_LEFT
;
7328 LISTVIEW_GetItemPosition(infoPtr
, nItem
, &lvFindInfo
.pt
);
7329 while ((nItem
= LISTVIEW_FindItemW(infoPtr
, nItem
, &lvFindInfo
)) != -1)
7331 if ((LISTVIEW_GetItemState(infoPtr
, nItem
, uMask
) & uMask
) == uMask
)
7336 else if (uFlags
& LVNI_TORIGHT
)
7338 if (infoPtr
->uView
== LV_VIEW_LIST
)
7340 nCountPerColumn
= LISTVIEW_GetCountPerColumn(infoPtr
);
7341 while (nItem
+ nCountPerColumn
< infoPtr
->nItemCount
)
7343 nItem
+= nCountPerColumn
;
7344 if ((LISTVIEW_GetItemState(infoPtr
, nItem
, uMask
) & uMask
) == uMask
)
7348 else if ((infoPtr
->uView
== LV_VIEW_SMALLICON
) || (infoPtr
->uView
== LV_VIEW_ICON
))
7350 /* Special case for autoarrange - move 'til the end of a row */
7351 if (is_autoarrange(infoPtr
))
7353 nCountPerRow
= LISTVIEW_GetCountPerRow(infoPtr
);
7354 while (nItem
% nCountPerRow
< nCountPerRow
- 1 )
7357 if ((LISTVIEW_GetItemState(infoPtr
, nItem
, uMask
) & uMask
) == uMask
)
7362 lvFindInfo
.flags
= LVFI_NEARESTXY
;
7363 lvFindInfo
.vkDirection
= VK_RIGHT
;
7364 LISTVIEW_GetItemPosition(infoPtr
, nItem
, &lvFindInfo
.pt
);
7365 while ((nItem
= LISTVIEW_FindItemW(infoPtr
, nItem
, &lvFindInfo
)) != -1)
7367 if ((LISTVIEW_GetItemState(infoPtr
, nItem
, uMask
) & uMask
) == uMask
)
7376 /* search by index */
7377 for (i
= nItem
; i
< infoPtr
->nItemCount
; i
++)
7379 if ((LISTVIEW_GetItemState(infoPtr
, i
, uMask
) & uMask
) == uMask
)
7387 /* LISTVIEW_GetNumberOfWorkAreas */
7391 * Retrieves the origin coordinates when in icon or small icon display mode.
7394 * [I] infoPtr : valid pointer to the listview structure
7395 * [O] lpptOrigin : coordinate information
7400 static void LISTVIEW_GetOrigin(const LISTVIEW_INFO
*infoPtr
, LPPOINT lpptOrigin
)
7402 INT nHorzPos
= 0, nVertPos
= 0;
7403 SCROLLINFO scrollInfo
;
7405 scrollInfo
.cbSize
= sizeof(SCROLLINFO
);
7406 scrollInfo
.fMask
= SIF_POS
;
7408 if (GetScrollInfo(infoPtr
->hwndSelf
, SB_HORZ
, &scrollInfo
))
7409 nHorzPos
= scrollInfo
.nPos
;
7410 if (GetScrollInfo(infoPtr
->hwndSelf
, SB_VERT
, &scrollInfo
))
7411 nVertPos
= scrollInfo
.nPos
;
7413 TRACE("nHorzPos=%d, nVertPos=%d\n", nHorzPos
, nVertPos
);
7415 lpptOrigin
->x
= infoPtr
->rcList
.left
;
7416 lpptOrigin
->y
= infoPtr
->rcList
.top
;
7417 if (infoPtr
->uView
== LV_VIEW_LIST
)
7418 nHorzPos
*= infoPtr
->nItemWidth
;
7419 else if (infoPtr
->uView
== LV_VIEW_DETAILS
)
7420 nVertPos
*= infoPtr
->nItemHeight
;
7422 lpptOrigin
->x
-= nHorzPos
;
7423 lpptOrigin
->y
-= nVertPos
;
7425 TRACE(" origin=%s\n", wine_dbgstr_point(lpptOrigin
));
7430 * Retrieves the width of a string.
7433 * [I] hwnd : window handle
7434 * [I] lpszText : text string to process
7435 * [I] isW : TRUE if lpszText is Unicode, FALSE otherwise
7438 * SUCCESS : string width (in pixels)
7441 static INT
LISTVIEW_GetStringWidthT(const LISTVIEW_INFO
*infoPtr
, LPCWSTR lpszText
, BOOL isW
)
7446 if (is_text(lpszText
))
7448 HFONT hFont
= infoPtr
->hFont
? infoPtr
->hFont
: infoPtr
->hDefaultFont
;
7449 HDC hdc
= GetDC(infoPtr
->hwndSelf
);
7450 HFONT hOldFont
= SelectObject(hdc
, hFont
);
7453 GetTextExtentPointW(hdc
, lpszText
, lstrlenW(lpszText
), &stringSize
);
7455 GetTextExtentPointA(hdc
, (LPCSTR
)lpszText
, lstrlenA((LPCSTR
)lpszText
), &stringSize
);
7456 SelectObject(hdc
, hOldFont
);
7457 ReleaseDC(infoPtr
->hwndSelf
, hdc
);
7459 return stringSize
.cx
;
7464 * Determines which listview item is located at the specified position.
7467 * [I] infoPtr : valid pointer to the listview structure
7468 * [IO] lpht : hit test information
7469 * [I] subitem : fill out iSubItem.
7470 * [I] select : return the index only if the hit selects the item
7473 * (mm 20001022): We must not allow iSubItem to be touched, for
7474 * an app might pass only a structure with space up to iItem!
7475 * (MS Office 97 does that for instance in the file open dialog)
7478 * SUCCESS : item index
7481 static INT
LISTVIEW_HitTest(const LISTVIEW_INFO
*infoPtr
, LPLVHITTESTINFO lpht
, BOOL subitem
, BOOL select
)
7483 WCHAR szDispText
[DISP_TEXT_SIZE
] = { '\0' };
7484 RECT rcBox
, rcBounds
, rcState
, rcIcon
, rcLabel
, rcSearch
;
7485 POINT Origin
, Position
, opt
;
7490 TRACE("(pt=%s, subitem=%d, select=%d)\n", wine_dbgstr_point(&lpht
->pt
), subitem
, select
);
7494 if (subitem
) lpht
->iSubItem
= 0;
7496 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
7498 /* set whole list relation flags */
7499 if (subitem
&& infoPtr
->uView
== LV_VIEW_DETAILS
)
7501 /* LVM_SUBITEMHITTEST checks left bound of possible client area */
7502 if (infoPtr
->rcList
.left
> lpht
->pt
.x
&& Origin
.x
< lpht
->pt
.x
)
7503 lpht
->flags
|= LVHT_TOLEFT
;
7505 if (lpht
->pt
.y
< infoPtr
->rcList
.top
&& lpht
->pt
.y
>= 0)
7506 opt
.y
= lpht
->pt
.y
+ infoPtr
->rcList
.top
;
7510 if (infoPtr
->rcList
.bottom
< opt
.y
)
7511 lpht
->flags
|= LVHT_BELOW
;
7515 if (infoPtr
->rcList
.left
> lpht
->pt
.x
)
7516 lpht
->flags
|= LVHT_TOLEFT
;
7517 else if (infoPtr
->rcList
.right
< lpht
->pt
.x
)
7518 lpht
->flags
|= LVHT_TORIGHT
;
7520 if (infoPtr
->rcList
.top
> lpht
->pt
.y
)
7521 lpht
->flags
|= LVHT_ABOVE
;
7522 else if (infoPtr
->rcList
.bottom
< lpht
->pt
.y
)
7523 lpht
->flags
|= LVHT_BELOW
;
7526 /* even if item is invalid try to find subitem */
7527 if (infoPtr
->uView
== LV_VIEW_DETAILS
&& subitem
)
7532 opt
.x
= lpht
->pt
.x
- Origin
.x
;
7534 lpht
->iSubItem
= -1;
7535 for (j
= 0; j
< DPA_GetPtrCount(infoPtr
->hdpaColumns
); j
++)
7537 pRect
= &LISTVIEW_GetColumnInfo(infoPtr
, j
)->rcHeader
;
7539 if ((opt
.x
>= pRect
->left
) && (opt
.x
< pRect
->right
))
7545 TRACE("lpht->iSubItem=%d\n", lpht
->iSubItem
);
7547 /* if we're outside horizontal columns bounds there's nothing to test further */
7548 if (lpht
->iSubItem
== -1)
7551 lpht
->flags
= LVHT_NOWHERE
;
7556 TRACE("lpht->flags=0x%x\n", lpht
->flags
);
7557 if (lpht
->flags
) return -1;
7559 lpht
->flags
|= LVHT_NOWHERE
;
7561 /* first deal with the large items */
7562 rcSearch
.left
= lpht
->pt
.x
;
7563 rcSearch
.top
= lpht
->pt
.y
;
7564 rcSearch
.right
= rcSearch
.left
+ 1;
7565 rcSearch
.bottom
= rcSearch
.top
+ 1;
7567 iterator_frameditems(&i
, infoPtr
, &rcSearch
);
7568 iterator_next(&i
); /* go to first item in the sequence */
7570 iterator_destroy(&i
);
7572 TRACE("lpht->iItem=%d\n", iItem
);
7573 if (iItem
== -1) return -1;
7575 lvItem
.mask
= LVIF_STATE
| LVIF_TEXT
;
7576 if (infoPtr
->uView
== LV_VIEW_DETAILS
) lvItem
.mask
|= LVIF_INDENT
;
7577 lvItem
.stateMask
= LVIS_STATEIMAGEMASK
;
7578 if (infoPtr
->uView
== LV_VIEW_ICON
) lvItem
.stateMask
|= LVIS_FOCUSED
;
7579 lvItem
.iItem
= iItem
;
7580 lvItem
.iSubItem
= subitem
? lpht
->iSubItem
: 0;
7581 lvItem
.pszText
= szDispText
;
7582 lvItem
.cchTextMax
= DISP_TEXT_SIZE
;
7583 if (!LISTVIEW_GetItemW(infoPtr
, &lvItem
)) return -1;
7584 if (!infoPtr
->bFocus
) lvItem
.state
&= ~LVIS_FOCUSED
;
7586 LISTVIEW_GetItemMetrics(infoPtr
, &lvItem
, &rcBox
, NULL
, &rcIcon
, &rcState
, &rcLabel
);
7587 LISTVIEW_GetItemOrigin(infoPtr
, iItem
, &Position
);
7588 opt
.x
= lpht
->pt
.x
- Position
.x
- Origin
.x
;
7590 if (lpht
->pt
.y
< infoPtr
->rcList
.top
&& lpht
->pt
.y
>= 0)
7591 opt
.y
= lpht
->pt
.y
- Position
.y
- Origin
.y
+ infoPtr
->rcList
.top
;
7593 opt
.y
= lpht
->pt
.y
- Position
.y
- Origin
.y
;
7595 if (infoPtr
->uView
== LV_VIEW_DETAILS
)
7598 if (infoPtr
->dwLvExStyle
& LVS_EX_FULLROWSELECT
)
7599 opt
.x
= lpht
->pt
.x
- Origin
.x
;
7603 UnionRect(&rcBounds
, &rcIcon
, &rcLabel
);
7604 UnionRect(&rcBounds
, &rcBounds
, &rcState
);
7606 TRACE("rcBounds=%s\n", wine_dbgstr_rect(&rcBounds
));
7607 if (!PtInRect(&rcBounds
, opt
)) return -1;
7609 if (PtInRect(&rcIcon
, opt
))
7610 lpht
->flags
|= LVHT_ONITEMICON
;
7611 else if (PtInRect(&rcLabel
, opt
))
7612 lpht
->flags
|= LVHT_ONITEMLABEL
;
7613 else if (infoPtr
->himlState
&& PtInRect(&rcState
, opt
))
7614 lpht
->flags
|= LVHT_ONITEMSTATEICON
;
7615 /* special case for LVS_EX_FULLROWSELECT */
7616 if (infoPtr
->uView
== LV_VIEW_DETAILS
&& infoPtr
->dwLvExStyle
& LVS_EX_FULLROWSELECT
&&
7617 !(lpht
->flags
& LVHT_ONITEM
))
7619 lpht
->flags
= LVHT_ONITEM
| LVHT_ABOVE
;
7621 if (lpht
->flags
& LVHT_ONITEM
)
7622 lpht
->flags
&= ~LVHT_NOWHERE
;
7623 TRACE("lpht->flags=0x%x\n", lpht
->flags
);
7625 if (select
&& !(infoPtr
->uView
== LV_VIEW_DETAILS
&&
7626 ((infoPtr
->dwLvExStyle
& LVS_EX_FULLROWSELECT
) ||
7627 (infoPtr
->dwStyle
& LVS_OWNERDRAWFIXED
))))
7629 if (infoPtr
->uView
== LV_VIEW_DETAILS
)
7631 /* get main item bounds */
7632 lvItem
.iSubItem
= 0;
7633 LISTVIEW_GetItemMetrics(infoPtr
, &lvItem
, &rcBox
, NULL
, &rcIcon
, &rcState
, &rcLabel
);
7634 UnionRect(&rcBounds
, &rcIcon
, &rcLabel
);
7635 UnionRect(&rcBounds
, &rcBounds
, &rcState
);
7637 if (!PtInRect(&rcBounds
, opt
)) iItem
= -1;
7639 return lpht
->iItem
= iItem
;
7644 * Inserts a new item in the listview control.
7647 * [I] infoPtr : valid pointer to the listview structure
7648 * [I] lpLVItem : item information
7649 * [I] isW : TRUE if lpLVItem is Unicode, FALSE if it's ANSI
7652 * SUCCESS : new item index
7655 static INT
LISTVIEW_InsertItemT(LISTVIEW_INFO
*infoPtr
, const LVITEMW
*lpLVItem
, BOOL isW
)
7662 BOOL is_sorted
, has_changed
;
7664 HWND hwndSelf
= infoPtr
->hwndSelf
;
7666 TRACE("(lpLVItem=%s, isW=%d)\n", debuglvitem_t(lpLVItem
, isW
), isW
);
7668 if (infoPtr
->dwStyle
& LVS_OWNERDATA
) return infoPtr
->nItemCount
++;
7670 /* make sure it's an item, and not a subitem; cannot insert a subitem */
7671 if (!lpLVItem
|| lpLVItem
->iSubItem
) return -1;
7673 if (!is_assignable_item(lpLVItem
, infoPtr
->dwStyle
)) return -1;
7675 if (!(lpItem
= Alloc(sizeof(ITEM_INFO
)))) return -1;
7677 /* insert item in listview control data structure */
7678 if ( !(hdpaSubItems
= DPA_Create(8)) ) goto fail
;
7679 if ( !DPA_SetPtr(hdpaSubItems
, 0, lpItem
) ) assert (FALSE
);
7681 /* link with id struct */
7682 if (!(lpID
= Alloc(sizeof(ITEM_ID
)))) goto fail
;
7684 lpID
->item
= hdpaSubItems
;
7685 lpID
->id
= get_next_itemid(infoPtr
);
7686 if ( DPA_InsertPtr(infoPtr
->hdpaItemIds
, infoPtr
->nItemCount
, lpID
) == -1) goto fail
;
7688 is_sorted
= (infoPtr
->dwStyle
& (LVS_SORTASCENDING
| LVS_SORTDESCENDING
)) &&
7689 !(infoPtr
->dwStyle
& LVS_OWNERDRAWFIXED
) && (LPSTR_TEXTCALLBACKW
!= lpLVItem
->pszText
);
7691 if (lpLVItem
->iItem
< 0 && !is_sorted
) return -1;
7693 /* calculate new item index */
7700 while (i
< infoPtr
->nItemCount
)
7702 hItem
= DPA_GetPtr( infoPtr
->hdpaItems
, i
);
7703 item_s
= DPA_GetPtr(hItem
, 0);
7705 cmpv
= textcmpWT(item_s
->hdr
.pszText
, lpLVItem
->pszText
, isW
);
7706 if (infoPtr
->dwStyle
& LVS_SORTDESCENDING
) cmpv
*= -1;
7708 if (cmpv
>= 0) break;
7714 nItem
= min(lpLVItem
->iItem
, infoPtr
->nItemCount
);
7716 TRACE(" inserting at %d, sorted=%d, count=%d, iItem=%d\n", nItem
, is_sorted
, infoPtr
->nItemCount
, lpLVItem
->iItem
);
7717 nItem
= DPA_InsertPtr( infoPtr
->hdpaItems
, nItem
, hdpaSubItems
);
7718 if (nItem
== -1) goto fail
;
7719 infoPtr
->nItemCount
++;
7721 /* shift indices first so they don't get tangled */
7722 LISTVIEW_ShiftIndices(infoPtr
, nItem
, 1);
7724 /* set the item attributes */
7725 if (lpLVItem
->mask
& (LVIF_GROUPID
|LVIF_COLUMNS
))
7727 /* full size structure expected - _WIN32IE >= 0x560 */
7730 else if (lpLVItem
->mask
& LVIF_INDENT
)
7732 /* indent member expected - _WIN32IE >= 0x300 */
7733 memcpy(&item
, lpLVItem
, offsetof( LVITEMW
, iGroupId
));
7737 /* minimal structure expected */
7738 memcpy(&item
, lpLVItem
, offsetof( LVITEMW
, iIndent
));
7741 if (infoPtr
->dwLvExStyle
& LVS_EX_CHECKBOXES
)
7743 item
.mask
|= LVIF_STATE
;
7744 item
.stateMask
|= LVIS_STATEIMAGEMASK
;
7745 item
.state
&= ~LVIS_STATEIMAGEMASK
;
7746 item
.state
|= INDEXTOSTATEIMAGEMASK(1);
7748 if (!set_main_item(infoPtr
, &item
, TRUE
, isW
, &has_changed
)) goto undo
;
7750 /* make room for the position, if we are in the right mode */
7751 if ((infoPtr
->uView
== LV_VIEW_SMALLICON
) || (infoPtr
->uView
== LV_VIEW_ICON
))
7753 if (DPA_InsertPtr(infoPtr
->hdpaPosX
, nItem
, 0) == -1)
7755 if (DPA_InsertPtr(infoPtr
->hdpaPosY
, nItem
, 0) == -1)
7757 DPA_DeletePtr(infoPtr
->hdpaPosX
, nItem
);
7762 /* send LVN_INSERTITEM notification */
7763 ZeroMemory(&nmlv
, sizeof(NMLISTVIEW
));
7765 nmlv
.lParam
= lpItem
->lParam
;
7766 notify_listview(infoPtr
, LVN_INSERTITEM
, &nmlv
);
7767 if (!IsWindow(hwndSelf
))
7770 /* align items (set position of each item) */
7771 if (infoPtr
->uView
== LV_VIEW_SMALLICON
|| infoPtr
->uView
== LV_VIEW_ICON
)
7775 if (infoPtr
->dwStyle
& LVS_ALIGNLEFT
)
7776 LISTVIEW_NextIconPosLeft(infoPtr
, &pt
);
7778 LISTVIEW_NextIconPosTop(infoPtr
, &pt
);
7780 LISTVIEW_MoveIconTo(infoPtr
, nItem
, &pt
, TRUE
);
7783 /* now is the invalidation fun */
7784 LISTVIEW_ScrollOnInsert(infoPtr
, nItem
, 1);
7788 LISTVIEW_ShiftIndices(infoPtr
, nItem
, -1);
7789 DPA_DeletePtr(infoPtr
->hdpaItems
, nItem
);
7790 infoPtr
->nItemCount
--;
7792 DPA_DeletePtr(hdpaSubItems
, 0);
7793 DPA_Destroy (hdpaSubItems
);
7800 * Checks item visibility.
7803 * [I] infoPtr : valid pointer to the listview structure
7804 * [I] nFirst : item index to check for
7807 * Item visible : TRUE
7808 * Item invisible or failure : FALSE
7810 static BOOL
LISTVIEW_IsItemVisible(const LISTVIEW_INFO
*infoPtr
, INT nItem
)
7812 POINT Origin
, Position
;
7817 TRACE("nItem=%d\n", nItem
);
7819 if (nItem
< 0 || nItem
>= DPA_GetPtrCount(infoPtr
->hdpaItems
)) return FALSE
;
7821 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
7822 LISTVIEW_GetItemOrigin(infoPtr
, nItem
, &Position
);
7823 rcItem
.left
= Position
.x
+ Origin
.x
;
7824 rcItem
.top
= Position
.y
+ Origin
.y
;
7825 rcItem
.right
= rcItem
.left
+ infoPtr
->nItemWidth
;
7826 rcItem
.bottom
= rcItem
.top
+ infoPtr
->nItemHeight
;
7828 hdc
= GetDC(infoPtr
->hwndSelf
);
7829 if (!hdc
) return FALSE
;
7830 ret
= RectVisible(hdc
, &rcItem
);
7831 ReleaseDC(infoPtr
->hwndSelf
, hdc
);
7838 * Redraws a range of items.
7841 * [I] infoPtr : valid pointer to the listview structure
7842 * [I] nFirst : first item
7843 * [I] nLast : last item
7849 static BOOL
LISTVIEW_RedrawItems(const LISTVIEW_INFO
*infoPtr
, INT nFirst
, INT nLast
)
7853 if (nLast
< nFirst
|| min(nFirst
, nLast
) < 0 ||
7854 max(nFirst
, nLast
) >= infoPtr
->nItemCount
)
7857 for (i
= nFirst
; i
<= nLast
; i
++)
7858 LISTVIEW_InvalidateItem(infoPtr
, i
);
7865 * Scroll the content of a listview.
7868 * [I] infoPtr : valid pointer to the listview structure
7869 * [I] dx : horizontal scroll amount in pixels
7870 * [I] dy : vertical scroll amount in pixels
7877 * If the control is in report view (LV_VIEW_DETAILS) the control can
7878 * be scrolled only in line increments. "dy" will be rounded to the
7879 * nearest number of pixels that are a whole line. Ex: if line height
7880 * is 16 and an 8 is passed, the list will be scrolled by 16. If a 7
7881 * is passed, then the scroll will be 0. (per MSDN 7/2002)
7883 * For: (per experimentation with native control and CSpy ListView)
7884 * LV_VIEW_ICON scrolling in any direction is allowed
7885 * LV_VIEW_SMALLICON scrolling in any direction is allowed
7886 * LV_VIEW_LIST dx=1 = 1 column (horizontal only)
7887 * but will only scroll 1 column per message
7888 * no matter what the value.
7889 * dy must be 0 or FALSE returned.
7890 * LV_VIEW_DETAILS dx=1 = 1 pixel
7894 static BOOL
LISTVIEW_Scroll(LISTVIEW_INFO
*infoPtr
, INT dx
, INT dy
)
7896 switch(infoPtr
->uView
) {
7897 case LV_VIEW_DETAILS
:
7898 dy
+= (dy
< 0 ? -1 : 1) * infoPtr
->nItemHeight
/2;
7899 dy
/= infoPtr
->nItemHeight
;
7902 if (dy
!= 0) return FALSE
;
7908 if (dx
!= 0) LISTVIEW_HScroll(infoPtr
, SB_INTERNAL
, dx
);
7909 if (dy
!= 0) LISTVIEW_VScroll(infoPtr
, SB_INTERNAL
, dy
);
7916 * Sets the background color.
7919 * [I] infoPtr : valid pointer to the listview structure
7920 * [I] color : background color
7926 static BOOL
LISTVIEW_SetBkColor(LISTVIEW_INFO
*infoPtr
, COLORREF color
)
7928 TRACE("(color=%x)\n", color
);
7930 if(infoPtr
->clrBk
!= color
) {
7931 if (infoPtr
->clrBk
!= CLR_NONE
) DeleteObject(infoPtr
->hBkBrush
);
7932 infoPtr
->clrBk
= color
;
7933 if (color
== CLR_NONE
)
7934 infoPtr
->hBkBrush
= (HBRUSH
)GetClassLongPtrW(infoPtr
->hwndSelf
, GCLP_HBRBACKGROUND
);
7937 infoPtr
->hBkBrush
= CreateSolidBrush(color
);
7938 infoPtr
->dwLvExStyle
&= ~LVS_EX_TRANSPARENTBKGND
;
7945 /* LISTVIEW_SetBkImage */
7947 /*** Helper for {Insert,Set}ColumnT *only* */
7948 static void column_fill_hditem(const LISTVIEW_INFO
*infoPtr
, HDITEMW
*lphdi
, INT nColumn
,
7949 const LVCOLUMNW
*lpColumn
, BOOL isW
)
7951 if (lpColumn
->mask
& LVCF_FMT
)
7953 /* format member is valid */
7954 lphdi
->mask
|= HDI_FORMAT
;
7956 /* set text alignment (leftmost column must be left-aligned) */
7957 if (nColumn
== 0 || (lpColumn
->fmt
& LVCFMT_JUSTIFYMASK
) == LVCFMT_LEFT
)
7958 lphdi
->fmt
|= HDF_LEFT
;
7959 else if ((lpColumn
->fmt
& LVCFMT_JUSTIFYMASK
) == LVCFMT_RIGHT
)
7960 lphdi
->fmt
|= HDF_RIGHT
;
7961 else if ((lpColumn
->fmt
& LVCFMT_JUSTIFYMASK
) == LVCFMT_CENTER
)
7962 lphdi
->fmt
|= HDF_CENTER
;
7964 if (lpColumn
->fmt
& LVCFMT_BITMAP_ON_RIGHT
)
7965 lphdi
->fmt
|= HDF_BITMAP_ON_RIGHT
;
7967 if (lpColumn
->fmt
& LVCFMT_COL_HAS_IMAGES
)
7969 lphdi
->fmt
|= HDF_IMAGE
;
7970 lphdi
->iImage
= I_IMAGECALLBACK
;
7973 if (lpColumn
->fmt
& LVCFMT_FIXED_WIDTH
)
7974 lphdi
->fmt
|= HDF_FIXEDWIDTH
;
7977 if (lpColumn
->mask
& LVCF_WIDTH
)
7979 lphdi
->mask
|= HDI_WIDTH
;
7980 if(lpColumn
->cx
== LVSCW_AUTOSIZE_USEHEADER
)
7982 /* make it fill the remainder of the controls width */
7986 for(item_index
= 0; item_index
< (nColumn
- 1); item_index
++)
7988 LISTVIEW_GetHeaderRect(infoPtr
, item_index
, &rcHeader
);
7989 lphdi
->cxy
+= rcHeader
.right
- rcHeader
.left
;
7992 /* retrieve the layout of the header */
7993 GetClientRect(infoPtr
->hwndSelf
, &rcHeader
);
7994 TRACE("start cxy=%d rcHeader=%s\n", lphdi
->cxy
, wine_dbgstr_rect(&rcHeader
));
7996 lphdi
->cxy
= (rcHeader
.right
- rcHeader
.left
) - lphdi
->cxy
;
7999 lphdi
->cxy
= lpColumn
->cx
;
8002 if (lpColumn
->mask
& LVCF_TEXT
)
8004 lphdi
->mask
|= HDI_TEXT
| HDI_FORMAT
;
8005 lphdi
->fmt
|= HDF_STRING
;
8006 lphdi
->pszText
= lpColumn
->pszText
;
8007 lphdi
->cchTextMax
= textlenT(lpColumn
->pszText
, isW
);
8010 if (lpColumn
->mask
& LVCF_IMAGE
)
8012 lphdi
->mask
|= HDI_IMAGE
;
8013 lphdi
->iImage
= lpColumn
->iImage
;
8016 if (lpColumn
->mask
& LVCF_ORDER
)
8018 lphdi
->mask
|= HDI_ORDER
;
8019 lphdi
->iOrder
= lpColumn
->iOrder
;
8026 * Inserts a new column.
8029 * [I] infoPtr : valid pointer to the listview structure
8030 * [I] nColumn : column index
8031 * [I] lpColumn : column information
8032 * [I] isW : TRUE if lpColumn is Unicode, FALSE otherwise
8035 * SUCCESS : new column index
8038 static INT
LISTVIEW_InsertColumnT(LISTVIEW_INFO
*infoPtr
, INT nColumn
,
8039 const LVCOLUMNW
*lpColumn
, BOOL isW
)
8041 COLUMN_INFO
*lpColumnInfo
;
8045 TRACE("(nColumn=%d, lpColumn=%s, isW=%d)\n", nColumn
, debuglvcolumn_t(lpColumn
, isW
), isW
);
8047 if (!lpColumn
|| nColumn
< 0) return -1;
8048 nColumn
= min(nColumn
, DPA_GetPtrCount(infoPtr
->hdpaColumns
));
8050 ZeroMemory(&hdi
, sizeof(HDITEMW
));
8051 column_fill_hditem(infoPtr
, &hdi
, nColumn
, lpColumn
, isW
);
8054 * A mask not including LVCF_WIDTH turns into a mask of width, width 10
8055 * (can be seen in SPY) otherwise column never gets added.
8057 if (!(lpColumn
->mask
& LVCF_WIDTH
)) {
8058 hdi
.mask
|= HDI_WIDTH
;
8063 * when the iSubItem is available Windows copies it to the header lParam. It seems
8064 * to happen only in LVM_INSERTCOLUMN - not in LVM_SETCOLUMN
8066 if (lpColumn
->mask
& LVCF_SUBITEM
)
8068 hdi
.mask
|= HDI_LPARAM
;
8069 hdi
.lParam
= lpColumn
->iSubItem
;
8072 /* create header if not present */
8073 LISTVIEW_CreateHeader(infoPtr
);
8074 if (!(LVS_NOCOLUMNHEADER
& infoPtr
->dwStyle
) &&
8075 (infoPtr
->uView
== LV_VIEW_DETAILS
) && (WS_VISIBLE
& infoPtr
->dwStyle
))
8077 ShowWindow(infoPtr
->hwndHeader
, SW_SHOWNORMAL
);
8080 /* insert item in header control */
8081 nNewColumn
= SendMessageW(infoPtr
->hwndHeader
,
8082 isW
? HDM_INSERTITEMW
: HDM_INSERTITEMA
,
8083 nColumn
, (LPARAM
)&hdi
);
8084 if (nNewColumn
== -1) return -1;
8085 if (nNewColumn
!= nColumn
) ERR("nColumn=%d, nNewColumn=%d\n", nColumn
, nNewColumn
);
8087 /* create our own column info */
8088 if (!(lpColumnInfo
= Alloc(sizeof(COLUMN_INFO
)))) goto fail
;
8089 if (DPA_InsertPtr(infoPtr
->hdpaColumns
, nNewColumn
, lpColumnInfo
) == -1) goto fail
;
8091 if (lpColumn
->mask
& LVCF_FMT
) lpColumnInfo
->fmt
= lpColumn
->fmt
;
8092 if (lpColumn
->mask
& LVCF_MINWIDTH
) lpColumnInfo
->cxMin
= lpColumn
->cxMin
;
8093 if (!SendMessageW(infoPtr
->hwndHeader
, HDM_GETITEMRECT
, nNewColumn
, (LPARAM
)&lpColumnInfo
->rcHeader
))
8096 /* now we have to actually adjust the data */
8097 if (!(infoPtr
->dwStyle
& LVS_OWNERDATA
) && infoPtr
->nItemCount
> 0)
8099 SUBITEM_INFO
*lpSubItem
;
8105 item
.iSubItem
= nNewColumn
;
8106 item
.mask
= LVIF_TEXT
| LVIF_IMAGE
;
8107 item
.iImage
= I_IMAGECALLBACK
;
8108 item
.pszText
= LPSTR_TEXTCALLBACKW
;
8110 for (nItem
= 0; nItem
< infoPtr
->nItemCount
; nItem
++)
8112 hdpaSubItems
= DPA_GetPtr(infoPtr
->hdpaItems
, nItem
);
8113 for (i
= 1; i
< DPA_GetPtrCount(hdpaSubItems
); i
++)
8115 lpSubItem
= DPA_GetPtr(hdpaSubItems
, i
);
8116 if (lpSubItem
->iSubItem
>= nNewColumn
)
8117 lpSubItem
->iSubItem
++;
8120 /* add new subitem for each item */
8122 set_sub_item(infoPtr
, &item
, isW
, &changed
);
8126 /* make space for the new column */
8127 LISTVIEW_ScrollColumns(infoPtr
, nNewColumn
+ 1, lpColumnInfo
->rcHeader
.right
- lpColumnInfo
->rcHeader
.left
);
8128 LISTVIEW_UpdateItemSize(infoPtr
);
8133 if (nNewColumn
!= -1) SendMessageW(infoPtr
->hwndHeader
, HDM_DELETEITEM
, nNewColumn
, 0);
8136 DPA_DeletePtr(infoPtr
->hdpaColumns
, nNewColumn
);
8144 * Sets the attributes of a header item.
8147 * [I] infoPtr : valid pointer to the listview structure
8148 * [I] nColumn : column index
8149 * [I] lpColumn : column attributes
8150 * [I] isW: if TRUE, then lpColumn is a LPLVCOLUMNW, else it is a LPLVCOLUMNA
8156 static BOOL
LISTVIEW_SetColumnT(const LISTVIEW_INFO
*infoPtr
, INT nColumn
,
8157 const LVCOLUMNW
*lpColumn
, BOOL isW
)
8159 HDITEMW hdi
, hdiget
;
8162 TRACE("(nColumn=%d, lpColumn=%s, isW=%d)\n", nColumn
, debuglvcolumn_t(lpColumn
, isW
), isW
);
8164 if (!lpColumn
|| nColumn
< 0 || nColumn
>= DPA_GetPtrCount(infoPtr
->hdpaColumns
)) return FALSE
;
8166 ZeroMemory(&hdi
, sizeof(HDITEMW
));
8167 if (lpColumn
->mask
& LVCF_FMT
)
8169 hdi
.mask
|= HDI_FORMAT
;
8170 hdiget
.mask
= HDI_FORMAT
;
8171 if (SendMessageW(infoPtr
->hwndHeader
, HDM_GETITEMW
, nColumn
, (LPARAM
)&hdiget
))
8172 hdi
.fmt
= hdiget
.fmt
& HDF_STRING
;
8174 column_fill_hditem(infoPtr
, &hdi
, nColumn
, lpColumn
, isW
);
8176 /* set header item attributes */
8177 bResult
= SendMessageW(infoPtr
->hwndHeader
, isW
? HDM_SETITEMW
: HDM_SETITEMA
, nColumn
, (LPARAM
)&hdi
);
8178 if (!bResult
) return FALSE
;
8180 if (lpColumn
->mask
& LVCF_FMT
)
8182 COLUMN_INFO
*lpColumnInfo
= LISTVIEW_GetColumnInfo(infoPtr
, nColumn
);
8183 INT oldFmt
= lpColumnInfo
->fmt
;
8185 lpColumnInfo
->fmt
= lpColumn
->fmt
;
8186 if ((oldFmt
^ lpColumn
->fmt
) & (LVCFMT_JUSTIFYMASK
| LVCFMT_IMAGE
))
8188 if (infoPtr
->uView
== LV_VIEW_DETAILS
) LISTVIEW_InvalidateColumn(infoPtr
, nColumn
);
8192 if (lpColumn
->mask
& LVCF_MINWIDTH
)
8193 LISTVIEW_GetColumnInfo(infoPtr
, nColumn
)->cxMin
= lpColumn
->cxMin
;
8200 * Sets the column order array
8203 * [I] infoPtr : valid pointer to the listview structure
8204 * [I] iCount : number of elements in column order array
8205 * [I] lpiArray : pointer to column order array
8211 static BOOL
LISTVIEW_SetColumnOrderArray(LISTVIEW_INFO
*infoPtr
, INT iCount
, const INT
*lpiArray
)
8213 TRACE("iCount %d lpiArray %p\n", iCount
, lpiArray
);
8215 if (!lpiArray
|| !IsWindow(infoPtr
->hwndHeader
)) return FALSE
;
8217 infoPtr
->colRectsDirty
= TRUE
;
8219 return SendMessageW(infoPtr
->hwndHeader
, HDM_SETORDERARRAY
, iCount
, (LPARAM
)lpiArray
);
8224 * Sets the width of a column
8227 * [I] infoPtr : valid pointer to the listview structure
8228 * [I] nColumn : column index
8229 * [I] cx : column width
8235 static BOOL
LISTVIEW_SetColumnWidth(LISTVIEW_INFO
*infoPtr
, INT nColumn
, INT cx
)
8237 WCHAR szDispText
[DISP_TEXT_SIZE
] = { 0 };
8241 TRACE("(nColumn=%d, cx=%d\n", nColumn
, cx
);
8243 /* set column width only if in report or list mode */
8244 if (infoPtr
->uView
!= LV_VIEW_DETAILS
&& infoPtr
->uView
!= LV_VIEW_LIST
) return FALSE
;
8246 /* take care of invalid cx values */
8247 if(infoPtr
->uView
== LV_VIEW_DETAILS
&& cx
< -2) cx
= LVSCW_AUTOSIZE
;
8248 else if (infoPtr
->uView
== LV_VIEW_LIST
&& cx
< 1) return FALSE
;
8250 /* resize all columns if in LV_VIEW_LIST mode */
8251 if(infoPtr
->uView
== LV_VIEW_LIST
)
8253 infoPtr
->nItemWidth
= cx
;
8254 LISTVIEW_InvalidateList(infoPtr
);
8258 if (nColumn
< 0 || nColumn
>= DPA_GetPtrCount(infoPtr
->hdpaColumns
)) return FALSE
;
8260 if (cx
== LVSCW_AUTOSIZE
|| (cx
== LVSCW_AUTOSIZE_USEHEADER
&& nColumn
< DPA_GetPtrCount(infoPtr
->hdpaColumns
) -1))
8265 lvItem
.mask
= LVIF_TEXT
;
8267 lvItem
.iSubItem
= nColumn
;
8268 lvItem
.pszText
= szDispText
;
8269 lvItem
.cchTextMax
= DISP_TEXT_SIZE
;
8270 for (; lvItem
.iItem
< infoPtr
->nItemCount
; lvItem
.iItem
++)
8272 if (!LISTVIEW_GetItemW(infoPtr
, &lvItem
)) continue;
8273 nLabelWidth
= LISTVIEW_GetStringWidthT(infoPtr
, lvItem
.pszText
, TRUE
);
8274 if (max_cx
< nLabelWidth
) max_cx
= nLabelWidth
;
8276 if (infoPtr
->himlSmall
&& (nColumn
== 0 || (LISTVIEW_GetColumnInfo(infoPtr
, nColumn
)->fmt
& LVCFMT_IMAGE
)))
8277 max_cx
+= infoPtr
->iconSize
.cx
;
8278 max_cx
+= TRAILING_LABEL_PADDING
;
8281 /* autosize based on listview items width */
8282 if(cx
== LVSCW_AUTOSIZE
)
8284 else if(cx
== LVSCW_AUTOSIZE_USEHEADER
)
8286 /* if iCol is the last column make it fill the remainder of the controls width */
8287 if(nColumn
== DPA_GetPtrCount(infoPtr
->hdpaColumns
) - 1)
8292 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
8293 LISTVIEW_GetHeaderRect(infoPtr
, nColumn
, &rcHeader
);
8295 cx
= infoPtr
->rcList
.right
- Origin
.x
- rcHeader
.left
;
8299 /* Despite what the MS docs say, if this is not the last
8300 column, then MS resizes the column to the width of the
8301 largest text string in the column, including headers
8302 and items. This is different from LVSCW_AUTOSIZE in that
8303 LVSCW_AUTOSIZE ignores the header string length. */
8306 /* retrieve header text */
8307 hdi
.mask
= HDI_TEXT
;
8308 hdi
.cchTextMax
= DISP_TEXT_SIZE
;
8309 hdi
.pszText
= szDispText
;
8310 if (SendMessageW(infoPtr
->hwndHeader
, HDM_GETITEMW
, nColumn
, (LPARAM
)&hdi
))
8312 HDC hdc
= GetDC(infoPtr
->hwndSelf
);
8313 HFONT old_font
= SelectObject(hdc
, (HFONT
)SendMessageW(infoPtr
->hwndHeader
, WM_GETFONT
, 0, 0));
8316 if (GetTextExtentPoint32W(hdc
, hdi
.pszText
, lstrlenW(hdi
.pszText
), &size
))
8317 cx
= size
.cx
+ TRAILING_HEADER_PADDING
;
8318 /* FIXME: Take into account the header image, if one is present */
8319 SelectObject(hdc
, old_font
);
8320 ReleaseDC(infoPtr
->hwndSelf
, hdc
);
8322 cx
= max (cx
, max_cx
);
8326 if (cx
< 0) return FALSE
;
8328 /* call header to update the column change */
8329 hdi
.mask
= HDI_WIDTH
;
8330 hdi
.cxy
= max(cx
, LISTVIEW_GetColumnInfo(infoPtr
, nColumn
)->cxMin
);
8331 TRACE("hdi.cxy=%d\n", hdi
.cxy
);
8332 return SendMessageW(infoPtr
->hwndHeader
, HDM_SETITEMW
, nColumn
, (LPARAM
)&hdi
);
8336 * Creates the checkbox imagelist. Helper for LISTVIEW_SetExtendedListViewStyle
8339 static HIMAGELIST
LISTVIEW_CreateCheckBoxIL(const LISTVIEW_INFO
*infoPtr
)
8342 HBITMAP hbm_im
, hbm_mask
, hbm_orig
;
8344 HBRUSH hbr_white
= GetStockObject(WHITE_BRUSH
);
8345 HBRUSH hbr_black
= GetStockObject(BLACK_BRUSH
);
8348 himl
= ImageList_Create(GetSystemMetrics(SM_CXSMICON
), GetSystemMetrics(SM_CYSMICON
),
8349 ILC_COLOR
| ILC_MASK
, 2, 2);
8350 hdc_wnd
= GetDC(infoPtr
->hwndSelf
);
8351 hdc
= CreateCompatibleDC(hdc_wnd
);
8352 hbm_im
= CreateCompatibleBitmap(hdc_wnd
, GetSystemMetrics(SM_CXSMICON
), GetSystemMetrics(SM_CYSMICON
));
8353 hbm_mask
= CreateBitmap(GetSystemMetrics(SM_CXSMICON
), GetSystemMetrics(SM_CYSMICON
), 1, 1, NULL
);
8354 ReleaseDC(infoPtr
->hwndSelf
, hdc_wnd
);
8356 rc
.left
= rc
.top
= 0;
8357 rc
.right
= GetSystemMetrics(SM_CXSMICON
);
8358 rc
.bottom
= GetSystemMetrics(SM_CYSMICON
);
8360 hbm_orig
= SelectObject(hdc
, hbm_mask
);
8361 FillRect(hdc
, &rc
, hbr_white
);
8362 InflateRect(&rc
, -2, -2);
8363 FillRect(hdc
, &rc
, hbr_black
);
8365 SelectObject(hdc
, hbm_im
);
8366 DrawFrameControl(hdc
, &rc
, DFC_BUTTON
, DFCS_BUTTONCHECK
| DFCS_MONO
);
8367 SelectObject(hdc
, hbm_orig
);
8368 ImageList_Add(himl
, hbm_im
, hbm_mask
);
8370 SelectObject(hdc
, hbm_im
);
8371 DrawFrameControl(hdc
, &rc
, DFC_BUTTON
, DFCS_BUTTONCHECK
| DFCS_MONO
| DFCS_CHECKED
);
8372 SelectObject(hdc
, hbm_orig
);
8373 ImageList_Add(himl
, hbm_im
, hbm_mask
);
8375 DeleteObject(hbm_mask
);
8376 DeleteObject(hbm_im
);
8384 * Sets the extended listview style.
8387 * [I] infoPtr : valid pointer to the listview structure
8389 * [I] dwStyle : style
8392 * SUCCESS : previous style
8395 static DWORD
LISTVIEW_SetExtendedListViewStyle(LISTVIEW_INFO
*infoPtr
, DWORD mask
, DWORD ex_style
)
8397 DWORD old_ex_style
= infoPtr
->dwLvExStyle
;
8399 TRACE("mask=0x%08x, ex_style=0x%08x\n", mask
, ex_style
);
8403 infoPtr
->dwLvExStyle
= (old_ex_style
& ~mask
) | (ex_style
& mask
);
8405 infoPtr
->dwLvExStyle
= ex_style
;
8407 if((infoPtr
->dwLvExStyle
^ old_ex_style
) & LVS_EX_CHECKBOXES
)
8409 HIMAGELIST himl
= 0;
8410 if(infoPtr
->dwLvExStyle
& LVS_EX_CHECKBOXES
)
8413 item
.mask
= LVIF_STATE
;
8414 item
.stateMask
= LVIS_STATEIMAGEMASK
;
8415 item
.state
= INDEXTOSTATEIMAGEMASK(1);
8416 LISTVIEW_SetItemState(infoPtr
, -1, &item
);
8418 himl
= LISTVIEW_CreateCheckBoxIL(infoPtr
);
8419 if(!(infoPtr
->dwStyle
& LVS_SHAREIMAGELISTS
))
8420 ImageList_Destroy(infoPtr
->himlState
);
8422 himl
= LISTVIEW_SetImageList(infoPtr
, LVSIL_STATE
, himl
);
8423 /* checkbox list replaces previous custom list or... */
8424 if(((infoPtr
->dwLvExStyle
& LVS_EX_CHECKBOXES
) &&
8425 !(infoPtr
->dwStyle
& LVS_SHAREIMAGELISTS
)) ||
8426 /* ...previous was checkbox list */
8427 (old_ex_style
& LVS_EX_CHECKBOXES
))
8428 ImageList_Destroy(himl
);
8431 if((infoPtr
->dwLvExStyle
^ old_ex_style
) & LVS_EX_HEADERDRAGDROP
)
8435 /* if not already created */
8436 LISTVIEW_CreateHeader(infoPtr
);
8438 style
= GetWindowLongW(infoPtr
->hwndHeader
, GWL_STYLE
);
8439 if (infoPtr
->dwLvExStyle
& LVS_EX_HEADERDRAGDROP
)
8440 style
|= HDS_DRAGDROP
;
8442 style
&= ~HDS_DRAGDROP
;
8443 SetWindowLongW(infoPtr
->hwndHeader
, GWL_STYLE
, style
);
8446 /* GRIDLINES adds decoration at top so changes sizes */
8447 if((infoPtr
->dwLvExStyle
^ old_ex_style
) & LVS_EX_GRIDLINES
)
8449 LISTVIEW_CreateHeader(infoPtr
);
8450 LISTVIEW_UpdateSize(infoPtr
);
8453 if((infoPtr
->dwLvExStyle
^ old_ex_style
) & LVS_EX_FULLROWSELECT
)
8455 LISTVIEW_CreateHeader(infoPtr
);
8458 if((infoPtr
->dwLvExStyle
^ old_ex_style
) & LVS_EX_TRANSPARENTBKGND
)
8460 if (infoPtr
->dwLvExStyle
& LVS_EX_TRANSPARENTBKGND
)
8461 LISTVIEW_SetBkColor(infoPtr
, CLR_NONE
);
8464 if((infoPtr
->dwLvExStyle
^ old_ex_style
) & LVS_EX_HEADERINALLVIEWS
)
8466 if (infoPtr
->dwLvExStyle
& LVS_EX_HEADERINALLVIEWS
)
8467 LISTVIEW_CreateHeader(infoPtr
);
8469 ShowWindow(infoPtr
->hwndHeader
, SW_HIDE
);
8470 LISTVIEW_UpdateSize(infoPtr
);
8471 LISTVIEW_UpdateScroll(infoPtr
);
8474 LISTVIEW_InvalidateList(infoPtr
);
8475 return old_ex_style
;
8480 * Sets the new hot cursor used during hot tracking and hover selection.
8483 * [I] infoPtr : valid pointer to the listview structure
8484 * [I] hCursor : the new hot cursor handle
8487 * Returns the previous hot cursor
8489 static HCURSOR
LISTVIEW_SetHotCursor(LISTVIEW_INFO
*infoPtr
, HCURSOR hCursor
)
8491 HCURSOR oldCursor
= infoPtr
->hHotCursor
;
8493 infoPtr
->hHotCursor
= hCursor
;
8501 * Sets the hot item index.
8504 * [I] infoPtr : valid pointer to the listview structure
8505 * [I] iIndex : index
8508 * SUCCESS : previous hot item index
8509 * FAILURE : -1 (no hot item)
8511 static INT
LISTVIEW_SetHotItem(LISTVIEW_INFO
*infoPtr
, INT iIndex
)
8513 INT iOldIndex
= infoPtr
->nHotItem
;
8515 infoPtr
->nHotItem
= iIndex
;
8523 * Sets the amount of time the cursor must hover over an item before it is selected.
8526 * [I] infoPtr : valid pointer to the listview structure
8527 * [I] dwHoverTime : hover time, if -1 the hover time is set to the default
8530 * Returns the previous hover time
8532 static DWORD
LISTVIEW_SetHoverTime(LISTVIEW_INFO
*infoPtr
, DWORD dwHoverTime
)
8534 DWORD oldHoverTime
= infoPtr
->dwHoverTime
;
8536 infoPtr
->dwHoverTime
= dwHoverTime
;
8538 return oldHoverTime
;
8543 * Sets spacing for icons of LVS_ICON style.
8546 * [I] infoPtr : valid pointer to the listview structure
8547 * [I] cx : horizontal spacing (-1 = system spacing, 0 = autosize)
8548 * [I] cy : vertical spacing (-1 = system spacing, 0 = autosize)
8551 * MAKELONG(oldcx, oldcy)
8553 static DWORD
LISTVIEW_SetIconSpacing(LISTVIEW_INFO
*infoPtr
, INT cx
, INT cy
)
8555 DWORD oldspacing
= MAKELONG(infoPtr
->iconSpacing
.cx
, infoPtr
->iconSpacing
.cy
);
8557 TRACE("requested=(%d,%d)\n", cx
, cy
);
8559 /* this is supported only for LVS_ICON style */
8560 if (infoPtr
->uView
!= LV_VIEW_ICON
) return oldspacing
;
8562 /* set to defaults, if instructed to */
8563 if (cx
== -1) cx
= GetSystemMetrics(SM_CXICONSPACING
);
8564 if (cy
== -1) cy
= GetSystemMetrics(SM_CYICONSPACING
);
8566 /* if 0 then compute width
8567 * FIXME: computed cx and cy is not matching native behaviour */
8569 cx
= GetSystemMetrics(SM_CXICONSPACING
);
8570 if (infoPtr
->iconSize
.cx
+ ICON_LR_PADDING
> cx
)
8571 cx
= infoPtr
->iconSize
.cx
+ ICON_LR_PADDING
;
8574 /* if 0 then compute height */
8576 cy
= infoPtr
->iconSize
.cy
+ 2 * infoPtr
->ntmHeight
+
8577 ICON_BOTTOM_PADDING
+ ICON_TOP_PADDING
+ LABEL_VERT_PADDING
;
8580 infoPtr
->iconSpacing
.cx
= cx
;
8581 infoPtr
->iconSpacing
.cy
= cy
;
8583 TRACE("old=(%d,%d), new=(%d,%d), iconSize=(%d,%d), ntmH=%d\n",
8584 LOWORD(oldspacing
), HIWORD(oldspacing
), cx
, cy
,
8585 infoPtr
->iconSize
.cx
, infoPtr
->iconSize
.cy
,
8586 infoPtr
->ntmHeight
);
8588 /* these depend on the iconSpacing */
8589 LISTVIEW_UpdateItemSize(infoPtr
);
8594 static inline void set_icon_size(SIZE
*size
, HIMAGELIST himl
, BOOL small
)
8598 if (himl
&& ImageList_GetIconSize(himl
, &cx
, &cy
))
8605 size
->cx
= GetSystemMetrics(small
? SM_CXSMICON
: SM_CXICON
);
8606 size
->cy
= GetSystemMetrics(small
? SM_CYSMICON
: SM_CYICON
);
8615 * [I] infoPtr : valid pointer to the listview structure
8616 * [I] nType : image list type
8617 * [I] himl : image list handle
8620 * SUCCESS : old image list
8623 static HIMAGELIST
LISTVIEW_SetImageList(LISTVIEW_INFO
*infoPtr
, INT nType
, HIMAGELIST himl
)
8625 INT oldHeight
= infoPtr
->nItemHeight
;
8626 HIMAGELIST himlOld
= 0;
8628 TRACE("(nType=%d, himl=%p\n", nType
, himl
);
8633 himlOld
= infoPtr
->himlNormal
;
8634 infoPtr
->himlNormal
= himl
;
8635 if (infoPtr
->uView
== LV_VIEW_ICON
) set_icon_size(&infoPtr
->iconSize
, himl
, FALSE
);
8636 LISTVIEW_SetIconSpacing(infoPtr
, 0, 0);
8640 himlOld
= infoPtr
->himlSmall
;
8641 infoPtr
->himlSmall
= himl
;
8642 if (infoPtr
->uView
!= LV_VIEW_ICON
) set_icon_size(&infoPtr
->iconSize
, himl
, TRUE
);
8646 himlOld
= infoPtr
->himlState
;
8647 infoPtr
->himlState
= himl
;
8648 set_icon_size(&infoPtr
->iconStateSize
, himl
, TRUE
);
8649 ImageList_SetBkColor(infoPtr
->himlState
, CLR_NONE
);
8653 ERR("Unknown icon type=%d\n", nType
);
8657 infoPtr
->nItemHeight
= LISTVIEW_CalculateItemHeight(infoPtr
);
8658 if (infoPtr
->nItemHeight
!= oldHeight
)
8659 LISTVIEW_UpdateScroll(infoPtr
);
8666 * Preallocates memory (does *not* set the actual count of items !)
8669 * [I] infoPtr : valid pointer to the listview structure
8670 * [I] nItems : item count (projected number of items to allocate)
8671 * [I] dwFlags : update flags
8677 static BOOL
LISTVIEW_SetItemCount(LISTVIEW_INFO
*infoPtr
, INT nItems
, DWORD dwFlags
)
8679 TRACE("(nItems=%d, dwFlags=%x)\n", nItems
, dwFlags
);
8681 if (infoPtr
->dwStyle
& LVS_OWNERDATA
)
8683 INT nOldCount
= infoPtr
->nItemCount
;
8685 if (nItems
< nOldCount
)
8687 RANGE range
= { nItems
, nOldCount
};
8688 ranges_del(infoPtr
->selectionRanges
, range
);
8689 if (infoPtr
->nFocusedItem
>= nItems
)
8691 LISTVIEW_SetItemFocus(infoPtr
, -1);
8692 SetRectEmpty(&infoPtr
->rcFocus
);
8696 infoPtr
->nItemCount
= nItems
;
8697 LISTVIEW_UpdateScroll(infoPtr
);
8699 /* the flags are valid only in ownerdata report and list modes */
8700 if (infoPtr
->uView
== LV_VIEW_ICON
|| infoPtr
->uView
== LV_VIEW_SMALLICON
) dwFlags
= 0;
8702 if (!(dwFlags
& LVSICF_NOSCROLL
) && infoPtr
->nFocusedItem
!= -1)
8703 LISTVIEW_EnsureVisible(infoPtr
, infoPtr
->nFocusedItem
, FALSE
);
8705 if (!(dwFlags
& LVSICF_NOINVALIDATEALL
))
8706 LISTVIEW_InvalidateList(infoPtr
);
8713 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
8714 nFrom
= min(nOldCount
, nItems
);
8715 nTo
= max(nOldCount
, nItems
);
8717 if (infoPtr
->uView
== LV_VIEW_DETAILS
)
8720 rcErase
.top
= nFrom
* infoPtr
->nItemHeight
;
8721 rcErase
.right
= infoPtr
->nItemWidth
;
8722 rcErase
.bottom
= nTo
* infoPtr
->nItemHeight
;
8723 OffsetRect(&rcErase
, Origin
.x
, Origin
.y
);
8724 if (IntersectRect(&rcErase
, &rcErase
, &infoPtr
->rcList
))
8725 LISTVIEW_InvalidateRect(infoPtr
, &rcErase
);
8727 else /* LV_VIEW_LIST */
8729 INT nPerCol
= LISTVIEW_GetCountPerColumn(infoPtr
);
8731 rcErase
.left
= (nFrom
/ nPerCol
) * infoPtr
->nItemWidth
;
8732 rcErase
.top
= (nFrom
% nPerCol
) * infoPtr
->nItemHeight
;
8733 rcErase
.right
= rcErase
.left
+ infoPtr
->nItemWidth
;
8734 rcErase
.bottom
= nPerCol
* infoPtr
->nItemHeight
;
8735 OffsetRect(&rcErase
, Origin
.x
, Origin
.y
);
8736 if (IntersectRect(&rcErase
, &rcErase
, &infoPtr
->rcList
))
8737 LISTVIEW_InvalidateRect(infoPtr
, &rcErase
);
8739 rcErase
.left
= (nFrom
/ nPerCol
+ 1) * infoPtr
->nItemWidth
;
8741 rcErase
.right
= (nTo
/ nPerCol
+ 1) * infoPtr
->nItemWidth
;
8742 rcErase
.bottom
= nPerCol
* infoPtr
->nItemHeight
;
8743 OffsetRect(&rcErase
, Origin
.x
, Origin
.y
);
8744 if (IntersectRect(&rcErase
, &rcErase
, &infoPtr
->rcList
))
8745 LISTVIEW_InvalidateRect(infoPtr
, &rcErase
);
8751 /* According to MSDN for non-LVS_OWNERDATA this is just
8752 * a performance issue. The control allocates its internal
8753 * data structures for the number of items specified. It
8754 * cuts down on the number of memory allocations. Therefore
8755 * we will just issue a WARN here
8757 WARN("for non-ownerdata performance option not implemented.\n");
8765 * Sets the position of an item.
8768 * [I] infoPtr : valid pointer to the listview structure
8769 * [I] nItem : item index
8770 * [I] pt : coordinate
8776 static BOOL
LISTVIEW_SetItemPosition(LISTVIEW_INFO
*infoPtr
, INT nItem
, const POINT
*pt
)
8780 TRACE("(nItem=%d, pt=%s\n", nItem
, wine_dbgstr_point(pt
));
8782 if (!pt
|| nItem
< 0 || nItem
>= infoPtr
->nItemCount
||
8783 !(infoPtr
->uView
== LV_VIEW_ICON
|| infoPtr
->uView
== LV_VIEW_SMALLICON
)) return FALSE
;
8786 LISTVIEW_GetOrigin(infoPtr
, &Origin
);
8788 /* This point value seems to be an undocumented feature.
8789 * The best guess is that it means either at the origin,
8790 * or at true beginning of the list. I will assume the origin. */
8791 if ((Pt
.x
== -1) && (Pt
.y
== -1))
8794 if (infoPtr
->uView
== LV_VIEW_ICON
)
8796 Pt
.x
-= (infoPtr
->nItemWidth
- infoPtr
->iconSize
.cx
) / 2;
8797 Pt
.y
-= ICON_TOP_PADDING
;
8802 infoPtr
->bAutoarrange
= FALSE
;
8804 return LISTVIEW_MoveIconTo(infoPtr
, nItem
, &Pt
, FALSE
);
8809 * Sets the state of one or many items.
8812 * [I] infoPtr : valid pointer to the listview structure
8813 * [I] nItem : item index
8814 * [I] item : item or subitem info
8820 static BOOL
LISTVIEW_SetItemState(LISTVIEW_INFO
*infoPtr
, INT nItem
, const LVITEMW
*item
)
8825 if (!item
) return FALSE
;
8827 lvItem
.iItem
= nItem
;
8828 lvItem
.iSubItem
= 0;
8829 lvItem
.mask
= LVIF_STATE
;
8830 lvItem
.state
= item
->state
;
8831 lvItem
.stateMask
= item
->stateMask
;
8832 TRACE("item=%s\n", debuglvitem_t(&lvItem
, TRUE
));
8839 /* select all isn't allowed in LVS_SINGLESEL */
8840 if ((lvItem
.state
& lvItem
.stateMask
& LVIS_SELECTED
) && (infoPtr
->dwStyle
& LVS_SINGLESEL
))
8843 /* focus all isn't allowed */
8844 if (lvItem
.state
& lvItem
.stateMask
& LVIS_FOCUSED
) return FALSE
;
8846 notify
= infoPtr
->bDoChangeNotify
;
8847 if (infoPtr
->dwStyle
& LVS_OWNERDATA
)
8849 infoPtr
->bDoChangeNotify
= FALSE
;
8850 if (!(lvItem
.state
& LVIS_SELECTED
) && LISTVIEW_GetSelectedCount(infoPtr
))
8851 oldstate
|= LVIS_SELECTED
;
8852 if (infoPtr
->nFocusedItem
!= -1) oldstate
|= LVIS_FOCUSED
;
8855 /* apply to all items */
8856 for (lvItem
.iItem
= 0; lvItem
.iItem
< infoPtr
->nItemCount
; lvItem
.iItem
++)
8857 if (!LISTVIEW_SetItemT(infoPtr
, &lvItem
, TRUE
)) ret
= FALSE
;
8859 if (infoPtr
->dwStyle
& LVS_OWNERDATA
)
8863 infoPtr
->bDoChangeNotify
= notify
;
8867 nmlv
.uNewState
= lvItem
.state
& lvItem
.stateMask
;
8868 nmlv
.uOldState
= oldstate
& lvItem
.stateMask
;
8869 nmlv
.uChanged
= LVIF_STATE
;
8870 nmlv
.ptAction
.x
= nmlv
.ptAction
.y
= 0;
8873 notify_listview(infoPtr
, LVN_ITEMCHANGED
, &nmlv
);
8877 ret
= LISTVIEW_SetItemT(infoPtr
, &lvItem
, TRUE
);
8884 * Sets the text of an item or subitem.
8887 * [I] hwnd : window handle
8888 * [I] nItem : item index
8889 * [I] lpLVItem : item or subitem info
8890 * [I] isW : TRUE if input is Unicode
8896 static BOOL
LISTVIEW_SetItemTextT(LISTVIEW_INFO
*infoPtr
, INT nItem
, const LVITEMW
*lpLVItem
, BOOL isW
)
8900 if (!lpLVItem
|| nItem
< 0 || nItem
>= infoPtr
->nItemCount
) return FALSE
;
8901 if (infoPtr
->dwStyle
& LVS_OWNERDATA
) return FALSE
;
8903 lvItem
.iItem
= nItem
;
8904 lvItem
.iSubItem
= lpLVItem
->iSubItem
;
8905 lvItem
.mask
= LVIF_TEXT
;
8906 lvItem
.pszText
= lpLVItem
->pszText
;
8907 lvItem
.cchTextMax
= lpLVItem
->cchTextMax
;
8909 TRACE("(nItem=%d, lpLVItem=%s, isW=%d)\n", nItem
, debuglvitem_t(&lvItem
, isW
), isW
);
8911 return LISTVIEW_SetItemT(infoPtr
, &lvItem
, isW
);
8916 * Set item index that marks the start of a multiple selection.
8919 * [I] infoPtr : valid pointer to the listview structure
8920 * [I] nIndex : index
8923 * Index number or -1 if there is no selection mark.
8925 static INT
LISTVIEW_SetSelectionMark(LISTVIEW_INFO
*infoPtr
, INT nIndex
)
8927 INT nOldIndex
= infoPtr
->nSelectionMark
;
8929 TRACE("(nIndex=%d)\n", nIndex
);
8931 infoPtr
->nSelectionMark
= nIndex
;
8938 * Sets the text background color.
8941 * [I] infoPtr : valid pointer to the listview structure
8942 * [I] color : text background color
8948 static BOOL
LISTVIEW_SetTextBkColor(LISTVIEW_INFO
*infoPtr
, COLORREF color
)
8950 TRACE("(color=%x)\n", color
);
8952 infoPtr
->clrTextBk
= color
;
8958 * Sets the text foreground color.
8961 * [I] infoPtr : valid pointer to the listview structure
8962 * [I] color : text color
8968 static BOOL
LISTVIEW_SetTextColor (LISTVIEW_INFO
*infoPtr
, COLORREF color
)
8970 TRACE("(color=%x)\n", color
);
8972 infoPtr
->clrText
= color
;
8978 * Sets new ToolTip window to ListView control.
8981 * [I] infoPtr : valid pointer to the listview structure
8982 * [I] hwndNewToolTip : handle to new ToolTip
8987 static HWND
LISTVIEW_SetToolTips( LISTVIEW_INFO
*infoPtr
, HWND hwndNewToolTip
)
8989 HWND hwndOldToolTip
= infoPtr
->hwndToolTip
;
8990 infoPtr
->hwndToolTip
= hwndNewToolTip
;
8991 return hwndOldToolTip
;
8996 * sets the Unicode character format flag for the control
8998 * [I] infoPtr :valid pointer to the listview structure
8999 * [I] fUnicode :true to switch to UNICODE false to switch to ANSI
9002 * Old Unicode Format
9004 static BOOL
LISTVIEW_SetUnicodeFormat( LISTVIEW_INFO
*infoPtr
, BOOL unicode
)
9006 SHORT rc
= infoPtr
->notifyFormat
;
9007 infoPtr
->notifyFormat
= (unicode
) ? NFR_UNICODE
: NFR_ANSI
;
9008 return rc
== NFR_UNICODE
;
9013 * sets the control view mode
9015 * [I] infoPtr :valid pointer to the listview structure
9016 * [I] nView :new view mode value
9022 static INT
LISTVIEW_SetView(LISTVIEW_INFO
*infoPtr
, DWORD nView
)
9024 SIZE oldIconSize
= infoPtr
->iconSize
;
9027 if (infoPtr
->uView
== nView
) return 1;
9029 if ((INT
)nView
< 0 || nView
> LV_VIEW_MAX
) return -1;
9030 if (nView
== LV_VIEW_TILE
)
9032 FIXME("View LV_VIEW_TILE unimplemented\n");
9036 infoPtr
->uView
= nView
;
9038 SendMessageW(infoPtr
->hwndEdit
, WM_KILLFOCUS
, 0, 0);
9039 ShowWindow(infoPtr
->hwndHeader
, SW_HIDE
);
9041 ShowScrollBar(infoPtr
->hwndSelf
, SB_BOTH
, FALSE
);
9042 SetRectEmpty(&infoPtr
->rcFocus
);
9044 himl
= (nView
== LV_VIEW_ICON
? infoPtr
->himlNormal
: infoPtr
->himlSmall
);
9045 set_icon_size(&infoPtr
->iconSize
, himl
, nView
!= LV_VIEW_ICON
);
9050 if ((infoPtr
->iconSize
.cx
!= oldIconSize
.cx
) || (infoPtr
->iconSize
.cy
!= oldIconSize
.cy
))
9052 TRACE("icon old size=(%d,%d), new size=(%d,%d)\n",
9053 oldIconSize
.cx
, oldIconSize
.cy
, infoPtr
->iconSize
.cx
, infoPtr
->iconSize
.cy
);
9054 LISTVIEW_SetIconSpacing(infoPtr
, 0, 0);
9056 LISTVIEW_Arrange(infoPtr
, LVA_DEFAULT
);
9058 case LV_VIEW_SMALLICON
:
9059 LISTVIEW_Arrange(infoPtr
, LVA_DEFAULT
);
9061 case LV_VIEW_DETAILS
:
9066 LISTVIEW_CreateHeader( infoPtr
);
9068 hl
.prc
= &infoPtr
->rcList
;
9070 SendMessageW(infoPtr
->hwndHeader
, HDM_LAYOUT
, 0, (LPARAM
)&hl
);
9071 SetWindowPos(infoPtr
->hwndHeader
, infoPtr
->hwndSelf
, wp
.x
, wp
.y
, wp
.cx
, wp
.cy
,
9072 wp
.flags
| ((infoPtr
->dwStyle
& LVS_NOCOLUMNHEADER
) ? SWP_HIDEWINDOW
: SWP_SHOWWINDOW
));
9079 LISTVIEW_UpdateItemSize(infoPtr
);
9080 LISTVIEW_UpdateSize(infoPtr
);
9081 LISTVIEW_UpdateScroll(infoPtr
);
9082 LISTVIEW_InvalidateList(infoPtr
);
9084 TRACE("nView=%d\n", nView
);
9089 /* LISTVIEW_SetWorkAreas */
9093 * Callback internally used by LISTVIEW_SortItems() in response of LVM_SORTITEMS
9096 * [I] first : pointer to first ITEM_INFO to compare
9097 * [I] second : pointer to second ITEM_INFO to compare
9098 * [I] lParam : HWND of control
9101 * if first comes before second : negative
9102 * if first comes after second : positive
9103 * if first and second are equivalent : zero
9105 static INT WINAPI
LISTVIEW_CallBackCompare(LPVOID first
, LPVOID second
, LPARAM lParam
)
9107 LISTVIEW_INFO
*infoPtr
= (LISTVIEW_INFO
*)lParam
;
9108 ITEM_INFO
* lv_first
= DPA_GetPtr( first
, 0 );
9109 ITEM_INFO
* lv_second
= DPA_GetPtr( second
, 0 );
9111 /* Forward the call to the client defined callback */
9112 return (infoPtr
->pfnCompare
)( lv_first
->lParam
, lv_second
->lParam
, infoPtr
->lParamSort
);
9117 * Callback internally used by LISTVIEW_SortItems() in response of LVM_SORTITEMSEX
9120 * [I] first : pointer to first ITEM_INFO to compare
9121 * [I] second : pointer to second ITEM_INFO to compare
9122 * [I] lParam : HWND of control
9125 * if first comes before second : negative
9126 * if first comes after second : positive
9127 * if first and second are equivalent : zero
9129 static INT WINAPI
LISTVIEW_CallBackCompareEx(LPVOID first
, LPVOID second
, LPARAM lParam
)
9131 LISTVIEW_INFO
*infoPtr
= (LISTVIEW_INFO
*)lParam
;
9132 INT first_idx
= DPA_GetPtrIndex( infoPtr
->hdpaItems
, first
);
9133 INT second_idx
= DPA_GetPtrIndex( infoPtr
->hdpaItems
, second
);
9135 /* Forward the call to the client defined callback */
9136 return (infoPtr
->pfnCompare
)( first_idx
, second_idx
, infoPtr
->lParamSort
);
9141 * Sorts the listview items.
9144 * [I] infoPtr : valid pointer to the listview structure
9145 * [I] pfnCompare : application-defined value
9146 * [I] lParamSort : pointer to comparison callback
9147 * [I] IsEx : TRUE when LVM_SORTITEMSEX used
9153 static BOOL
LISTVIEW_SortItems(LISTVIEW_INFO
*infoPtr
, PFNLVCOMPARE pfnCompare
,
9154 LPARAM lParamSort
, BOOL IsEx
)
9158 LPVOID selectionMarkItem
= NULL
;
9159 LPVOID focusedItem
= NULL
;
9162 TRACE("(pfnCompare=%p, lParamSort=%lx)\n", pfnCompare
, lParamSort
);
9164 if (infoPtr
->dwStyle
& LVS_OWNERDATA
) return FALSE
;
9166 if (!pfnCompare
) return FALSE
;
9167 if (!infoPtr
->hdpaItems
) return FALSE
;
9169 /* if there are 0 or 1 items, there is no need to sort */
9170 if (infoPtr
->nItemCount
< 2) return TRUE
;
9172 /* clear selection */
9173 ranges_clear(infoPtr
->selectionRanges
);
9175 /* save selection mark and focused item */
9176 if (infoPtr
->nSelectionMark
>= 0)
9177 selectionMarkItem
= DPA_GetPtr(infoPtr
->hdpaItems
, infoPtr
->nSelectionMark
);
9178 if (infoPtr
->nFocusedItem
>= 0)
9179 focusedItem
= DPA_GetPtr(infoPtr
->hdpaItems
, infoPtr
->nFocusedItem
);
9181 infoPtr
->pfnCompare
= pfnCompare
;
9182 infoPtr
->lParamSort
= lParamSort
;
9184 DPA_Sort(infoPtr
->hdpaItems
, LISTVIEW_CallBackCompareEx
, (LPARAM
)infoPtr
);
9186 DPA_Sort(infoPtr
->hdpaItems
, LISTVIEW_CallBackCompare
, (LPARAM
)infoPtr
);
9188 /* restore selection ranges */
9189 for (i
=0; i
< infoPtr
->nItemCount
; i
++)
9191 hdpaSubItems
= DPA_GetPtr(infoPtr
->hdpaItems
, i
);
9192 lpItem
= DPA_GetPtr(hdpaSubItems
, 0);
9194 if (lpItem
->state
& LVIS_SELECTED
)
9195 ranges_additem(infoPtr
->selectionRanges
, i
);
9197 /* restore selection mark and focused item */
9198 infoPtr
->nSelectionMark
= DPA_GetPtrIndex(infoPtr
->hdpaItems
, selectionMarkItem
);
9199 infoPtr
->nFocusedItem
= DPA_GetPtrIndex(infoPtr
->hdpaItems
, focusedItem
);
9201 /* I believe nHotItem should be left alone, see LISTVIEW_ShiftIndices */
9203 /* refresh the display */
9204 LISTVIEW_InvalidateList(infoPtr
);
9210 * Update theme handle after a theme change.
9213 * [I] infoPtr : valid pointer to the listview structure
9217 * FAILURE : something else
9219 static LRESULT
LISTVIEW_ThemeChanged(const LISTVIEW_INFO
*infoPtr
)
9221 HTHEME theme
= GetWindowTheme(infoPtr
->hwndSelf
);
9222 CloseThemeData(theme
);
9223 OpenThemeData(infoPtr
->hwndSelf
, themeClass
);
9229 * Updates an items or rearranges the listview control.
9232 * [I] infoPtr : valid pointer to the listview structure
9233 * [I] nItem : item index
9239 static BOOL
LISTVIEW_Update(LISTVIEW_INFO
*infoPtr
, INT nItem
)
9241 TRACE("(nItem=%d)\n", nItem
);
9243 if (nItem
< 0 || nItem
>= infoPtr
->nItemCount
) return FALSE
;
9245 /* rearrange with default alignment style */
9246 if (is_autoarrange(infoPtr
))
9247 LISTVIEW_Arrange(infoPtr
, LVA_DEFAULT
);
9249 LISTVIEW_InvalidateItem(infoPtr
, nItem
);
9256 * Draw the track line at the place defined in the infoPtr structure.
9257 * The line is drawn with a XOR pen so drawing the line for the second time
9258 * in the same place erases the line.
9261 * [I] infoPtr : valid pointer to the listview structure
9267 static BOOL
LISTVIEW_DrawTrackLine(const LISTVIEW_INFO
*infoPtr
)
9271 if (infoPtr
->xTrackLine
== -1)
9274 if (!(hdc
= GetDC(infoPtr
->hwndSelf
)))
9276 PatBlt( hdc
, infoPtr
->xTrackLine
, infoPtr
->rcList
.top
,
9277 1, infoPtr
->rcList
.bottom
- infoPtr
->rcList
.top
, DSTINVERT
);
9278 ReleaseDC(infoPtr
->hwndSelf
, hdc
);
9284 * Called when an edit control should be displayed. This function is called after
9285 * we are sure that there was a single click - not a double click (this is a TIMERPROC).
9288 * [I] hwnd : Handle to the listview
9289 * [I] uMsg : WM_TIMER (ignored)
9290 * [I] idEvent : The timer ID interpreted as a pointer to a DELAYED_EDIT_ITEM struct
9291 * [I] dwTimer : The elapsed time (ignored)
9296 static VOID CALLBACK
LISTVIEW_DelayedEditItem(HWND hwnd
, UINT uMsg
, UINT_PTR idEvent
, DWORD dwTime
)
9298 DELAYED_ITEM_EDIT
*editItem
= (DELAYED_ITEM_EDIT
*)idEvent
;
9299 LISTVIEW_INFO
*infoPtr
= (LISTVIEW_INFO
*)GetWindowLongPtrW(hwnd
, 0);
9301 KillTimer(hwnd
, idEvent
);
9302 editItem
->fEnabled
= FALSE
;
9303 /* check if the item is still selected */
9304 if (infoPtr
->bFocus
&& LISTVIEW_GetItemState(infoPtr
, editItem
->iItem
, LVIS_SELECTED
))
9305 LISTVIEW_EditLabelT(infoPtr
, editItem
->iItem
, TRUE
);
9310 * Creates the listview control - the WM_NCCREATE phase.
9313 * [I] hwnd : window handle
9314 * [I] lpcs : the create parameters
9320 static LRESULT
LISTVIEW_NCCreate(HWND hwnd
, const CREATESTRUCTW
*lpcs
)
9322 LISTVIEW_INFO
*infoPtr
;
9325 TRACE("(lpcs=%p)\n", lpcs
);
9327 /* initialize info pointer */
9328 infoPtr
= Alloc(sizeof(LISTVIEW_INFO
));
9329 if (!infoPtr
) return FALSE
;
9331 SetWindowLongPtrW(hwnd
, 0, (DWORD_PTR
)infoPtr
);
9333 infoPtr
->hwndSelf
= hwnd
;
9334 infoPtr
->dwStyle
= lpcs
->style
; /* Note: may be changed in WM_CREATE */
9335 map_style_view(infoPtr
);
9336 /* determine the type of structures to use */
9337 infoPtr
->hwndNotify
= lpcs
->hwndParent
;
9338 /* infoPtr->notifyFormat will be filled in WM_CREATE */
9340 /* initialize color information */
9341 infoPtr
->clrBk
= CLR_NONE
;
9342 infoPtr
->clrText
= CLR_DEFAULT
;
9343 infoPtr
->clrTextBk
= CLR_DEFAULT
;
9344 LISTVIEW_SetBkColor(infoPtr
, comctl32_color
.clrWindow
);
9346 /* set default values */
9347 infoPtr
->nFocusedItem
= -1;
9348 infoPtr
->nSelectionMark
= -1;
9349 infoPtr
->nHotItem
= -1;
9350 infoPtr
->bRedraw
= TRUE
;
9351 infoPtr
->bNoItemMetrics
= TRUE
;
9352 infoPtr
->bDoChangeNotify
= TRUE
;
9353 infoPtr
->iconSpacing
.cx
= GetSystemMetrics(SM_CXICONSPACING
);
9354 infoPtr
->iconSpacing
.cy
= GetSystemMetrics(SM_CYICONSPACING
);
9355 infoPtr
->nEditLabelItem
= -1;
9356 infoPtr
->nLButtonDownItem
= -1;
9357 infoPtr
->dwHoverTime
= HOVER_DEFAULT
; /* default system hover time */
9358 infoPtr
->nMeasureItemHeight
= 0;
9359 infoPtr
->xTrackLine
= -1; /* no track line */
9360 infoPtr
->itemEdit
.fEnabled
= FALSE
;
9361 infoPtr
->iVersion
= COMCTL32_VERSION
;
9362 infoPtr
->colRectsDirty
= FALSE
;
9364 /* get default font (icon title) */
9365 SystemParametersInfoW(SPI_GETICONTITLELOGFONT
, 0, &logFont
, 0);
9366 infoPtr
->hDefaultFont
= CreateFontIndirectW(&logFont
);
9367 infoPtr
->hFont
= infoPtr
->hDefaultFont
;
9368 LISTVIEW_SaveTextMetrics(infoPtr
);
9370 /* allocate memory for the data structure */
9371 if (!(infoPtr
->selectionRanges
= ranges_create(10))) goto fail
;
9372 if (!(infoPtr
->hdpaItems
= DPA_Create(10))) goto fail
;
9373 if (!(infoPtr
->hdpaItemIds
= DPA_Create(10))) goto fail
;
9374 if (!(infoPtr
->hdpaPosX
= DPA_Create(10))) goto fail
;
9375 if (!(infoPtr
->hdpaPosY
= DPA_Create(10))) goto fail
;
9376 if (!(infoPtr
->hdpaColumns
= DPA_Create(10))) goto fail
;
9380 DestroyWindow(infoPtr
->hwndHeader
);
9381 ranges_destroy(infoPtr
->selectionRanges
);
9382 DPA_Destroy(infoPtr
->hdpaItems
);
9383 DPA_Destroy(infoPtr
->hdpaItemIds
);
9384 DPA_Destroy(infoPtr
->hdpaPosX
);
9385 DPA_Destroy(infoPtr
->hdpaPosY
);
9386 DPA_Destroy(infoPtr
->hdpaColumns
);
9393 * Creates the listview control - the WM_CREATE phase. Most of the data is
9394 * already set up in LISTVIEW_NCCreate
9397 * [I] hwnd : window handle
9398 * [I] lpcs : the create parameters
9404 static LRESULT
LISTVIEW_Create(HWND hwnd
, const CREATESTRUCTW
*lpcs
)
9406 LISTVIEW_INFO
*infoPtr
= (LISTVIEW_INFO
*)GetWindowLongPtrW(hwnd
, 0);
9408 TRACE("(lpcs=%p, style=0x%08x)\n", lpcs
, lpcs
->style
);
9410 infoPtr
->dwStyle
= lpcs
->style
;
9411 map_style_view(infoPtr
);
9413 infoPtr
->notifyFormat
= SendMessageW(infoPtr
->hwndNotify
, WM_NOTIFYFORMAT
,
9414 (WPARAM
)infoPtr
->hwndSelf
, NF_QUERY
);
9415 /* on error defaulting to ANSI notifications */
9416 if (infoPtr
->notifyFormat
== 0) infoPtr
->notifyFormat
= NFR_ANSI
;
9417 TRACE("notify format=%d\n", infoPtr
->notifyFormat
);
9419 if ((infoPtr
->uView
== LV_VIEW_DETAILS
) && (lpcs
->style
& WS_VISIBLE
))
9421 if (LISTVIEW_CreateHeader(infoPtr
) < 0) return -1;
9424 infoPtr
->hwndHeader
= 0;
9426 /* init item size to avoid division by 0 */
9427 LISTVIEW_UpdateItemSize (infoPtr
);
9428 LISTVIEW_UpdateSize (infoPtr
);
9430 if (infoPtr
->uView
== LV_VIEW_DETAILS
)
9432 if (!(LVS_NOCOLUMNHEADER
& lpcs
->style
) && (WS_VISIBLE
& lpcs
->style
))
9434 ShowWindow(infoPtr
->hwndHeader
, SW_SHOWNORMAL
);
9436 LISTVIEW_UpdateScroll(infoPtr
);
9437 /* send WM_MEASUREITEM notification */
9438 if (infoPtr
->dwStyle
& LVS_OWNERDRAWFIXED
) notify_measureitem(infoPtr
);
9441 OpenThemeData(hwnd
, themeClass
);
9443 /* initialize the icon sizes */
9444 set_icon_size(&infoPtr
->iconSize
, infoPtr
->himlNormal
, infoPtr
->uView
!= LV_VIEW_ICON
);
9445 set_icon_size(&infoPtr
->iconStateSize
, infoPtr
->himlState
, TRUE
);
9451 * Destroys the listview control.
9454 * [I] infoPtr : valid pointer to the listview structure
9460 static LRESULT
LISTVIEW_Destroy(LISTVIEW_INFO
*infoPtr
)
9462 HTHEME theme
= GetWindowTheme(infoPtr
->hwndSelf
);
9463 CloseThemeData(theme
);
9465 /* delete all items */
9466 LISTVIEW_DeleteAllItems(infoPtr
, TRUE
);
9473 * Enables the listview control.
9476 * [I] infoPtr : valid pointer to the listview structure
9477 * [I] bEnable : specifies whether to enable or disable the window
9483 static BOOL
LISTVIEW_Enable(const LISTVIEW_INFO
*infoPtr
)
9485 if (infoPtr
->dwStyle
& LVS_OWNERDRAWFIXED
)
9486 InvalidateRect(infoPtr
->hwndSelf
, NULL
, TRUE
);
9492 * Erases the background of the listview control.
9495 * [I] infoPtr : valid pointer to the listview structure
9496 * [I] hdc : device context handle
9502 static inline BOOL
LISTVIEW_EraseBkgnd(const LISTVIEW_INFO
*infoPtr
, HDC hdc
)
9506 TRACE("(hdc=%p)\n", hdc
);
9508 if (!GetClipBox(hdc
, &rc
)) return FALSE
;
9510 if (infoPtr
->clrBk
== CLR_NONE
)
9512 if (infoPtr
->dwLvExStyle
& LVS_EX_TRANSPARENTBKGND
)
9513 return SendMessageW(infoPtr
->hwndNotify
, WM_PRINTCLIENT
,
9514 (WPARAM
)hdc
, PRF_ERASEBKGND
);
9516 return SendMessageW(infoPtr
->hwndNotify
, WM_ERASEBKGND
, (WPARAM
)hdc
, 0);
9519 /* for double buffered controls we need to do this during refresh */
9520 if (infoPtr
->dwLvExStyle
& LVS_EX_DOUBLEBUFFER
) return FALSE
;
9522 return LISTVIEW_FillBkgnd(infoPtr
, hdc
, &rc
);
9528 * Helper function for LISTVIEW_[HV]Scroll *only*.
9529 * Performs vertical/horizontal scrolling by a give amount.
9532 * [I] infoPtr : valid pointer to the listview structure
9533 * [I] dx : amount of horizontal scroll
9534 * [I] dy : amount of vertical scroll
9536 static void scroll_list(LISTVIEW_INFO
*infoPtr
, INT dx
, INT dy
)
9538 /* now we can scroll the list */
9539 ScrollWindowEx(infoPtr
->hwndSelf
, dx
, dy
, &infoPtr
->rcList
,
9540 &infoPtr
->rcList
, 0, 0, SW_ERASE
| SW_INVALIDATE
);
9541 /* if we have focus, adjust rect */
9542 OffsetRect(&infoPtr
->rcFocus
, dx
, dy
);
9543 UpdateWindow(infoPtr
->hwndSelf
);
9548 * Performs vertical scrolling.
9551 * [I] infoPtr : valid pointer to the listview structure
9552 * [I] nScrollCode : scroll code
9553 * [I] nScrollDiff : units to scroll in SB_INTERNAL mode, 0 otherwise
9554 * [I] hScrollWnd : scrollbar control window handle
9560 * SB_LINEUP/SB_LINEDOWN:
9561 * for LVS_ICON, LVS_SMALLICON is 37 by experiment
9562 * for LVS_REPORT is 1 line
9563 * for LVS_LIST cannot occur
9566 static LRESULT
LISTVIEW_VScroll(LISTVIEW_INFO
*infoPtr
, INT nScrollCode
,
9569 INT nOldScrollPos
, nNewScrollPos
;
9570 SCROLLINFO scrollInfo
;
9573 TRACE("(nScrollCode=%d(%s), nScrollDiff=%d)\n", nScrollCode
,
9574 debugscrollcode(nScrollCode
), nScrollDiff
);
9576 if (infoPtr
->hwndEdit
) SendMessageW(infoPtr
->hwndEdit
, WM_KILLFOCUS
, 0, 0);
9578 scrollInfo
.cbSize
= sizeof(SCROLLINFO
);
9579 scrollInfo
.fMask
= SIF_PAGE
| SIF_POS
| SIF_RANGE
| SIF_TRACKPOS
;
9581 is_an_icon
= ((infoPtr
->uView
== LV_VIEW_ICON
) || (infoPtr
->uView
== LV_VIEW_SMALLICON
));
9583 if (!GetScrollInfo(infoPtr
->hwndSelf
, SB_VERT
, &scrollInfo
)) return 1;
9585 nOldScrollPos
= scrollInfo
.nPos
;
9586 switch (nScrollCode
)
9592 nScrollDiff
= (is_an_icon
) ? -LISTVIEW_SCROLL_ICON_LINE_SIZE
: -1;
9596 nScrollDiff
= (is_an_icon
) ? LISTVIEW_SCROLL_ICON_LINE_SIZE
: 1;
9600 nScrollDiff
= -scrollInfo
.nPage
;
9604 nScrollDiff
= scrollInfo
.nPage
;
9607 case SB_THUMBPOSITION
:
9609 nScrollDiff
= scrollInfo
.nTrackPos
- scrollInfo
.nPos
;
9616 /* quit right away if pos isn't changing */
9617 if (nScrollDiff
== 0) return 0;
9619 /* calculate new position, and handle overflows */
9620 nNewScrollPos
= scrollInfo
.nPos
+ nScrollDiff
;
9621 if (nScrollDiff
> 0) {
9622 if (nNewScrollPos
< nOldScrollPos
||
9623 nNewScrollPos
> scrollInfo
.nMax
)
9624 nNewScrollPos
= scrollInfo
.nMax
;
9626 if (nNewScrollPos
> nOldScrollPos
||
9627 nNewScrollPos
< scrollInfo
.nMin
)
9628 nNewScrollPos
= scrollInfo
.nMin
;
9631 /* set the new position, and reread in case it changed */
9632 scrollInfo
.fMask
= SIF_POS
;
9633 scrollInfo
.nPos
= nNewScrollPos
;
9634 nNewScrollPos
= SetScrollInfo(infoPtr
->hwndSelf
, SB_VERT
, &scrollInfo
, TRUE
);
9636 /* carry on only if it really changed */
9637 if (nNewScrollPos
== nOldScrollPos
) return 0;
9639 /* now adjust to client coordinates */
9640 nScrollDiff
= nOldScrollPos
- nNewScrollPos
;
9641 if (infoPtr
->uView
== LV_VIEW_DETAILS
) nScrollDiff
*= infoPtr
->nItemHeight
;
9643 /* and scroll the window */
9644 scroll_list(infoPtr
, 0, nScrollDiff
);
9651 * Performs horizontal scrolling.
9654 * [I] infoPtr : valid pointer to the listview structure
9655 * [I] nScrollCode : scroll code
9656 * [I] nScrollDiff : units to scroll in SB_INTERNAL mode, 0 otherwise
9657 * [I] hScrollWnd : scrollbar control window handle
9663 * SB_LINELEFT/SB_LINERIGHT:
9664 * for LVS_ICON, LVS_SMALLICON 1 pixel
9665 * for LVS_REPORT is 1 pixel
9666 * for LVS_LIST is 1 column --> which is a 1 because the
9667 * scroll is based on columns not pixels
9670 static LRESULT
LISTVIEW_HScroll(LISTVIEW_INFO
*infoPtr
, INT nScrollCode
,
9673 INT nOldScrollPos
, nNewScrollPos
;
9674 SCROLLINFO scrollInfo
;
9677 TRACE("(nScrollCode=%d(%s), nScrollDiff=%d)\n", nScrollCode
,
9678 debugscrollcode(nScrollCode
), nScrollDiff
);
9680 if (infoPtr
->hwndEdit
) SendMessageW(infoPtr
->hwndEdit
, WM_KILLFOCUS
, 0, 0);
9682 scrollInfo
.cbSize
= sizeof(SCROLLINFO
);
9683 scrollInfo
.fMask
= SIF_PAGE
| SIF_POS
| SIF_RANGE
| SIF_TRACKPOS
;
9685 is_an_icon
= ((infoPtr
->uView
== LV_VIEW_ICON
) || (infoPtr
->uView
== LV_VIEW_SMALLICON
));
9687 if (!GetScrollInfo(infoPtr
->hwndSelf
, SB_HORZ
, &scrollInfo
)) return 1;
9689 nOldScrollPos
= scrollInfo
.nPos
;
9691 switch (nScrollCode
)
9697 nScrollDiff
= (is_an_icon
) ? -LISTVIEW_SCROLL_ICON_LINE_SIZE
: -1;
9701 nScrollDiff
= (is_an_icon
) ? LISTVIEW_SCROLL_ICON_LINE_SIZE
: 1;
9705 nScrollDiff
= -scrollInfo
.nPage
;
9709 nScrollDiff
= scrollInfo
.nPage
;
9712 case SB_THUMBPOSITION
:
9714 nScrollDiff
= scrollInfo
.nTrackPos
- scrollInfo
.nPos
;
9721 /* quit right away if pos isn't changing */
9722 if (nScrollDiff
== 0) return 0;
9724 /* calculate new position, and handle overflows */
9725 nNewScrollPos
= scrollInfo
.nPos
+ nScrollDiff
;
9726 if (nScrollDiff
> 0) {
9727 if (nNewScrollPos
< nOldScrollPos
||
9728 nNewScrollPos
> scrollInfo
.nMax
)
9729 nNewScrollPos
= scrollInfo
.nMax
;
9731 if (nNewScrollPos
> nOldScrollPos
||
9732 nNewScrollPos
< scrollInfo
.nMin
)
9733 nNewScrollPos
= scrollInfo
.nMin
;
9736 /* set the new position, and reread in case it changed */
9737 scrollInfo
.fMask
= SIF_POS
;
9738 scrollInfo
.nPos
= nNewScrollPos
;
9739 nNewScrollPos
= SetScrollInfo(infoPtr
->hwndSelf
, SB_HORZ
, &scrollInfo
, TRUE
);
9741 /* carry on only if it really changed */
9742 if (nNewScrollPos
== nOldScrollPos
) return 0;
9744 if (infoPtr
->hwndHeader
) LISTVIEW_UpdateHeaderSize(infoPtr
, nNewScrollPos
);
9746 /* now adjust to client coordinates */
9747 nScrollDiff
= nOldScrollPos
- nNewScrollPos
;
9748 if (infoPtr
->uView
== LV_VIEW_LIST
) nScrollDiff
*= infoPtr
->nItemWidth
;
9750 /* and scroll the window */
9751 scroll_list(infoPtr
, nScrollDiff
, 0);
9756 static LRESULT
LISTVIEW_MouseWheel(LISTVIEW_INFO
*infoPtr
, INT wheelDelta
)
9758 INT gcWheelDelta
= 0;
9759 INT pulScrollLines
= 3;
9761 TRACE("(wheelDelta=%d)\n", wheelDelta
);
9763 SystemParametersInfoW(SPI_GETWHEELSCROLLLINES
,0, &pulScrollLines
, 0);
9764 gcWheelDelta
-= wheelDelta
;
9766 switch(infoPtr
->uView
)
9769 case LV_VIEW_SMALLICON
:
9771 * listview should be scrolled by a multiple of 37 dependently on its dimension or its visible item number
9772 * should be fixed in the future.
9774 LISTVIEW_VScroll(infoPtr
, SB_INTERNAL
, (gcWheelDelta
< 0) ?
9775 -LISTVIEW_SCROLL_ICON_LINE_SIZE
: LISTVIEW_SCROLL_ICON_LINE_SIZE
);
9778 case LV_VIEW_DETAILS
:
9779 if (abs(gcWheelDelta
) >= WHEEL_DELTA
&& pulScrollLines
)
9781 int cLineScroll
= min(LISTVIEW_GetCountPerColumn(infoPtr
), pulScrollLines
);
9782 cLineScroll
*= (gcWheelDelta
/ WHEEL_DELTA
);
9783 LISTVIEW_VScroll(infoPtr
, SB_INTERNAL
, cLineScroll
);
9788 LISTVIEW_HScroll(infoPtr
, (gcWheelDelta
< 0) ? SB_LINELEFT
: SB_LINERIGHT
, 0);
9799 * [I] infoPtr : valid pointer to the listview structure
9800 * [I] nVirtualKey : virtual key
9801 * [I] lKeyData : key data
9806 static LRESULT
LISTVIEW_KeyDown(LISTVIEW_INFO
*infoPtr
, INT nVirtualKey
, LONG lKeyData
)
9808 HWND hwndSelf
= infoPtr
->hwndSelf
;
9810 NMLVKEYDOWN nmKeyDown
;
9812 TRACE("(nVirtualKey=%d, lKeyData=%d)\n", nVirtualKey
, lKeyData
);
9814 /* send LVN_KEYDOWN notification */
9815 nmKeyDown
.wVKey
= nVirtualKey
;
9816 nmKeyDown
.flags
= 0;
9817 notify_hdr(infoPtr
, LVN_KEYDOWN
, &nmKeyDown
.hdr
);
9818 if (!IsWindow(hwndSelf
))
9821 switch (nVirtualKey
)
9824 nItem
= infoPtr
->nFocusedItem
;
9825 if (infoPtr
->dwLvExStyle
& LVS_EX_CHECKBOXES
)
9826 toggle_checkbox_state(infoPtr
, infoPtr
->nFocusedItem
);
9830 if ((infoPtr
->nItemCount
> 0) && (infoPtr
->nFocusedItem
!= -1))
9832 if (!notify(infoPtr
, NM_RETURN
)) return 0;
9833 if (!notify(infoPtr
, LVN_ITEMACTIVATE
)) return 0;
9838 if (infoPtr
->nItemCount
> 0)
9843 if (infoPtr
->nItemCount
> 0)
9844 nItem
= infoPtr
->nItemCount
- 1;
9848 nItem
= LISTVIEW_GetNextItem(infoPtr
, infoPtr
->nFocusedItem
, LVNI_TOLEFT
);
9852 nItem
= LISTVIEW_GetNextItem(infoPtr
, infoPtr
->nFocusedItem
, LVNI_ABOVE
);
9856 nItem
= LISTVIEW_GetNextItem(infoPtr
, infoPtr
->nFocusedItem
, LVNI_TORIGHT
);
9860 nItem
= LISTVIEW_GetNextItem(infoPtr
, infoPtr
->nFocusedItem
, LVNI_BELOW
);
9864 if (infoPtr
->uView
== LV_VIEW_DETAILS
)
9866 INT topidx
= LISTVIEW_GetTopIndex(infoPtr
);
9867 if (infoPtr
->nFocusedItem
== topidx
)
9868 nItem
= topidx
- LISTVIEW_GetCountPerColumn(infoPtr
) + 1;
9873 nItem
= infoPtr
->nFocusedItem
- LISTVIEW_GetCountPerColumn(infoPtr
)
9874 * LISTVIEW_GetCountPerRow(infoPtr
);
9875 if(nItem
< 0) nItem
= 0;
9879 if (infoPtr
->uView
== LV_VIEW_DETAILS
)
9881 INT topidx
= LISTVIEW_GetTopIndex(infoPtr
);
9882 INT cnt
= LISTVIEW_GetCountPerColumn(infoPtr
);
9883 if (infoPtr
->nFocusedItem
== topidx
+ cnt
- 1)
9884 nItem
= infoPtr
->nFocusedItem
+ cnt
- 1;
9886 nItem
= topidx
+ cnt
- 1;
9889 nItem
= infoPtr
->nFocusedItem
+ LISTVIEW_GetCountPerColumn(infoPtr
)
9890 * LISTVIEW_GetCountPerRow(infoPtr
);
9891 if(nItem
>= infoPtr
->nItemCount
) nItem
= infoPtr
->nItemCount
- 1;
9895 if ((nItem
!= -1) && (nItem
!= infoPtr
->nFocusedItem
|| nVirtualKey
== VK_SPACE
))
9896 LISTVIEW_KeySelection(infoPtr
, nItem
, nVirtualKey
== VK_SPACE
);
9906 * [I] infoPtr : valid pointer to the listview structure
9911 static LRESULT
LISTVIEW_KillFocus(LISTVIEW_INFO
*infoPtr
)
9915 /* if we did not have the focus, there's nothing to do */
9916 if (!infoPtr
->bFocus
) return 0;
9918 /* send NM_KILLFOCUS notification */
9919 if (!notify(infoPtr
, NM_KILLFOCUS
)) return 0;
9921 /* if we have a focus rectangle, get rid of it */
9922 LISTVIEW_ShowFocusRect(infoPtr
, FALSE
);
9924 /* if have a marquee selection, stop it */
9925 if (infoPtr
->bMarqueeSelect
)
9927 /* Remove the marquee rectangle and release our mouse capture */
9928 LISTVIEW_InvalidateRect(infoPtr
, &infoPtr
->marqueeRect
);
9931 SetRect(&infoPtr
->marqueeRect
, 0, 0, 0, 0);
9933 infoPtr
->bMarqueeSelect
= FALSE
;
9934 infoPtr
->bScrolling
= FALSE
;
9935 KillTimer(infoPtr
->hwndSelf
, (UINT_PTR
) infoPtr
);
9938 /* set window focus flag */
9939 infoPtr
->bFocus
= FALSE
;
9941 /* invalidate the selected items before resetting focus flag */
9942 LISTVIEW_InvalidateSelectedItems(infoPtr
);
9949 * Processes double click messages (left mouse button).
9952 * [I] infoPtr : valid pointer to the listview structure
9953 * [I] wKey : key flag
9954 * [I] x,y : mouse coordinate
9959 static LRESULT
LISTVIEW_LButtonDblClk(LISTVIEW_INFO
*infoPtr
, WORD wKey
, INT x
, INT y
)
9961 LVHITTESTINFO htInfo
;
9963 TRACE("(key=%hu, X=%u, Y=%u)\n", wKey
, x
, y
);
9965 /* Cancel the item edition if any */
9966 if (infoPtr
->itemEdit
.fEnabled
)
9968 KillTimer(infoPtr
->hwndSelf
, (UINT_PTR
)&infoPtr
->itemEdit
);
9969 infoPtr
->itemEdit
.fEnabled
= FALSE
;
9972 /* send NM_RELEASEDCAPTURE notification */
9973 if (!notify(infoPtr
, NM_RELEASEDCAPTURE
)) return 0;
9978 /* send NM_DBLCLK notification */
9979 LISTVIEW_HitTest(infoPtr
, &htInfo
, TRUE
, FALSE
);
9980 if (!notify_click(infoPtr
, NM_DBLCLK
, &htInfo
)) return 0;
9982 /* To send the LVN_ITEMACTIVATE, it must be on an Item */
9983 if(htInfo
.iItem
!= -1) notify_itemactivate(infoPtr
,&htInfo
);
9990 * Processes mouse down messages (left mouse button).
9993 * infoPtr [I ] valid pointer to the listview structure
9994 * wKey [I ] key flag
9995 * x,y [I ] mouse coordinate
10000 static LRESULT
LISTVIEW_LButtonDown(LISTVIEW_INFO
*infoPtr
, WORD wKey
, INT x
, INT y
)
10002 LVHITTESTINFO lvHitTestInfo
;
10003 static BOOL bGroupSelect
= TRUE
;
10004 POINT pt
= { x
, y
};
10007 TRACE("(key=%hu, X=%u, Y=%u)\n", wKey
, x
, y
);
10009 /* send NM_RELEASEDCAPTURE notification */
10010 if (!notify(infoPtr
, NM_RELEASEDCAPTURE
)) return 0;
10012 /* set left button down flag and record the click position */
10013 infoPtr
->bLButtonDown
= TRUE
;
10014 infoPtr
->ptClickPos
= pt
;
10015 infoPtr
->bDragging
= FALSE
;
10016 infoPtr
->bMarqueeSelect
= FALSE
;
10017 infoPtr
->bScrolling
= FALSE
;
10019 lvHitTestInfo
.pt
.x
= x
;
10020 lvHitTestInfo
.pt
.y
= y
;
10022 nItem
= LISTVIEW_HitTest(infoPtr
, &lvHitTestInfo
, TRUE
, TRUE
);
10023 TRACE("at %s, nItem=%d\n", wine_dbgstr_point(&pt
), nItem
);
10024 if ((nItem
>= 0) && (nItem
< infoPtr
->nItemCount
))
10026 if ((infoPtr
->dwLvExStyle
& LVS_EX_CHECKBOXES
) && (lvHitTestInfo
.flags
& LVHT_ONITEMSTATEICON
))
10028 toggle_checkbox_state(infoPtr
, nItem
);
10032 if (infoPtr
->dwStyle
& LVS_SINGLESEL
)
10034 if (LISTVIEW_GetItemState(infoPtr
, nItem
, LVIS_SELECTED
))
10035 infoPtr
->nEditLabelItem
= nItem
;
10037 LISTVIEW_SetSelection(infoPtr
, nItem
);
10041 if ((wKey
& MK_CONTROL
) && (wKey
& MK_SHIFT
))
10045 if (!LISTVIEW_AddGroupSelection(infoPtr
, nItem
)) return 0;
10046 LISTVIEW_SetItemFocus(infoPtr
, nItem
);
10047 infoPtr
->nSelectionMark
= nItem
;
10053 item
.state
= LVIS_SELECTED
| LVIS_FOCUSED
;
10054 item
.stateMask
= LVIS_SELECTED
| LVIS_FOCUSED
;
10056 LISTVIEW_SetItemState(infoPtr
,nItem
,&item
);
10057 infoPtr
->nSelectionMark
= nItem
;
10060 else if (wKey
& MK_CONTROL
)
10064 bGroupSelect
= (LISTVIEW_GetItemState(infoPtr
, nItem
, LVIS_SELECTED
) == 0);
10066 item
.state
= (bGroupSelect
? LVIS_SELECTED
: 0) | LVIS_FOCUSED
;
10067 item
.stateMask
= LVIS_SELECTED
| LVIS_FOCUSED
;
10068 LISTVIEW_SetItemState(infoPtr
, nItem
, &item
);
10069 infoPtr
->nSelectionMark
= nItem
;
10071 else if (wKey
& MK_SHIFT
)
10073 LISTVIEW_SetGroupSelection(infoPtr
, nItem
);
10077 if (LISTVIEW_GetItemState(infoPtr
, nItem
, LVIS_SELECTED
))
10079 infoPtr
->nEditLabelItem
= nItem
;
10080 infoPtr
->nLButtonDownItem
= nItem
;
10082 LISTVIEW_SetItemFocus(infoPtr
, nItem
);
10085 /* set selection (clears other pre-existing selections) */
10086 LISTVIEW_SetSelection(infoPtr
, nItem
);
10090 if (infoPtr
->dwLvExStyle
& LVS_EX_ONECLICKACTIVATE
)
10091 if(lvHitTestInfo
.iItem
!= -1) notify_itemactivate(infoPtr
,&lvHitTestInfo
);
10095 if (!infoPtr
->bFocus
)
10096 SetFocus(infoPtr
->hwndSelf
);
10098 /* remove all selections */
10099 if (!(wKey
& MK_CONTROL
) && !(wKey
& MK_SHIFT
))
10100 LISTVIEW_DeselectAll(infoPtr
);
10109 * Processes mouse up messages (left mouse button).
10112 * infoPtr [I ] valid pointer to the listview structure
10113 * wKey [I ] key flag
10114 * x,y [I ] mouse coordinate
10119 static LRESULT
LISTVIEW_LButtonUp(LISTVIEW_INFO
*infoPtr
, WORD wKey
, INT x
, INT y
)
10121 LVHITTESTINFO lvHitTestInfo
;
10123 TRACE("(key=%hu, X=%u, Y=%u)\n", wKey
, x
, y
);
10125 if (!infoPtr
->bLButtonDown
) return 0;
10127 lvHitTestInfo
.pt
.x
= x
;
10128 lvHitTestInfo
.pt
.y
= y
;
10130 /* send NM_CLICK notification */
10131 LISTVIEW_HitTest(infoPtr
, &lvHitTestInfo
, TRUE
, FALSE
);
10132 if (!notify_click(infoPtr
, NM_CLICK
, &lvHitTestInfo
)) return 0;
10134 /* set left button flag */
10135 infoPtr
->bLButtonDown
= FALSE
;
10137 /* set a single selection, reset others */
10138 if(lvHitTestInfo
.iItem
== infoPtr
->nLButtonDownItem
&& lvHitTestInfo
.iItem
!= -1)
10139 LISTVIEW_SetSelection(infoPtr
, infoPtr
->nLButtonDownItem
);
10140 infoPtr
->nLButtonDownItem
= -1;
10142 if (infoPtr
->bDragging
|| infoPtr
->bMarqueeSelect
)
10144 /* Remove the marquee rectangle and release our mouse capture */
10145 if (infoPtr
->bMarqueeSelect
)
10147 LISTVIEW_InvalidateRect(infoPtr
, &infoPtr
->marqueeDrawRect
);
10151 SetRect(&infoPtr
->marqueeRect
, 0, 0, 0, 0);
10152 SetRect(&infoPtr
->marqueeDrawRect
, 0, 0, 0, 0);
10154 infoPtr
->bDragging
= FALSE
;
10155 infoPtr
->bMarqueeSelect
= FALSE
;
10156 infoPtr
->bScrolling
= FALSE
;
10158 KillTimer(infoPtr
->hwndSelf
, (UINT_PTR
) infoPtr
);
10162 /* if we clicked on a selected item, edit the label */
10163 if(lvHitTestInfo
.iItem
== infoPtr
->nEditLabelItem
&& (lvHitTestInfo
.flags
& LVHT_ONITEMLABEL
))
10165 /* we want to make sure the user doesn't want to do a double click. So we will
10166 * delay the edit. WM_LBUTTONDBLCLICK will cancel the timer
10168 infoPtr
->itemEdit
.fEnabled
= TRUE
;
10169 infoPtr
->itemEdit
.iItem
= lvHitTestInfo
.iItem
;
10170 SetTimer(infoPtr
->hwndSelf
,
10171 (UINT_PTR
)&infoPtr
->itemEdit
,
10172 GetDoubleClickTime(),
10173 LISTVIEW_DelayedEditItem
);
10176 if (!infoPtr
->bFocus
)
10177 SetFocus(infoPtr
->hwndSelf
);
10184 * Destroys the listview control (called after WM_DESTROY).
10187 * [I] infoPtr : valid pointer to the listview structure
10192 static LRESULT
LISTVIEW_NCDestroy(LISTVIEW_INFO
*infoPtr
)
10198 /* destroy data structure */
10199 DPA_Destroy(infoPtr
->hdpaItems
);
10200 DPA_Destroy(infoPtr
->hdpaItemIds
);
10201 DPA_Destroy(infoPtr
->hdpaPosX
);
10202 DPA_Destroy(infoPtr
->hdpaPosY
);
10204 for (i
= 0; i
< DPA_GetPtrCount(infoPtr
->hdpaColumns
); i
++)
10205 Free(DPA_GetPtr(infoPtr
->hdpaColumns
, i
));
10206 DPA_Destroy(infoPtr
->hdpaColumns
);
10207 ranges_destroy(infoPtr
->selectionRanges
);
10209 /* destroy image lists */
10210 if (!(infoPtr
->dwStyle
& LVS_SHAREIMAGELISTS
))
10212 ImageList_Destroy(infoPtr
->himlNormal
);
10213 ImageList_Destroy(infoPtr
->himlSmall
);
10214 ImageList_Destroy(infoPtr
->himlState
);
10217 /* destroy font, bkgnd brush */
10218 infoPtr
->hFont
= 0;
10219 if (infoPtr
->hDefaultFont
) DeleteObject(infoPtr
->hDefaultFont
);
10220 if (infoPtr
->clrBk
!= CLR_NONE
) DeleteObject(infoPtr
->hBkBrush
);
10222 SetWindowLongPtrW(infoPtr
->hwndSelf
, 0, 0);
10224 /* free listview info pointer*/
10232 * Handles notifications.
10235 * [I] infoPtr : valid pointer to the listview structure
10236 * [I] lpnmhdr : notification information
10241 static LRESULT
LISTVIEW_Notify(LISTVIEW_INFO
*infoPtr
, const NMHDR
*lpnmhdr
)
10243 const NMHEADERW
*lpnmh
;
10245 TRACE("(lpnmhdr=%p)\n", lpnmhdr
);
10247 if (!lpnmhdr
|| lpnmhdr
->hwndFrom
!= infoPtr
->hwndHeader
) return 0;
10249 /* remember: HDN_LAST < HDN_FIRST */
10250 if (lpnmhdr
->code
> HDN_FIRST
|| lpnmhdr
->code
< HDN_LAST
) return 0;
10251 lpnmh
= (const NMHEADERW
*)lpnmhdr
;
10253 if (lpnmh
->iItem
< 0 || lpnmh
->iItem
>= DPA_GetPtrCount(infoPtr
->hdpaColumns
)) return 0;
10255 switch (lpnmhdr
->code
)
10260 COLUMN_INFO
*lpColumnInfo
;
10264 if (!lpnmh
->pitem
|| !(lpnmh
->pitem
->mask
& HDI_WIDTH
))
10267 /* remove the old line (if any) */
10268 LISTVIEW_DrawTrackLine(infoPtr
);
10270 /* compute & draw the new line */
10271 lpColumnInfo
= LISTVIEW_GetColumnInfo(infoPtr
, lpnmh
->iItem
);
10272 x
= lpColumnInfo
->rcHeader
.left
+ lpnmh
->pitem
->cxy
;
10273 LISTVIEW_GetOrigin(infoPtr
, &ptOrigin
);
10274 infoPtr
->xTrackLine
= x
+ ptOrigin
.x
;
10275 LISTVIEW_DrawTrackLine(infoPtr
);
10279 case HDN_ENDTRACKA
:
10280 case HDN_ENDTRACKW
:
10281 /* remove the track line (if any) */
10282 LISTVIEW_DrawTrackLine(infoPtr
);
10283 infoPtr
->xTrackLine
= -1;
10286 case HDN_BEGINDRAG
:
10287 notify_forward_header(infoPtr
, lpnmh
);
10288 return (infoPtr
->dwLvExStyle
& LVS_EX_HEADERDRAGDROP
) == 0;
10291 infoPtr
->colRectsDirty
= TRUE
;
10292 LISTVIEW_InvalidateList(infoPtr
);
10293 notify_forward_header(infoPtr
, lpnmh
);
10296 case HDN_ITEMCHANGEDW
:
10297 case HDN_ITEMCHANGEDA
:
10299 COLUMN_INFO
*lpColumnInfo
;
10303 if (!lpnmh
->pitem
|| !(lpnmh
->pitem
->mask
& HDI_WIDTH
))
10305 hdi
.mask
= HDI_WIDTH
;
10306 if (!SendMessageW(infoPtr
->hwndHeader
, HDM_GETITEMW
, lpnmh
->iItem
, (LPARAM
)&hdi
)) return 0;
10310 cxy
= lpnmh
->pitem
->cxy
;
10312 /* determine how much we change since the last know position */
10313 lpColumnInfo
= LISTVIEW_GetColumnInfo(infoPtr
, lpnmh
->iItem
);
10314 dx
= cxy
- (lpColumnInfo
->rcHeader
.right
- lpColumnInfo
->rcHeader
.left
);
10317 lpColumnInfo
->rcHeader
.right
+= dx
;
10319 hdi
.mask
= HDI_ORDER
;
10320 SendMessageW(infoPtr
->hwndHeader
, HDM_GETITEMW
, lpnmh
->iItem
, (LPARAM
)&hdi
);
10322 /* not the rightmost one */
10323 if (hdi
.iOrder
+ 1 < DPA_GetPtrCount(infoPtr
->hdpaColumns
))
10325 INT nIndex
= SendMessageW(infoPtr
->hwndHeader
, HDM_ORDERTOINDEX
,
10326 hdi
.iOrder
+ 1, 0);
10327 LISTVIEW_ScrollColumns(infoPtr
, nIndex
, dx
);
10331 /* only needs to update the scrolls */
10332 infoPtr
->nItemWidth
+= dx
;
10333 LISTVIEW_UpdateScroll(infoPtr
);
10335 LISTVIEW_UpdateItemSize(infoPtr
);
10336 if (infoPtr
->uView
== LV_VIEW_DETAILS
&& is_redrawing(infoPtr
))
10339 RECT rcCol
= lpColumnInfo
->rcHeader
;
10341 LISTVIEW_GetOrigin(infoPtr
, &ptOrigin
);
10342 OffsetRect(&rcCol
, ptOrigin
.x
, 0);
10344 rcCol
.top
= infoPtr
->rcList
.top
;
10345 rcCol
.bottom
= infoPtr
->rcList
.bottom
;
10347 /* resizing left-aligned columns leaves most of the left side untouched */
10348 if ((lpColumnInfo
->fmt
& LVCFMT_JUSTIFYMASK
) == LVCFMT_LEFT
)
10350 INT nMaxDirty
= infoPtr
->nEllipsisWidth
+ infoPtr
->ntmMaxCharWidth
;
10353 rcCol
.left
= max (rcCol
.left
, rcCol
.right
- nMaxDirty
);
10356 /* when shrinking the last column clear the now unused field */
10357 if (hdi
.iOrder
== DPA_GetPtrCount(infoPtr
->hdpaColumns
) - 1)
10363 /* deal with right from rightmost column area */
10364 right
.left
= rcCol
.right
;
10365 right
.top
= rcCol
.top
;
10366 right
.bottom
= rcCol
.bottom
;
10367 right
.right
= infoPtr
->rcList
.right
;
10369 LISTVIEW_InvalidateRect(infoPtr
, &right
);
10372 LISTVIEW_InvalidateRect(infoPtr
, &rcCol
);
10378 case HDN_ITEMCLICKW
:
10379 case HDN_ITEMCLICKA
:
10381 /* Handle sorting by Header Column */
10384 ZeroMemory(&nmlv
, sizeof(NMLISTVIEW
));
10386 nmlv
.iSubItem
= lpnmh
->iItem
;
10387 notify_listview(infoPtr
, LVN_COLUMNCLICK
, &nmlv
);
10388 notify_forward_header(infoPtr
, lpnmh
);
10392 case HDN_DIVIDERDBLCLICKW
:
10393 case HDN_DIVIDERDBLCLICKA
:
10394 /* FIXME: for LVS_EX_HEADERINALLVIEWS and not LV_VIEW_DETAILS
10395 we should use LVSCW_AUTOSIZE_USEHEADER, helper rework or
10396 split needed for that */
10397 LISTVIEW_SetColumnWidth(infoPtr
, lpnmh
->iItem
, LVSCW_AUTOSIZE
);
10398 notify_forward_header(infoPtr
, lpnmh
);
10407 * Paint non-client area of control.
10410 * [I] infoPtr : valid pointer to the listview structureof the sender
10411 * [I] region : update region
10414 * TRUE - frame was painted
10415 * FALSE - call default window proc
10417 static BOOL
LISTVIEW_NCPaint(const LISTVIEW_INFO
*infoPtr
, HRGN region
)
10419 HTHEME theme
= GetWindowTheme (infoPtr
->hwndSelf
);
10423 int cxEdge
= GetSystemMetrics (SM_CXEDGE
),
10424 cyEdge
= GetSystemMetrics (SM_CYEDGE
);
10427 return DefWindowProcW (infoPtr
->hwndSelf
, WM_NCPAINT
, (WPARAM
)region
, 0);
10429 GetWindowRect(infoPtr
->hwndSelf
, &r
);
10431 cliprgn
= CreateRectRgn (r
.left
+ cxEdge
, r
.top
+ cyEdge
,
10432 r
.right
- cxEdge
, r
.bottom
- cyEdge
);
10433 if (region
!= (HRGN
)1)
10434 CombineRgn (cliprgn
, cliprgn
, region
, RGN_AND
);
10435 OffsetRect(&r
, -r
.left
, -r
.top
);
10437 dc
= GetDCEx(infoPtr
->hwndSelf
, region
, DCX_WINDOW
|DCX_INTERSECTRGN
);
10438 OffsetRect(&r
, -r
.left
, -r
.top
);
10440 if (IsThemeBackgroundPartiallyTransparent (theme
, 0, 0))
10441 DrawThemeParentBackground(infoPtr
->hwndSelf
, dc
, &r
);
10442 DrawThemeBackground (theme
, dc
, 0, 0, &r
, 0);
10443 ReleaseDC(infoPtr
->hwndSelf
, dc
);
10445 /* Call default proc to get the scrollbars etc. painted */
10446 DefWindowProcW (infoPtr
->hwndSelf
, WM_NCPAINT
, (WPARAM
)cliprgn
, 0);
10453 * Determines the type of structure to use.
10456 * [I] infoPtr : valid pointer to the listview structureof the sender
10457 * [I] hwndFrom : listview window handle
10458 * [I] nCommand : command specifying the nature of the WM_NOTIFYFORMAT
10463 static LRESULT
LISTVIEW_NotifyFormat(LISTVIEW_INFO
*infoPtr
, HWND hwndFrom
, INT nCommand
)
10465 TRACE("(hwndFrom=%p, nCommand=%d)\n", hwndFrom
, nCommand
);
10467 if (nCommand
== NF_REQUERY
)
10468 infoPtr
->notifyFormat
= SendMessageW(infoPtr
->hwndNotify
, WM_NOTIFYFORMAT
, (WPARAM
)infoPtr
->hwndSelf
, NF_QUERY
);
10470 return infoPtr
->notifyFormat
;
10475 * Paints/Repaints the listview control. Internal use.
10478 * [I] infoPtr : valid pointer to the listview structure
10479 * [I] hdc : device context handle
10484 static LRESULT
LISTVIEW_Paint(LISTVIEW_INFO
*infoPtr
, HDC hdc
)
10486 TRACE("(hdc=%p)\n", hdc
);
10488 if (infoPtr
->bNoItemMetrics
&& infoPtr
->nItemCount
)
10490 infoPtr
->bNoItemMetrics
= FALSE
;
10491 LISTVIEW_UpdateItemSize(infoPtr
);
10492 if (infoPtr
->uView
== LV_VIEW_ICON
|| infoPtr
->uView
== LV_VIEW_SMALLICON
)
10493 LISTVIEW_Arrange(infoPtr
, LVA_DEFAULT
);
10494 LISTVIEW_UpdateScroll(infoPtr
);
10497 if (infoPtr
->hwndHeader
) UpdateWindow(infoPtr
->hwndHeader
);
10500 LISTVIEW_Refresh(infoPtr
, hdc
, NULL
);
10505 hdc
= BeginPaint(infoPtr
->hwndSelf
, &ps
);
10506 if (!hdc
) return 1;
10507 LISTVIEW_Refresh(infoPtr
, hdc
, ps
.fErase
? &ps
.rcPaint
: NULL
);
10508 EndPaint(infoPtr
->hwndSelf
, &ps
);
10516 * Paints/Repaints the listview control, WM_PAINT handler.
10519 * [I] infoPtr : valid pointer to the listview structure
10520 * [I] hdc : device context handle
10525 static inline LRESULT
LISTVIEW_WMPaint(LISTVIEW_INFO
*infoPtr
, HDC hdc
)
10527 TRACE("(hdc=%p)\n", hdc
);
10529 if (!is_redrawing(infoPtr
))
10530 return DefWindowProcW (infoPtr
->hwndSelf
, WM_PAINT
, (WPARAM
)hdc
, 0);
10532 return LISTVIEW_Paint(infoPtr
, hdc
);
10537 * Paints/Repaints the listview control.
10540 * [I] infoPtr : valid pointer to the listview structure
10541 * [I] hdc : device context handle
10542 * [I] options : drawing options
10547 static LRESULT
LISTVIEW_PrintClient(LISTVIEW_INFO
*infoPtr
, HDC hdc
, DWORD options
)
10549 FIXME("Partial Stub: (hdc=%p options=0x%08x)\n", hdc
, options
);
10551 if ((options
& PRF_CHECKVISIBLE
) && !IsWindowVisible(infoPtr
->hwndSelf
))
10554 if (options
& PRF_ERASEBKGND
)
10555 LISTVIEW_EraseBkgnd(infoPtr
, hdc
);
10557 if (options
& PRF_CLIENT
)
10558 LISTVIEW_Paint(infoPtr
, hdc
);
10566 * Processes double click messages (right mouse button).
10569 * [I] infoPtr : valid pointer to the listview structure
10570 * [I] wKey : key flag
10571 * [I] x,y : mouse coordinate
10576 static LRESULT
LISTVIEW_RButtonDblClk(const LISTVIEW_INFO
*infoPtr
, WORD wKey
, INT x
, INT y
)
10578 LVHITTESTINFO lvHitTestInfo
;
10580 TRACE("(key=%hu,X=%u,Y=%u)\n", wKey
, x
, y
);
10582 /* send NM_RELEASEDCAPTURE notification */
10583 if (!notify(infoPtr
, NM_RELEASEDCAPTURE
)) return 0;
10585 /* send NM_RDBLCLK notification */
10586 lvHitTestInfo
.pt
.x
= x
;
10587 lvHitTestInfo
.pt
.y
= y
;
10588 LISTVIEW_HitTest(infoPtr
, &lvHitTestInfo
, TRUE
, FALSE
);
10589 notify_click(infoPtr
, NM_RDBLCLK
, &lvHitTestInfo
);
10596 * Processes mouse down messages (right mouse button).
10599 * [I] infoPtr : valid pointer to the listview structure
10600 * [I] wKey : key flag
10601 * [I] x,y : mouse coordinate
10606 static LRESULT
LISTVIEW_RButtonDown(LISTVIEW_INFO
*infoPtr
, WORD wKey
, INT x
, INT y
)
10608 LVHITTESTINFO lvHitTestInfo
;
10611 TRACE("(key=%hu,X=%u,Y=%u)\n", wKey
, x
, y
);
10613 /* send NM_RELEASEDCAPTURE notification */
10614 if (!notify(infoPtr
, NM_RELEASEDCAPTURE
)) return 0;
10616 /* make sure the listview control window has the focus */
10617 if (!infoPtr
->bFocus
) SetFocus(infoPtr
->hwndSelf
);
10619 /* set right button down flag */
10620 infoPtr
->bRButtonDown
= TRUE
;
10622 /* determine the index of the selected item */
10623 lvHitTestInfo
.pt
.x
= x
;
10624 lvHitTestInfo
.pt
.y
= y
;
10625 nItem
= LISTVIEW_HitTest(infoPtr
, &lvHitTestInfo
, TRUE
, TRUE
);
10627 if ((nItem
>= 0) && (nItem
< infoPtr
->nItemCount
))
10629 LISTVIEW_SetItemFocus(infoPtr
, nItem
);
10630 if (!((wKey
& MK_SHIFT
) || (wKey
& MK_CONTROL
)) &&
10631 !LISTVIEW_GetItemState(infoPtr
, nItem
, LVIS_SELECTED
))
10632 LISTVIEW_SetSelection(infoPtr
, nItem
);
10636 LISTVIEW_DeselectAll(infoPtr
);
10644 * Processes mouse up messages (right mouse button).
10647 * [I] infoPtr : valid pointer to the listview structure
10648 * [I] wKey : key flag
10649 * [I] x,y : mouse coordinate
10654 static LRESULT
LISTVIEW_RButtonUp(LISTVIEW_INFO
*infoPtr
, WORD wKey
, INT x
, INT y
)
10656 LVHITTESTINFO lvHitTestInfo
;
10659 TRACE("(key=%hu,X=%u,Y=%u)\n", wKey
, x
, y
);
10661 if (!infoPtr
->bRButtonDown
) return 0;
10663 /* set button flag */
10664 infoPtr
->bRButtonDown
= FALSE
;
10666 /* Send NM_RCLICK notification */
10667 lvHitTestInfo
.pt
.x
= x
;
10668 lvHitTestInfo
.pt
.y
= y
;
10669 LISTVIEW_HitTest(infoPtr
, &lvHitTestInfo
, TRUE
, FALSE
);
10670 if (!notify_click(infoPtr
, NM_RCLICK
, &lvHitTestInfo
)) return 0;
10672 /* Change to screen coordinate for WM_CONTEXTMENU */
10673 pt
= lvHitTestInfo
.pt
;
10674 ClientToScreen(infoPtr
->hwndSelf
, &pt
);
10676 /* Send a WM_CONTEXTMENU message in response to the RBUTTONUP */
10677 SendMessageW(infoPtr
->hwndSelf
, WM_CONTEXTMENU
,
10678 (WPARAM
)infoPtr
->hwndSelf
, MAKELPARAM(pt
.x
, pt
.y
));
10689 * [I] infoPtr : valid pointer to the listview structure
10690 * [I] hwnd : window handle of window containing the cursor
10691 * [I] nHittest : hit-test code
10692 * [I] wMouseMsg : ideintifier of the mouse message
10695 * TRUE if cursor is set
10698 static BOOL
LISTVIEW_SetCursor(const LISTVIEW_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
10700 LVHITTESTINFO lvHitTestInfo
;
10702 if (!LISTVIEW_IsHotTracking(infoPtr
)) goto forward
;
10704 if (!infoPtr
->hHotCursor
) goto forward
;
10706 GetCursorPos(&lvHitTestInfo
.pt
);
10707 if (LISTVIEW_HitTest(infoPtr
, &lvHitTestInfo
, FALSE
, FALSE
) < 0) goto forward
;
10709 SetCursor(infoPtr
->hHotCursor
);
10715 return DefWindowProcW(infoPtr
->hwndSelf
, WM_SETCURSOR
, wParam
, lParam
);
10723 * [I] infoPtr : valid pointer to the listview structure
10724 * [I] hwndLoseFocus : handle of previously focused window
10729 static LRESULT
LISTVIEW_SetFocus(LISTVIEW_INFO
*infoPtr
, HWND hwndLoseFocus
)
10731 TRACE("(hwndLoseFocus=%p)\n", hwndLoseFocus
);
10733 /* if we have the focus already, there's nothing to do */
10734 if (infoPtr
->bFocus
) return 0;
10736 /* send NM_SETFOCUS notification */
10737 if (!notify(infoPtr
, NM_SETFOCUS
)) return 0;
10739 /* set window focus flag */
10740 infoPtr
->bFocus
= TRUE
;
10742 /* put the focus rect back on */
10743 LISTVIEW_ShowFocusRect(infoPtr
, TRUE
);
10745 /* redraw all visible selected items */
10746 LISTVIEW_InvalidateSelectedItems(infoPtr
);
10756 * [I] infoPtr : valid pointer to the listview structure
10757 * [I] fRedraw : font handle
10758 * [I] fRedraw : redraw flag
10763 static LRESULT
LISTVIEW_SetFont(LISTVIEW_INFO
*infoPtr
, HFONT hFont
, WORD fRedraw
)
10765 HFONT oldFont
= infoPtr
->hFont
;
10767 TRACE("(hfont=%p,redraw=%hu)\n", hFont
, fRedraw
);
10769 infoPtr
->hFont
= hFont
? hFont
: infoPtr
->hDefaultFont
;
10770 if (infoPtr
->hFont
== oldFont
) return 0;
10772 LISTVIEW_SaveTextMetrics(infoPtr
);
10774 if (infoPtr
->uView
== LV_VIEW_DETAILS
)
10776 SendMessageW(infoPtr
->hwndHeader
, WM_SETFONT
, (WPARAM
)hFont
, MAKELPARAM(fRedraw
, 0));
10777 LISTVIEW_UpdateSize(infoPtr
);
10778 LISTVIEW_UpdateScroll(infoPtr
);
10781 if (fRedraw
) LISTVIEW_InvalidateList(infoPtr
);
10788 * Message handling for WM_SETREDRAW.
10789 * For the Listview, it invalidates the entire window (the doc specifies otherwise)
10792 * [I] infoPtr : valid pointer to the listview structure
10793 * [I] bRedraw: state of redraw flag
10796 * DefWinProc return value
10798 static LRESULT
LISTVIEW_SetRedraw(LISTVIEW_INFO
*infoPtr
, BOOL bRedraw
)
10800 TRACE("infoPtr->bRedraw=%d, bRedraw=%d\n", infoPtr
->bRedraw
, bRedraw
);
10802 /* we cannot use straight equality here because _any_ non-zero value is TRUE */
10803 if ((infoPtr
->bRedraw
&& bRedraw
) || (!infoPtr
->bRedraw
&& !bRedraw
)) return 0;
10805 infoPtr
->bRedraw
= bRedraw
;
10807 if(!bRedraw
) return 0;
10809 if (is_autoarrange(infoPtr
))
10810 LISTVIEW_Arrange(infoPtr
, LVA_DEFAULT
);
10811 LISTVIEW_UpdateScroll(infoPtr
);
10813 /* despite what the WM_SETREDRAW docs says, apps expect us
10814 * to invalidate the listview here... stupid! */
10815 LISTVIEW_InvalidateList(infoPtr
);
10822 * Resizes the listview control. This function processes WM_SIZE
10823 * messages. At this time, the width and height are not used.
10826 * [I] infoPtr : valid pointer to the listview structure
10827 * [I] Width : new width
10828 * [I] Height : new height
10833 static LRESULT
LISTVIEW_Size(LISTVIEW_INFO
*infoPtr
, int Width
, int Height
)
10835 RECT rcOld
= infoPtr
->rcList
;
10837 TRACE("(width=%d, height=%d)\n", Width
, Height
);
10839 LISTVIEW_UpdateSize(infoPtr
);
10840 if (EqualRect(&rcOld
, &infoPtr
->rcList
)) return 0;
10842 /* do not bother with display related stuff if we're not redrawing */
10843 if (!is_redrawing(infoPtr
)) return 0;
10845 if (is_autoarrange(infoPtr
))
10846 LISTVIEW_Arrange(infoPtr
, LVA_DEFAULT
);
10848 LISTVIEW_UpdateScroll(infoPtr
);
10850 /* refresh all only for lists whose height changed significantly */
10851 if ((infoPtr
->uView
== LV_VIEW_LIST
) &&
10852 (rcOld
.bottom
- rcOld
.top
) / infoPtr
->nItemHeight
!=
10853 (infoPtr
->rcList
.bottom
- infoPtr
->rcList
.top
) / infoPtr
->nItemHeight
)
10854 LISTVIEW_InvalidateList(infoPtr
);
10861 * Sets the size information.
10864 * [I] infoPtr : valid pointer to the listview structure
10869 static void LISTVIEW_UpdateSize(LISTVIEW_INFO
*infoPtr
)
10871 TRACE("uView=%d, rcList(old)=%s\n", infoPtr
->uView
, wine_dbgstr_rect(&infoPtr
->rcList
));
10873 GetClientRect(infoPtr
->hwndSelf
, &infoPtr
->rcList
);
10875 if (infoPtr
->uView
== LV_VIEW_LIST
)
10877 /* Apparently the "LIST" style is supposed to have the same
10878 * number of items in a column even if there is no scroll bar.
10879 * Since if a scroll bar already exists then the bottom is already
10880 * reduced, only reduce if the scroll bar does not currently exist.
10881 * The "2" is there to mimic the native control. I think it may be
10882 * related to either padding or edges. (GLA 7/2002)
10884 if (!(GetWindowLongW(infoPtr
->hwndSelf
, GWL_STYLE
) & WS_HSCROLL
))
10885 infoPtr
->rcList
.bottom
-= GetSystemMetrics(SM_CYHSCROLL
);
10886 infoPtr
->rcList
.bottom
= max (infoPtr
->rcList
.bottom
- 2, 0);
10889 /* if control created invisible header isn't created */
10890 if (infoPtr
->hwndHeader
)
10895 hl
.prc
= &infoPtr
->rcList
;
10897 SendMessageW( infoPtr
->hwndHeader
, HDM_LAYOUT
, 0, (LPARAM
)&hl
);
10898 TRACE(" wp.flags=0x%08x, wp=%d,%d (%dx%d)\n", wp
.flags
, wp
.x
, wp
.y
, wp
.cx
, wp
.cy
);
10900 if (LISTVIEW_IsHeaderEnabled(infoPtr
))
10901 wp
.flags
|= SWP_SHOWWINDOW
;
10904 wp
.flags
|= SWP_HIDEWINDOW
;
10908 SetWindowPos(wp
.hwnd
, wp
.hwndInsertAfter
, wp
.x
, wp
.y
, wp
.cx
, wp
.cy
, wp
.flags
);
10909 TRACE(" after SWP wp=%d,%d (%dx%d)\n", wp
.x
, wp
.y
, wp
.cx
, wp
.cy
);
10911 infoPtr
->rcList
.top
= max(wp
.cy
, 0);
10913 /* extra padding for grid */
10914 if (infoPtr
->uView
== LV_VIEW_DETAILS
&& infoPtr
->dwLvExStyle
& LVS_EX_GRIDLINES
)
10915 infoPtr
->rcList
.top
+= 2;
10917 TRACE(" rcList=%s\n", wine_dbgstr_rect(&infoPtr
->rcList
));
10922 * Processes WM_STYLECHANGED messages.
10925 * [I] infoPtr : valid pointer to the listview structure
10926 * [I] wStyleType : window style type (normal or extended)
10927 * [I] lpss : window style information
10932 static INT
LISTVIEW_StyleChanged(LISTVIEW_INFO
*infoPtr
, WPARAM wStyleType
,
10933 const STYLESTRUCT
*lpss
)
10935 UINT uNewView
= lpss
->styleNew
& LVS_TYPEMASK
;
10936 UINT uOldView
= lpss
->styleOld
& LVS_TYPEMASK
;
10939 TRACE("(styletype=%lx, styleOld=0x%08x, styleNew=0x%08x)\n",
10940 wStyleType
, lpss
->styleOld
, lpss
->styleNew
);
10942 if (wStyleType
!= GWL_STYLE
) return 0;
10944 infoPtr
->dwStyle
= lpss
->styleNew
;
10945 map_style_view(infoPtr
);
10947 if (((lpss
->styleOld
& WS_HSCROLL
) != 0)&&
10948 ((lpss
->styleNew
& WS_HSCROLL
) == 0))
10949 ShowScrollBar(infoPtr
->hwndSelf
, SB_HORZ
, FALSE
);
10951 if (((lpss
->styleOld
& WS_VSCROLL
) != 0)&&
10952 ((lpss
->styleNew
& WS_VSCROLL
) == 0))
10953 ShowScrollBar(infoPtr
->hwndSelf
, SB_VERT
, FALSE
);
10955 if (uNewView
!= uOldView
)
10957 SIZE oldIconSize
= infoPtr
->iconSize
;
10960 SendMessageW(infoPtr
->hwndEdit
, WM_KILLFOCUS
, 0, 0);
10961 ShowWindow(infoPtr
->hwndHeader
, SW_HIDE
);
10963 ShowScrollBar(infoPtr
->hwndSelf
, SB_BOTH
, FALSE
);
10964 SetRectEmpty(&infoPtr
->rcFocus
);
10966 himl
= (uNewView
== LVS_ICON
? infoPtr
->himlNormal
: infoPtr
->himlSmall
);
10967 set_icon_size(&infoPtr
->iconSize
, himl
, uNewView
!= LVS_ICON
);
10969 if (uNewView
== LVS_ICON
)
10971 if ((infoPtr
->iconSize
.cx
!= oldIconSize
.cx
) || (infoPtr
->iconSize
.cy
!= oldIconSize
.cy
))
10973 TRACE("icon old size=(%d,%d), new size=(%d,%d)\n",
10974 oldIconSize
.cx
, oldIconSize
.cy
, infoPtr
->iconSize
.cx
, infoPtr
->iconSize
.cy
);
10975 LISTVIEW_SetIconSpacing(infoPtr
, 0, 0);
10978 else if (uNewView
== LVS_REPORT
)
10983 LISTVIEW_CreateHeader( infoPtr
);
10985 hl
.prc
= &infoPtr
->rcList
;
10987 SendMessageW( infoPtr
->hwndHeader
, HDM_LAYOUT
, 0, (LPARAM
)&hl
);
10988 SetWindowPos(infoPtr
->hwndHeader
, infoPtr
->hwndSelf
, wp
.x
, wp
.y
, wp
.cx
, wp
.cy
,
10989 wp
.flags
| ((infoPtr
->dwStyle
& LVS_NOCOLUMNHEADER
)
10990 ? SWP_HIDEWINDOW
: SWP_SHOWWINDOW
));
10993 LISTVIEW_UpdateItemSize(infoPtr
);
10996 if (uNewView
== LVS_REPORT
|| infoPtr
->dwLvExStyle
& LVS_EX_HEADERINALLVIEWS
)
10998 if ((lpss
->styleOld
^ lpss
->styleNew
) & LVS_NOCOLUMNHEADER
)
11000 if (lpss
->styleNew
& LVS_NOCOLUMNHEADER
)
11002 /* Turn off the header control */
11003 style
= GetWindowLongW(infoPtr
->hwndHeader
, GWL_STYLE
);
11004 TRACE("Hide header control, was 0x%08x\n", style
);
11005 SetWindowLongW(infoPtr
->hwndHeader
, GWL_STYLE
, style
| HDS_HIDDEN
);
11007 /* Turn on the header control */
11008 if ((style
= GetWindowLongW(infoPtr
->hwndHeader
, GWL_STYLE
)) & HDS_HIDDEN
)
11010 TRACE("Show header control, was 0x%08x\n", style
);
11011 SetWindowLongW(infoPtr
->hwndHeader
, GWL_STYLE
, (style
& ~HDS_HIDDEN
) | WS_VISIBLE
);
11017 if ( (uNewView
== LVS_ICON
|| uNewView
== LVS_SMALLICON
) &&
11018 (uNewView
!= uOldView
|| ((lpss
->styleNew
^ lpss
->styleOld
) & LVS_ALIGNMASK
)) )
11019 LISTVIEW_Arrange(infoPtr
, LVA_DEFAULT
);
11021 /* update the size of the client area */
11022 LISTVIEW_UpdateSize(infoPtr
);
11024 /* add scrollbars if needed */
11025 LISTVIEW_UpdateScroll(infoPtr
);
11027 /* invalidate client area + erase background */
11028 LISTVIEW_InvalidateList(infoPtr
);
11035 * Processes WM_STYLECHANGING messages.
11038 * [I] wStyleType : window style type (normal or extended)
11039 * [I0] lpss : window style information
11044 static INT
LISTVIEW_StyleChanging(WPARAM wStyleType
,
11047 TRACE("(styletype=%lx, styleOld=0x%08x, styleNew=0x%08x)\n",
11048 wStyleType
, lpss
->styleOld
, lpss
->styleNew
);
11050 /* don't forward LVS_OWNERDATA only if not already set to */
11051 if ((lpss
->styleNew
^ lpss
->styleOld
) & LVS_OWNERDATA
)
11053 if (lpss
->styleOld
& LVS_OWNERDATA
)
11054 lpss
->styleNew
|= LVS_OWNERDATA
;
11056 lpss
->styleNew
&= ~LVS_OWNERDATA
;
11064 * Processes WM_SHOWWINDOW messages.
11067 * [I] infoPtr : valid pointer to the listview structure
11068 * [I] bShown : window is being shown (FALSE when hidden)
11069 * [I] iStatus : window show status
11074 static LRESULT
LISTVIEW_ShowWindow(LISTVIEW_INFO
*infoPtr
, WPARAM bShown
, LPARAM iStatus
)
11076 /* header delayed creation */
11077 if ((infoPtr
->uView
== LV_VIEW_DETAILS
) && bShown
)
11079 LISTVIEW_CreateHeader(infoPtr
);
11081 if (!(LVS_NOCOLUMNHEADER
& infoPtr
->dwStyle
))
11082 ShowWindow(infoPtr
->hwndHeader
, SW_SHOWNORMAL
);
11085 return DefWindowProcW(infoPtr
->hwndSelf
, WM_SHOWWINDOW
, bShown
, iStatus
);
11090 * Processes CCM_GETVERSION messages.
11093 * [I] infoPtr : valid pointer to the listview structure
11098 static inline LRESULT
LISTVIEW_GetVersion(const LISTVIEW_INFO
*infoPtr
)
11100 return infoPtr
->iVersion
;
11105 * Processes CCM_SETVERSION messages.
11108 * [I] infoPtr : valid pointer to the listview structure
11109 * [I] iVersion : version to be set
11112 * -1 when requested version is greater than DLL version;
11113 * previous version otherwise
11115 static LRESULT
LISTVIEW_SetVersion(LISTVIEW_INFO
*infoPtr
, DWORD iVersion
)
11117 INT iOldVersion
= infoPtr
->iVersion
;
11119 if (iVersion
> COMCTL32_VERSION
)
11122 infoPtr
->iVersion
= iVersion
;
11124 TRACE("new version %d\n", iVersion
);
11126 return iOldVersion
;
11131 * Window procedure of the listview control.
11134 static LRESULT WINAPI
11135 LISTVIEW_WindowProc(HWND hwnd
, UINT uMsg
, WPARAM wParam
, LPARAM lParam
)
11137 LISTVIEW_INFO
*infoPtr
= (LISTVIEW_INFO
*)GetWindowLongPtrW(hwnd
, 0);
11139 TRACE("(hwnd=%p uMsg=%x wParam=%lx lParam=%lx)\n", hwnd
, uMsg
, wParam
, lParam
);
11141 if (!infoPtr
&& (uMsg
!= WM_NCCREATE
))
11142 return DefWindowProcW(hwnd
, uMsg
, wParam
, lParam
);
11146 case LVM_APPROXIMATEVIEWRECT
:
11147 return LISTVIEW_ApproximateViewRect(infoPtr
, (INT
)wParam
,
11148 LOWORD(lParam
), HIWORD(lParam
));
11150 return LISTVIEW_Arrange(infoPtr
, (INT
)wParam
);
11152 case LVM_CANCELEDITLABEL
:
11153 return LISTVIEW_CancelEditLabel(infoPtr
);
11155 case LVM_CREATEDRAGIMAGE
:
11156 return (LRESULT
)LISTVIEW_CreateDragImage(infoPtr
, (INT
)wParam
, (LPPOINT
)lParam
);
11158 case LVM_DELETEALLITEMS
:
11159 return LISTVIEW_DeleteAllItems(infoPtr
, FALSE
);
11161 case LVM_DELETECOLUMN
:
11162 return LISTVIEW_DeleteColumn(infoPtr
, (INT
)wParam
);
11164 case LVM_DELETEITEM
:
11165 return LISTVIEW_DeleteItem(infoPtr
, (INT
)wParam
);
11167 case LVM_EDITLABELA
:
11168 case LVM_EDITLABELW
:
11169 return (LRESULT
)LISTVIEW_EditLabelT(infoPtr
, (INT
)wParam
,
11170 uMsg
== LVM_EDITLABELW
);
11171 /* case LVM_ENABLEGROUPVIEW: */
11173 case LVM_ENSUREVISIBLE
:
11174 return LISTVIEW_EnsureVisible(infoPtr
, (INT
)wParam
, (BOOL
)lParam
);
11176 case LVM_FINDITEMW
:
11177 return LISTVIEW_FindItemW(infoPtr
, (INT
)wParam
, (LPLVFINDINFOW
)lParam
);
11179 case LVM_FINDITEMA
:
11180 return LISTVIEW_FindItemA(infoPtr
, (INT
)wParam
, (LPLVFINDINFOA
)lParam
);
11182 case LVM_GETBKCOLOR
:
11183 return infoPtr
->clrBk
;
11185 /* case LVM_GETBKIMAGE: */
11187 case LVM_GETCALLBACKMASK
:
11188 return infoPtr
->uCallbackMask
;
11190 case LVM_GETCOLUMNA
:
11191 case LVM_GETCOLUMNW
:
11192 return LISTVIEW_GetColumnT(infoPtr
, (INT
)wParam
, (LPLVCOLUMNW
)lParam
,
11193 uMsg
== LVM_GETCOLUMNW
);
11195 case LVM_GETCOLUMNORDERARRAY
:
11196 return LISTVIEW_GetColumnOrderArray(infoPtr
, (INT
)wParam
, (LPINT
)lParam
);
11198 case LVM_GETCOLUMNWIDTH
:
11199 return LISTVIEW_GetColumnWidth(infoPtr
, (INT
)wParam
);
11201 case LVM_GETCOUNTPERPAGE
:
11202 return LISTVIEW_GetCountPerPage(infoPtr
);
11204 case LVM_GETEDITCONTROL
:
11205 return (LRESULT
)infoPtr
->hwndEdit
;
11207 case LVM_GETEXTENDEDLISTVIEWSTYLE
:
11208 return infoPtr
->dwLvExStyle
;
11210 /* case LVM_GETGROUPINFO: */
11212 /* case LVM_GETGROUPMETRICS: */
11214 case LVM_GETHEADER
:
11215 return (LRESULT
)infoPtr
->hwndHeader
;
11217 case LVM_GETHOTCURSOR
:
11218 return (LRESULT
)infoPtr
->hHotCursor
;
11220 case LVM_GETHOTITEM
:
11221 return infoPtr
->nHotItem
;
11223 case LVM_GETHOVERTIME
:
11224 return infoPtr
->dwHoverTime
;
11226 case LVM_GETIMAGELIST
:
11227 return (LRESULT
)LISTVIEW_GetImageList(infoPtr
, (INT
)wParam
);
11229 /* case LVM_GETINSERTMARK: */
11231 /* case LVM_GETINSERTMARKCOLOR: */
11233 /* case LVM_GETINSERTMARKRECT: */
11235 case LVM_GETISEARCHSTRINGA
:
11236 case LVM_GETISEARCHSTRINGW
:
11237 FIXME("LVM_GETISEARCHSTRING: unimplemented\n");
11242 return LISTVIEW_GetItemExtT(infoPtr
, (LPLVITEMW
)lParam
, uMsg
== LVM_GETITEMW
);
11244 case LVM_GETITEMCOUNT
:
11245 return infoPtr
->nItemCount
;
11247 case LVM_GETITEMPOSITION
:
11248 return LISTVIEW_GetItemPosition(infoPtr
, (INT
)wParam
, (LPPOINT
)lParam
);
11250 case LVM_GETITEMRECT
:
11251 return LISTVIEW_GetItemRect(infoPtr
, (INT
)wParam
, (LPRECT
)lParam
);
11253 case LVM_GETITEMSPACING
:
11254 return LISTVIEW_GetItemSpacing(infoPtr
, (BOOL
)wParam
);
11256 case LVM_GETITEMSTATE
:
11257 return LISTVIEW_GetItemState(infoPtr
, (INT
)wParam
, (UINT
)lParam
);
11259 case LVM_GETITEMTEXTA
:
11260 case LVM_GETITEMTEXTW
:
11261 return LISTVIEW_GetItemTextT(infoPtr
, (INT
)wParam
, (LPLVITEMW
)lParam
,
11262 uMsg
== LVM_GETITEMTEXTW
);
11264 case LVM_GETNEXTITEM
:
11265 return LISTVIEW_GetNextItem(infoPtr
, (INT
)wParam
, LOWORD(lParam
));
11267 case LVM_GETNUMBEROFWORKAREAS
:
11268 FIXME("LVM_GETNUMBEROFWORKAREAS: unimplemented\n");
11271 case LVM_GETORIGIN
:
11272 if (!lParam
) return FALSE
;
11273 if (infoPtr
->uView
== LV_VIEW_DETAILS
||
11274 infoPtr
->uView
== LV_VIEW_LIST
) return FALSE
;
11275 LISTVIEW_GetOrigin(infoPtr
, (LPPOINT
)lParam
);
11278 /* case LVM_GETOUTLINECOLOR: */
11280 /* case LVM_GETSELECTEDCOLUMN: */
11282 case LVM_GETSELECTEDCOUNT
:
11283 return LISTVIEW_GetSelectedCount(infoPtr
);
11285 case LVM_GETSELECTIONMARK
:
11286 return infoPtr
->nSelectionMark
;
11288 case LVM_GETSTRINGWIDTHA
:
11289 case LVM_GETSTRINGWIDTHW
:
11290 return LISTVIEW_GetStringWidthT(infoPtr
, (LPCWSTR
)lParam
,
11291 uMsg
== LVM_GETSTRINGWIDTHW
);
11293 case LVM_GETSUBITEMRECT
:
11294 return LISTVIEW_GetSubItemRect(infoPtr
, (UINT
)wParam
, (LPRECT
)lParam
);
11296 case LVM_GETTEXTBKCOLOR
:
11297 return infoPtr
->clrTextBk
;
11299 case LVM_GETTEXTCOLOR
:
11300 return infoPtr
->clrText
;
11302 /* case LVM_GETTILEINFO: */
11304 /* case LVM_GETTILEVIEWINFO: */
11306 case LVM_GETTOOLTIPS
:
11307 if( !infoPtr
->hwndToolTip
)
11308 infoPtr
->hwndToolTip
= COMCTL32_CreateToolTip( hwnd
);
11309 return (LRESULT
)infoPtr
->hwndToolTip
;
11311 case LVM_GETTOPINDEX
:
11312 return LISTVIEW_GetTopIndex(infoPtr
);
11314 case LVM_GETUNICODEFORMAT
:
11315 return (infoPtr
->notifyFormat
== NFR_UNICODE
);
11318 return infoPtr
->uView
;
11320 case LVM_GETVIEWRECT
:
11321 return LISTVIEW_GetViewRect(infoPtr
, (LPRECT
)lParam
);
11323 case LVM_GETWORKAREAS
:
11324 FIXME("LVM_GETWORKAREAS: unimplemented\n");
11327 /* case LVM_HASGROUP: */
11330 return LISTVIEW_HitTest(infoPtr
, (LPLVHITTESTINFO
)lParam
, FALSE
, TRUE
);
11332 case LVM_INSERTCOLUMNA
:
11333 case LVM_INSERTCOLUMNW
:
11334 return LISTVIEW_InsertColumnT(infoPtr
, (INT
)wParam
, (LPLVCOLUMNW
)lParam
,
11335 uMsg
== LVM_INSERTCOLUMNW
);
11337 /* case LVM_INSERTGROUP: */
11339 /* case LVM_INSERTGROUPSORTED: */
11341 case LVM_INSERTITEMA
:
11342 case LVM_INSERTITEMW
:
11343 return LISTVIEW_InsertItemT(infoPtr
, (LPLVITEMW
)lParam
, uMsg
== LVM_INSERTITEMW
);
11345 /* case LVM_INSERTMARKHITTEST: */
11347 /* case LVM_ISGROUPVIEWENABLED: */
11349 case LVM_ISITEMVISIBLE
:
11350 return LISTVIEW_IsItemVisible(infoPtr
, (INT
)wParam
);
11352 case LVM_MAPIDTOINDEX
:
11353 return LISTVIEW_MapIdToIndex(infoPtr
, (UINT
)wParam
);
11355 case LVM_MAPINDEXTOID
:
11356 return LISTVIEW_MapIndexToId(infoPtr
, (INT
)wParam
);
11358 /* case LVM_MOVEGROUP: */
11360 /* case LVM_MOVEITEMTOGROUP: */
11362 case LVM_REDRAWITEMS
:
11363 return LISTVIEW_RedrawItems(infoPtr
, (INT
)wParam
, (INT
)lParam
);
11365 /* case LVM_REMOVEALLGROUPS: */
11367 /* case LVM_REMOVEGROUP: */
11370 return LISTVIEW_Scroll(infoPtr
, (INT
)wParam
, (INT
)lParam
);
11372 case LVM_SETBKCOLOR
:
11373 return LISTVIEW_SetBkColor(infoPtr
, (COLORREF
)lParam
);
11375 /* case LVM_SETBKIMAGE: */
11377 case LVM_SETCALLBACKMASK
:
11378 infoPtr
->uCallbackMask
= (UINT
)wParam
;
11381 case LVM_SETCOLUMNA
:
11382 case LVM_SETCOLUMNW
:
11383 return LISTVIEW_SetColumnT(infoPtr
, (INT
)wParam
, (LPLVCOLUMNW
)lParam
,
11384 uMsg
== LVM_SETCOLUMNW
);
11386 case LVM_SETCOLUMNORDERARRAY
:
11387 return LISTVIEW_SetColumnOrderArray(infoPtr
, (INT
)wParam
, (LPINT
)lParam
);
11389 case LVM_SETCOLUMNWIDTH
:
11390 return LISTVIEW_SetColumnWidth(infoPtr
, (INT
)wParam
, (short)LOWORD(lParam
));
11392 case LVM_SETEXTENDEDLISTVIEWSTYLE
:
11393 return LISTVIEW_SetExtendedListViewStyle(infoPtr
, (DWORD
)wParam
, (DWORD
)lParam
);
11395 /* case LVM_SETGROUPINFO: */
11397 /* case LVM_SETGROUPMETRICS: */
11399 case LVM_SETHOTCURSOR
:
11400 return (LRESULT
)LISTVIEW_SetHotCursor(infoPtr
, (HCURSOR
)lParam
);
11402 case LVM_SETHOTITEM
:
11403 return LISTVIEW_SetHotItem(infoPtr
, (INT
)wParam
);
11405 case LVM_SETHOVERTIME
:
11406 return LISTVIEW_SetHoverTime(infoPtr
, (DWORD
)lParam
);
11408 case LVM_SETICONSPACING
:
11409 return LISTVIEW_SetIconSpacing(infoPtr
, (short)LOWORD(lParam
), (short)HIWORD(lParam
));
11411 case LVM_SETIMAGELIST
:
11412 return (LRESULT
)LISTVIEW_SetImageList(infoPtr
, (INT
)wParam
, (HIMAGELIST
)lParam
);
11414 /* case LVM_SETINFOTIP: */
11416 /* case LVM_SETINSERTMARK: */
11418 /* case LVM_SETINSERTMARKCOLOR: */
11423 if (infoPtr
->dwStyle
& LVS_OWNERDATA
) return FALSE
;
11424 return LISTVIEW_SetItemT(infoPtr
, (LPLVITEMW
)lParam
, (uMsg
== LVM_SETITEMW
));
11427 case LVM_SETITEMCOUNT
:
11428 return LISTVIEW_SetItemCount(infoPtr
, (INT
)wParam
, (DWORD
)lParam
);
11430 case LVM_SETITEMPOSITION
:
11433 pt
.x
= (short)LOWORD(lParam
);
11434 pt
.y
= (short)HIWORD(lParam
);
11435 return LISTVIEW_SetItemPosition(infoPtr
, (INT
)wParam
, &pt
);
11438 case LVM_SETITEMPOSITION32
:
11439 return LISTVIEW_SetItemPosition(infoPtr
, (INT
)wParam
, (POINT
*)lParam
);
11441 case LVM_SETITEMSTATE
:
11442 return LISTVIEW_SetItemState(infoPtr
, (INT
)wParam
, (LPLVITEMW
)lParam
);
11444 case LVM_SETITEMTEXTA
:
11445 case LVM_SETITEMTEXTW
:
11446 return LISTVIEW_SetItemTextT(infoPtr
, (INT
)wParam
, (LPLVITEMW
)lParam
,
11447 uMsg
== LVM_SETITEMTEXTW
);
11449 /* case LVM_SETOUTLINECOLOR: */
11451 /* case LVM_SETSELECTEDCOLUMN: */
11453 case LVM_SETSELECTIONMARK
:
11454 return LISTVIEW_SetSelectionMark(infoPtr
, (INT
)lParam
);
11456 case LVM_SETTEXTBKCOLOR
:
11457 return LISTVIEW_SetTextBkColor(infoPtr
, (COLORREF
)lParam
);
11459 case LVM_SETTEXTCOLOR
:
11460 return LISTVIEW_SetTextColor(infoPtr
, (COLORREF
)lParam
);
11462 /* case LVM_SETTILEINFO: */
11464 /* case LVM_SETTILEVIEWINFO: */
11466 /* case LVM_SETTILEWIDTH: */
11468 case LVM_SETTOOLTIPS
:
11469 return (LRESULT
)LISTVIEW_SetToolTips(infoPtr
, (HWND
)lParam
);
11471 case LVM_SETUNICODEFORMAT
:
11472 return LISTVIEW_SetUnicodeFormat(infoPtr
, wParam
);
11475 return LISTVIEW_SetView(infoPtr
, wParam
);
11477 /* case LVM_SETWORKAREAS: */
11479 /* case LVM_SORTGROUPS: */
11481 case LVM_SORTITEMS
:
11482 case LVM_SORTITEMSEX
:
11483 return LISTVIEW_SortItems(infoPtr
, (PFNLVCOMPARE
)lParam
, wParam
,
11484 uMsg
== LVM_SORTITEMSEX
);
11485 case LVM_SUBITEMHITTEST
:
11486 return LISTVIEW_HitTest(infoPtr
, (LPLVHITTESTINFO
)lParam
, TRUE
, FALSE
);
11489 return LISTVIEW_Update(infoPtr
, (INT
)wParam
);
11491 case CCM_GETVERSION
:
11492 return LISTVIEW_GetVersion(infoPtr
);
11494 case CCM_SETVERSION
:
11495 return LISTVIEW_SetVersion(infoPtr
, wParam
);
11498 return LISTVIEW_ProcessLetterKeys( infoPtr
, wParam
, lParam
);
11501 return LISTVIEW_Command(infoPtr
, wParam
, lParam
);
11504 return LISTVIEW_NCCreate(hwnd
, (LPCREATESTRUCTW
)lParam
);
11507 return LISTVIEW_Create(hwnd
, (LPCREATESTRUCTW
)lParam
);
11510 return LISTVIEW_Destroy(infoPtr
);
11513 return LISTVIEW_Enable(infoPtr
);
11515 case WM_ERASEBKGND
:
11516 return LISTVIEW_EraseBkgnd(infoPtr
, (HDC
)wParam
);
11518 case WM_GETDLGCODE
:
11519 return DLGC_WANTCHARS
| DLGC_WANTARROWS
;
11522 return (LRESULT
)infoPtr
->hFont
;
11525 return LISTVIEW_HScroll(infoPtr
, (INT
)LOWORD(wParam
), 0);
11528 return LISTVIEW_KeyDown(infoPtr
, (INT
)wParam
, (LONG
)lParam
);
11531 return LISTVIEW_KillFocus(infoPtr
);
11533 case WM_LBUTTONDBLCLK
:
11534 return LISTVIEW_LButtonDblClk(infoPtr
, (WORD
)wParam
, (SHORT
)LOWORD(lParam
), (SHORT
)HIWORD(lParam
));
11536 case WM_LBUTTONDOWN
:
11537 return LISTVIEW_LButtonDown(infoPtr
, (WORD
)wParam
, (SHORT
)LOWORD(lParam
), (SHORT
)HIWORD(lParam
));
11540 return LISTVIEW_LButtonUp(infoPtr
, (WORD
)wParam
, (SHORT
)LOWORD(lParam
), (SHORT
)HIWORD(lParam
));
11543 return LISTVIEW_MouseMove (infoPtr
, (WORD
)wParam
, (SHORT
)LOWORD(lParam
), (SHORT
)HIWORD(lParam
));
11545 case WM_MOUSEHOVER
:
11546 return LISTVIEW_MouseHover(infoPtr
, (SHORT
)LOWORD(lParam
), (SHORT
)HIWORD(lParam
));
11549 return LISTVIEW_NCDestroy(infoPtr
);
11552 return LISTVIEW_NCPaint(infoPtr
, (HRGN
)wParam
);
11555 return LISTVIEW_Notify(infoPtr
, (LPNMHDR
)lParam
);
11557 case WM_NOTIFYFORMAT
:
11558 return LISTVIEW_NotifyFormat(infoPtr
, (HWND
)wParam
, (INT
)lParam
);
11560 case WM_PRINTCLIENT
:
11561 return LISTVIEW_PrintClient(infoPtr
, (HDC
)wParam
, (DWORD
)lParam
);
11564 return LISTVIEW_WMPaint(infoPtr
, (HDC
)wParam
);
11566 case WM_RBUTTONDBLCLK
:
11567 return LISTVIEW_RButtonDblClk(infoPtr
, (WORD
)wParam
, (SHORT
)LOWORD(lParam
), (SHORT
)HIWORD(lParam
));
11569 case WM_RBUTTONDOWN
:
11570 return LISTVIEW_RButtonDown(infoPtr
, (WORD
)wParam
, (SHORT
)LOWORD(lParam
), (SHORT
)HIWORD(lParam
));
11573 return LISTVIEW_RButtonUp(infoPtr
, (WORD
)wParam
, (SHORT
)LOWORD(lParam
), (SHORT
)HIWORD(lParam
));
11576 return LISTVIEW_SetCursor(infoPtr
, wParam
, lParam
);
11579 return LISTVIEW_SetFocus(infoPtr
, (HWND
)wParam
);
11582 return LISTVIEW_SetFont(infoPtr
, (HFONT
)wParam
, (WORD
)lParam
);
11585 return LISTVIEW_SetRedraw(infoPtr
, (BOOL
)wParam
);
11587 case WM_SHOWWINDOW
:
11588 return LISTVIEW_ShowWindow(infoPtr
, wParam
, lParam
);
11590 case WM_STYLECHANGED
:
11591 return LISTVIEW_StyleChanged(infoPtr
, wParam
, (LPSTYLESTRUCT
)lParam
);
11593 case WM_STYLECHANGING
:
11594 return LISTVIEW_StyleChanging(wParam
, (LPSTYLESTRUCT
)lParam
);
11596 case WM_SYSCOLORCHANGE
:
11597 COMCTL32_RefreshSysColors();
11600 /* case WM_TIMER: */
11601 case WM_THEMECHANGED
:
11602 return LISTVIEW_ThemeChanged(infoPtr
);
11605 return LISTVIEW_VScroll(infoPtr
, (INT
)LOWORD(wParam
), 0);
11607 case WM_MOUSEWHEEL
:
11608 if (wParam
& (MK_SHIFT
| MK_CONTROL
))
11609 return DefWindowProcW(hwnd
, uMsg
, wParam
, lParam
);
11610 return LISTVIEW_MouseWheel(infoPtr
, (short int)HIWORD(wParam
));
11612 case WM_WINDOWPOSCHANGED
:
11613 if (!(((WINDOWPOS
*)lParam
)->flags
& SWP_NOSIZE
))
11615 SetWindowPos(infoPtr
->hwndSelf
, 0, 0, 0, 0, 0, SWP_FRAMECHANGED
| SWP_NOACTIVATE
|
11616 SWP_NOZORDER
| SWP_NOMOVE
| SWP_NOSIZE
);
11618 if ((infoPtr
->dwStyle
& LVS_OWNERDRAWFIXED
) && (infoPtr
->uView
== LV_VIEW_DETAILS
))
11620 if (notify_measureitem(infoPtr
)) LISTVIEW_InvalidateList(infoPtr
);
11622 LISTVIEW_Size(infoPtr
, ((WINDOWPOS
*)lParam
)->cx
, ((WINDOWPOS
*)lParam
)->cy
);
11624 return DefWindowProcW(hwnd
, uMsg
, wParam
, lParam
);
11626 /* case WM_WININICHANGE: */
11629 if ((uMsg
>= WM_USER
) && (uMsg
< WM_APP
) && !COMCTL32_IsReflectedMessage(uMsg
))
11630 ERR("unknown msg %04x wp=%08lx lp=%08lx\n", uMsg
, wParam
, lParam
);
11632 return DefWindowProcW(hwnd
, uMsg
, wParam
, lParam
);
11639 * Registers the window class.
11647 void LISTVIEW_Register(void)
11649 WNDCLASSW wndClass
;
11651 ZeroMemory(&wndClass
, sizeof(WNDCLASSW
));
11652 wndClass
.style
= CS_GLOBALCLASS
| CS_DBLCLKS
;
11653 wndClass
.lpfnWndProc
= LISTVIEW_WindowProc
;
11654 wndClass
.cbClsExtra
= 0;
11655 wndClass
.cbWndExtra
= sizeof(LISTVIEW_INFO
*);
11656 wndClass
.hCursor
= LoadCursorW(0, (LPWSTR
)IDC_ARROW
);
11657 wndClass
.hbrBackground
= (HBRUSH
)(COLOR_WINDOW
+ 1);
11658 wndClass
.lpszClassName
= WC_LISTVIEWW
;
11659 RegisterClassW(&wndClass
);
11664 * Unregisters the window class.
11672 void LISTVIEW_Unregister(void)
11674 UnregisterClassW(WC_LISTVIEWW
, NULL
);
11679 * Handle any WM_COMMAND messages
11682 * [I] infoPtr : valid pointer to the listview structure
11683 * [I] wParam : the first message parameter
11684 * [I] lParam : the second message parameter
11689 static LRESULT
LISTVIEW_Command(LISTVIEW_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
11692 TRACE("(%p %x %x %lx)\n", infoPtr
, HIWORD(wParam
), LOWORD(wParam
), lParam
);
11694 if (!infoPtr
->hwndEdit
) return 0;
11696 switch (HIWORD(wParam
))
11701 * Adjust the edit window size
11703 WCHAR buffer
[1024];
11704 HDC hdc
= GetDC(infoPtr
->hwndEdit
);
11705 HFONT hFont
, hOldFont
= 0;
11709 if (!infoPtr
->hwndEdit
|| !hdc
) return 0;
11710 GetWindowTextW(infoPtr
->hwndEdit
, buffer
, sizeof(buffer
)/sizeof(buffer
[0]));
11711 GetWindowRect(infoPtr
->hwndEdit
, &rect
);
11713 /* Select font to get the right dimension of the string */
11714 hFont
= (HFONT
)SendMessageW(infoPtr
->hwndEdit
, WM_GETFONT
, 0, 0);
11717 hOldFont
= SelectObject(hdc
, hFont
);
11720 if (GetTextExtentPoint32W(hdc
, buffer
, lstrlenW(buffer
), &sz
))
11722 TEXTMETRICW textMetric
;
11724 /* Add Extra spacing for the next character */
11725 GetTextMetricsW(hdc
, &textMetric
);
11726 sz
.cx
+= (textMetric
.tmMaxCharWidth
* 2);
11728 SetWindowPos(infoPtr
->hwndEdit
, NULL
, 0, 0, sz
.cx
,
11729 rect
.bottom
- rect
.top
, SWP_DRAWFRAME
| SWP_NOMOVE
| SWP_NOZORDER
);
11732 SelectObject(hdc
, hOldFont
);
11734 ReleaseDC(infoPtr
->hwndEdit
, hdc
);
11740 LISTVIEW_CancelEditLabel(infoPtr
);
11745 return SendMessageW (infoPtr
->hwndNotify
, WM_COMMAND
, wParam
, lParam
);