?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Listview_ProcessLetterKeys: fixed never ending loop when end index is
[wine.git] / dlls / comctl32 / listview.c
blob28771830d24ad7e0bc146c8f3e83e54954520da5
1 /*
2 * Listview control
3 *
4 * Copyright 1998, 1999 Eric Kohl
5 * Copyright 1999 Luc Tourangeau
6 * Copyright 2000 Jason Mawdsley
7 * Copyright 2001 Codeweavers Inc.
8 * Copyright 2002 Dimitrie O. Paun
9 *
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
14 *
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with this library; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 *
24 * NOTES
25 * Listview control implementation.
26 *
27 * TODO:
28 * 1. No horizontal scrolling when header is larger than the client area.
29 * 2. Drawing optimizations.
30 * 3. Hot item handling.
31 *
32 * Notifications:
33 * LISTVIEW_Notify : most notifications from children (editbox and header)
34 *
35 * Data structure:
36 * LISTVIEW_SetItemCount : not completed for non OWNERDATA
37 *
38 * Advanced functionality:
39 * LISTVIEW_GetNumberOfWorkAreas : not implemented
40 * LISTVIEW_GetISearchString : not implemented
41 * LISTVIEW_GetBkImage : not implemented
42 * LISTVIEW_SetBkImage : not implemented
43 * LISTVIEW_GetColumnOrderArray : simple hack only
44 * LISTVIEW_SetColumnOrderArray : simple hack only
45 * LISTVIEW_Arrange : empty stub
46 * LISTVIEW_ApproximateViewRect : incomplete
47 * LISTVIEW_Update : not completed
48 *
49 * Known differences in message stream from native control (not known if
50 * these differences cause problems):
51 * LVM_INSERTITEM issues LVM_SETITEMSTATE and LVM_SETITEM in certain cases.
52 * LVM_SETITEM does not always issue LVN_ITEMCHANGING/LVN_ITEMCHANGED.
53 * WM_PAINT does LVN_GETDISPINFO in item order 0->n, native does n->0.
54 * WM_SETREDRAW(True) native does LVN_GETDISPINFO for all items and
55 * does *not* invoke DefWindowProc
56 * WM_CREATE does not issue WM_QUERYUISTATE and associated registry
57 * processing for "USEDOUBLECLICKTIME".
58 */
59
60
61 #include "config.h"
62 #include "wine/port.h"
63
64 #include <ctype.h>
65 #include <string.h>
66 #include <stdlib.h>
67 #include <stdio.h>
68
69 #include "winbase.h"
70 #include "winnt.h"
71 #include "heap.h"
72 #include "commctrl.h"
73 #include "comctl32.h"
74 #include "wine/debug.h"
75
76 WINE_DEFAULT_DEBUG_CHANNEL(listview);
77
78 /* Some definitions for inline edit control */
79
80 typedef struct tagLV_INTHIT
81 {
82 LVHITTESTINFO ht;
83 DWORD distance; /* distance to closest item */
84 INT iDistItem; /* item number that is closest */
85 } LV_INTHIT, *LPLV_INTHIT;
86
87 typedef struct tagITEMHDR
88 {
89 LPWSTR pszText;
90 INT iImage;
91 } ITEMHDR, *LPITEMHDR;
92
93 typedef struct tagLISTVIEW_SUBITEM
94 {
95 ITEMHDR hdr;
96 INT iSubItem;
97 } LISTVIEW_SUBITEM;
98
99 typedef struct tagLISTVIEW_ITEM
100 {
101 ITEMHDR hdr;
102 UINT state;
103 LPARAM lParam;
104 INT iIndent;
105 POINT ptPosition;
106 BOOL valid;
107 } LISTVIEW_ITEM;
108
109 typedef struct tagLISTVIEW_SELECTION
110 {
111 DWORD lower;
112 DWORD upper;
113 } LISTVIEW_SELECTION;
114
115 typedef struct tagLISTVIEW_INFO
116 {
117 HWND hwndSelf;
118 HBRUSH hBkBrush;
119 COLORREF clrBk;
120 COLORREF clrText;
121 COLORREF clrTextBk;
122 HIMAGELIST himlNormal;
123 HIMAGELIST himlSmall;
124 HIMAGELIST himlState;
125 BOOL bLButtonDown;
126 BOOL bRButtonDown;
127 INT nItemHeight;
128 INT nItemWidth;
129 HDPA hdpaSelectionRanges;
130 INT nSelectionMark;
131 INT nHotItem;
132 SHORT notifyFormat;
133 RECT rcList;
134 RECT rcView;
135 SIZE iconSize;
136 SIZE iconSpacing;
137 UINT uCallbackMask;
138 HWND hwndHeader;
139 HFONT hDefaultFont;
140 HCURSOR hHotCursor;
141 HFONT hFont;
142 INT ntmHeight; /* from GetTextMetrics from above font */
143 INT ntmAveCharWidth; /* from GetTextMetrics from above font */
144 BOOL bFocus;
145 INT nFocusedItem;
146 RECT rcFocus;
147 DWORD dwExStyle; /* extended listview style */
148 HDPA hdpaItems;
149 PFNLVCOMPARE pfnCompare;
150 LPARAM lParamSort;
151 HWND hwndEdit;
152 BOOL bEditing;
153 WNDPROC EditWndProc;
154 INT nEditLabelItem;
155 DWORD dwHoverTime;
156 INT nColumnCount; /* the number of columns in this control */
157
158 DWORD lastKeyPressTimestamp; /* Added */
159 WPARAM charCode; /* Added */
160 INT nSearchParamLength; /* Added */
161 WCHAR szSearchParam[ MAX_PATH ]; /* Added */
162 BOOL bIsDrawing;
163 } LISTVIEW_INFO;
164
165 DEFINE_COMMON_NOTIFICATIONS(LISTVIEW_INFO, hwndSelf);
166
167 /*
168 * constants
169 */
170
171 /* Internal interface to LISTVIEW_HScroll and LISTVIEW_VScroll */
172 #define SB_INTERNAL -1
173
174 /* maximum size of a label */
175 #define DISP_TEXT_SIZE 512
176
177 /* padding for items in list and small icon display modes */
178 #define WIDTH_PADDING 12
179
180 /* padding for items in list, report and small icon display modes */
181 #define HEIGHT_PADDING 1
182
183 /* offset of items in report display mode */
184 #define REPORT_MARGINX 2
185
186 /* padding for icon in large icon display mode
187 * ICON_TOP_PADDING_NOTHITABLE - space between top of box and area
188 * that HITTEST will see.
189 * ICON_TOP_PADDING_HITABLE - spacing between above and icon.
190 * ICON_TOP_PADDING - sum of the two above.
191 * ICON_BOTTOM_PADDING - between bottom of icon and top of text
192 * LABEL_VERT_PADDING - between bottom of text and end of box
193 */
194 #define ICON_TOP_PADDING_NOTHITABLE 2
195 #define ICON_TOP_PADDING_HITABLE 2
196 #define ICON_TOP_PADDING (ICON_TOP_PADDING_NOTHITABLE + ICON_TOP_PADDING_HITABLE)
197 #define ICON_BOTTOM_PADDING 4
198 #define LABEL_VERT_PADDING 7
199
200 /* default label width for items in list and small icon display modes */
201 #define DEFAULT_LABEL_WIDTH 40
202
203 /* default column width for items in list display mode */
204 #define DEFAULT_COLUMN_WIDTH 128
205
206 /* Size of "line" scroll for V & H scrolls */
207 #define LISTVIEW_SCROLL_ICON_LINE_SIZE 37
208
209 /* Padding betwen image and label */
210 #define IMAGE_PADDING 2
211
212 /* Padding behind the label */
213 #define TRAILING_PADDING 5
214
215 /* Border for the icon caption */
216 #define CAPTION_BORDER 2
217
218 /* Standard DrawText flags for LISTVIEW_UpdateLargeItemLabelRect and LISTVIEW_DrawLargeItem */
219 #define LISTVIEW_DTFLAGS DT_TOP | DT_CENTER | DT_WORDBREAK | DT_NOPREFIX | DT_EDITCONTROL
220
221 /*
222 * macros
223 */
224 /* retrieve the number of items in the listview */
225 #define GETITEMCOUNT(infoPtr) ((infoPtr)->hdpaItems->nItemCount)
226
227 #define LISTVIEW_DUMP(iP) do { \
228 TRACE("hwndSelf=%08x, clrBk=0x%06lx, clrText=0x%06lx, clrTextBk=0x%06lx, ItemHeight=%d, ItemWidth=%d, Style=0x%08lx\n", \
229 iP->hwndSelf, iP->clrBk, iP->clrText, iP->clrTextBk, \
230 iP->nItemHeight, iP->nItemWidth, GetWindowLongW (iP->hwndSelf, GWL_STYLE)); \
231 TRACE("hwndSelf=%08x, himlNor=%p, himlSml=%p, himlState=%p, Focused=%d, Hot=%d, exStyle=0x%08lx\n", \
232 iP->hwndSelf, iP->himlNormal, iP->himlSmall, iP->himlState, \
233 iP->nFocusedItem, iP->nHotItem, iP->dwExStyle); \
234 TRACE("hwndSelf=%08x, ntmH=%d, icSz.cx=%ld, icSz.cy=%ld, icSp.cx=%ld, icSp.cy=%ld, notifyFmt=%d\n", \
235 iP->hwndSelf, iP->ntmHeight, iP->iconSize.cx, iP->iconSize.cy, \
236 iP->iconSpacing.cx, iP->iconSpacing.cy, iP->notifyFormat); \
237 TRACE("hwndSelf=%08x, rcList=(%d,%d)-(%d,%d), rcView=(%d,%d)-(%d,%d)\n", \
238 iP->hwndSelf, \
239 iP->rcList.left, iP->rcList.top, iP->rcList.right, iP->rcList.bottom, \
240 iP->rcView.left, iP->rcView.top, iP->rcView.right, iP->rcView.bottom); \
241 } while(0)
242
243
244 /*
245 * forward declarations
246 */
247 static LRESULT LISTVIEW_GetItemT(LISTVIEW_INFO *, LPLVITEMW, BOOL, BOOL);
248 static INT LISTVIEW_SuperHitTestItem(LISTVIEW_INFO *, LPLV_INTHIT, BOOL);
249 static INT LISTVIEW_HitTestItem(LISTVIEW_INFO *, LPLVHITTESTINFO, BOOL);
250 static void LISTVIEW_AlignLeft(LISTVIEW_INFO *);
251 static void LISTVIEW_AlignTop(LISTVIEW_INFO *);
252 static void LISTVIEW_AddGroupSelection(LISTVIEW_INFO *, INT);
253 static void LISTVIEW_AddSelection(LISTVIEW_INFO *, INT);
254 static INT LISTVIEW_GetItemHeight(LISTVIEW_INFO *);
255 static BOOL LISTVIEW_GetItemBoundBox(LISTVIEW_INFO *, INT, LPRECT);
256 static BOOL LISTVIEW_GetItemPosition(LISTVIEW_INFO *, INT, LPPOINT);
257 static LRESULT LISTVIEW_GetItemRect(LISTVIEW_INFO *, INT, LPRECT);
258 static LRESULT LISTVIEW_GetSubItemRect(LISTVIEW_INFO *, INT, INT, INT, LPRECT);
259 static INT LISTVIEW_GetItemWidth(LISTVIEW_INFO *);
260 static INT LISTVIEW_GetLabelWidth(LISTVIEW_INFO *, INT);
261 static LRESULT LISTVIEW_GetOrigin(LISTVIEW_INFO *, LPPOINT);
262 static LRESULT LISTVIEW_GetViewRect(LISTVIEW_INFO *, LPRECT);
263 static BOOL LISTVIEW_RemoveColumn(HDPA, INT);
264 static BOOL LISTVIEW_RemoveSubItem(HDPA, INT);
265 static void LISTVIEW_SetGroupSelection(LISTVIEW_INFO *, INT);
266 static BOOL LISTVIEW_SetItemT(LISTVIEW_INFO *, LPLVITEMW, BOOL);
267 static BOOL LISTVIEW_SetItemPosition(LISTVIEW_INFO *, INT, LONG, LONG);
268 static void LISTVIEW_UpdateScroll(LISTVIEW_INFO *);
269 static void LISTVIEW_SetSelection(LISTVIEW_INFO *, INT);
270 static BOOL LISTVIEW_UpdateSize(LISTVIEW_INFO *);
271 static LRESULT LISTVIEW_SetViewRect(LISTVIEW_INFO *, LPRECT);
272 static void LISTVIEW_UnsupportedStyles(LONG);
273 static HWND LISTVIEW_EditLabelT(LISTVIEW_INFO *, INT, BOOL);
274 static LRESULT LISTVIEW_Command(LISTVIEW_INFO *, WPARAM, LPARAM);
275 static LRESULT LISTVIEW_SortItems(LISTVIEW_INFO *, PFNLVCOMPARE, LPARAM);
276 static LRESULT LISTVIEW_GetStringWidthT(LISTVIEW_INFO *, LPCWSTR, BOOL);
277 static INT LISTVIEW_ProcessLetterKeys(LISTVIEW_INFO *, WPARAM, LPARAM);
278 static BOOL LISTVIEW_KeySelection(LISTVIEW_INFO *, INT);
279 static LRESULT LISTVIEW_GetItemState(LISTVIEW_INFO *, INT, UINT);
280 static LRESULT LISTVIEW_SetItemState(LISTVIEW_INFO *, INT, LPLVITEMW);
281 static void LISTVIEW_UpdateLargeItemLabelRect (LISTVIEW_INFO *, int, RECT*);
282 static LRESULT LISTVIEW_GetColumnT(LISTVIEW_INFO *, INT, LPLVCOLUMNW, BOOL);
283 static LRESULT LISTVIEW_VScroll(LISTVIEW_INFO *, INT, INT, HWND);
284 static LRESULT LISTVIEW_HScroll(LISTVIEW_INFO *, INT, INT, HWND);
285 static INT LISTVIEW_GetTopIndex(LISTVIEW_INFO *);
286 static BOOL LISTVIEW_EnsureVisible(LISTVIEW_INFO *, INT, BOOL);
287 static HWND CreateEditLabelT(LISTVIEW_INFO *, LPCWSTR, DWORD, INT, INT, INT, INT, BOOL);
288
289 /******** Defines that LISTVIEW_ProcessLetterKeys uses ****************/
290 #define KEY_DELAY 450
291
292 #define COUNTOF(array) (sizeof(array)/sizeof(array[0]))
293
294 static inline BOOL is_textW(LPCWSTR text)
295 {
296 return text != NULL && text != LPSTR_TEXTCALLBACKW;
297 }
298
299 static inline BOOL is_textT(LPCWSTR text, BOOL isW)
300 {
301 /* we can ignore isW since LPSTR_TEXTCALLBACKW == LPSTR_TEXTCALLBACKA */
302 return is_textW(text);
303 }
304
305 static inline int textlenT(LPCWSTR text, BOOL isW)
306 {
307 return !is_textT(text, isW) ? 0 :
308 isW ? lstrlenW(text) : lstrlenA((LPCSTR)text);
309 }
310
311 static inline void textcpynT(LPWSTR dest, BOOL isDestW, LPCWSTR src, BOOL isSrcW, INT max)
312 {
313 if (isDestW)
314 if (isSrcW) lstrcpynW(dest, src, max);
315 else MultiByteToWideChar(CP_ACP, 0, (LPCSTR)src, -1, dest, max);
316 else
317 if (isSrcW) WideCharToMultiByte(CP_ACP, 0, src, -1, (LPSTR)dest, max, NULL, NULL);
318 else lstrcpynA((LPSTR)dest, (LPCSTR)src, max);
319 }
320
321 static inline LPCSTR debugtext_t(LPCWSTR text, BOOL isW)
322 {
323 if (text == LPSTR_TEXTCALLBACKW) return "(callback)";
324 return isW ? debugstr_w(text) : debugstr_a((LPCSTR)text);
325 }
326
327 static inline LPCSTR debugtext_tn(LPCWSTR text, BOOL isW, INT n)
328 {
329 if (text == LPSTR_TEXTCALLBACKW) return "(callback)";
330 n = min(textlenT(text, isW), n);
331 return isW ? debugstr_wn(text, n) : debugstr_an((LPCSTR)text, n);
332 }
333
334 static inline LPWSTR textdupTtoW(LPCWSTR text, BOOL isW)
335 {
336 LPWSTR wstr = (LPWSTR)text;
337
338 TRACE("(text=%s, isW=%d)\n", debugtext_t(text, isW), isW);
339 if (!isW && is_textT(text, isW))
340 {
341 INT len = MultiByteToWideChar(CP_ACP, 0, (LPCSTR)text, -1, NULL, 0);
342 wstr = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
343 if (wstr) MultiByteToWideChar(CP_ACP, 0, (LPCSTR)text, -1, wstr, len);
344 }
345 TRACE(" wstr=%s\n", debugstr_w(wstr));
346 return wstr;
347 }
348
349 static inline void textfreeT(LPWSTR wstr, BOOL isW)
350 {
351 if (!isW && is_textT(wstr, isW)) HeapFree(GetProcessHeap(), 0, wstr);
352 }
353
354 /*
355 * dest is a pointer to a Unicode string
356 * src is a pointer to a string (Unicode if isW, ANSI if !isW)
357 */
358 static BOOL textsetptrT(LPWSTR *dest, LPWSTR src, BOOL isW)
359 {
360 BOOL bResult = TRUE;
361
362 if (src == LPSTR_TEXTCALLBACKW)
363 {
364 if (is_textW(*dest)) COMCTL32_Free(*dest);
365 *dest = LPSTR_TEXTCALLBACKW;
366 }
367 else
368 {
369 LPWSTR pszText = textdupTtoW(src, isW);
370 if (*dest == LPSTR_TEXTCALLBACKW) *dest = NULL;
371 bResult = Str_SetPtrW(dest, pszText);
372 textfreeT(pszText, isW);
373 }
374 return bResult;
375 }
376
377 /*
378 * compares a Unicode to a Unicode/ANSI text string
379 */
380 static inline int textcmpWT(LPWSTR aw, LPWSTR bt, BOOL isW)
381 {
382 if (!aw) return bt ? -1 : 0;
383 if (!bt) return aw ? 1 : 0;
384 if (aw == LPSTR_TEXTCALLBACKW)
385 return bt == LPSTR_TEXTCALLBACKW ? 0 : -1;
386 if (bt != LPSTR_TEXTCALLBACKW)
387 {
388 LPWSTR bw = textdupTtoW(bt, isW);
389 int r = bw ? lstrcmpW(aw, bw) : 1;
390 textfreeT(bw, isW);
391 return r;
392 }
393
394 return 1;
395 }
396
397 static inline LRESULT CallWindowProcT(WNDPROC proc, HWND hwnd, UINT uMsg,
398 WPARAM wParam, LPARAM lParam, BOOL isW)
399 {
400 if (isW)
401 return CallWindowProcW(proc, hwnd, uMsg, wParam, lParam);
402 else
403 return CallWindowProcA(proc, hwnd, uMsg, wParam, lParam);
404 }
405
406 static inline BOOL notify(LISTVIEW_INFO *infoPtr, INT code, LPNMHDR pnmh)
407 {
408 pnmh->hwndFrom = infoPtr->hwndSelf;
409 pnmh->idFrom = GetWindowLongW(infoPtr->hwndSelf, GWL_ID);
410 pnmh->code = code;
411 return (BOOL)SendMessageW(GetParent(infoPtr->hwndSelf), WM_NOTIFY,
412 (WPARAM)pnmh->idFrom, (LPARAM)pnmh);
413 }
414
415 static inline void notify_itemactivate(LISTVIEW_INFO *infoPtr)
416 {
417 hwnd_notify(infoPtr->hwndSelf, LVN_ITEMACTIVATE);
418 }
419
420 static inline BOOL listview_notify(LISTVIEW_INFO *infoPtr, INT code, LPNMLISTVIEW plvnm)
421 {
422 return notify(infoPtr, code, (LPNMHDR)plvnm);
423 }
424
425 static int tabNotification[] = {
426 LVN_BEGINLABELEDITW, LVN_BEGINLABELEDITA,
427 LVN_ENDLABELEDITW, LVN_ENDLABELEDITA,
428 LVN_GETDISPINFOW, LVN_GETDISPINFOA,
429 LVN_SETDISPINFOW, LVN_SETDISPINFOA,
430 LVN_ODFINDITEMW, LVN_ODFINDITEMA,
431 LVN_GETINFOTIPW, LVN_GETINFOTIPA,
432 0
433 };
434
435 static int get_ansi_notification(INT unicodeNotificationCode)
436 {
437 int *pTabNotif = tabNotification;
438 while (*pTabNotif && (unicodeNotificationCode != *pTabNotif++));
439 if (*pTabNotif) return *pTabNotif;
440 ERR("unknown notification %x\n", unicodeNotificationCode);
441 return unicodeNotificationCode;
442 }
443
444 /*
445 Send notification. depends on dispinfoW having same
446 structure as dispinfoA.
447 infoPtr : listview struct
448 notificationCode : *Unicode* notification code
449 pdi : dispinfo structure (can be unicode or ansi)
450 isW : TRUE if dispinfo is Unicode
451 */
452 static BOOL dispinfo_notifyT(LISTVIEW_INFO *infoPtr, INT notificationCode, LPNMLVDISPINFOW pdi, BOOL isW)
453 {
454 BOOL bResult = FALSE;
455 BOOL convertToAnsi = FALSE, convertToUnicode = FALSE;
456 INT realNotifCode;
457 INT cchTempBufMax = 0, savCchTextMax = 0;
458 LPWSTR pszTempBuf = NULL, savPszText = NULL;
459
460 TRACE("(code=%x, pdi=%p, isW=%d)\n", notificationCode, pdi, isW);
461 TRACE(" notifyFormat=%s\n",
462 infoPtr->notifyFormat == NFR_UNICODE ? "NFR_UNICODE" :
463 infoPtr->notifyFormat == NFR_ANSI ? "NFR_ANSI" : "(not set)");
464 if (infoPtr->notifyFormat == NFR_ANSI)
465 realNotifCode = get_ansi_notification(notificationCode);
466 else
467 realNotifCode = notificationCode;
468
469 if (is_textT(pdi->item.pszText, isW))
470 {
471 if (isW && infoPtr->notifyFormat == NFR_ANSI)
472 convertToAnsi = TRUE;
473 if (!isW && infoPtr->notifyFormat == NFR_UNICODE)
474 convertToUnicode = TRUE;
475 }
476
477 if (convertToAnsi || convertToUnicode)
478 {
479 TRACE(" we have to convert the text to the correct format\n");
480 if (notificationCode != LVN_GETDISPINFOW)
481 { /* length of existing text */
482 cchTempBufMax = convertToUnicode ?
483 MultiByteToWideChar(CP_ACP, 0, (LPCSTR)pdi->item.pszText, -1, NULL, 0):
484 WideCharToMultiByte(CP_ACP, 0, pdi->item.pszText, -1, NULL, 0, NULL, NULL);
485 }
486 else
487 cchTempBufMax = pdi->item.cchTextMax;
488
489 pszTempBuf = HeapAlloc(GetProcessHeap(), 0,
490 (convertToUnicode ? sizeof(WCHAR) : sizeof(CHAR)) * cchTempBufMax);
491 if (!pszTempBuf) return FALSE;
492 if (convertToUnicode)
493 MultiByteToWideChar(CP_ACP, 0, (LPCSTR)pdi->item.pszText, -1,
494 pszTempBuf, cchTempBufMax);
495 else
496 WideCharToMultiByte(CP_ACP, 0, pdi->item.pszText, -1, (LPSTR) pszTempBuf,
497 cchTempBufMax, NULL, NULL);
498 TRACE(" text=%s\n", debugtext_t(pszTempBuf, convertToUnicode));
499 savCchTextMax = pdi->item.cchTextMax;
500 savPszText = pdi->item.pszText;
501 pdi->item.pszText = pszTempBuf;
502 pdi->item.cchTextMax = cchTempBufMax;
503 }
504
505 bResult = notify(infoPtr, realNotifCode, (LPNMHDR)pdi);
506
507 if (convertToUnicode || convertToAnsi)
508 { /* convert back result */
509 TRACE(" returned text=%s\n", debugtext_t(pdi->item.pszText, convertToUnicode));
510 if (convertToUnicode) /* note : pointer can be changed by app ! */
511 WideCharToMultiByte(CP_ACP, 0, pdi->item.pszText, -1, (LPSTR) savPszText,
512 savCchTextMax, NULL, NULL);
513 else
514 MultiByteToWideChar(CP_ACP, 0, (LPSTR) pdi->item.pszText, -1,
515 savPszText, savCchTextMax);
516 pdi->item.pszText = savPszText; /* restores our buffer */
517 pdi->item.cchTextMax = savCchTextMax;
518 HeapFree(GetProcessHeap(), 0, pszTempBuf);
519 }
520 return bResult;
521 }
522
523 static inline LRESULT LISTVIEW_GetItemW(LISTVIEW_INFO *infoPtr, LPLVITEMW lpLVItem, BOOL internal)
524 {
525 return LISTVIEW_GetItemT(infoPtr, lpLVItem, internal, TRUE);
526 }
527
528 static inline int lstrncmpiW(LPCWSTR s1, LPCWSTR s2, int n)
529 {
530 int res;
531
532 n = min(min(n, strlenW(s1)), strlenW(s2));
533 res = CompareStringW(LOCALE_USER_DEFAULT, NORM_IGNORECASE, s1, n, s2, n);
534 return res ? res - sizeof(WCHAR) : res;
535 }
536
537 static char* debuglvitem_t(LPLVITEMW lpLVItem, BOOL isW)
538 {
539 static int index = 0;
540 static char buffers[20][256];
541 char* buf = buffers[index++ % 20];
542 if (lpLVItem == NULL) return "(null)";
543 snprintf(buf, 256, "{mask=%x, iItem=%d, iSubItem=%d, state=%x, stateMask=%x,"
544 " pszText=%s, cchTextMax=%d, iImage=%d, lParam=%lx, iIndent=%d}",
545 lpLVItem->mask, lpLVItem->iItem, lpLVItem->iSubItem,
546 lpLVItem->state, lpLVItem->stateMask,
547 debugtext_tn(lpLVItem->pszText, isW, 80),
548 lpLVItem->cchTextMax, lpLVItem->iImage, lpLVItem->lParam,
549 lpLVItem->iIndent);
550 return buf;
551 }
552
553 static char* debuglvcolumn_t(LPLVCOLUMNW lpColumn, BOOL isW)
554 {
555 static int index = 0;
556 static char buffers[20][256];
557 char* buf = buffers[index++ % 20];
558 if (lpColumn == NULL) return "(null)";
559 snprintf(buf, 256, "{mask=%x, fmt=%x, cx=%d,"
560 " pszText=%s, cchTextMax=%d, iSubItem=%d}",
561 lpColumn->mask, lpColumn->fmt, lpColumn->cx,
562 lpColumn->mask & LVCF_TEXT ? debugtext_tn(lpColumn->pszText, isW, 80): "",
563 lpColumn->mask & LVCF_TEXT ? lpColumn->cchTextMax: 0, lpColumn->iSubItem);
564 return buf;
565 }
566
567 static BOOL
568 LISTVIEW_SendCustomDrawNotify (LISTVIEW_INFO *infoPtr, DWORD dwDrawStage, HDC hdc,
569 RECT rc)
570 {
571 NMLVCUSTOMDRAW nmcdhdr;
572 LPNMCUSTOMDRAW nmcd;
573
574 TRACE("(dwDrawStage=%lx, hdc=%x, rc=?)\n", dwDrawStage, hdc);
575
576 nmcd= & nmcdhdr.nmcd;
577 nmcd->hdr.hwndFrom = infoPtr->hwndSelf;
578 nmcd->hdr.idFrom = GetWindowLongW( infoPtr->hwndSelf, GWL_ID);
579 nmcd->hdr.code = NM_CUSTOMDRAW;
580 nmcd->dwDrawStage= dwDrawStage;
581 nmcd->hdc = hdc;
582 nmcd->rc.left = rc.left;
583 nmcd->rc.right = rc.right;
584 nmcd->rc.bottom = rc.bottom;
585 nmcd->rc.top = rc.top;
586 nmcd->dwItemSpec = 0;
587 nmcd->uItemState = 0;
588 nmcd->lItemlParam= 0;
589 nmcdhdr.clrText = infoPtr->clrText;
590 nmcdhdr.clrTextBk= infoPtr->clrBk;
591
592 return (BOOL)SendMessageW (GetParent (infoPtr->hwndSelf), WM_NOTIFY,
593 (WPARAM) nmcd->hdr.idFrom, (LPARAM)&nmcdhdr);
594 }
595
596 static BOOL
597 LISTVIEW_SendCustomDrawItemNotify (LISTVIEW_INFO *infoPtr, HDC hdc,
598 UINT iItem, UINT iSubItem,
599 UINT uItemDrawState)
600 {
601 NMLVCUSTOMDRAW nmcdhdr;
602 LPNMCUSTOMDRAW nmcd;
603 DWORD dwDrawStage,dwItemSpec;
604 UINT uItemState;
605 INT retval;
606 RECT itemRect;
607 LVITEMW item;
608
609 ZeroMemory(&item,sizeof(item));
610 item.iItem = iItem;
611 item.mask = LVIF_PARAM;
612 ListView_GetItemW(infoPtr->hwndSelf,&item);
613
614 dwDrawStage=CDDS_ITEM | uItemDrawState;
615 dwItemSpec=iItem;
616 uItemState=0;
617
618 if (LISTVIEW_GetItemState(infoPtr, iItem, LVIS_SELECTED)) uItemState |= CDIS_SELECTED;
619 if (LISTVIEW_GetItemState(infoPtr, iItem, LVIS_FOCUSED)) uItemState |= CDIS_FOCUS;
620 if (iItem == infoPtr->nHotItem) uItemState |= CDIS_HOT;
621
622 itemRect.left = LVIR_BOUNDS;
623 LISTVIEW_GetItemRect(infoPtr, iItem, &itemRect);
624
625 nmcd= & nmcdhdr.nmcd;
626 nmcd->hdr.hwndFrom = infoPtr->hwndSelf;
627 nmcd->hdr.idFrom = GetWindowLongW( infoPtr->hwndSelf, GWL_ID);
628 nmcd->hdr.code = NM_CUSTOMDRAW;
629 nmcd->dwDrawStage= dwDrawStage;
630 nmcd->hdc = hdc;
631 nmcd->rc.left = itemRect.left;
632 nmcd->rc.right = itemRect.right;
633 nmcd->rc.bottom = itemRect.bottom;
634 nmcd->rc.top = itemRect.top;
635 nmcd->dwItemSpec = dwItemSpec;
636 nmcd->uItemState = uItemState;
637 nmcd->lItemlParam= item.lParam;
638 nmcdhdr.clrText = infoPtr->clrText;
639 nmcdhdr.clrTextBk= infoPtr->clrBk;
640 nmcdhdr.iSubItem =iSubItem;
641
642 TRACE("drawstage=%lx hdc=%x item=%lx, itemstate=%x, lItemlParam=%lx\n",
643 nmcd->dwDrawStage, nmcd->hdc, nmcd->dwItemSpec,
644 nmcd->uItemState, nmcd->lItemlParam);
645
646 retval=SendMessageW (GetParent (infoPtr->hwndSelf), WM_NOTIFY,
647 (WPARAM)nmcd->hdr.idFrom, (LPARAM)&nmcdhdr);
648
649 infoPtr->clrText=nmcdhdr.clrText;
650 infoPtr->clrBk =nmcdhdr.clrTextBk;
651 return (BOOL) retval;
652 }
653
654 static inline int LISTVIEW_GetType(LISTVIEW_INFO *infoPtr)
655 {
656 return GetWindowLongW(infoPtr->hwndSelf, GWL_STYLE) & LVS_TYPEMASK;
657 }
658
659 /***
660 * DESCRIPTION:
661 * Retrieves the number of items that can fit vertically in the client area.
662 *
663 * PARAMETER(S):
664 * [I] infoPtr : valid pointer to the listview structure
665 *
666 * RETURN:
667 * Number of items per row.
668 */
669 static inline INT LISTVIEW_GetCountPerRow(LISTVIEW_INFO *infoPtr)
670 {
671 INT nListWidth = infoPtr->rcList.right - infoPtr->rcList.left;
672
673 return max(nListWidth/infoPtr->nItemWidth, 1);
674 }
675
676 /***
677 * DESCRIPTION:
678 * Retrieves the number of items that can fit horizontally in the client
679 * area.
680 *
681 * PARAMETER(S):
682 * [I] infoPtr : valid pointer to the listview structure
683 *
684 * RETURN:
685 * Number of items per column.
686 */
687 static inline INT LISTVIEW_GetCountPerColumn(LISTVIEW_INFO *infoPtr)
688 {
689 INT nListHeight = infoPtr->rcList.bottom - infoPtr->rcList.top;
690
691 return max(nListHeight / infoPtr->nItemHeight, 1);
692 }
693
694 /***
695 * DESCRIPTION:
696 * Retrieves the count of visible items. Note that the returned count may
697 * be a bit larger than the actual count.
698 *
699 * PARAMETER(S):
700 * [I] infoPtr : valid pointer to the listview structure
701 *
702 * RETURN:
703 * maximum visible item count
704 */
705 static INT LISTVIEW_GetVisibleCount(LISTVIEW_INFO *infoPtr)
706 {
707 UINT uView = LISTVIEW_GetType(infoPtr);
708 INT nPerCol, nPerRow;
709
710 if (uView == LVS_REPORT)
711 {
712 nPerCol = LISTVIEW_GetCountPerColumn(infoPtr) + 1;
713 nPerRow = 1;
714 }
715 else if (uView == LVS_LIST)
716 {
717 nPerCol = LISTVIEW_GetCountPerColumn(infoPtr) + 1;
718 nPerRow = LISTVIEW_GetCountPerRow(infoPtr);
719 }
720 else
721 {
722 nPerCol = LISTVIEW_GetCountPerColumn(infoPtr) + 1;
723 nPerRow = LISTVIEW_GetCountPerRow(infoPtr) + 1;
724 }
725
726 return nPerCol * nPerRow;
727 }
728
729
730 /*************************************************************************
731 * LISTVIEW_ProcessLetterKeys
732 *
733 * Processes keyboard messages generated by pressing the letter keys
734 * on the keyboard.
735 * What this does is perform a case insensitive search from the
736 * current position with the following quirks:
737 * - If two chars or more are pressed in quick succession we search
738 * for the corresponding string (e.g. 'abc').
739 * - If there is a delay we wipe away the current search string and
740 * restart with just that char.
741 * - If the user keeps pressing the same character, whether slowly or
742 * fast, so that the search string is entirely composed of this
743 * character ('aaaaa' for instance), then we search for first item
744 * that starting with that character.
745 * - If the user types the above character in quick succession, then
746 * we must also search for the corresponding string ('aaaaa'), and
747 * go to that string if there is a match.
748 *
749 * PARAMETERS
750 * [I] hwnd : handle to the window
751 * [I] charCode : the character code, the actual character
752 * [I] keyData : key data
753 *
754 * RETURNS
755 *
756 * Zero.
757 *
758 * BUGS
759 *
760 * - The current implementation has a list of characters it will
761 * accept and it ignores averything else. In particular it will
762 * ignore accentuated characters which seems to match what
763 * Windows does. But I'm not sure it makes sense to follow
764 * Windows there.
765 * - We don't sound a beep when the search fails.
766 *
767 * SEE ALSO
768 *
769 * TREEVIEW_ProcessLetterKeys
770 */
771 static INT LISTVIEW_ProcessLetterKeys(LISTVIEW_INFO *infoPtr, WPARAM charCode, LPARAM keyData)
772 {
773 INT nItem;
774 INT nSize;
775 INT endidx,idx;
776 LVITEMW item;
777 WCHAR buffer[MAX_PATH];
778 DWORD timestamp,elapsed;
779
780 /* simple parameter checking */
781 if (!charCode || !keyData)
782 return 0;
783
784 if (!infoPtr)
785 return 0;
786
787 /* only allow the valid WM_CHARs through */
788 if (!isalnum(charCode) &&
789 charCode != '.' && charCode != '`' && charCode != '!' &&
790 charCode != '@' && charCode != '#' && charCode != '$' &&
791 charCode != '%' && charCode != '^' && charCode != '&' &&
792 charCode != '*' && charCode != '(' && charCode != ')' &&
793 charCode != '-' && charCode != '_' && charCode != '+' &&
794 charCode != '=' && charCode != '\\'&& charCode != ']' &&
795 charCode != '}' && charCode != '[' && charCode != '{' &&
796 charCode != '/' && charCode != '?' && charCode != '>' &&
797 charCode != '<' && charCode != ',' && charCode != '~')
798 return 0;
799
800 nSize=GETITEMCOUNT(infoPtr);
801 /* if there's one item or less, there is no where to go */
802 if (nSize <= 1)
803 return 0;
804
805 /* compute how much time elapsed since last keypress */
806 timestamp=GetTickCount();
807 if (timestamp > infoPtr->lastKeyPressTimestamp) {
808 elapsed=timestamp-infoPtr->lastKeyPressTimestamp;
809 } else {
810 elapsed=infoPtr->lastKeyPressTimestamp-timestamp;
811 }
812
813 /* update the search parameters */
814 infoPtr->lastKeyPressTimestamp=timestamp;
815 if (elapsed < KEY_DELAY) {
816 if (infoPtr->nSearchParamLength < COUNTOF(infoPtr->szSearchParam)) {
817 infoPtr->szSearchParam[infoPtr->nSearchParamLength++]=charCode;
818 }
819 if (infoPtr->charCode != charCode) {
820 infoPtr->charCode=charCode=0;
821 }
822 } else {
823 infoPtr->charCode=charCode;
824 infoPtr->szSearchParam[0]=charCode;
825 infoPtr->nSearchParamLength=1;
826 /* Redundant with the 1 char string */
827 charCode=0;
828 }
829
830 /* and search from the current position */
831 nItem=-1;
832 if (infoPtr->nFocusedItem >= 0) {
833 endidx=infoPtr->nFocusedItem;
834 idx=endidx;
835 /* if looking for single character match,
836 * then we must always move forward
837 */
838 if (infoPtr->nSearchParamLength == 1)
839 idx++;
840 } else {
841 endidx=nSize;
842 idx=0;
843 }
844 do {
845 if (idx == nSize) {
846 if (endidx == nSize || endidx == 0)
847 break;
848 idx=0;
849 }
850
851 /* get item */
852 ZeroMemory(&item, sizeof(item));
853 item.mask = LVIF_TEXT;
854 item.iItem = idx;
855 item.iSubItem = 0;
856 item.pszText = buffer;
857 item.cchTextMax = COUNTOF(buffer);
858 ListView_GetItemW(infoPtr->hwndSelf, &item);
859
860 /* check for a match */
861 if (lstrncmpiW(item.pszText,infoPtr->szSearchParam,infoPtr->nSearchParamLength) == 0) {
862 nItem=idx;
863 break;
864 } else if ( (charCode != 0) && (nItem == -1) && (nItem != infoPtr->nFocusedItem) &&
865 (lstrncmpiW(item.pszText,infoPtr->szSearchParam,1) == 0) ) {
866 /* This would work but we must keep looking for a longer match */
867 nItem=idx;
868 }
869 idx++;
870 } while (idx != endidx);
871
872 if (nItem != -1)
873 LISTVIEW_KeySelection(infoPtr, nItem);
874
875 return 0;
876 }
877
878 /*************************************************************************
879 * LISTVIEW_UpdateHeaderSize [Internal]
880 *
881 * Function to resize the header control
882 *
883 * PARAMS
884 * hwnd [I] handle to a window
885 * nNewScrollPos [I] Scroll Pos to Set
886 *
887 * RETURNS
888 * nothing
889 *
890 * NOTES
891 */
892 static void LISTVIEW_UpdateHeaderSize(LISTVIEW_INFO *infoPtr, INT nNewScrollPos)
893 {
894 RECT winRect;
895 POINT point[2];
896
897 GetWindowRect(infoPtr->hwndHeader, &winRect);
898 point[0].x = winRect.left;
899 point[0].y = winRect.top;
900 point[1].x = winRect.right;
901 point[1].y = winRect.bottom;
902
903 MapWindowPoints(HWND_DESKTOP, infoPtr->hwndSelf, point, 2);
904 point[0].x = -nNewScrollPos;
905 point[1].x += nNewScrollPos;
906
907 SetWindowPos(infoPtr->hwndHeader,0,
908 point[0].x,point[0].y,point[1].x,point[1].y,
909 SWP_NOZORDER | SWP_NOACTIVATE);
910 }
911
912 /***
913 * DESCRIPTION:
914 * Update the scrollbars. This functions should be called whenever
915 * the content, size or view changes.
916 *
917 * PARAMETER(S):
918 * [I] infoPtr : valid pointer to the listview structure
919 *
920 * RETURN:
921 * None
922 */
923 static void LISTVIEW_UpdateScroll(LISTVIEW_INFO *infoPtr)
924 {
925 LONG lStyle = GetWindowLongW(infoPtr->hwndSelf, GWL_STYLE);
926 UINT uView = lStyle & LVS_TYPEMASK;
927 INT nListHeight = infoPtr->rcList.bottom - infoPtr->rcList.top;
928 INT nListWidth = infoPtr->rcList.right - infoPtr->rcList.left;
929 SCROLLINFO scrollInfo;
930
931 if (lStyle & LVS_NOSCROLL) return;
932
933 ZeroMemory(&scrollInfo, sizeof(SCROLLINFO));
934 scrollInfo.cbSize = sizeof(SCROLLINFO);
935
936 if (uView == LVS_LIST)
937 {
938 /* update horizontal scrollbar */
939 INT nCountPerColumn = LISTVIEW_GetCountPerColumn(infoPtr);
940 INT nCountPerRow = LISTVIEW_GetCountPerRow(infoPtr);
941 INT nNumOfItems = GETITEMCOUNT(infoPtr);
942
943 TRACE("items=%d, perColumn=%d, perRow=%d\n",
944 nNumOfItems, nCountPerColumn, nCountPerRow);
945
946 scrollInfo.nMax = nNumOfItems / nCountPerColumn;
947 if((nNumOfItems % nCountPerColumn) == 0)
948 scrollInfo.nMax--;
949 if (scrollInfo.nMax < 0) scrollInfo.nMax = 0;
950 scrollInfo.nPos = ListView_GetTopIndex(infoPtr->hwndSelf) / nCountPerColumn;
951 scrollInfo.nPage = nCountPerRow;
952 scrollInfo.fMask = SIF_RANGE | SIF_POS | SIF_PAGE;
953 SetScrollInfo(infoPtr->hwndSelf, SB_HORZ, &scrollInfo, TRUE);
954 ShowScrollBar(infoPtr->hwndSelf, SB_VERT, FALSE);
955 }
956 else if (uView == LVS_REPORT)
957 {
958 BOOL test;
959
960 /* update vertical scrollbar */
961 scrollInfo.nMin = 0;
962 scrollInfo.nMax = GETITEMCOUNT(infoPtr) - 1;
963 scrollInfo.nPos = ListView_GetTopIndex(infoPtr->hwndSelf);
964 scrollInfo.nPage = LISTVIEW_GetCountPerColumn(infoPtr);
965 scrollInfo.fMask = SIF_RANGE | SIF_POS | SIF_PAGE;
966 test = (scrollInfo.nMin >= scrollInfo.nMax - max((INT)scrollInfo.nPage - 1, 0));
967 TRACE("LVS_REPORT Vert. nMax=%d, nPage=%d, test=%d\n",
968 scrollInfo.nMax, scrollInfo.nPage, test);
969 SetScrollInfo(infoPtr->hwndSelf, SB_VERT, &scrollInfo, TRUE);
970 ShowScrollBar(infoPtr->hwndSelf, SB_VERT, (test) ? FALSE : TRUE);
971
972 /* update horizontal scrollbar */
973 nListWidth = infoPtr->rcList.right - infoPtr->rcList.left;
974 if (GetScrollInfo(infoPtr->hwndSelf, SB_HORZ, &scrollInfo) == FALSE
975 || GETITEMCOUNT(infoPtr) == 0)
976 {
977 scrollInfo.nPos = 0;
978 }
979 scrollInfo.nMin = 0;
980 scrollInfo.fMask = SIF_RANGE | SIF_POS | SIF_PAGE ;
981 scrollInfo.nPage = nListWidth;
982 scrollInfo.nMax = max(infoPtr->nItemWidth, 0)-1;
983 test = (scrollInfo.nMin >= scrollInfo.nMax - max((INT)scrollInfo.nPage - 1, 0));
984 TRACE("LVS_REPORT Horz. nMax=%d, nPage=%d, test=%d\n",
985 scrollInfo.nMax, scrollInfo.nPage, test);
986 SetScrollInfo(infoPtr->hwndSelf, SB_HORZ, &scrollInfo, TRUE);
987 ShowScrollBar(infoPtr->hwndSelf, SB_HORZ, (test) ? FALSE : TRUE);
988
989 /* Update the Header Control */
990 scrollInfo.fMask = SIF_POS;
991 GetScrollInfo(infoPtr->hwndSelf, SB_HORZ, &scrollInfo);
992 LISTVIEW_UpdateHeaderSize(infoPtr, scrollInfo.nPos);
993
994 }
995 else
996 {
997 RECT rcView;
998
999 if (LISTVIEW_GetViewRect(infoPtr, &rcView))
1000 {
1001 INT nViewWidth = rcView.right - rcView.left;
1002 INT nViewHeight = rcView.bottom - rcView.top;
1003
1004 /* Update Horizontal Scrollbar */
1005 scrollInfo.fMask = SIF_POS;
1006 if (GetScrollInfo(infoPtr->hwndSelf, SB_HORZ, &scrollInfo) == FALSE
1007 || GETITEMCOUNT(infoPtr) == 0)
1008 {
1009 scrollInfo.nPos = 0;
1010 }
1011 scrollInfo.nMax = max(nViewWidth, 0)-1;
1012 scrollInfo.nMin = 0;
1013 scrollInfo.nPage = nListWidth;
1014 scrollInfo.fMask = SIF_RANGE | SIF_POS | SIF_PAGE;
1015 TRACE("LVS_ICON/SMALLICON Horz.\n");
1016 SetScrollInfo(infoPtr->hwndSelf, SB_HORZ, &scrollInfo, TRUE);
1017
1018 /* Update Vertical Scrollbar */
1019 nListHeight = infoPtr->rcList.bottom - infoPtr->rcList.top;
1020 scrollInfo.fMask = SIF_POS;
1021 if (GetScrollInfo(infoPtr->hwndSelf, SB_VERT, &scrollInfo) == FALSE
1022 || GETITEMCOUNT(infoPtr) == 0)
1023 {
1024 scrollInfo.nPos = 0;
1025 }
1026 scrollInfo.nMax = max(nViewHeight,0)-1;
1027 scrollInfo.nMin = 0;
1028 scrollInfo.nPage = nListHeight;
1029 scrollInfo.fMask = SIF_RANGE | SIF_POS | SIF_PAGE;
1030 TRACE("LVS_ICON/SMALLICON Vert.\n");
1031 SetScrollInfo(infoPtr->hwndSelf, SB_VERT, &scrollInfo, TRUE);
1032 }
1033 }
1034 }
1035
1036
1037 /***
1038 * Toggles (draws/erase) the focus rectangle.
1039 */
1040 static inline void LISTVIEW_ToggleFocusRect(LISTVIEW_INFO *infoPtr)
1041 {
1042 /* if we have a focus rectagle, draw it */
1043 if (!IsRectEmpty(&infoPtr->rcFocus))
1044 {
1045 HDC hdc = GetDC(infoPtr->hwndSelf);
1046 DrawFocusRect(hdc, &infoPtr->rcFocus);
1047 ReleaseDC(infoPtr->hwndSelf, hdc);
1048 }
1049 }
1050
1051 /***
1052 * Invalidates all visible selected items.
1053 */
1054 static void LISTVIEW_InvalidateSelectedItems(LISTVIEW_INFO *infoPtr)
1055 {
1056 INT i, nTop, nBottom;
1057
1058 nTop = LISTVIEW_GetTopIndex(infoPtr);
1059 nBottom = nTop + LISTVIEW_GetVisibleCount(infoPtr);
1060 if (nBottom > GETITEMCOUNT(infoPtr)) nBottom = GETITEMCOUNT(infoPtr);
1061
1062 for (i = nTop; i <= nBottom; i++)
1063 {
1064 if (LISTVIEW_GetItemState(infoPtr, i, LVIS_SELECTED))
1065 {
1066 RECT rcItem;
1067 rcItem.left = LVIR_BOUNDS;
1068 LISTVIEW_GetItemRect(infoPtr, i, &rcItem);
1069 InvalidateRect(infoPtr->hwndSelf, &rcItem, FALSE);
1070 }
1071 }
1072 }
1073
1074
1075 /***
1076 * DESCRIPTION:
1077 * Prints a message for unsupported window styles.
1078 * A kind of TODO list for window styles.
1079 *
1080 * PARAMETER(S):
1081 * [I] LONG : window style
1082 *
1083 * RETURN:
1084 * None
1085 */
1086 static void LISTVIEW_UnsupportedStyles(LONG lStyle)
1087 {
1088 if ((LVS_TYPESTYLEMASK & lStyle) == LVS_NOSCROLL)
1089 FIXME(" LVS_NOSCROLL\n");
1090
1091 if (lStyle & LVS_NOLABELWRAP)
1092 FIXME(" LVS_NOLABELWRAP\n");
1093
1094 if (!(lStyle & LVS_SHAREIMAGELISTS))
1095 FIXME(" !LVS_SHAREIMAGELISTS\n");
1096
1097 if (lStyle & LVS_SORTASCENDING)
1098 FIXME(" LVS_SORTASCENDING\n");
1099
1100 if (lStyle & LVS_SORTDESCENDING)
1101 FIXME(" LVS_SORTDESCENDING\n");
1102 }
1103
1104 /***
1105 * DESCRIPTION:
1106 * Aligns the items with the top edge of the window.
1107 *
1108 * PARAMETER(S):
1109 * [I] infoPtr : valid pointer to the listview structure
1110 *
1111 * RETURN:
1112 * None
1113 */
1114 static void LISTVIEW_AlignTop(LISTVIEW_INFO *infoPtr)
1115 {
1116 UINT uView = LISTVIEW_GetType(infoPtr);
1117 INT nListWidth = infoPtr->rcList.right - infoPtr->rcList.left;
1118 POINT ptItem;
1119 RECT rcView;
1120 INT i, off_x=0, off_y=0;
1121
1122 if ((uView == LVS_SMALLICON) || (uView == LVS_ICON))
1123 {
1124 /* Since SetItemPosition uses upper-left of icon, and for
1125 style=LVS_ICON the icon is not left adjusted, get the offset */
1126 if (uView == LVS_ICON)
1127 {
1128 off_y = ICON_TOP_PADDING;
1129 off_x = (infoPtr->iconSpacing.cx - infoPtr->iconSize.cx) / 2;
1130 }
1131 ptItem.x = off_x;
1132 ptItem.y = off_y;
1133 ZeroMemory(&rcView, sizeof(RECT));
1134 TRACE("Icon off.x=%d, off.y=%d, left=%d, right=%d\n",
1135 off_x, off_y,
1136 infoPtr->rcList.left, infoPtr->rcList.right);
1137
1138 if (nListWidth > infoPtr->nItemWidth)
1139 {
1140 for (i = 0; i < GETITEMCOUNT(infoPtr); i++)
1141 {
1142 if ((ptItem.x-off_x) + infoPtr->nItemWidth > nListWidth)
1143 {
1144 ptItem.x = off_x;
1145 ptItem.y += infoPtr->nItemHeight;
1146 }
1147
1148 LISTVIEW_SetItemPosition(infoPtr, i, ptItem.x, ptItem.y);
1149 ptItem.x += infoPtr->nItemWidth;
1150 rcView.right = max(rcView.right, ptItem.x);
1151 }
1152
1153 rcView.right -= off_x;
1154 rcView.bottom = (ptItem.y-off_y) + infoPtr->nItemHeight;
1155 }
1156 else
1157 {
1158 for (i = 0; i < GETITEMCOUNT(infoPtr); i++)
1159 {
1160 LISTVIEW_SetItemPosition(infoPtr, i, ptItem.x, ptItem.y);
1161 ptItem.y += infoPtr->nItemHeight;
1162 }
1163
1164 rcView.right = infoPtr->nItemWidth;
1165 rcView.bottom = ptItem.y-off_y;
1166 }
1167
1168 LISTVIEW_SetViewRect(infoPtr, &rcView);
1169 }
1170 }
1171
1172 /***
1173 * DESCRIPTION:
1174 * Aligns the items with the left edge of the window.
1175 *
1176 * PARAMETER(S):
1177 * [I] infoPtr : valid pointer to the listview structure
1178 *
1179 * RETURN:
1180 * None
1181 */
1182 static void LISTVIEW_AlignLeft(LISTVIEW_INFO *infoPtr)
1183 {
1184 UINT uView = LISTVIEW_GetType(infoPtr);
1185 INT nListHeight = infoPtr->rcList.bottom - infoPtr->rcList.top;
1186 POINT ptItem;
1187 RECT rcView;
1188 INT i, off_x=0, off_y=0;
1189
1190 if ((uView == LVS_SMALLICON) || (uView == LVS_ICON))
1191 {
1192 /* Since SetItemPosition uses upper-left of icon, and for
1193 style=LVS_ICON the icon is not left adjusted, get the offset */
1194 if (uView == LVS_ICON)
1195 {
1196 off_y = ICON_TOP_PADDING;
1197 off_x = (infoPtr->iconSpacing.cx - infoPtr->iconSize.cx) / 2;
1198 }
1199 ptItem.x = off_x;
1200 ptItem.y = off_y;
1201 ZeroMemory(&rcView, sizeof(RECT));
1202 TRACE("Icon off.x=%d, off.y=%d\n", off_x, off_y);
1203
1204 if (nListHeight > infoPtr->nItemHeight)
1205 {
1206 for (i = 0; i < GETITEMCOUNT(infoPtr); i++)
1207 {
1208 if (ptItem.y + infoPtr->nItemHeight > nListHeight)
1209 {
1210 ptItem.y = off_y;
1211 ptItem.x += infoPtr->nItemWidth;
1212 }
1213
1214 LISTVIEW_SetItemPosition(infoPtr, i, ptItem.x, ptItem.y);
1215 ptItem.y += infoPtr->nItemHeight;
1216 rcView.bottom = max(rcView.bottom, ptItem.y);
1217 }
1218
1219 rcView.right = ptItem.x + infoPtr->nItemWidth;
1220 }
1221 else
1222 {
1223 for (i = 0; i < GETITEMCOUNT(infoPtr); i++)
1224 {
1225 LISTVIEW_SetItemPosition(infoPtr, i, ptItem.x, ptItem.y);
1226 ptItem.x += infoPtr->nItemWidth;
1227 }
1228
1229 rcView.bottom = infoPtr->nItemHeight;
1230 rcView.right = ptItem.x;
1231 }
1232
1233 LISTVIEW_SetViewRect(infoPtr, &rcView);
1234 }
1235 }
1236
1237 /***
1238 * DESCRIPTION:
1239 * Set the bounding rectangle of all the items.
1240 *
1241 * PARAMETER(S):
1242 * [I] infoPtr : valid pointer to the listview structure
1243 * [I] LPRECT : bounding rectangle
1244 *
1245 * RETURN:
1246 * SUCCESS : TRUE
1247 * FAILURE : FALSE
1248 */
1249 static LRESULT LISTVIEW_SetViewRect(LISTVIEW_INFO *infoPtr, LPRECT lprcView)
1250 {
1251 BOOL bResult = FALSE;
1252
1253 TRACE("(left=%d, top=%d, right=%d, bottom=%d)\n",
1254 lprcView->left, lprcView->top, lprcView->right, lprcView->bottom);
1255
1256 if (lprcView != NULL)
1257 {
1258 bResult = TRUE;
1259 infoPtr->rcView.left = lprcView->left;
1260 infoPtr->rcView.top = lprcView->top;
1261 infoPtr->rcView.right = lprcView->right;
1262 infoPtr->rcView.bottom = lprcView->bottom;
1263 }
1264
1265 return bResult;
1266 }
1267
1268 /***
1269 * DESCRIPTION:
1270 * Retrieves the bounding rectangle of all the items.
1271 *
1272 * PARAMETER(S):
1273 * [I] infoPtr : valid pointer to the listview structure
1274 * [O] LPRECT : bounding rectangle
1275 *
1276 * RETURN:
1277 * SUCCESS : TRUE
1278 * FAILURE : FALSE
1279 */
1280 static LRESULT LISTVIEW_GetViewRect(LISTVIEW_INFO *infoPtr, LPRECT lprcView)
1281 {
1282 BOOL bResult = FALSE;
1283 POINT ptOrigin;
1284
1285 TRACE("(lprcView=%p)\n", lprcView);
1286
1287 if (lprcView != NULL)
1288 {
1289 bResult = LISTVIEW_GetOrigin(infoPtr, &ptOrigin);
1290 if (bResult)
1291 {
1292 lprcView->left = infoPtr->rcView.left + ptOrigin.x;
1293 lprcView->top = infoPtr->rcView.top + ptOrigin.y;
1294 lprcView->right = infoPtr->rcView.right + ptOrigin.x;
1295 lprcView->bottom = infoPtr->rcView.bottom + ptOrigin.y;
1296 }
1297
1298 TRACE("(left=%d, top=%d, right=%d, bottom=%d)\n",
1299 lprcView->left, lprcView->top, lprcView->right, lprcView->bottom);
1300 }
1301
1302 return bResult;
1303 }
1304
1305 /***
1306 * DESCRIPTION:
1307 * Retrieves the subitem pointer associated with the subitem index.
1308 *
1309 * PARAMETER(S):
1310 * [I] HDPA : DPA handle for a specific item
1311 * [I] INT : index of subitem
1312 *
1313 * RETURN:
1314 * SUCCESS : subitem pointer
1315 * FAILURE : NULL
1316 */
1317 static LISTVIEW_SUBITEM* LISTVIEW_GetSubItemPtr(HDPA hdpaSubItems,
1318 INT nSubItem)
1319 {
1320 LISTVIEW_SUBITEM *lpSubItem;
1321 INT i;
1322
1323 /* we should binary search here if need be */
1324 for (i = 1; i < hdpaSubItems->nItemCount; i++)
1325 {
1326 lpSubItem = (LISTVIEW_SUBITEM *) DPA_GetPtr(hdpaSubItems, i);
1327 if (lpSubItem && (lpSubItem->iSubItem == nSubItem))
1328 return lpSubItem;
1329 }
1330
1331 return NULL;
1332 }
1333
1334
1335 /***
1336 * DESCRIPTION:
1337 * Calculates the width of a specific item.
1338 *
1339 * PARAMETER(S):
1340 * [I] infoPtr : valid pointer to the listview structure
1341 * [I] nItem : item to calculate width, or -1 for max of all
1342 *
1343 * RETURN:
1344 * Returns the width of an item width an item.
1345 */
1346 static INT LISTVIEW_CalculateWidth(LISTVIEW_INFO *infoPtr, INT nItem)
1347 {
1348 UINT uView = LISTVIEW_GetType(infoPtr);
1349 INT nItemWidth = 0, i;
1350
1351 if (uView == LVS_ICON)
1352 nItemWidth = infoPtr->iconSpacing.cx;
1353 else if (uView == LVS_REPORT)
1354 {
1355 INT nHeaderItemCount;
1356 RECT rcHeaderItem;
1357
1358 /* calculate width of header */
1359 nHeaderItemCount = Header_GetItemCount(infoPtr->hwndHeader);
1360 for (i = 0; i < nHeaderItemCount; i++)
1361 if (Header_GetItemRect(infoPtr->hwndHeader, i, &rcHeaderItem))
1362 nItemWidth += (rcHeaderItem.right - rcHeaderItem.left);
1363 }
1364 else
1365 {
1366 INT nLabelWidth;
1367
1368 if (GETITEMCOUNT(infoPtr) == 0) return DEFAULT_COLUMN_WIDTH;
1369
1370 /* get width of string */
1371 if (nItem == -1)
1372 {
1373 for (i = 0; i < GETITEMCOUNT(infoPtr); i++)
1374 {
1375 nLabelWidth = LISTVIEW_GetLabelWidth(infoPtr, i);
1376 nItemWidth = max(nItemWidth, nLabelWidth);
1377 }
1378 }
1379 else
1380 nItemWidth = LISTVIEW_GetLabelWidth(infoPtr, nItem);
1381 if (!nItemWidth) return DEFAULT_COLUMN_WIDTH;
1382 nItemWidth += WIDTH_PADDING;
1383 if (infoPtr->himlSmall) nItemWidth += infoPtr->iconSize.cx;
1384 if (infoPtr->himlState) nItemWidth += infoPtr->iconSize.cx; /*FIXME: is this correct */
1385 if (nItem == -1) nItemWidth = max(DEFAULT_COLUMN_WIDTH, nItemWidth);
1386 }
1387
1388 return max(nItemWidth, 1);
1389 }
1390
1391 /***
1392 * DESCRIPTION:
1393 * Calculates the max width of any item in the list.
1394 *
1395 * PARAMETER(S):
1396 * [I] infoPtr : valid pointer to the listview structure
1397 * [I] LONG : window style
1398 *
1399 * RETURN:
1400 * Returns item width.
1401 */
1402 static inline INT LISTVIEW_GetItemWidth(LISTVIEW_INFO *infoPtr)
1403 {
1404 return LISTVIEW_CalculateWidth(infoPtr, -1);
1405 }
1406
1407 /***
1408 * DESCRIPTION:
1409 * Retrieves and saves important text metrics info for the current
1410 * Listview font.
1411 *
1412 * PARAMETER(S):
1413 * [I] infoPtr : valid pointer to the listview structure
1414 *
1415 */
1416 static void LISTVIEW_SaveTextMetrics(LISTVIEW_INFO *infoPtr)
1417 {
1418 TEXTMETRICW tm;
1419 HDC hdc = GetDC(infoPtr->hwndSelf);
1420 HFONT hOldFont = SelectObject(hdc, infoPtr->hFont);
1421 INT oldHeight, oldACW;
1422
1423 GetTextMetricsW(hdc, &tm);
1424
1425 oldHeight = infoPtr->ntmHeight;
1426 oldACW = infoPtr->ntmAveCharWidth;
1427 infoPtr->ntmHeight = tm.tmHeight;
1428 infoPtr->ntmAveCharWidth = tm.tmAveCharWidth;
1429
1430 SelectObject(hdc, hOldFont);
1431 ReleaseDC(infoPtr->hwndSelf, hdc);
1432 TRACE("tmHeight old=%d,new=%d; tmAveCharWidth old=%d,new=%d\n",
1433 oldHeight, infoPtr->ntmHeight, oldACW, infoPtr->ntmAveCharWidth);
1434 }
1435
1436
1437 /***
1438 * DESCRIPTION:
1439 * Calculates the height of an item.
1440 *
1441 * PARAMETER(S):
1442 * [I] infoPtr : valid pointer to the listview structure
1443 *
1444 * RETURN:
1445 * Returns item height.
1446 */
1447 static INT LISTVIEW_GetItemHeight(LISTVIEW_INFO *infoPtr)
1448 {
1449 UINT uView = LISTVIEW_GetType(infoPtr);
1450 INT nItemHeight = 0;
1451
1452 if (uView == LVS_ICON)
1453 {
1454 nItemHeight = infoPtr->iconSpacing.cy;
1455 }
1456 else
1457 {
1458 if(infoPtr->himlState || infoPtr->himlSmall)
1459 nItemHeight = max(infoPtr->ntmHeight, infoPtr->iconSize.cy) + HEIGHT_PADDING;
1460 else
1461 nItemHeight = infoPtr->ntmHeight;
1462 }
1463
1464 return nItemHeight;
1465 }
1466
1467 #if 0
1468 static void LISTVIEW_PrintSelectionRanges(LISTVIEW_INFO *infoPtr)
1469 {
1470 LISTVIEW_SELECTION *selection;
1471 INT topSelection = infoPtr->hdpaSelectionRanges->nItemCount;
1472 INT i;
1473
1474 TRACE("Selections are:\n");
1475 for (i = 0; i < topSelection; i++)
1476 {
1477 selection = DPA_GetPtr(infoPtr->hdpaSelectionRanges,i);
1478 TRACE(" %lu - %lu\n",selection->lower,selection->upper);
1479 }
1480 }
1481 #endif
1482
1483 /***
1484 * DESCRIPTION:
1485 * A compare function for selection ranges
1486 *
1487 *PARAMETER(S)
1488 * [I] range1 : pointer to selection range 1;
1489 * [I] range2 : pointer to selection range 2;
1490 * [I] flags : flags
1491 *
1492 *RETURNS:
1493 * >0 : if Item 1 > Item 2
1494 * <0 : if Item 2 > Item 1
1495 * 0 : if Item 1 == Item 2
1496 */
1497 static INT CALLBACK LISTVIEW_CompareSelectionRanges(LPVOID range1, LPVOID range2, LPARAM flags)
1498 {
1499 if (((LISTVIEW_SELECTION*)(range1))->upper <
1500 ((LISTVIEW_SELECTION*)(range2))->lower)
1501 return -1;
1502 if (((LISTVIEW_SELECTION*)(range2))->upper <
1503 ((LISTVIEW_SELECTION*)(range1))->lower)
1504 return 1;
1505 return 0;
1506 }
1507
1508 /***
1509 * Helper function for LISTVIEW_AddSelectionRange, and LISTVIEW_SetItem.
1510 */
1511 static BOOL add_selection_range(LISTVIEW_INFO *infoPtr, INT lower, INT upper, BOOL adj_sel_only)
1512 {
1513 LISTVIEW_SELECTION selection;
1514 LVITEMW lvItem;
1515 INT index, i;
1516
1517 TRACE("range (%i - %i)\n", lower, upper);
1518
1519 /* try find overlapping selections first */
1520 selection.lower = lower - 1;
1521 selection.upper = upper + 1;
1522 index = DPA_Search(infoPtr->hdpaSelectionRanges, &selection, 0,
1523 LISTVIEW_CompareSelectionRanges, 0, 0);
1524
1525 if (index == -1)
1526 {
1527 LISTVIEW_SELECTION *newsel;
1528
1529 /* create the brand new selection to insert */
1530 newsel = (LISTVIEW_SELECTION *)COMCTL32_Alloc(sizeof(LISTVIEW_SELECTION));
1531 if(!newsel) return FALSE;
1532 newsel->lower = lower;
1533 newsel->upper = upper;
1534
1535 /* figure out where to insert it */
1536 index = DPA_Search(infoPtr->hdpaSelectionRanges, newsel, 0,
1537 LISTVIEW_CompareSelectionRanges, 0, DPAS_INSERTAFTER);
1538 if (index == -1) index = 0;
1539
1540 /* and get it over with */
1541 DPA_InsertPtr(infoPtr->hdpaSelectionRanges, index, newsel);
1542 }
1543 else
1544 {
1545 LISTVIEW_SELECTION *chksel, *mrgsel;
1546 INT fromindex, mergeindex;
1547
1548 chksel = DPA_GetPtr(infoPtr->hdpaSelectionRanges, index);
1549 if (!chksel) return FALSE;
1550 TRACE("Merge with index %i (%lu - %lu)\n",
1551 index,chksel->lower, chksel->upper);
1552
1553 chksel->lower = min(lower, chksel->lower);
1554 chksel->upper = max(upper, chksel->upper);
1555
1556 TRACE("New range %i (%lu - %lu)\n",
1557 index,chksel->lower, chksel->upper);
1558
1559 /* merge now common selection ranges */
1560 fromindex = 0;
1561 selection.lower = chksel->lower - 1;
1562 selection.upper = chksel->upper + 1;
1563
1564 do
1565 {
1566 mergeindex = DPA_Search(infoPtr->hdpaSelectionRanges, &selection, fromindex,
1567 LISTVIEW_CompareSelectionRanges, 0, 0);
1568 if (mergeindex == -1) break;
1569 if (mergeindex == index)
1570 {
1571 fromindex = index + 1;
1572 continue;
1573 }
1574
1575 TRACE("Merge with index %i\n", mergeindex);
1576
1577 mrgsel = DPA_GetPtr(infoPtr->hdpaSelectionRanges, mergeindex);
1578 if (!mrgsel) return FALSE;
1579
1580 chksel->lower = min(chksel->lower, mrgsel->lower);
1581 chksel->upper = max(chksel->upper, mrgsel->upper);
1582 COMCTL32_Free(mrgsel);
1583 DPA_DeletePtr(infoPtr->hdpaSelectionRanges, mergeindex);
1584 if (mergeindex < index) index --;
1585 } while(1);
1586 }
1587
1588 /* FIXME: do we really need it? */
1589 DPA_Sort(infoPtr->hdpaSelectionRanges, LISTVIEW_CompareSelectionRanges, 0);
1590
1591 if (adj_sel_only) return TRUE;
1592
1593 /* set the selection on items */
1594 ZeroMemory(&lvItem, sizeof(lvItem));
1595 lvItem.state = LVIS_SELECTED;
1596 lvItem.stateMask = LVIS_SELECTED;
1597 for(i = lower; i <= upper; i++)
1598 LISTVIEW_SetItemState(infoPtr, i, &lvItem);
1599
1600 return TRUE;
1601 }
1602
1603 /***
1604 * Helper function for LISTVIEW_RemoveSelectionRange, and LISTVIEW_SetItem.
1605 */
1606 static BOOL remove_selection_range(LISTVIEW_INFO *infoPtr, INT lower, INT upper, BOOL adj_sel_only)
1607 {
1608 LISTVIEW_SELECTION remsel, tmpsel, *chksel;
1609 BOOL done = FALSE;
1610 LVITEMW lvItem;
1611 INT index, i;
1612
1613 ZeroMemory(&lvItem, sizeof(lvItem));
1614 lvItem.stateMask = LVIS_SELECTED;
1615
1616 remsel.lower = lower;
1617 remsel.upper = upper;
1618
1619 TRACE("range: (%lu - %lu)\n", remsel.lower, remsel.upper);
1620
1621 do
1622 {
1623 index = DPA_Search(infoPtr->hdpaSelectionRanges, &remsel, 0,
1624 LISTVIEW_CompareSelectionRanges, 0, 0);
1625 if (index == -1) return TRUE;
1626
1627 chksel = DPA_GetPtr(infoPtr->hdpaSelectionRanges, index);
1628 if (!chksel) return FALSE;
1629
1630 TRACE("Matches range index %i (%lu-%lu)\n",
1631 index, chksel->lower, chksel->upper);
1632
1633 /* case 1: Same range */
1634 if ( (chksel->upper == remsel.upper) &&
1635 (chksel->lower == remsel.lower) )
1636 {
1637 DPA_DeletePtr(infoPtr->hdpaSelectionRanges, index);
1638 done = TRUE;
1639 }
1640 /* case 2: engulf */
1641 else if ( (chksel->upper <= remsel.upper) &&
1642 (chksel->lower >= remsel.lower) )
1643 {
1644 DPA_DeletePtr(infoPtr->hdpaSelectionRanges, index);
1645 }
1646 /* case 3: overlap upper */
1647 else if ( (chksel->upper < remsel.upper) &&
1648 (chksel->lower < remsel.lower) )
1649 {
1650 chksel->upper = remsel.lower - 1;
1651 }
1652 /* case 4: overlap lower */
1653 else if ( (chksel->upper > remsel.upper) &&
1654 (chksel->lower > remsel.lower) )
1655 {
1656 chksel->lower = remsel.upper + 1;
1657 }
1658 /* case 5: fully internal */
1659 else
1660 {
1661 LISTVIEW_SELECTION *newsel =
1662 (LISTVIEW_SELECTION *)COMCTL32_Alloc(sizeof(LISTVIEW_SELECTION));
1663 if (!newsel) return FALSE;
1664 tmpsel = *chksel;
1665 newsel->lower = chksel->lower;
1666 newsel->upper = remsel.lower - 1;
1667 chksel->lower = remsel.upper + 1;
1668 DPA_InsertPtr(infoPtr->hdpaSelectionRanges, index, newsel);
1669 /*FIXME: why do we need the sort??? */
1670 DPA_Sort(infoPtr->hdpaSelectionRanges, LISTVIEW_CompareSelectionRanges, 0);
1671 chksel = &tmpsel;
1672 }
1673
1674 if (adj_sel_only) continue;
1675
1676 /* here, chksel holds the selection to delete */
1677 for (i = chksel->lower; i <= chksel->upper; i++)
1678 LISTVIEW_SetItemState(infoPtr, i, &lvItem);
1679 }
1680 while(!done);
1681
1682 return TRUE;
1683 }
1684
1685 /**
1686 * DESCRIPTION:
1687 * Adds a selection range.
1688 *
1689 * PARAMETER(S):
1690 * [I] infoPtr : valid pointer to the listview structure
1691 * [I] lower : lower item index
1692 * [I] upper : upper item index
1693 *
1694 * RETURN:
1695 * Success: TRUE
1696 * Failure: FALSE
1697 */
1698 static inline BOOL LISTVIEW_AddSelectionRange(LISTVIEW_INFO *infoPtr, INT lower, INT upper)
1699 {
1700 return add_selection_range(infoPtr, lower, upper, FALSE);
1701 }
1702
1703 /***
1704 * DESCRIPTION:
1705 * Removes a range selections.
1706 *
1707 * PARAMETER(S):
1708 * [I] infoPtr : valid pointer to the listview structure
1709 * [I] lower : lower item index
1710 * [I] upper : upper item index
1711 *
1712 * RETURN:
1713 * Success: TRUE
1714 * Failure: FALSE
1715 */
1716 static inline BOOL LISTVIEW_RemoveSelectionRange(LISTVIEW_INFO *infoPtr, INT lower, INT upper)
1717 {
1718 return remove_selection_range(infoPtr, lower, upper, FALSE);
1719 }
1720
1721 /***
1722 * DESCRIPTION:
1723 * Removes all selection ranges
1724 *
1725 * Parameters(s):
1726 * [I] infoPtr : valid pointer to the listview structure
1727 *
1728 * RETURNS:
1729 * SUCCESS : TRUE
1730 * FAILURE : TRUE
1731 */
1732 static LRESULT LISTVIEW_RemoveAllSelections(LISTVIEW_INFO *infoPtr)
1733 {
1734 LISTVIEW_SELECTION *sel;
1735 static BOOL removing_all_selections = FALSE;
1736
1737 if (removing_all_selections) return TRUE;
1738
1739 removing_all_selections = TRUE;
1740
1741 TRACE("()\n");
1742
1743 do
1744 {
1745 sel = DPA_GetPtr(infoPtr->hdpaSelectionRanges,0);
1746 if (sel) LISTVIEW_RemoveSelectionRange(infoPtr, sel->lower, sel->upper);
1747 }
1748 while (infoPtr->hdpaSelectionRanges->nItemCount > 0);
1749
1750 removing_all_selections = FALSE;
1751
1752 return TRUE;
1753 }
1754
1755 /***
1756 * DESCRIPTION:
1757 * Manages the item focus.
1758 *
1759 * PARAMETER(S):
1760 * [I] infoPtr : valid pointer to the listview structure
1761 * [I] INT : item index
1762 *
1763 * RETURN:
1764 * TRUE : focused item changed
1765 * FALSE : focused item has NOT changed
1766 */
1767 static inline BOOL LISTVIEW_SetItemFocus(LISTVIEW_INFO *infoPtr, INT nItem)
1768 {
1769 INT oldFocus = infoPtr->nFocusedItem;
1770 LVITEMW lvItem;
1771
1772 ZeroMemory(&lvItem, sizeof(lvItem));
1773 lvItem.state = LVIS_FOCUSED;
1774 lvItem.stateMask = LVIS_FOCUSED;
1775 LISTVIEW_SetItemState(infoPtr, nItem, &lvItem);
1776
1777 return oldFocus != infoPtr->nFocusedItem;
1778 }
1779
1780 /**
1781 * DESCRIPTION:
1782 * Updates the various indices after an item has been inserted or deleted.
1783 *
1784 * PARAMETER(S):
1785 * [I] infoPtr : valid pointer to the listview structure
1786 * [I] INT : item index
1787 * [I] INT : Direction of shift, +1 or -1.
1788 *
1789 * RETURN:
1790 * None
1791 */
1792 static void LISTVIEW_ShiftIndices(LISTVIEW_INFO *infoPtr, INT nItem, INT direction)
1793 {
1794 LISTVIEW_SELECTION selection,*checkselection;
1795 INT index;
1796
1797 TRACE("Shifting %iu, %i steps\n",nItem,direction);
1798
1799 selection.upper = nItem;
1800 selection.lower = nItem;
1801
1802 index = DPA_Search(infoPtr->hdpaSelectionRanges, &selection, 0,
1803 LISTVIEW_CompareSelectionRanges,
1804 0,DPAS_SORTED|DPAS_INSERTAFTER);
1805
1806 while ((index < infoPtr->hdpaSelectionRanges->nItemCount)&&(index != -1))
1807 {
1808 checkselection = DPA_GetPtr(infoPtr->hdpaSelectionRanges,index);
1809 if ((checkselection->lower >= nItem)&&
1810 ((int)(checkselection->lower + direction) >= 0))
1811 checkselection->lower += direction;
1812 if ((checkselection->upper >= nItem)&&
1813 ((int)(checkselection->upper + direction) >= 0))
1814 checkselection->upper += direction;
1815 index ++;
1816 }
1817
1818 /* Note that the following will fail if direction != +1 and -1 */
1819 if (infoPtr->nSelectionMark > nItem)
1820 infoPtr->nSelectionMark += direction;
1821 else if (infoPtr->nSelectionMark == nItem)
1822 {
1823 if (direction > 0)
1824 infoPtr->nSelectionMark += direction;
1825 else if (infoPtr->nSelectionMark >= GETITEMCOUNT(infoPtr))
1826 infoPtr->nSelectionMark = GETITEMCOUNT(infoPtr) - 1;
1827 }
1828
1829 if (infoPtr->nFocusedItem > nItem)
1830 infoPtr->nFocusedItem += direction;
1831 else if (infoPtr->nFocusedItem == nItem)
1832 {
1833 if (direction > 0)
1834 infoPtr->nFocusedItem += direction;
1835 else
1836 {
1837 if (infoPtr->nFocusedItem >= GETITEMCOUNT(infoPtr))
1838 infoPtr->nFocusedItem = GETITEMCOUNT(infoPtr) - 1;
1839 if (infoPtr->nFocusedItem >= 0)
1840 LISTVIEW_SetItemFocus(infoPtr, infoPtr->nFocusedItem);
1841 }
1842 }
1843 /* But we are not supposed to modify nHotItem! */
1844 }
1845
1846
1847 /**
1848 * DESCRIPTION:
1849 * Adds a block of selections.
1850 *
1851 * PARAMETER(S):
1852 * [I] infoPtr : valid pointer to the listview structure
1853 * [I] INT : item index
1854 *
1855 * RETURN:
1856 * None
1857 */
1858 static void LISTVIEW_AddGroupSelection(LISTVIEW_INFO *infoPtr, INT nItem)
1859 {
1860 INT nFirst = min(infoPtr->nSelectionMark, nItem);
1861 INT nLast = max(infoPtr->nSelectionMark, nItem);
1862 INT i;
1863 LVITEMW item;
1864
1865 if (nFirst == -1)
1866 nFirst = nItem;
1867
1868 ZeroMemory(&item,sizeof(item));
1869 item.stateMask = LVIS_SELECTED;
1870 item.state = LVIS_SELECTED;
1871
1872 /* FIXME: this is not correct LVS_OWNERDATA
1873 * See docu for LVN_ITEMCHANGED. Is there something similar for
1874 * RemoveGroupSelection (is there such a thing?)?
1875 */
1876 for (i = nFirst; i <= nLast; i++)
1877 LISTVIEW_SetItemState(infoPtr,i,&item);
1878
1879 LISTVIEW_SetItemFocus(infoPtr, nItem);
1880 infoPtr->nSelectionMark = nItem;
1881 }
1882
1883
1884 /***
1885 * DESCRIPTION:
1886 * Adds a single selection.
1887 *
1888 * PARAMETER(S):
1889 * [I] infoPtr : valid pointer to the listview structure
1890 * [I] INT : item index
1891 *
1892 * RETURN:
1893 * None
1894 */
1895 static void LISTVIEW_AddSelection(LISTVIEW_INFO *infoPtr, INT nItem)
1896 {
1897 LVITEMW item;
1898
1899 ZeroMemory(&item,sizeof(item));
1900 item.state = LVIS_SELECTED;
1901 item.stateMask = LVIS_SELECTED;
1902
1903 LISTVIEW_SetItemState(infoPtr,nItem,&item);
1904
1905 LISTVIEW_SetItemFocus(infoPtr, nItem);
1906 infoPtr->nSelectionMark = nItem;
1907 }
1908
1909 /***
1910 * DESCRIPTION:
1911 * Selects items based on view coordinates.
1912 *
1913 * PARAMETER(S):
1914 * [I] infoPtr : valid pointer to the listview structure
1915 * [I] rcSelRect : selection rectangle
1916 *
1917 * RETURN:
1918 * None
1919 */
1920 static void LISTVIEW_SetSelectionRect(LISTVIEW_INFO *infoPtr, RECT rcSelRect)
1921 {
1922 POINT ptItem;
1923 INT i;
1924 LVITEMW item;
1925
1926 ZeroMemory(&item,sizeof(item));
1927 item.stateMask = LVIS_SELECTED;
1928
1929 /* FIXME: shouldn't we iterate over visible items only? */
1930 for (i = 0; i < GETITEMCOUNT(infoPtr); i++)
1931 {
1932 LISTVIEW_GetItemPosition(infoPtr, i, &ptItem);
1933
1934 item.state = PtInRect(&rcSelRect, ptItem) ? LVIS_SELECTED : 0;
1935 LISTVIEW_SetItemState(infoPtr,i,&item);
1936 }
1937 }
1938
1939 /***
1940 * DESCRIPTION:
1941 * Sets a single group selection.
1942 *
1943 * PARAMETER(S):
1944 * [I] infoPtr : valid pointer to the listview structure
1945 * [I] INT : item index
1946 *
1947 * RETURN:
1948 * None
1949 */
1950 static void LISTVIEW_SetGroupSelection(LISTVIEW_INFO *infoPtr, INT nItem)
1951 {
1952 UINT uView = LISTVIEW_GetType(infoPtr);
1953 LVITEMW item;
1954
1955 ZeroMemory(&item,sizeof(item));
1956 item.stateMask = LVIS_SELECTED;
1957
1958 if ((uView == LVS_LIST) || (uView == LVS_REPORT))
1959 {
1960 INT i;
1961 INT nFirst, nLast;
1962
1963 if (infoPtr->nSelectionMark == -1)
1964 {
1965 infoPtr->nSelectionMark = nFirst = nLast = nItem;
1966 }
1967 else
1968 {
1969 nFirst = min(infoPtr->nSelectionMark, nItem);
1970 nLast = max(infoPtr->nSelectionMark, nItem);
1971 }
1972
1973 for (i = 0; i <= GETITEMCOUNT(infoPtr); i++)
1974 {
1975 if ((i < nFirst) || (i > nLast))
1976 item.state = 0;
1977 else
1978 item.state = LVIS_SELECTED;
1979 LISTVIEW_SetItemState(infoPtr,i,&item);
1980 }
1981 }
1982 else
1983 {
1984 RECT rcItem;
1985 RECT rcSelMark;
1986 RECT rcSel;
1987 LISTVIEW_GetItemBoundBox(infoPtr, nItem, &rcItem);
1988 LISTVIEW_GetItemBoundBox(infoPtr, infoPtr->nSelectionMark, &rcSelMark);
1989 rcSel.left = min(rcSelMark.left, rcItem.left);
1990 rcSel.top = min(rcSelMark.top, rcItem.top);
1991 rcSel.right = max(rcSelMark.right, rcItem.right);
1992 rcSel.bottom = max(rcSelMark.bottom, rcItem.bottom);
1993 LISTVIEW_SetSelectionRect(infoPtr, rcSel);
1994 TRACE("item %d (%d,%d)-(%d,%d), mark %d (%d,%d)-(%d,%d), sel (%d,%d)-(%d,%d)\n",
1995 nItem, rcItem.left, rcItem.top, rcItem.right, rcItem.bottom,
1996 infoPtr->nSelectionMark,
1997 rcSelMark.left, rcSelMark.top, rcSelMark.right, rcSelMark.bottom,
1998 rcSel.left, rcSel.top, rcSel.right, rcSel.bottom);
1999
2000 }
2001
2002 LISTVIEW_SetItemFocus(infoPtr, nItem);
2003 }
2004
2005 /***
2006 * DESCRIPTION:
2007 * Sets a single selection.
2008 *
2009 * PARAMETER(S):
2010 * [I] infoPtr : valid pointer to the listview structure
2011 * [I] INT : item index
2012 *
2013 * RETURN:
2014 * None
2015 */
2016 static void LISTVIEW_SetSelection(LISTVIEW_INFO *infoPtr, INT nItem)
2017 {
2018 LVITEMW lvItem;
2019
2020 LISTVIEW_RemoveAllSelections(infoPtr);
2021
2022 ZeroMemory(&lvItem, sizeof(lvItem));
2023 lvItem.state = LVIS_FOCUSED | LVIS_SELECTED;
2024 lvItem.stateMask = LVIS_FOCUSED | LVIS_SELECTED;
2025 LISTVIEW_SetItemState(infoPtr, nItem, &lvItem);
2026
2027 infoPtr->nSelectionMark = nItem;
2028 }
2029
2030 /***
2031 * DESCRIPTION:
2032 * Set selection(s) with keyboard.
2033 *
2034 * PARAMETER(S):
2035 * [I] infoPtr : valid pointer to the listview structure
2036 * [I] INT : item index
2037 *
2038 * RETURN:
2039 * SUCCESS : TRUE (needs to be repainted)
2040 * FAILURE : FALSE (nothing has changed)
2041 */
2042 static BOOL LISTVIEW_KeySelection(LISTVIEW_INFO *infoPtr, INT nItem)
2043 {
2044 /* FIXME: pass in the state */
2045 LONG lStyle = GetWindowLongW(infoPtr->hwndSelf, GWL_STYLE);
2046 WORD wShift = HIWORD(GetKeyState(VK_SHIFT));
2047 WORD wCtrl = HIWORD(GetKeyState(VK_CONTROL));
2048 BOOL bResult = FALSE;
2049
2050 if ((nItem >= 0) && (nItem < GETITEMCOUNT(infoPtr)))
2051 {
2052 if (lStyle & LVS_SINGLESEL)
2053 {
2054 bResult = TRUE;
2055 LISTVIEW_SetSelection(infoPtr, nItem);
2056 ListView_EnsureVisible(infoPtr->hwndSelf, nItem, FALSE);
2057 }
2058 else
2059 {
2060 if (wShift)
2061 {
2062 bResult = TRUE;
2063 LISTVIEW_SetGroupSelection(infoPtr, nItem);
2064 }
2065 else if (wCtrl)
2066 {
2067 bResult = LISTVIEW_SetItemFocus(infoPtr, nItem);
2068 }
2069 else
2070 {
2071 bResult = TRUE;
2072 LISTVIEW_SetSelection(infoPtr, nItem);
2073 ListView_EnsureVisible(infoPtr->hwndSelf, nItem, FALSE);
2074 }
2075 }
2076 }
2077
2078 UpdateWindow(infoPtr->hwndSelf); /* update client area */
2079 return bResult;
2080 }
2081
2082 /***
2083 * DESCRIPTION:
2084 * Selects an item based on coordinates.
2085 *
2086 * PARAMETER(S):
2087 * [I] infoPtr : valid pointer to the listview structure
2088 * [I] pt : mouse click ccordinates
2089 *
2090 * RETURN:
2091 * SUCCESS : item index
2092 * FAILURE : -1
2093 */
2094 static INT LISTVIEW_GetItemAtPt(LISTVIEW_INFO *infoPtr, POINT pt)
2095 {
2096 INT i, nTop, nBottom;
2097 RECT rcItem;
2098
2099 nTop = LISTVIEW_GetTopIndex(infoPtr);
2100 nBottom = nTop + LISTVIEW_GetVisibleCount(infoPtr);
2101 if (nBottom > GETITEMCOUNT(infoPtr)) nBottom = GETITEMCOUNT(infoPtr);
2102
2103 for (i = nTop; i <= nBottom; i++)
2104 {
2105 rcItem.left = LVIR_SELECTBOUNDS;
2106 if (LISTVIEW_GetItemRect(infoPtr, i, &rcItem))
2107 if (PtInRect(&rcItem, pt)) return i;
2108 }
2109 return -1;
2110 }
2111
2112 /***
2113 * DESCRIPTION:
2114 * Called when the mouse is being actively tracked and has hovered for a specified
2115 * amount of time
2116 *
2117 * PARAMETER(S):
2118 * [I] infoPtr : valid pointer to the listview structure
2119 * [I] fwKeys : key indicator
2120 * [I] pts : mouse position
2121 *
2122 * RETURN:
2123 * 0 if the message was processed, non-zero if there was an error
2124 *
2125 * INFO:
2126 * LVS_EX_TRACKSELECT: An item is automatically selected when the cursor remains
2127 * over the item for a certain period of time.
2128 *
2129 */
2130 static LRESULT LISTVIEW_MouseHover(LISTVIEW_INFO *infoPtr, WORD fwKyes, POINTS pts)
2131 {
2132 POINT pt = { pts.x, pts.y };
2133
2134 if(infoPtr->dwExStyle & LVS_EX_TRACKSELECT)
2135 /* FIXME: select the item!!! */
2136 LISTVIEW_GetItemAtPt(infoPtr, pt);
2137
2138 return 0;
2139 }
2140
2141 /***
2142 * DESCRIPTION:
2143 * Called whenever WM_MOUSEMOVE is received.
2144 *
2145 * PARAMETER(S):
2146 * [I] infoPtr : valid pointer to the listview structure
2147 * [I] fwKeys : key indicator
2148 * [I] pts : mouse position
2149 *
2150 * RETURN:
2151 * 0 if the message is processed, non-zero if there was an error
2152 */
2153 static LRESULT LISTVIEW_MouseMove(LISTVIEW_INFO *infoPtr, WORD fwKeys, POINTS pts)
2154 {
2155 TRACKMOUSEEVENT trackinfo;
2156
2157 /* see if we are supposed to be tracking mouse hovering */
2158 if(infoPtr->dwExStyle & LVS_EX_TRACKSELECT) {
2159 /* fill in the trackinfo struct */
2160 trackinfo.cbSize = sizeof(TRACKMOUSEEVENT);
2161 trackinfo.dwFlags = TME_QUERY;
2162 trackinfo.hwndTrack = infoPtr->hwndSelf;
2163 trackinfo.dwHoverTime = infoPtr->dwHoverTime;
2164
2165 /* see if we are already tracking this hwnd */
2166 _TrackMouseEvent(&trackinfo);
2167
2168 if(!(trackinfo.dwFlags & TME_HOVER)) {
2169 trackinfo.dwFlags = TME_HOVER;
2170
2171 /* call TRACKMOUSEEVENT so we receive WM_MOUSEHOVER messages */
2172 _TrackMouseEvent(&trackinfo);
2173 }
2174 }
2175
2176 return 0;
2177 }
2178
2179 /***
2180 * DESCRIPTION:
2181 * Removes a column.
2182 *
2183 * PARAMETER(S):
2184 * [IO] HDPA : dynamic pointer array handle
2185 * [I] INT : column index (subitem index)
2186 *
2187 * RETURN:
2188 * SUCCCESS : TRUE
2189 * FAILURE : FALSE
2190 */
2191 static BOOL LISTVIEW_RemoveColumn(HDPA hdpaItems, INT nSubItem)
2192 {
2193 BOOL bResult = TRUE;
2194 HDPA hdpaSubItems;
2195 INT i;
2196
2197 for (i = 0; i < hdpaItems->nItemCount; i++)
2198 {
2199 hdpaSubItems = (HDPA)DPA_GetPtr(hdpaItems, i);
2200 if (hdpaSubItems != NULL)
2201 {
2202 if (!LISTVIEW_RemoveSubItem(hdpaSubItems, nSubItem))
2203 {
2204 bResult = FALSE;
2205 }
2206 }
2207 }
2208
2209 return bResult;
2210 }
2211
2212 /***
2213 * DESCRIPTION:
2214 * Removes a subitem at a given position.
2215 *
2216 * PARAMETER(S):
2217 * [IO] HDPA : dynamic pointer array handle
2218 * [I] INT : subitem index
2219 *
2220 * RETURN:
2221 * SUCCCESS : TRUE
2222 * FAILURE : FALSE
2223 */
2224 static BOOL LISTVIEW_RemoveSubItem(HDPA hdpaSubItems, INT nSubItem)
2225 {
2226 LISTVIEW_SUBITEM *lpSubItem;
2227 INT i;
2228
2229 for (i = 1; i < hdpaSubItems->nItemCount; i++)
2230 {
2231 lpSubItem = (LISTVIEW_SUBITEM *)DPA_GetPtr(hdpaSubItems, i);
2232 if (lpSubItem != NULL)
2233 {
2234 if (lpSubItem->iSubItem == nSubItem)
2235 {
2236 /* free string */
2237 if (is_textW(lpSubItem->hdr.pszText))
2238 COMCTL32_Free(lpSubItem->hdr.pszText);
2239
2240 /* free item */
2241 COMCTL32_Free(lpSubItem);
2242
2243 /* free dpa memory */
2244 if (DPA_DeletePtr(hdpaSubItems, i) == NULL)
2245 return FALSE;
2246 }
2247 else if (lpSubItem->iSubItem > nSubItem)
2248 return TRUE;
2249 }
2250 }
2251
2252 return TRUE;
2253 }
2254
2255
2256 /***
2257 * Tests wheather the item is assignable to a list with style lStyle
2258 */
2259 static inline BOOL is_assignable_item(LPLVITEMW lpLVItem, LONG lStyle)
2260 {
2261 if ( (lpLVItem->mask & LVIF_TEXT) &&
2262 (lpLVItem->pszText == LPSTR_TEXTCALLBACKW) &&
2263 (lStyle & (LVS_SORTASCENDING | LVS_SORTDESCENDING)) ) return FALSE;
2264
2265 return TRUE;
2266 }
2267
2268 /***
2269 * DESCRIPTION:
2270 * Helper for LISTVIEW_SetItemT *only*: sets item attributes.
2271 *
2272 * PARAMETER(S):
2273 * [I] infoPtr : valid pointer to the listview structure
2274 * [I] lpLVItem : valid pointer to new item atttributes
2275 * [I] isW : TRUE if lpLVItem is Unicode, FALSE if it's ANSI
2276 *
2277 * RETURN:
2278 * SUCCESS : TRUE
2279 * FAILURE : FALSE
2280 */
2281 static BOOL set_main_item(LISTVIEW_INFO *infoPtr, LPLVITEMW lpLVItem, BOOL isW)
2282 {
2283 LONG lStyle = GetWindowLongW(infoPtr->hwndSelf, GWL_STYLE);
2284 UINT uView = lStyle & LVS_TYPEMASK;
2285 HDPA hdpaSubItems;
2286 LISTVIEW_ITEM *lpItem;
2287 NMLISTVIEW nmlv;
2288 UINT uChanged = 0;
2289
2290 TRACE("(lpLVItem=%s, isW=%d)\n", debuglvitem_t(lpLVItem, isW), isW);
2291
2292
2293 if (lStyle & LVS_OWNERDATA)
2294 {
2295 INT oldState;
2296
2297 /* a virtual livst view stores only state for the mai item */
2298 if (lpLVItem->iSubItem || !(lpLVItem->mask & LVIF_STATE)) return FALSE;
2299
2300 oldState = LISTVIEW_GetItemState(infoPtr, lpLVItem->iItem, LVIS_FOCUSED | LVIS_SELECTED);
2301
2302 /* we're done if we don't need to change anything we handle */
2303 if ( (oldState ^ lpLVItem->state) & lpLVItem->stateMask &
2304 ~infoPtr->uCallbackMask & (LVIS_FOCUSED | LVIS_SELECTED)) return FALSE;
2305
2306 /*
2307 * As per MSDN LVN_ITEMCHANGING notifications are _NOT_ sent for
2308 * by LVS_OWERNDATA list controls
2309 */
2310
2311 /* if we handle the focus, and we're asked to change it, do it now */
2312 if ( lpLVItem->stateMask & LVIS_FOCUSED )
2313 {
2314 if (lpLVItem->state & LVIS_FOCUSED)
2315 infoPtr->nFocusedItem = lpLVItem->iItem;
2316 else if (infoPtr->nFocusedItem == lpLVItem->iItem)
2317 infoPtr->nFocusedItem = -1;
2318 }
2319
2320 /* and the selection is the only other state a virtual list may hold */
2321 if (lpLVItem->stateMask & LVIS_SELECTED)
2322 {
2323 if (lpLVItem->state & LVIS_SELECTED)
2324 {
2325 if (lStyle & LVS_SINGLESEL) LISTVIEW_RemoveAllSelections(infoPtr);
2326 add_selection_range(infoPtr, lpLVItem->iItem, lpLVItem->iItem, TRUE);
2327 }
2328 else
2329 remove_selection_range(infoPtr, lpLVItem->iItem, lpLVItem->iItem, TRUE);
2330 }
2331
2332 /* notify the parent now that things have changed */
2333 ZeroMemory(&nmlv, sizeof(nmlv));
2334 nmlv.iItem = lpLVItem->iItem;
2335 nmlv.uNewState = lpLVItem->state;
2336 nmlv.uOldState = oldState;
2337 nmlv.uChanged = LVIF_STATE;
2338 listview_notify(infoPtr, LVN_ITEMCHANGED, &nmlv);
2339
2340 return TRUE;
2341 }
2342
2343 /* sanity checks first */
2344 if (!is_assignable_item(lpLVItem, lStyle)) return FALSE;
2345
2346 hdpaSubItems = (HDPA)DPA_GetPtr(infoPtr->hdpaItems, lpLVItem->iItem);
2347 if (!hdpaSubItems && hdpaSubItems != (HDPA)-1) return FALSE;
2348
2349 lpItem = (LISTVIEW_ITEM *)DPA_GetPtr(hdpaSubItems, lpLVItem->iSubItem);
2350 if (!lpItem) return FALSE;
2351
2352 /* determine what fields will change */
2353 if ((lpLVItem->mask & LVIF_STATE) &&
2354 ((lpItem->state ^ lpLVItem->state) & lpLVItem->stateMask))
2355 uChanged |= LVIF_STATE;
2356
2357 if ((lpLVItem->mask & LVIF_IMAGE) && (lpItem->hdr.iImage != lpLVItem->iImage))
2358 uChanged |= LVIF_IMAGE;
2359
2360 if ((lpLVItem->mask & LVIF_PARAM) && (lpItem->lParam != lpLVItem->lParam))
2361 uChanged |= LVIF_PARAM;
2362
2363 if ((lpLVItem->mask & LVIF_INDENT) && (lpItem->iIndent != lpLVItem->iIndent))
2364 uChanged |= LVIF_INDENT;
2365
2366 if ((lpLVItem->mask & LVIF_TEXT) && textcmpWT(lpItem->hdr.pszText, lpLVItem->pszText, isW))
2367 uChanged |= LVIF_TEXT;
2368
2369 if (!uChanged) return TRUE;
2370
2371 ZeroMemory(&nmlv, sizeof(NMLISTVIEW));
2372 nmlv.iItem = lpLVItem->iItem;
2373 nmlv.uNewState = lpLVItem->state & lpLVItem->stateMask;
2374 nmlv.uOldState = lpItem->state & lpLVItem->stateMask;
2375 nmlv.uChanged = uChanged;
2376 nmlv.lParam = lpItem->lParam;
2377
2378 /* send LVN_ITEMCHANGING notification, if the item is not being inserted */
2379 if(lpItem->valid && listview_notify(infoPtr, LVN_ITEMCHANGING, &nmlv))
2380 return FALSE;
2381
2382 /* copy information */
2383 if (lpLVItem->mask & LVIF_TEXT)
2384 textsetptrT(&lpItem->hdr.pszText, lpLVItem->pszText, isW);
2385
2386 if (lpLVItem->mask & LVIF_IMAGE)
2387 lpItem->hdr.iImage = lpLVItem->iImage;
2388
2389 if (lpLVItem->mask & LVIF_PARAM)
2390 lpItem->lParam = lpLVItem->lParam;
2391
2392 if (lpLVItem->mask & LVIF_INDENT)
2393 lpItem->iIndent = lpLVItem->iIndent;
2394
2395 if (uChanged & LVIF_STATE)
2396 {
2397 lpItem->state &= ~lpLVItem->stateMask;
2398 lpItem->state |= (lpLVItem->state & lpLVItem->stateMask);
2399 if (nmlv.uNewState & LVIS_SELECTED)
2400 {
2401 if (lStyle & LVS_SINGLESEL) LISTVIEW_RemoveAllSelections(infoPtr);
2402 add_selection_range(infoPtr, lpLVItem->iItem, lpLVItem->iItem, TRUE);
2403 }
2404 else if (lpLVItem->stateMask & LVIS_SELECTED)
2405 remove_selection_range(infoPtr, lpLVItem->iItem, lpLVItem->iItem, TRUE);
2406
2407 /* if we are asked to change focus, and we manage it, do it */
2408 if (nmlv.uNewState & ~infoPtr->uCallbackMask & LVIS_FOCUSED)
2409 {
2410 if (lpLVItem->state & LVIS_FOCUSED)
2411 {
2412 infoPtr->nFocusedItem = lpLVItem->iItem;
2413 LISTVIEW_EnsureVisible(infoPtr, lpLVItem->iItem, FALSE);
2414 }
2415 else if (infoPtr->nFocusedItem == lpLVItem->iItem)
2416 infoPtr->nFocusedItem = -1;
2417 }
2418 }
2419
2420 /* if LVS_LIST or LVS_SMALLICON, update the width of the items */
2421 if((uChanged & LVIF_TEXT) && ((uView == LVS_LIST) || (uView == LVS_SMALLICON)))
2422 {
2423 int item_width = LISTVIEW_CalculateWidth(infoPtr, lpLVItem->iItem);
2424 if(item_width > infoPtr->nItemWidth) infoPtr->nItemWidth = item_width;
2425 }
2426
2427 /* if we're inserting the item, we're done */
2428 if (!lpItem->valid) return TRUE;
2429
2430 /* send LVN_ITEMCHANGED notification */
2431 nmlv.lParam = lpItem->lParam;
2432 listview_notify(infoPtr, LVN_ITEMCHANGED, &nmlv);
2433
2434 return TRUE;
2435 }
2436
2437 /***
2438 * DESCRIPTION:
2439 * Helper for LISTVIEW_SetItemT *only*: sets subitem attributes.
2440 *
2441 * PARAMETER(S):
2442 * [I] infoPtr : valid pointer to the listview structure
2443 * [I] lpLVItem : valid pointer to new subitem atttributes
2444 * [I] isW : TRUE if lpLVItem is Unicode, FALSE if it's ANSI
2445 *
2446 * RETURN:
2447 * SUCCESS : TRUE
2448 * FAILURE : FALSE
2449 */
2450 static BOOL set_sub_item(LISTVIEW_INFO *infoPtr, LPLVITEMW lpLVItem, BOOL isW)
2451 {
2452 LONG lStyle = GetWindowLongW(infoPtr->hwndSelf, GWL_STYLE);
2453 HDPA hdpaSubItems;
2454 LISTVIEW_SUBITEM *lpSubItem;
2455
2456 TRACE("(lpLVItem=%s, isW=%d)\n", debuglvitem_t(lpLVItem, isW), isW);
2457
2458 if (lStyle & LVS_OWNERDATA) return FALSE;
2459
2460 /* set subitem only if column is present */
2461 if (Header_GetItemCount(infoPtr->hwndHeader) <= lpLVItem->iSubItem)
2462 return FALSE;
2463
2464 /* First do some sanity checks */
2465 if (lpLVItem->mask & ~(LVIF_TEXT | LVIF_IMAGE)) return FALSE;
2466
2467 if (!is_assignable_item(lpLVItem, lStyle)) return FALSE;
2468
2469 /* get the subitem structure, and create it if not there */
2470 hdpaSubItems = (HDPA)DPA_GetPtr(infoPtr->hdpaItems, lpLVItem->iItem);
2471 if (!hdpaSubItems) return FALSE;
2472
2473 lpSubItem = LISTVIEW_GetSubItemPtr(hdpaSubItems, lpLVItem->iSubItem);
2474 if (!lpSubItem)
2475 {
2476 LISTVIEW_SUBITEM *tmpSubItem;
2477 INT i;
2478
2479 lpSubItem = (LISTVIEW_SUBITEM *)COMCTL32_Alloc(sizeof(LISTVIEW_SUBITEM));
2480 if (!lpSubItem) return FALSE;
2481 ZeroMemory(lpSubItem, sizeof(LISTVIEW_SUBITEM));
2482
2483 /* we could binary search here, if need be...*/
2484 for (i = 1; i < hdpaSubItems->nItemCount; i++)
2485 {
2486 tmpSubItem = (LISTVIEW_SUBITEM *)DPA_GetPtr(hdpaSubItems, i);
2487 if (tmpSubItem && tmpSubItem->iSubItem > lpLVItem->iSubItem) break;
2488 }
2489 if (DPA_InsertPtr(hdpaSubItems, i, lpSubItem) == -1)
2490 {
2491 COMCTL32_Free(lpSubItem);
2492 return FALSE;
2493 }
2494 }
2495
2496 lpSubItem->iSubItem = lpLVItem->iSubItem;
2497
2498 if (lpLVItem->mask & LVIF_IMAGE)
2499 lpSubItem->hdr.iImage = lpLVItem->iImage;
2500
2501 if (lpLVItem->mask & LVIF_TEXT)
2502 textsetptrT(&lpSubItem->hdr.pszText, lpLVItem->pszText, isW);
2503
2504 return TRUE;
2505 }
2506
2507 /***
2508 * DESCRIPTION:
2509 * Sets item attributes.
2510 *
2511 * PARAMETER(S):
2512 * [I] infoPtr : valid pointer to the listview structure
2513 * [I] LPLVITEM : new item atttributes
2514 * [I] isW : TRUE if lpLVItem is Unicode, FALSE if it's ANSI
2515 *
2516 * RETURN:
2517 * SUCCESS : TRUE
2518 * FAILURE : FALSE
2519 */
2520 static BOOL LISTVIEW_SetItemT(LISTVIEW_INFO *infoPtr, LPLVITEMW lpLVItem, BOOL isW)
2521 {
2522 INT oldFocus = infoPtr->nFocusedItem;
2523 LPWSTR pszText = NULL;
2524 RECT rcItem;
2525 BOOL bResult;
2526
2527 if (!lpLVItem || lpLVItem->iItem < 0 ||
2528 lpLVItem->iItem>=GETITEMCOUNT(infoPtr))
2529 return FALSE;
2530
2531 /* For efficiency, we transform the lpLVItem->pszText to Unicode here */
2532 if ((lpLVItem->mask & LVIF_TEXT) && lpLVItem->pszText)
2533 {
2534 pszText = lpLVItem->pszText;
2535 lpLVItem->pszText = textdupTtoW(lpLVItem->pszText, isW);
2536 }
2537 /* actually set the fields */
2538 if (lpLVItem->iSubItem)
2539 bResult = set_sub_item(infoPtr, lpLVItem, TRUE);
2540 else
2541 bResult = set_main_item(infoPtr, lpLVItem, TRUE);
2542 /* redraw item, if necessary */
2543 if (bResult && !infoPtr->bIsDrawing)
2544 {
2545 if (oldFocus != infoPtr->nFocusedItem && infoPtr->bFocus)
2546 LISTVIEW_ToggleFocusRect(infoPtr);
2547 rcItem.left = LVIR_BOUNDS;
2548 LISTVIEW_GetItemRect(infoPtr, lpLVItem->iItem, &rcItem);
2549 InvalidateRect(infoPtr->hwndSelf, &rcItem, TRUE);
2550 }
2551 /* restore text */
2552 if (pszText)
2553 {
2554 textfreeT(lpLVItem->pszText, isW);
2555 lpLVItem->pszText = pszText;
2556 }
2557
2558 return bResult;
2559 }
2560
2561 /***
2562 * DESCRIPTION:
2563 * Retrieves the index of the item at coordinate (0, 0) of the client area.
2564 *
2565 * PARAMETER(S):
2566 * [I] infoPtr : valid pointer to the listview structure
2567 *
2568 * RETURN:
2569 * item index
2570 */
2571 static INT LISTVIEW_GetTopIndex(LISTVIEW_INFO *infoPtr)
2572 {
2573 LONG lStyle = GetWindowLongW(infoPtr->hwndSelf, GWL_STYLE);
2574 UINT uView = lStyle & LVS_TYPEMASK;
2575 INT nItem = 0;
2576 SCROLLINFO scrollInfo;
2577
2578 ZeroMemory(&scrollInfo, sizeof(SCROLLINFO));
2579 scrollInfo.cbSize = sizeof(SCROLLINFO);
2580 scrollInfo.fMask = SIF_POS;
2581
2582 if (uView == LVS_LIST)
2583 {
2584 if ((lStyle & WS_HSCROLL) && GetScrollInfo(infoPtr->hwndSelf, SB_HORZ, &scrollInfo))
2585 nItem = scrollInfo.nPos * LISTVIEW_GetCountPerColumn(infoPtr);
2586 }
2587 else if (uView == LVS_REPORT)
2588 {
2589 if ((lStyle & WS_VSCROLL) && GetScrollInfo(infoPtr->hwndSelf, SB_VERT, &scrollInfo))
2590 nItem = scrollInfo.nPos;
2591 }
2592
2593 return nItem;
2594 }
2595
2596
2597 /***
2598 * DESCRIPTION:
2599 * Draws a subitem.
2600 *
2601 * PARAMETER(S):
2602 * [I] infoPtr : valid pointer to the listview structure
2603 * [I] HDC : device context handle
2604 * [I] INT : item index
2605 * [I] INT : subitem index
2606 * [I] RECT * : clipping rectangle
2607 *
2608 * RETURN:
2609 * None
2610 */
2611 static void LISTVIEW_DrawSubItem(LISTVIEW_INFO *infoPtr, HDC hdc, INT nItem, INT nSubItem,
2612 RECT rcItem, BOOL Selected)
2613 {
2614 WCHAR szDispText[DISP_TEXT_SIZE];
2615 LVITEMW lvItem;
2616 LVCOLUMNW lvColumn;
2617 UINT textoutOptions = ETO_CLIPPED | ETO_OPAQUE;
2618 RECT rcTemp;
2619 INT textLeft;
2620 INT nLabelWidth = 0;
2621
2622 TRACE("(hdc=%x, nItem=%d, nSubItem=%d)\n", hdc,
2623 nItem, nSubItem);
2624
2625 /* get information needed for drawing the item */
2626 ZeroMemory(&lvItem, sizeof(lvItem));
2627 lvItem.mask = LVIF_TEXT;
2628 lvItem.iItem = nItem;
2629 lvItem.iSubItem = nSubItem;
2630 lvItem.cchTextMax = DISP_TEXT_SIZE;
2631 lvItem.pszText = szDispText;
2632 *lvItem.pszText = '\0';
2633 LISTVIEW_GetItemW(infoPtr, &lvItem, TRUE);
2634 TRACE(" lvItem=%s\n", debuglvitem_t(&lvItem, TRUE));
2635
2636 ZeroMemory(&lvColumn, sizeof(lvColumn));
2637 lvColumn.mask = LVCF_FMT;
2638 LISTVIEW_GetColumnT(infoPtr, nSubItem, &lvColumn, TRUE);
2639 textLeft = rcItem.left;
2640 TRACE("lvColumn.fmt=%d\n", lvColumn.fmt);
2641 if (lvColumn.fmt != LVCFMT_LEFT)
2642 {
2643 if ((nLabelWidth = LISTVIEW_GetStringWidthT(infoPtr, lvItem.pszText, TRUE)))
2644 {
2645 if (lvColumn.fmt == LVCFMT_RIGHT)
2646 textLeft = rcItem.right - nLabelWidth;
2647 else
2648 textLeft = rcItem.left + (rcItem.right-rcItem.left-nLabelWidth)/2;
2649 }
2650 }
2651
2652
2653 /* redraw the background of the item */
2654 rcTemp = rcItem;
2655 if(infoPtr->nColumnCount == (nSubItem + 1))
2656 rcTemp.right = infoPtr->rcList.right;
2657 else
2658 rcTemp.right += WIDTH_PADDING;
2659
2660 if (infoPtr->clrBk != CLR_NONE) FillRect(hdc, &rcTemp, infoPtr->hBkBrush);
2661
2662 /* set item colors */
2663 if (ListView_GetItemState(infoPtr->hwndSelf,nItem,LVIS_SELECTED) && Selected)
2664 {
2665 if (infoPtr->bFocus)
2666 {
2667 SetBkColor(hdc, comctl32_color.clrHighlight);
2668 SetTextColor(hdc, comctl32_color.clrHighlightText);
2669 }
2670 else
2671 {
2672 SetBkColor(hdc, comctl32_color.clr3dFace);
2673 SetTextColor(hdc, comctl32_color.clrBtnText);
2674 }
2675 }
2676 else
2677 {
2678 if ( (infoPtr->clrTextBk == CLR_DEFAULT) || (infoPtr->clrTextBk == CLR_NONE) )
2679 {
2680 SetBkMode(hdc, TRANSPARENT);
2681 textoutOptions &= ~ETO_OPAQUE;
2682 }
2683 else
2684 {
2685 SetBkMode(hdc, OPAQUE);
2686 SetBkColor(hdc, infoPtr->clrTextBk);
2687 }
2688
2689 SetTextColor(hdc, infoPtr->clrText);
2690 }
2691
2692 TRACE("drawing text %s, l=%d, t=%d, rect=(%d,%d)-(%d,%d)\n",
2693 debugstr_w(lvItem.pszText), textLeft, rcItem.top,
2694 rcItem.left, rcItem.top, rcItem.right, rcItem.bottom);
2695 ExtTextOutW(hdc, textLeft, rcItem.top, textoutOptions,
2696 &rcItem, lvItem.pszText, lstrlenW(lvItem.pszText), NULL);
2697
2698 if (Selected)
2699 {
2700 /* fill in the gap */
2701 RECT rec;
2702 if (nSubItem < Header_GetItemCount(infoPtr->hwndHeader)-1)
2703 {
2704 CopyRect(&rec,&rcItem);
2705 rec.left = rec.right;
2706 rec.right = rec.left+REPORT_MARGINX;
2707 ExtTextOutW(hdc, rec.left , rec.top, textoutOptions,
2708 &rec, NULL, 0, NULL);
2709 }
2710 CopyRect(&rec,&rcItem);
2711 rec.right = rec.left;
2712 rec.left = rec.left - REPORT_MARGINX;
2713 ExtTextOutW(hdc, rec.left , rec.top, textoutOptions,
2714 &rec, NULL, 0, NULL);
2715 }
2716 }
2717
2718
2719 /***
2720 * DESCRIPTION:
2721 * Draws an item.
2722 *
2723 * PARAMETER(S):
2724 * [I] infoPtr : valid pointer to the listview structure
2725 * [I] hdc : device context handle
2726 * [I] nItem : item index
2727 * [I] rcItem : item rectangle
2728 * [I] bFullSelect : TRUE if all item is selected
2729 * [O] lprcFocus : pointer to rectangle to receive focus rect
2730 *
2731 * RETURN:
2732 * None
2733 */
2734 static void LISTVIEW_DrawItem(LISTVIEW_INFO *infoPtr, HDC hdc, INT nItem, RECT rcItem, BOOL bFullSelect, RECT* lprcFocus)
2735 {
2736 WCHAR szDispText[DISP_TEXT_SIZE];
2737 INT nLabelWidth;
2738 LVITEMW lvItem;
2739 INT nMixMode;
2740 DWORD dwBkColor;
2741 DWORD dwTextColor,dwTextX;
2742 BOOL bImage = FALSE;
2743 INT iBkMode = -1;
2744 UINT textoutOptions = ETO_OPAQUE | ETO_CLIPPED;
2745 RECT rcTemp;
2746
2747 TRACE("(hdc=%x, nItem=%d)\n", hdc, nItem);
2748
2749 /* get information needed for drawing the item */
2750 ZeroMemory(&lvItem, sizeof(lvItem));
2751 lvItem.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_STATE | LVIF_INDENT;
2752 lvItem.stateMask = LVIS_SELECTED | LVIS_STATEIMAGEMASK;
2753 lvItem.iItem = nItem;
2754 lvItem.iSubItem = 0;
2755 lvItem.cchTextMax = DISP_TEXT_SIZE;
2756 lvItem.pszText = szDispText;
2757 *lvItem.pszText = '\0';
2758 LISTVIEW_GetItemW(infoPtr, &lvItem, TRUE);
2759 TRACE(" lvItem=%s\n", debuglvitem_t(&lvItem, TRUE));
2760
2761 /* redraw the background of the item */
2762 rcTemp = rcItem;
2763 if(infoPtr->nColumnCount == (nItem + 1))
2764 rcTemp.right = infoPtr->rcList.right;
2765 else
2766 rcTemp.right+=WIDTH_PADDING;
2767
2768 if (infoPtr->clrBk != CLR_NONE) FillRect(hdc, &rcTemp, infoPtr->hBkBrush);
2769
2770 /* do indent */
2771 if (lvItem.iIndent>0 && infoPtr->iconSize.cx > 0)
2772 {
2773 rcItem.left += infoPtr->iconSize.cx * lvItem.iIndent;
2774 }
2775
2776 /* state icons */
2777 if (infoPtr->himlState != NULL)
2778 {
2779 UINT uStateImage = (lvItem.state & LVIS_STATEIMAGEMASK) >> 12;
2780 if (uStateImage > 0)
2781 ImageList_Draw(infoPtr->himlState, uStateImage - 1, hdc, rcItem.left,
2782 rcItem.top, ILD_NORMAL);
2783
2784 rcItem.left += infoPtr->iconSize.cx;
2785 bImage = TRUE;
2786 }
2787
2788 /* small icons */
2789 if (infoPtr->himlSmall != NULL)
2790 {
2791 if ((lvItem.state & LVIS_SELECTED) && (infoPtr->bFocus) &&
2792 (lvItem.iImage>=0))
2793 {
2794 ImageList_SetBkColor(infoPtr->himlSmall, CLR_NONE);
2795 ImageList_Draw(infoPtr->himlSmall, lvItem.iImage, hdc, rcItem.left,
2796 rcItem.top, ILD_SELECTED);
2797 }
2798 else if (lvItem.iImage>=0)
2799 {
2800 ImageList_SetBkColor(infoPtr->himlSmall, CLR_NONE);
2801 ImageList_Draw(infoPtr->himlSmall, lvItem.iImage, hdc, rcItem.left,
2802 rcItem.top, ILD_NORMAL);
2803 }
2804
2805 rcItem.left += infoPtr->iconSize.cx;
2806 bImage = TRUE;
2807 }
2808
2809 /* Don't bother painting item being edited */
2810 if (infoPtr->bEditing && lprcFocus && !bFullSelect)
2811 {
2812 SetRectEmpty(lprcFocus);
2813 return;
2814 }
2815
2816 if ((lvItem.state & LVIS_SELECTED) && (infoPtr->bFocus))
2817 {
2818 /* set item colors */
2819 dwBkColor = SetBkColor(hdc, comctl32_color.clrHighlight);
2820 dwTextColor = SetTextColor(hdc, comctl32_color.clrHighlightText);
2821 /* set raster mode */
2822 nMixMode = SetROP2(hdc, R2_XORPEN);
2823 }
2824 else if ((GetWindowLongW(infoPtr->hwndSelf, GWL_STYLE) & LVS_SHOWSELALWAYS) &&
2825 (lvItem.state & LVIS_SELECTED) && (!infoPtr->bFocus))
2826 {
2827 dwBkColor = SetBkColor(hdc, comctl32_color.clr3dFace);
2828 dwTextColor = SetTextColor(hdc, comctl32_color.clrBtnText);
2829 /* set raster mode */
2830 nMixMode = SetROP2(hdc, R2_COPYPEN);
2831 }
2832 else
2833 {
2834 /* set item colors */
2835 if ( (infoPtr->clrTextBk == CLR_DEFAULT) || (infoPtr->clrTextBk == CLR_NONE) )
2836 {
2837 dwBkColor = GetBkColor(hdc);
2838 iBkMode = SetBkMode(hdc, TRANSPARENT);
2839 textoutOptions &= ~ETO_OPAQUE;
2840 }
2841 else
2842 {
2843 dwBkColor = SetBkColor(hdc, infoPtr->clrTextBk);
2844 iBkMode = SetBkMode(hdc, OPAQUE);
2845 }
2846
2847 dwTextColor = SetTextColor(hdc, infoPtr->clrText);
2848 /* set raster mode */
2849 nMixMode = SetROP2(hdc, R2_COPYPEN);
2850 }
2851
2852 nLabelWidth = LISTVIEW_GetStringWidthT(infoPtr, lvItem.pszText, TRUE);
2853 if (rcItem.left + nLabelWidth < rcItem.right)
2854 {
2855 if (!bFullSelect)
2856 rcItem.right = rcItem.left + nLabelWidth + TRAILING_PADDING;
2857 if (bImage)
2858 rcItem.right += IMAGE_PADDING;
2859 }
2860
2861 /* draw label */
2862 dwTextX = rcItem.left + 1;
2863 if (bImage)
2864 dwTextX += IMAGE_PADDING;
2865
2866 /* compute the focus rectangle */
2867 if(lprcFocus)
2868 {
2869 if (lvItem.pszText)
2870 {
2871 *lprcFocus = rcItem;
2872 lprcFocus->right -= 2;
2873 }
2874 else SetRectEmpty(lprcFocus);
2875 }
2876
2877 if (lvItem.pszText)
2878 {
2879 TRACE("drawing text rect=(%d,%d)-(%d,%d)\n",
2880 rcItem.left, rcItem.top, rcItem.right, rcItem.bottom);
2881 ExtTextOutW(hdc, dwTextX, rcItem.top, textoutOptions,
2882 &rcItem, lvItem.pszText, lstrlenW(lvItem.pszText), NULL);
2883 }
2884
2885 if ((bFullSelect) && (Header_GetItemCount(infoPtr->hwndHeader) > 1))
2886 {
2887 /* fill in the gap */
2888 RECT rec;
2889 CopyRect(&rec,&rcItem);
2890 rec.left = rec.right;
2891 rec.right = rec.left+REPORT_MARGINX;
2892 ExtTextOutW(hdc, rec.left , rec.top, textoutOptions,
2893 &rec, NULL, 0, NULL);
2894 }
2895
2896 if (nMixMode != 0)
2897 {
2898 SetROP2(hdc, R2_COPYPEN);
2899 SetBkColor(hdc, dwBkColor);
2900 SetTextColor(hdc, dwTextColor);
2901 if (iBkMode != -1)
2902 SetBkMode(hdc, iBkMode);
2903 }
2904 }
2905
2906 /***
2907 * DESCRIPTION:
2908 * Draws an item when in large icon display mode.
2909 *
2910 * PARAMETER(S):
2911 * [I] infoPtr : valid pointer to the listview structure
2912 * [I] hdc : device context handle
2913 * [I] nItem : item index
2914 * [I] rcItem : clipping rectangle
2915 * [O] lprcFocus : the text rectangle about which to draw the focus
2916 *
2917 * RETURN:
2918 * None
2919 */
2920 static void LISTVIEW_DrawLargeItem(LISTVIEW_INFO *infoPtr, HDC hdc, INT nItem, RECT rcItem,
2921 RECT *lprcFocus)
2922 {
2923 WCHAR szDispText[DISP_TEXT_SIZE] = { '\0' };
2924 LVITEMW lvItem;
2925 UINT uFormat = LISTVIEW_DTFLAGS;
2926 RECT rcFill;
2927
2928 TRACE("(hdc=%x, nItem=%d, left=%d, top=%d, right=%d, bottom=%d)\n",
2929 hdc, nItem, rcItem.left, rcItem.top, rcItem.right, rcItem.bottom);
2930
2931 /* get information needed for drawing the item */
2932 ZeroMemory(&lvItem, sizeof(lvItem));
2933 lvItem.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_STATE;
2934 lvItem.stateMask = LVIS_SELECTED | LVIS_FOCUSED;
2935 lvItem.iItem = nItem;
2936 lvItem.iSubItem = 0;
2937 lvItem.cchTextMax = DISP_TEXT_SIZE;
2938 lvItem.pszText = szDispText;
2939 *lvItem.pszText = '\0';
2940 LISTVIEW_GetItemW(infoPtr, &lvItem, FALSE);
2941 TRACE(" lvItem=%s\n", debuglvitem_t(&lvItem, TRUE));
2942
2943 rcFill = rcItem;
2944
2945 TRACE("background rect (%d,%d)-(%d,%d)\n",
2946 rcFill.left, rcFill.top, rcFill.right, rcFill.bottom);
2947
2948 if (infoPtr->clrBk != CLR_NONE) FillRect(hdc, &rcFill, infoPtr->hBkBrush);
2949
2950 /* Figure out text colours etc. depending on state
2951 * At least the following states exist; there may be more.
2952 * Many items may be selected
2953 * At most one item may have the focus
2954 * The application may not actually be active currently
2955 * 1. The item is not selected in any way
2956 * 2. The cursor is flying over the icon or text and the text is being
2957 * expanded because it is not fully displayed currently.
2958 * 3. The item is selected and is focussed, i.e. the user has not clicked
2959 * in the blank area of the window, and the window (or application?)
2960 * still has the focus.
2961 * 4. As 3 except that a different window has the focus
2962 * 5. The item is the selected item of all the items, but the user has
2963 * clicked somewhere else on the window.
2964 * Only a few of these are handled currently. In particular 2 is not yet
2965 * handled since we do not support the functionality currently (or at least
2966 * we didn't when I wrote this)
2967 */
2968
2969 if (lvItem.state & LVIS_SELECTED)
2970 {
2971 /* set item colors */
2972 SetBkColor(hdc, comctl32_color.clrHighlight);
2973 SetTextColor(hdc, comctl32_color.clrHighlightText);
2974 SetBkMode (hdc, OPAQUE);
2975 /* set raster mode */
2976 SetROP2(hdc, R2_XORPEN);
2977 /* When exactly is it in XOR? while being dragged? */
2978 }
2979 else
2980 {
2981 /* set item colors */
2982 if ( (infoPtr->clrTextBk == CLR_DEFAULT) || (infoPtr->clrTextBk == CLR_NONE) )
2983 {
2984 SetBkMode(hdc, TRANSPARENT);
2985 }
2986 else
2987 {
2988 SetBkMode(hdc, OPAQUE);
2989 SetBkColor(hdc, infoPtr->clrTextBk);
2990 }
2991
2992 SetTextColor(hdc, infoPtr->clrText);
2993 /* set raster mode */
2994 SetROP2(hdc, R2_COPYPEN);
2995 }
2996
2997 /* In cases 2,3 and 5 (see above) the full text is displayed, with word
2998 * wrapping and long words split.
2999 * In cases 1 and 4 only a portion of the text is displayed with word
3000 * wrapping and both word and end ellipsis. (I don't yet know about path
3001 * ellipsis)
3002 */
3003 uFormat |= lprcFocus ? DT_NOCLIP : DT_WORD_ELLIPSIS | DT_END_ELLIPSIS;
3004
3005 /* draw the icon */
3006 if (infoPtr->himlNormal != NULL)
3007 {
3008 if (lvItem.iImage >= 0)
3009 {
3010 ImageList_Draw (infoPtr->himlNormal, lvItem.iImage, hdc, rcItem.left,
3011 rcItem.top,
3012 (lvItem.state & LVIS_SELECTED) ? ILD_SELECTED : ILD_NORMAL);
3013 TRACE("icon %d at (%d,%d)\n",
3014 lvItem.iImage, rcItem.left, rcItem.top);
3015 }
3016 }
3017
3018 /* Draw the text below the icon */
3019
3020 /* Don't bother painting item being edited */
3021 if ((infoPtr->bEditing && lprcFocus) || !lvItem.pszText || !lstrlenW(lvItem.pszText))
3022 {
3023 if(lprcFocus) SetRectEmpty(lprcFocus);
3024 return;
3025 }
3026
3027 /* Since rcItem.left is left point of icon, compute left point of item box */
3028 rcItem.left -= ((infoPtr->nItemWidth - infoPtr->iconSize.cx) / 2);
3029 rcItem.right = rcItem.left + infoPtr->nItemWidth;
3030 rcItem.bottom = rcItem.top + infoPtr->nItemHeight;
3031 TRACE("bound box for text+icon (%d,%d)-(%d,%d), iS.cx=%ld, nItemWidth=%d\n",
3032 rcItem.left, rcItem.top, rcItem.right, rcItem.bottom,
3033 infoPtr->iconSize.cx, infoPtr->nItemWidth);
3034 TRACE("rcList (%d,%d)-(%d,%d), rcView (%d,%d)-(%d,%d)\n",
3035 infoPtr->rcList.left, infoPtr->rcList.top,
3036 infoPtr->rcList.right, infoPtr->rcList.bottom,
3037 infoPtr->rcView.left, infoPtr->rcView.top,
3038 infoPtr->rcView.right, infoPtr->rcView.bottom);
3039
3040 InflateRect(&rcItem, -(2*CAPTION_BORDER), 0);
3041 rcItem.top += infoPtr->iconSize.cy + ICON_BOTTOM_PADDING;
3042
3043
3044 /* draw label */
3045
3046 /* I am sure of most of the uFormat values. However I am not sure about
3047 * whether we need or do not need the following:
3048 * DT_EXTERNALLEADING, DT_INTERNAL, DT_CALCRECT, DT_NOFULLWIDTHCHARBREAK,
3049 * DT_PATH_ELLIPSIS, DT_RTLREADING,
3050 * We certainly do not need
3051 * DT_BOTTOM, DT_VCENTER, DT_MODIFYSTRING, DT_LEFT, DT_RIGHT, DT_PREFIXONLY,
3052 * DT_SINGLELINE, DT_TABSTOP, DT_EXPANDTABS
3053 */
3054
3055 /* If the text is being drawn without clipping (i.e. the full text) then we
3056 * need to jump through a few hoops to ensure that it all gets displayed and
3057 * that the background is complete
3058 */
3059 if (uFormat & DT_NOCLIP)
3060 {
3061 RECT rcBack=rcItem;
3062 HBRUSH hBrush = CreateSolidBrush(GetBkColor (hdc));
3063 int dx, dy, old_wid, new_wid;
3064 DrawTextW (hdc, lvItem.pszText, -1, &rcItem, uFormat | DT_CALCRECT);
3065 /* Microsoft, in their great wisdom, have decided that the rectangle
3066 * returned by DrawText on DT_CALCRECT will only guarantee the dimension,
3067 * not the location. So we have to do the centring ourselves (and take
3068 * responsibility for agreeing off-by-one consistency with them).
3069 */
3070 old_wid = rcItem.right-rcItem.left;
3071 new_wid = rcBack.right - rcBack.left;
3072 dx = rcBack.left - rcItem.left + (new_wid-old_wid)/2;
3073 dy = rcBack.top - rcItem.top;
3074 OffsetRect (&rcItem, dx, dy);
3075 FillRect(hdc, &rcItem, hBrush);
3076 DeleteObject(hBrush);
3077 }
3078 /* else ? What if we are losing the focus? will we not get a complete
3079 * background?
3080 */
3081 DrawTextW (hdc, lvItem.pszText, -1, &rcItem, uFormat);
3082 TRACE("text at (%d,%d)-(%d,%d) is %s\n",
3083 rcItem.left, rcItem.top, rcItem.right, rcItem.bottom,
3084 debugstr_w(lvItem.pszText));
3085
3086 if(lprcFocus) CopyRect(lprcFocus, &rcItem);
3087 }
3088
3089 /***
3090 * DESCRIPTION:
3091 * Draws listview items when in report display mode.
3092 *
3093 * PARAMETER(S):
3094 * [I] infoPtr : valid pointer to the listview structure
3095 * [I] HDC : device context handle
3096 *
3097 * RETURN:
3098 * None
3099 */
3100 static void LISTVIEW_RefreshReport(LISTVIEW_INFO *infoPtr, HDC hdc, DWORD cdmode)
3101 {
3102 SCROLLINFO scrollInfo;
3103 INT nDrawPosY = infoPtr->rcList.top;
3104 INT nColumnCount;
3105 RECT rcItem, rcFull, *lprcFocus;
3106 INT j;
3107 INT nItem;
3108 INT nLast;
3109 BOOL FullSelected;
3110 DWORD cditemmode = CDRF_DODEFAULT;
3111 LONG lStyle = GetWindowLongW(infoPtr->hwndSelf, GWL_STYLE);
3112 INT scrollOffset;
3113
3114 TRACE("\n");
3115
3116 nItem = ListView_GetTopIndex(infoPtr->hwndSelf);
3117
3118 /* add 1 for displaying a partial item at the bottom */
3119 nLast = min(nItem + LISTVIEW_GetCountPerColumn(infoPtr) + 1, GETITEMCOUNT(infoPtr));
3120
3121 /* send cache hint notification */
3122 if (lStyle & LVS_OWNERDATA)
3123 {
3124 NMLVCACHEHINT nmlv;
3125
3126 nmlv.hdr.hwndFrom = infoPtr->hwndSelf;
3127 nmlv.hdr.idFrom = GetWindowLongW(infoPtr->hwndSelf,GWL_ID);
3128 nmlv.hdr.code = LVN_ODCACHEHINT;
3129 nmlv.iFrom = nItem;
3130 nmlv.iTo = nLast;
3131
3132 SendMessageW(GetParent(infoPtr->hwndSelf), WM_NOTIFY, (WPARAM)nmlv.hdr.idFrom,
3133 (LPARAM)&nmlv);
3134 }
3135
3136 nColumnCount = Header_GetItemCount(infoPtr->hwndHeader);
3137 infoPtr->nColumnCount = nColumnCount; /* update nColumnCount */
3138 FullSelected = infoPtr->dwExStyle & LVS_EX_FULLROWSELECT;
3139
3140 /* nothing to draw */
3141 if(GETITEMCOUNT(infoPtr) == 0)
3142 return;
3143
3144 /* if we have focus, precompute full select rect, if need be */
3145 if (infoPtr->bFocus && FullSelected)
3146 {
3147 RECT br;
3148
3149 Header_GetItemRect(infoPtr->hwndHeader, 0, &rcFull);
3150 Header_GetItemRect(infoPtr->hwndHeader, nColumnCount-1, &br);
3151
3152 rcFull.left += REPORT_MARGINX;
3153 rcFull.right = max(rcFull.left, br.right - REPORT_MARGINX);
3154 }
3155
3156 /* Get scroll bar info once before loop */
3157 ZeroMemory(&scrollInfo, sizeof(SCROLLINFO));
3158 scrollInfo.cbSize = sizeof(SCROLLINFO);
3159 scrollInfo.fMask = SIF_POS;
3160 GetScrollInfo(infoPtr->hwndSelf, SB_HORZ, &scrollInfo);
3161 scrollOffset = scrollInfo.nPos;
3162
3163 for (; nItem < nLast; nItem++)
3164 {
3165 /* Do Owner Draw */
3166 if (lStyle & LVS_OWNERDRAWFIXED)
3167 {
3168 UINT uID = GetWindowLongW(infoPtr->hwndSelf, GWL_ID);
3169 DRAWITEMSTRUCT dis;
3170 LVITEMW item;
3171 RECT br;
3172
3173 TRACE("Owner Drawn\n");
3174 dis.CtlType = ODT_LISTVIEW;
3175 dis.CtlID = uID;
3176 dis.itemID = nItem;
3177 dis.itemAction = ODA_DRAWENTIRE;
3178 dis.itemState = 0;
3179
3180 if (LISTVIEW_GetItemState(infoPtr, nItem, LVIS_SELECTED))
3181 dis.itemState |= ODS_SELECTED;
3182 if (LISTVIEW_GetItemState(infoPtr, nItem, LVIS_FOCUSED))
3183 dis.itemState |= ODS_FOCUS;
3184
3185 dis.hwndItem = infoPtr->hwndSelf;
3186 dis.hDC = hdc;
3187
3188 Header_GetItemRect(infoPtr->hwndHeader, nColumnCount-1, &br);
3189
3190 dis.rcItem.left = -scrollOffset;
3191 dis.rcItem.right = max(dis.rcItem.left, br.right - scrollOffset);
3192 dis.rcItem.top = nDrawPosY;
3193 dis.rcItem.bottom = dis.rcItem.top + infoPtr->nItemHeight;
3194
3195 ZeroMemory(&item,sizeof(item));
3196 item.iItem = nItem;
3197 item.mask = LVIF_PARAM;
3198 ListView_GetItemW(infoPtr->hwndSelf, &item);
3199
3200 dis.itemData = item.lParam;
3201
3202 if (SendMessageW(GetParent(infoPtr->hwndSelf),WM_DRAWITEM,(WPARAM)uID,(LPARAM)&dis))
3203 {
3204 nDrawPosY += infoPtr->nItemHeight;
3205 continue;
3206 }
3207 }
3208
3209 /* if we have focus, calculate focus rect */
3210 if (infoPtr->bFocus && LISTVIEW_GetItemState(infoPtr, nItem, LVIS_FOCUSED))
3211 lprcFocus = &infoPtr->rcFocus;
3212 else
3213 lprcFocus = 0;
3214
3215 for (j = 0; j < nColumnCount; j++)
3216 {
3217 if (cdmode & CDRF_NOTIFYITEMDRAW)
3218 cditemmode = LISTVIEW_SendCustomDrawItemNotify (infoPtr, hdc, nItem, j,
3219 CDDS_ITEMPREPAINT);
3220 if (cditemmode & CDRF_SKIPDEFAULT)
3221 continue;
3222
3223 Header_GetItemRect(infoPtr->hwndHeader, j, &rcItem);
3224
3225 rcItem.left += REPORT_MARGINX;
3226 rcItem.right = max(rcItem.left, rcItem.right - REPORT_MARGINX);
3227 rcItem.top = nDrawPosY;
3228 rcItem.bottom = rcItem.top + infoPtr->nItemHeight;
3229
3230 /* Offset the Scroll Bar Pos */
3231 rcItem.left -= scrollOffset;
3232 rcItem.right -= scrollOffset;
3233
3234 if (j == 0)
3235 LISTVIEW_DrawItem(infoPtr, hdc, nItem, rcItem, FullSelected, lprcFocus);
3236 else
3237 LISTVIEW_DrawSubItem(infoPtr, hdc, nItem, j, rcItem, FullSelected);
3238
3239 if (cditemmode & CDRF_NOTIFYPOSTPAINT)
3240 LISTVIEW_SendCustomDrawItemNotify(infoPtr, hdc, nItem, 0,
3241 CDDS_ITEMPOSTPAINT);
3242 }
3243
3244 /* Adjust focus if we have it, and we are in full select */
3245 if (lprcFocus && FullSelected)
3246 {
3247 rcFull.top = nDrawPosY;
3248 rcFull.bottom = rcFull.top + infoPtr->nItemHeight;
3249 infoPtr->rcFocus = rcFull;
3250 }
3251
3252 nDrawPosY += infoPtr->nItemHeight;
3253 }
3254 }
3255
3256 /***
3257 * DESCRIPTION:
3258 * Draws listview items when in list display mode.
3259 *
3260 * PARAMETER(S):
3261 * [I] infoPtr : valid pointer to the listview structure
3262 * [I] HDC : device context handle
3263 *
3264 * RETURN:
3265 * None
3266 */
3267 static void LISTVIEW_RefreshList(LISTVIEW_INFO *infoPtr, HDC hdc, DWORD cdmode)
3268 {
3269 RECT rcItem, *lprcFocus;
3270 INT i, j;
3271 INT nItem;
3272 INT nColumnCount;
3273 INT nCountPerColumn;
3274 INT nItemWidth = infoPtr->nItemWidth;
3275 INT nItemHeight = infoPtr->nItemHeight;
3276 INT nListWidth = infoPtr->rcList.right - infoPtr->rcList.left;
3277 DWORD cditemmode = CDRF_DODEFAULT;
3278
3279 /* get number of fully visible columns */
3280 nColumnCount = nListWidth / nItemWidth;
3281 if (nListWidth % nItemWidth) nColumnCount++;
3282 infoPtr->nColumnCount = nColumnCount;
3283 nCountPerColumn = LISTVIEW_GetCountPerColumn(infoPtr);
3284 nItem = ListView_GetTopIndex(infoPtr->hwndSelf);
3285 TRACE("nColumnCount=%d, nCountPerColumn=%d, start item=%d\n",
3286 nColumnCount, nCountPerColumn, nItem);
3287
3288 /* nothing to draw, return here */
3289 if(GETITEMCOUNT(infoPtr) == 0)
3290 return;
3291
3292 for (i = 0; i < nColumnCount; i++)
3293 {
3294 for (j = 0; j < nCountPerColumn; j++, nItem++)
3295 {
3296 if (nItem >= GETITEMCOUNT(infoPtr))
3297 return;
3298
3299 if (cdmode & CDRF_NOTIFYITEMDRAW)
3300 cditemmode = LISTVIEW_SendCustomDrawItemNotify (infoPtr, hdc, nItem, 0,
3301 CDDS_ITEMPREPAINT);
3302 if (cditemmode & CDRF_SKIPDEFAULT)
3303 continue;
3304
3305 rcItem.top = j * nItemHeight;
3306 rcItem.left = i * nItemWidth;
3307 rcItem.bottom = rcItem.top + nItemHeight;
3308 rcItem.right = rcItem.left + nItemWidth;
3309
3310 /* if we have focus, calculate focus rect */
3311 if (infoPtr->bFocus && LISTVIEW_GetItemState(infoPtr, nItem, LVIS_FOCUSED))
3312 lprcFocus = &infoPtr->rcFocus;
3313 else
3314 lprcFocus = 0;
3315
3316 LISTVIEW_DrawItem(infoPtr, hdc, nItem, rcItem, FALSE, lprcFocus);
3317
3318 if (cditemmode & CDRF_NOTIFYPOSTPAINT)
3319 LISTVIEW_SendCustomDrawItemNotify(infoPtr, hdc, nItem, 0,
3320 CDDS_ITEMPOSTPAINT);
3321
3322 }
3323 }
3324 }
3325
3326 /***
3327 * DESCRIPTION:
3328 * Draws listview items when in icon or small icon display mode.
3329 *
3330 * PARAMETER(S):
3331 * [I] infoPtr : valid pointer to the listview structure
3332 * [I] HDC : device context handle
3333 *
3334 * RETURN:
3335 * None
3336 */
3337 static void LISTVIEW_RefreshIcon(LISTVIEW_INFO *infoPtr, HDC hdc, BOOL bSmall, DWORD cdmode)
3338 {
3339 POINT ptPosition;
3340 POINT ptOrigin;
3341 RECT rcItem, *lprcFocus;
3342 INT i;
3343 DWORD cditemmode = CDRF_DODEFAULT;
3344
3345 TRACE("\n");
3346 infoPtr->nColumnCount = 1; /* set this to an arbitrary value to prevent */
3347 /* DrawItem from erasing the incorrect background area */
3348
3349 /* nothing to draw, return here */
3350 if(GETITEMCOUNT(infoPtr) == 0)
3351 return;
3352
3353 LISTVIEW_GetOrigin(infoPtr, &ptOrigin);
3354 for (i = 0; i < GETITEMCOUNT(infoPtr); i++)
3355 {
3356 if (cdmode & CDRF_NOTIFYITEMDRAW)
3357 cditemmode = LISTVIEW_SendCustomDrawItemNotify (infoPtr, hdc, i, 0,
3358 CDDS_ITEMPREPAINT);
3359 if (cditemmode & CDRF_SKIPDEFAULT)
3360 continue;
3361
3362 LISTVIEW_GetItemPosition(infoPtr, i, &ptPosition);
3363 ptPosition.x += ptOrigin.x;
3364 ptPosition.y += ptOrigin.y;
3365
3366 if (ptPosition.y + infoPtr->nItemHeight > infoPtr->rcList.top)
3367 {
3368 if (ptPosition.x + infoPtr->nItemWidth > infoPtr->rcList.left)
3369 {
3370 if (ptPosition.y < infoPtr->rcList.bottom)
3371 {
3372 if (ptPosition.x < infoPtr->rcList.right)
3373 {
3374 rcItem.top = ptPosition.y;
3375 rcItem.left = ptPosition.x;
3376 rcItem.bottom = rcItem.top + infoPtr->nItemHeight;
3377 rcItem.right = rcItem.left + infoPtr->nItemWidth;
3378
3379 /* if we have focus, calculate focus rect */
3380 if (infoPtr->bFocus && LISTVIEW_GetItemState(infoPtr, i, LVIS_FOCUSED))
3381 lprcFocus = &infoPtr->rcFocus;
3382 else
3383 lprcFocus = 0;
3384
3385 if (bSmall)
3386 LISTVIEW_DrawItem(infoPtr, hdc, i, rcItem, FALSE, lprcFocus);
3387 else
3388 LISTVIEW_DrawLargeItem(infoPtr, hdc, i, rcItem, lprcFocus);
3389 }
3390 }
3391 }
3392 }
3393 if (cditemmode & CDRF_NOTIFYPOSTPAINT)
3394 LISTVIEW_SendCustomDrawItemNotify(infoPtr, hdc, i, 0,
3395 CDDS_ITEMPOSTPAINT);
3396 }
3397 }
3398
3399 /***
3400 * DESCRIPTION:
3401 * Draws listview items.
3402 *
3403 * PARAMETER(S):
3404 * [I] infoPtr : valid pointer to the listview structure
3405 * [I] HDC : device context handle
3406 *
3407 * RETURN:
3408 * NoneX
3409 */
3410 static void LISTVIEW_Refresh(LISTVIEW_INFO *infoPtr, HDC hdc)
3411 {
3412 UINT uView = LISTVIEW_GetType(infoPtr);
3413 HFONT hOldFont;
3414 DWORD cdmode;
3415 RECT rcClient, rcTemp;
3416
3417 LISTVIEW_DUMP(infoPtr);
3418
3419 GetClientRect(infoPtr->hwndSelf, &rcClient);
3420
3421 cdmode = LISTVIEW_SendCustomDrawNotify(infoPtr, CDDS_PREPAINT, hdc, rcClient);
3422 if (cdmode == CDRF_SKIPDEFAULT) return;
3423
3424 infoPtr->bIsDrawing = TRUE;
3425
3426 /* select font */
3427 hOldFont = SelectObject(hdc, infoPtr->hFont);
3428
3429 /* select transparent brush (for drawing the focus box) */
3430 SelectObject(hdc, GetStockObject(NULL_BRUSH));
3431
3432 /* paint the background of the control that doesn't contain any items */
3433 SubtractRect(&rcTemp, &infoPtr->rcList, &infoPtr->rcView);
3434 if (infoPtr->clrBk != CLR_NONE) FillRect(hdc, &rcTemp, infoPtr->hBkBrush);
3435
3436 if (uView == LVS_LIST)
3437 LISTVIEW_RefreshList(infoPtr, hdc, cdmode);
3438 else if (uView == LVS_REPORT)
3439 LISTVIEW_RefreshReport(infoPtr, hdc, cdmode);
3440 else
3441 LISTVIEW_RefreshIcon(infoPtr, hdc, uView == LVS_SMALLICON, cdmode);
3442
3443 /* if we have a focus rect, draw it */
3444 if (infoPtr->bFocus && !IsRectEmpty(&infoPtr->rcFocus))
3445 DrawFocusRect(hdc, &infoPtr->rcFocus);
3446
3447 /* unselect objects */
3448 SelectObject(hdc, hOldFont);
3449
3450 if (cdmode & CDRF_NOTIFYPOSTPAINT)
3451 LISTVIEW_SendCustomDrawNotify(infoPtr, CDDS_POSTPAINT, hdc, rcClient);
3452
3453 infoPtr->bIsDrawing = FALSE;
3454 }
3455
3456
3457 /***
3458 * DESCRIPTION:
3459 * Calculates the approximate width and height of a given number of items.
3460 *
3461 * PARAMETER(S):
3462 * [I] infoPtr : valid pointer to the listview structure
3463 * [I] INT : number of items
3464 * [I] INT : width
3465 * [I] INT : height
3466 *
3467 * RETURN:
3468 * Returns a DWORD. The width in the low word and the height in high word.
3469 */
3470 static LRESULT LISTVIEW_ApproximateViewRect(LISTVIEW_INFO *infoPtr, INT nItemCount,
3471 WORD wWidth, WORD wHeight)
3472 {
3473 UINT uView = LISTVIEW_GetType(infoPtr);
3474 INT nItemCountPerColumn = 1;
3475 INT nColumnCount = 0;
3476 DWORD dwViewRect = 0;
3477
3478 if (nItemCount == -1)
3479 nItemCount = GETITEMCOUNT(infoPtr);
3480
3481 if (uView == LVS_LIST)
3482 {
3483 if (wHeight == 0xFFFF)
3484 {
3485 /* use current height */
3486 wHeight = infoPtr->rcList.bottom - infoPtr->rcList.top;
3487 }
3488
3489 if (wHeight < infoPtr->nItemHeight)
3490 wHeight = infoPtr->nItemHeight;
3491
3492 if (nItemCount > 0)
3493 {
3494 if (infoPtr->nItemHeight > 0)
3495 {
3496 nItemCountPerColumn = wHeight / infoPtr->nItemHeight;
3497 if (nItemCountPerColumn == 0)
3498 nItemCountPerColumn = 1;
3499
3500 if (nItemCount % nItemCountPerColumn != 0)
3501 nColumnCount = nItemCount / nItemCountPerColumn;
3502 else
3503 nColumnCount = nItemCount / nItemCountPerColumn + 1;
3504 }
3505 }
3506
3507 /* Microsoft padding magic */
3508 wHeight = nItemCountPerColumn * infoPtr->nItemHeight + 2;
3509 wWidth = nColumnCount * infoPtr->nItemWidth + 2;
3510
3511 dwViewRect = MAKELONG(wWidth, wHeight);
3512 }
3513 else if (uView == LVS_REPORT)
3514 FIXME("uView == LVS_REPORT: not implemented\n");
3515 else if (uView == LVS_SMALLICON)
3516 FIXME("uView == LVS_SMALLICON: not implemented\n");
3517 else if (uView == LVS_ICON)
3518 FIXME("uView == LVS_ICON: not implemented\n");
3519
3520 return dwViewRect;
3521 }
3522
3523 /***
3524 * DESCRIPTION:
3525 * Arranges listview items in icon display mode.
3526 *
3527 * PARAMETER(S):
3528 * [I] infoPtr : valid pointer to the listview structure
3529 * [I] INT : alignment code
3530 *
3531 * RETURN:
3532 * SUCCESS : TRUE
3533 * FAILURE : FALSE
3534 */
3535 static LRESULT LISTVIEW_Arrange(LISTVIEW_INFO *infoPtr, INT nAlignCode)
3536 {
3537 UINT uView = LISTVIEW_GetType(infoPtr);
3538 BOOL bResult = FALSE;
3539
3540 if ((uView == LVS_ICON) || (uView == LVS_SMALLICON))
3541 {
3542 switch (nAlignCode)
3543 {
3544 case LVA_ALIGNLEFT:
3545 FIXME("nAlignCode=LVA_ALIGNLEFT: not implemented\n");
3546 break;
3547 case LVA_ALIGNTOP:
3548 FIXME("nAlignCode=LVA_ALIGNTOP: not implemented\n");
3549 break;
3550 case LVA_DEFAULT:
3551 FIXME("nAlignCode=LVA_DEFAULT: not implemented\n");
3552 break;
3553 case LVA_SNAPTOGRID:
3554 FIXME("nAlignCode=LVA_SNAPTOGRID: not implemented\n");
3555 break;
3556 }
3557 }
3558
3559 return bResult;
3560 }
3561
3562 /* << LISTVIEW_CreateDragImage >> */
3563
3564
3565 /***
3566 * DESCRIPTION:
3567 * Removes all listview items and subitems.
3568 *
3569 * PARAMETER(S):
3570 * [I] infoPtr : valid pointer to the listview structure
3571 *
3572 * RETURN:
3573 * SUCCESS : TRUE
3574 * FAILURE : FALSE
3575 */
3576 static LRESULT LISTVIEW_DeleteAllItems(LISTVIEW_INFO *infoPtr)
3577 {
3578 LONG lStyle = GetWindowLongW(infoPtr->hwndSelf, GWL_STYLE);
3579 UINT uView = lStyle & LVS_TYPEMASK;
3580 LISTVIEW_ITEM *lpItem;
3581 LISTVIEW_SUBITEM *lpSubItem;
3582 NMLISTVIEW nmlv;
3583 BOOL bSuppress;
3584 BOOL bResult = FALSE;
3585 HDPA hdpaSubItems;
3586
3587 TRACE("()\n");
3588
3589 LISTVIEW_RemoveAllSelections(infoPtr);
3590 infoPtr->nSelectionMark=-1;
3591 infoPtr->nFocusedItem=-1;
3592 /* But we are supposed to leave nHotItem as is! */
3593
3594 if (lStyle & LVS_OWNERDATA)
3595 {
3596 infoPtr->hdpaItems->nItemCount = 0;
3597 InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
3598 return TRUE;
3599 }
3600
3601 if (GETITEMCOUNT(infoPtr) > 0)
3602 {
3603 INT i, j;
3604
3605 /* send LVN_DELETEALLITEMS notification */
3606 /* verify if subsequent LVN_DELETEITEM notifications should be
3607 suppressed */
3608 ZeroMemory(&nmlv, sizeof(NMLISTVIEW));
3609 nmlv.iItem = -1;
3610 bSuppress = listview_notify(infoPtr, LVN_DELETEALLITEMS, &nmlv);
3611
3612 for (i = 0; i < GETITEMCOUNT(infoPtr); i++)
3613 {
3614 hdpaSubItems = (HDPA)DPA_GetPtr(infoPtr->hdpaItems, i);
3615 if (hdpaSubItems != NULL)
3616 {
3617 for (j = 1; j < hdpaSubItems->nItemCount; j++)
3618 {
3619 lpSubItem = (LISTVIEW_SUBITEM *)DPA_GetPtr(hdpaSubItems, j);
3620 if (lpSubItem != NULL)
3621 {
3622 /* free subitem string */
3623 if (is_textW(lpSubItem->hdr.pszText))
3624 COMCTL32_Free(lpSubItem->hdr.pszText);
3625
3626 /* free subitem */
3627 COMCTL32_Free(lpSubItem);
3628 }
3629 }
3630
3631 lpItem = (LISTVIEW_ITEM *)DPA_GetPtr(hdpaSubItems, 0);
3632 if (lpItem != NULL)
3633 {
3634 if (!bSuppress)
3635 {
3636 /* send LVN_DELETEITEM notification */
3637 nmlv.iItem = i;
3638 nmlv.lParam = lpItem->lParam;
3639 listview_notify(infoPtr, LVN_DELETEITEM, &nmlv);
3640 }
3641
3642 /* free item string */
3643 if (is_textW(lpItem->hdr.pszText))
3644 COMCTL32_Free(lpItem->hdr.pszText);
3645
3646 /* free item */
3647 COMCTL32_Free(lpItem);
3648 }
3649
3650 DPA_Destroy(hdpaSubItems);
3651 }
3652 }
3653
3654 /* reinitialize listview memory */
3655 bResult = DPA_DeleteAllPtrs(infoPtr->hdpaItems);
3656
3657 /* align items (set position of each item) */
3658 if ((uView == LVS_ICON) || (uView == LVS_SMALLICON))
3659 {
3660 if (lStyle & LVS_ALIGNLEFT)
3661 {
3662 LISTVIEW_AlignLeft(infoPtr);
3663 }
3664 else
3665 {
3666 LISTVIEW_AlignTop(infoPtr);
3667 }
3668 }
3669
3670 LISTVIEW_UpdateScroll(infoPtr);
3671
3672 /* invalidate client area (optimization needed) */
3673 InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
3674 }
3675
3676 return bResult;
3677 }
3678
3679 /***
3680 * DESCRIPTION:
3681 * Removes a column from the listview control.
3682 *
3683 * PARAMETER(S):
3684 * [I] infoPtr : valid pointer to the listview structure
3685 * [I] INT : column index
3686 *
3687 * RETURN:
3688 * SUCCESS : TRUE
3689 * FAILURE : FALSE
3690 */
3691 static LRESULT LISTVIEW_DeleteColumn(LISTVIEW_INFO *infoPtr, INT nColumn)
3692 {
3693 UINT uView = LISTVIEW_GetType(infoPtr);
3694 UINT uOwnerData = GetWindowLongW(infoPtr->hwndSelf, GWL_STYLE) & LVS_OWNERDATA;
3695 BOOL bResult = FALSE;
3696
3697 if (Header_DeleteItem(infoPtr->hwndHeader, nColumn))
3698 {
3699 bResult = uOwnerData ? TRUE : LISTVIEW_RemoveColumn(infoPtr->hdpaItems, nColumn);
3700
3701 /* Need to reset the item width when deleting a column */
3702 infoPtr->nItemWidth = LISTVIEW_GetItemWidth(infoPtr);
3703
3704 /* reset scroll parameters */
3705 if (uView == LVS_REPORT)
3706 {
3707 /* update scrollbar(s) */
3708 LISTVIEW_UpdateScroll(infoPtr);
3709
3710 /* refresh client area */
3711 InvalidateRect(infoPtr->hwndSelf, NULL, FALSE);
3712 }
3713 }
3714
3715 return bResult;
3716 }
3717
3718 /***
3719 * DESCRIPTION:
3720 * Removes an item from the listview control.
3721 *
3722 * PARAMETER(S):
3723 * [I] infoPtr : valid pointer to the listview structure
3724 * [I] INT : item index
3725 *
3726 * RETURN:
3727 * SUCCESS : TRUE
3728 * FAILURE : FALSE
3729 */
3730 static LRESULT LISTVIEW_DeleteItem(LISTVIEW_INFO *infoPtr, INT nItem)
3731 {
3732 LONG lStyle = GetWindowLongW(infoPtr->hwndSelf, GWL_STYLE);
3733 UINT uView = lStyle & LVS_TYPEMASK;
3734 LONG lCtrlId = GetWindowLongW(infoPtr->hwndSelf, GWL_ID);
3735 NMLISTVIEW nmlv;
3736 BOOL bResult = FALSE;
3737 HDPA hdpaSubItems;
3738 LISTVIEW_ITEM *lpItem;
3739 LISTVIEW_SUBITEM *lpSubItem;
3740 INT i;
3741 LVITEMW item;
3742
3743 TRACE("(nItem=%d)\n", nItem);
3744
3745
3746 /* First, send LVN_DELETEITEM notification. */
3747 memset(&nmlv, 0, sizeof (NMLISTVIEW));
3748 nmlv.hdr.hwndFrom = infoPtr->hwndSelf;
3749 nmlv.hdr.idFrom = lCtrlId;
3750 nmlv.hdr.code = LVN_DELETEITEM;
3751 nmlv.iItem = nItem;
3752 SendMessageW(GetParent(infoPtr->hwndSelf), WM_NOTIFY, (WPARAM)lCtrlId,
3753 (LPARAM)&nmlv);
3754
3755
3756 /* remove it from the selection range */
3757 ZeroMemory(&item,sizeof(item));
3758 item.stateMask = LVIS_SELECTED;
3759 LISTVIEW_SetItemState(infoPtr,nItem,&item);
3760
3761 if (lStyle & LVS_OWNERDATA)
3762 {
3763 infoPtr->hdpaItems->nItemCount --;
3764 InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
3765 return TRUE;
3766 }
3767
3768 if ((nItem >= 0) && (nItem < GETITEMCOUNT(infoPtr)))
3769 {
3770 /* initialize memory */
3771 ZeroMemory(&nmlv, sizeof(NMLISTVIEW));
3772
3773 hdpaSubItems = (HDPA)DPA_DeletePtr(infoPtr->hdpaItems, nItem);
3774 if (hdpaSubItems != NULL)
3775 {
3776 for (i = 1; i < hdpaSubItems->nItemCount; i++)
3777 {
3778 lpSubItem = (LISTVIEW_SUBITEM *)DPA_GetPtr(hdpaSubItems, i);
3779 if (lpSubItem != NULL)
3780 {
3781 /* free item string */
3782 if (is_textW(lpSubItem->hdr.pszText))
3783 COMCTL32_Free(lpSubItem->hdr.pszText);
3784
3785 /* free item */
3786 COMCTL32_Free(lpSubItem);
3787 }
3788 }
3789
3790 lpItem = (LISTVIEW_ITEM *)DPA_GetPtr(hdpaSubItems, 0);
3791 if (lpItem != NULL)
3792 {
3793 /* free item string */
3794 if (is_textW(lpItem->hdr.pszText))
3795 COMCTL32_Free(lpItem->hdr.pszText);
3796
3797 /* free item */
3798 COMCTL32_Free(lpItem);
3799 }
3800
3801 bResult = DPA_Destroy(hdpaSubItems);
3802 }
3803
3804 LISTVIEW_ShiftIndices(infoPtr,nItem,-1);
3805
3806 /* align items (set position of each item) */
3807 if ((uView == LVS_SMALLICON) || (uView == LVS_ICON))
3808 {
3809 if (lStyle & LVS_ALIGNLEFT)
3810 LISTVIEW_AlignLeft(infoPtr);
3811 else
3812 LISTVIEW_AlignTop(infoPtr);
3813 }
3814
3815 LISTVIEW_UpdateScroll(infoPtr);
3816
3817 /* refresh client area */
3818 InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
3819 }
3820
3821 return bResult;
3822 }
3823
3824
3825 /***
3826 * DESCRIPTION:
3827 * Callback implementation for editlabel control
3828 *
3829 * PARAMETER(S):
3830 * [I] infoPtr : valid pointer to the listview structure
3831 * [I] pszText : modified text
3832 * [I] isW : TRUE if psxText is Unicode, FALSE if it's ANSI
3833 *
3834 * RETURN:
3835 * SUCCESS : TRUE
3836 * FAILURE : FALSE
3837 */
3838 static BOOL LISTVIEW_EndEditLabelT(LISTVIEW_INFO *infoPtr, LPWSTR pszText, BOOL isW)
3839 {
3840 LONG lStyle = GetWindowLongW(infoPtr->hwndSelf, GWL_STYLE);
3841 NMLVDISPINFOW dispInfo;
3842 LISTVIEW_ITEM *lpItem;
3843 HDPA hdpaSubItems;
3844 LISTVIEW_ITEM lvItemRef;
3845 LVITEMW item;
3846 BOOL bResult = TRUE;
3847 INT nItem = infoPtr->nEditLabelItem;
3848
3849 TRACE("(pszText=%s, nItem=%d, isW=%d)\n", debugtext_t(pszText, isW), nItem, isW);
3850
3851 infoPtr->bEditing = FALSE;
3852 if (!(lStyle & LVS_OWNERDATA))
3853 {
3854 if (!(hdpaSubItems = (HDPA)DPA_GetPtr(infoPtr->hdpaItems, nItem)))
3855 return FALSE;
3856
3857 if (!(lpItem = (LISTVIEW_ITEM *)DPA_GetPtr(hdpaSubItems, 0)))
3858 return FALSE;
3859 }
3860 else
3861 {
3862 ZeroMemory(&lvItemRef,sizeof(LISTVIEW_ITEM));
3863 ZeroMemory(&item,sizeof(item));
3864 item.iItem = nItem;
3865 item.iSubItem = 0;
3866 item.mask = LVIF_PARAM | LVIF_STATE;
3867 ListView_GetItemW(infoPtr->hwndSelf, &item);
3868 lvItemRef.hdr.iImage = item.iImage;
3869 lvItemRef.state = item.state;
3870 lvItemRef.lParam = item.lParam;
3871 lpItem = &lvItemRef;
3872 }
3873
3874 ZeroMemory(&dispInfo, sizeof(dispInfo));
3875 dispInfo.item.mask = 0;
3876 dispInfo.item.iItem = nItem;
3877 dispInfo.item.state = lpItem->state;
3878 dispInfo.item.stateMask = 0;
3879 dispInfo.item.pszText = pszText;
3880 dispInfo.item.cchTextMax = textlenT(pszText, isW);
3881 dispInfo.item.iImage = lpItem->hdr.iImage;
3882 dispInfo.item.lParam = lpItem->lParam;
3883
3884 /* Do we need to update the Item Text */
3885 if(dispinfo_notifyT(infoPtr, LVN_ENDLABELEDITW, &dispInfo, isW))
3886 if (lpItem->hdr.pszText != LPSTR_TEXTCALLBACKW && !(lStyle & LVS_OWNERDATA))
3887 bResult = textsetptrT(&lpItem->hdr.pszText, pszText, isW);
3888
3889 return bResult;
3890 }
3891
3892 /***
3893 * DESCRIPTION:
3894 * Begin in place editing of specified list view item
3895 *
3896 * PARAMETER(S):
3897 * [I] infoPtr : valid pointer to the listview structure
3898 * [I] INT : item index
3899 * [I] isW : TRUE if it's a Unicode req, FALSE if ASCII
3900 *
3901 * RETURN:
3902 * SUCCESS : TRUE
3903 * FAILURE : FALSE
3904 */
3905 static HWND LISTVIEW_EditLabelT(LISTVIEW_INFO *infoPtr, INT nItem, BOOL isW)
3906 {
3907 NMLVDISPINFOW dispInfo;
3908 RECT rect;
3909 LISTVIEW_ITEM *lpItem;
3910 HWND hedit;
3911 HDPA hdpaSubItems;
3912 WCHAR szDispText[DISP_TEXT_SIZE];
3913 LVITEMW lvItem;
3914 LISTVIEW_ITEM lvItemRef;
3915 LONG lStyle = GetWindowLongW(infoPtr->hwndSelf, GWL_STYLE);
3916
3917 if (~GetWindowLongW(infoPtr->hwndSelf, GWL_STYLE) & LVS_EDITLABELS)
3918 return FALSE;
3919
3920 infoPtr->nEditLabelItem = nItem;
3921
3922 TRACE("(nItem=%d, isW=%d)\n", nItem, isW);
3923
3924 /* Is the EditBox still there, if so remove it */
3925 if(infoPtr->hwndEdit != 0)
3926 {
3927 SetFocus(infoPtr->hwndSelf);
3928 infoPtr->hwndEdit = 0;
3929 }
3930
3931 LISTVIEW_SetSelection(infoPtr, nItem);
3932 LISTVIEW_SetItemFocus(infoPtr, nItem);
3933
3934 if (!(lStyle & LVS_OWNERDATA))
3935 {
3936 if (NULL == (hdpaSubItems = (HDPA)DPA_GetPtr(infoPtr->hdpaItems, nItem)))
3937 return 0;
3938
3939 if (NULL == (lpItem = (LISTVIEW_ITEM *)DPA_GetPtr(hdpaSubItems, 0)))
3940 return 0;
3941 }
3942 else
3943 {
3944 LVITEMW item;
3945 ZeroMemory(&lvItemRef,sizeof(LISTVIEW_ITEM));
3946 ZeroMemory(&item, sizeof(item));
3947 item.iItem = nItem;
3948 item.iSubItem = 0;
3949 item.mask = LVIF_PARAM | LVIF_STATE;
3950 ListView_GetItemW(infoPtr->hwndSelf, &item);
3951 lvItemRef.hdr.iImage = item.iImage;
3952 lvItemRef.state = item.state;
3953 lvItemRef.lParam = item.lParam;
3954 lpItem = &lvItemRef;
3955 }
3956
3957 /* get information needed for drawing the item */
3958 ZeroMemory(&lvItem, sizeof(lvItem));
3959 lvItem.mask = LVIF_TEXT;
3960 lvItem.iItem = nItem;
3961 lvItem.iSubItem = 0;
3962 lvItem.cchTextMax = DISP_TEXT_SIZE;
3963 lvItem.pszText = szDispText;
3964 *lvItem.pszText = '\0';
3965 LISTVIEW_GetItemT(infoPtr, &lvItem, FALSE, isW);
3966
3967 ZeroMemory(&dispInfo, sizeof(dispInfo));
3968 dispInfo.item.mask = 0;
3969 dispInfo.item.iItem = nItem;
3970 dispInfo.item.state = lpItem->state;
3971 dispInfo.item.stateMask = 0;
3972 dispInfo.item.pszText = lvItem.pszText;
3973 dispInfo.item.cchTextMax = lstrlenW(lvItem.pszText);
3974 dispInfo.item.iImage = lpItem->hdr.iImage;
3975 dispInfo.item.lParam = lpItem->lParam;
3976
3977 if (dispinfo_notifyT(infoPtr, LVN_BEGINLABELEDITW, &dispInfo, isW))
3978 return 0;
3979
3980 rect.left = LVIR_LABEL;
3981 if (!LISTVIEW_GetItemRect(infoPtr, nItem, &rect))
3982 return 0;
3983
3984 if (!(hedit = CreateEditLabelT(infoPtr, szDispText, WS_VISIBLE,
3985 rect.left-2, rect.top-1, 0, rect.bottom - rect.top+2, isW)))
3986 return 0;
3987
3988 infoPtr->hwndEdit = hedit;
3989
3990 ShowWindow(infoPtr->hwndEdit,SW_NORMAL);
3991 infoPtr->bEditing = TRUE;
3992 SetFocus(infoPtr->hwndEdit);
3993 SendMessageW(infoPtr->hwndEdit, EM_SETSEL, 0, -1);
3994 return infoPtr->hwndEdit;
3995 }
3996
3997
3998 /***
3999 * DESCRIPTION:
4000 * Ensures the specified item is visible, scrolling into view if necessary.
4001 *
4002 * PARAMETER(S):
4003 * [I] infoPtr : valid pointer to the listview structure
4004 * [I] nItem : item index
4005 * [I] bPartial : partially or entirely visible
4006 *
4007 * RETURN:
4008 * SUCCESS : TRUE
4009 * FAILURE : FALSE
4010 */
4011 static BOOL LISTVIEW_EnsureVisible(LISTVIEW_INFO *infoPtr, INT nItem, BOOL bPartial)
4012 {
4013 UINT uView = LISTVIEW_GetType(infoPtr);
4014 INT nScrollPosHeight = 0;
4015 INT nScrollPosWidth = 0;
4016 SCROLLINFO scrollInfo;
4017 RECT rcItem;
4018 BOOL bRedraw = FALSE;
4019
4020 ZeroMemory(&scrollInfo, sizeof(SCROLLINFO));
4021 scrollInfo.cbSize = sizeof(SCROLLINFO);
4022 scrollInfo.fMask = SIF_POS;
4023
4024 /* ALWAYS bPartial == FALSE, FOR NOW! */
4025
4026 rcItem.left = LVIR_BOUNDS;
4027 if (LISTVIEW_GetItemRect(infoPtr, nItem, &rcItem))
4028 {
4029 if (rcItem.left < infoPtr->rcList.left)
4030 {
4031 if (GetScrollInfo(infoPtr->hwndSelf, SB_HORZ, &scrollInfo))
4032 {
4033 /* scroll left */
4034 bRedraw = TRUE;
4035 if (uView == LVS_LIST)
4036 {
4037 nScrollPosWidth = infoPtr->nItemWidth;
4038 rcItem.left += infoPtr->rcList.left;
4039 }
4040 else if ((uView == LVS_SMALLICON) || (uView == LVS_ICON))
4041 {
4042 nScrollPosWidth = 1;
4043 rcItem.left += infoPtr->rcList.left;
4044 }
4045
4046 /* When in LVS_REPORT view, the scroll position should
4047 not be updated. */
4048 if (nScrollPosWidth != 0)
4049 {
4050 if (rcItem.left % nScrollPosWidth == 0)
4051 scrollInfo.nPos += rcItem.left / nScrollPosWidth;
4052 else
4053 scrollInfo.nPos += rcItem.left / nScrollPosWidth - 1;
4054
4055 SetScrollInfo(infoPtr->hwndSelf, SB_HORZ, &scrollInfo, TRUE);
4056 }
4057 }
4058 }
4059 else if (rcItem.right > infoPtr->rcList.right)
4060 {
4061 if (GetScrollInfo(infoPtr->hwndSelf, SB_HORZ, &scrollInfo))
4062 {
4063 /* scroll right */
4064 bRedraw = TRUE;
4065 if (uView == LVS_LIST)
4066 {
4067 rcItem.right -= infoPtr->rcList.right;
4068 nScrollPosWidth = infoPtr->nItemWidth;
4069 }
4070 else if ((uView == LVS_SMALLICON) || (uView == LVS_ICON))
4071 {
4072 rcItem.right -= infoPtr->rcList.right;
4073 nScrollPosWidth = 1;
4074 }
4075
4076 /* When in LVS_REPORT view, the scroll position should
4077 not be updated. */
4078 if (nScrollPosWidth != 0)
4079 {
4080 if (rcItem.right % nScrollPosWidth == 0)
4081 scrollInfo.nPos += rcItem.right / nScrollPosWidth;
4082 else
4083 scrollInfo.nPos += rcItem.right / nScrollPosWidth + 1;
4084
4085 SetScrollInfo(infoPtr->hwndSelf, SB_HORZ, &scrollInfo, TRUE);
4086 }
4087 }
4088 }
4089
4090 if (rcItem.top < infoPtr->rcList.top)
4091 {
4092 /* scroll up */
4093 bRedraw = TRUE;
4094 if (GetScrollInfo(infoPtr->hwndSelf, SB_VERT, &scrollInfo))
4095 {
4096 if (uView == LVS_REPORT)
4097 {
4098 rcItem.top -= infoPtr->rcList.top;
4099 nScrollPosHeight = infoPtr->nItemHeight;
4100 }
4101 else if ((uView == LVS_ICON) || (uView == LVS_SMALLICON))
4102 {
4103 nScrollPosHeight = 1;
4104 rcItem.top += infoPtr->rcList.top;
4105 }
4106
4107 if (rcItem.top % nScrollPosHeight == 0)
4108 scrollInfo.nPos += rcItem.top / nScrollPosHeight;
4109 else
4110 scrollInfo.nPos += rcItem.top / nScrollPosHeight - 1;
4111
4112 SetScrollInfo(infoPtr->hwndSelf, SB_VERT, &scrollInfo, TRUE);
4113 }
4114 }
4115 else if (rcItem.bottom > infoPtr->rcList.bottom)
4116 {
4117 /* scroll down */
4118 bRedraw = TRUE;
4119 if (GetScrollInfo(infoPtr->hwndSelf, SB_VERT, &scrollInfo))
4120 {
4121 if (uView == LVS_REPORT)
4122 {
4123 rcItem.bottom -= infoPtr->rcList.bottom;
4124 nScrollPosHeight = infoPtr->nItemHeight;
4125 }
4126 else if ((uView == LVS_ICON) || (uView == LVS_SMALLICON))
4127 {
4128 nScrollPosHeight = 1;
4129 rcItem.bottom -= infoPtr->rcList.bottom;
4130 }
4131
4132 if (rcItem.bottom % nScrollPosHeight == 0)
4133 scrollInfo.nPos += rcItem.bottom / nScrollPosHeight;
4134 else
4135 scrollInfo.nPos += rcItem.bottom / nScrollPosHeight + 1;
4136
4137 SetScrollInfo(infoPtr->hwndSelf, SB_VERT, &scrollInfo, TRUE);
4138 }
4139 }
4140 }
4141
4142 if(bRedraw)
4143 InvalidateRect(infoPtr->hwndSelf,NULL,TRUE);
4144 return TRUE;
4145 }
4146
4147 /***
4148 * DESCRIPTION:
4149 * Retrieves the nearest item, given a position and a direction.
4150 *
4151 * PARAMETER(S):
4152 * [I] infoPtr : valid pointer to the listview structure
4153 * [I] POINT : start position
4154 * [I] UINT : direction
4155 *
4156 * RETURN:
4157 * Item index if successdful, -1 otherwise.
4158 */
4159 static INT LISTVIEW_GetNearestItem(LISTVIEW_INFO *infoPtr, POINT pt, UINT vkDirection)
4160 {
4161 LV_INTHIT lvIntHit;
4162 INT nItem = -1;
4163 RECT rcView;
4164
4165 TRACE("point %ld,%ld, direction %s\n", pt.x, pt.y,
4166 (vkDirection == VK_DOWN) ? "VK_DOWN" :
4167 ((vkDirection == VK_UP) ? "VK_UP" :
4168 ((vkDirection == VK_LEFT) ? "VK_LEFT" : "VK_RIGHT")));
4169
4170 if (LISTVIEW_GetViewRect(infoPtr, &rcView))
4171 {
4172 ZeroMemory(&lvIntHit, sizeof(lvIntHit));
4173 LISTVIEW_GetOrigin(infoPtr, &lvIntHit.ht.pt);
4174 lvIntHit.ht.pt.x += pt.x;
4175 lvIntHit.ht.pt.y += pt.y;
4176
4177 if (vkDirection == VK_DOWN)
4178 lvIntHit.ht.pt.y += infoPtr->nItemHeight;
4179 else if (vkDirection == VK_UP)
4180 lvIntHit.ht.pt.y -= infoPtr->nItemHeight;
4181 else if (vkDirection == VK_LEFT)
4182 lvIntHit.ht.pt.x -= infoPtr->nItemWidth;
4183 else if (vkDirection == VK_RIGHT)
4184 lvIntHit.ht.pt.x += infoPtr->nItemWidth;
4185
4186 if (!PtInRect(&rcView, lvIntHit.ht.pt))
4187 return -1;
4188 else
4189 {
4190 nItem = LISTVIEW_SuperHitTestItem(infoPtr, &lvIntHit, TRUE);
4191 return nItem == -1 ? lvIntHit.iDistItem : nItem;
4192 }
4193 }
4194
4195 return nItem;
4196 }
4197
4198 /***
4199 * DESCRIPTION:
4200 * Searches for an item with specific characteristics.
4201 *
4202 * PARAMETER(S):
4203 * [I] hwnd : window handle
4204 * [I] nStart : base item index
4205 * [I] lpFindInfo : item information to look for
4206 *
4207 * RETURN:
4208 * SUCCESS : index of item
4209 * FAILURE : -1
4210 */
4211 static LRESULT LISTVIEW_FindItemW(LISTVIEW_INFO *infoPtr, INT nStart,
4212 LPLVFINDINFOW lpFindInfo)
4213 {
4214 POINT ptItem;
4215 WCHAR szDispText[DISP_TEXT_SIZE] = { '\0' };
4216 LVITEMW lvItem;
4217 BOOL bWrap = FALSE;
4218 INT nItem = nStart;
4219 INT nLast = GETITEMCOUNT(infoPtr);
4220
4221 if ((nItem >= -1) && (lpFindInfo != NULL))
4222 {
4223 ZeroMemory(&lvItem, sizeof(lvItem));
4224
4225 if (lpFindInfo->flags & LVFI_PARAM)
4226 {
4227 lvItem.mask |= LVIF_PARAM;
4228 }
4229
4230 if (lpFindInfo->flags & (LVFI_STRING | LVFI_PARTIAL))
4231 {
4232 lvItem.mask |= LVIF_TEXT;
4233 lvItem.pszText = szDispText;
4234 lvItem.cchTextMax = DISP_TEXT_SIZE;
4235 }
4236
4237 if (lpFindInfo->flags & LVFI_WRAP)
4238 bWrap = TRUE;
4239
4240 if (lpFindInfo->flags & LVFI_NEARESTXY)
4241 {
4242 ptItem.x = lpFindInfo->pt.x;
4243 ptItem.y = lpFindInfo->pt.y;
4244 }
4245
4246 while (1)
4247 {
4248 while (nItem < nLast)
4249 {
4250 if (lpFindInfo->flags & LVFI_NEARESTXY)
4251 {
4252 nItem = LISTVIEW_GetNearestItem(infoPtr, ptItem,
4253 lpFindInfo->vkDirection);
4254 if (nItem != -1)
4255 {
4256 /* get position of the new item index */
4257 if (!ListView_GetItemPosition(infoPtr->hwndSelf, nItem, &ptItem))
4258 return -1;
4259 }
4260 else
4261 return -1;
4262 }
4263 else
4264 {
4265 nItem++;
4266 }
4267
4268 lvItem.iItem = nItem;
4269 lvItem.iSubItem = 0;
4270 if (LISTVIEW_GetItemW(infoPtr, &lvItem, TRUE))
4271 {
4272 if (lvItem.mask & LVIF_TEXT)
4273 {
4274 if (lpFindInfo->flags & LVFI_PARTIAL)
4275 {
4276 if (strstrW(lvItem.pszText, lpFindInfo->psz) == NULL)
4277 continue;
4278 }
4279 else
4280 {
4281 if (lstrcmpW(lvItem.pszText, lpFindInfo->psz) != 0)
4282 continue;
4283 }
4284 }
4285
4286 if (lvItem.mask & LVIF_PARAM)
4287 {
4288 if (lpFindInfo->lParam != lvItem.lParam)
4289 continue;
4290 }
4291
4292 return nItem;
4293 }
4294 }
4295
4296 if (bWrap)
4297 {
4298 nItem = -1;
4299 nLast = nStart + 1;
4300 bWrap = FALSE;
4301 }
4302 else
4303 {
4304 return -1;
4305 }
4306 }
4307 }
4308
4309 return -1;
4310 }
4311
4312 /***
4313 * DESCRIPTION:
4314 * Searches for an item with specific characteristics.
4315 *
4316 * PARAMETER(S):
4317 * [I] hwnd : window handle
4318 * [I] nStart : base item index
4319 * [I] lpFindInfo : item information to look for
4320 *
4321 * RETURN:
4322 * SUCCESS : index of item
4323 * FAILURE : -1
4324 */
4325 static LRESULT LISTVIEW_FindItemA(LISTVIEW_INFO *infoPtr, INT nStart,
4326 LPLVFINDINFOA lpFindInfo)
4327 {
4328 BOOL hasText = lpFindInfo->flags & (LVFI_STRING | LVFI_PARTIAL);
4329 LVFINDINFOW fiw;
4330 LRESULT res;
4331
4332 memcpy(&fiw, lpFindInfo, sizeof(fiw));
4333 if (hasText) fiw.psz = textdupTtoW((LPCWSTR)lpFindInfo->psz, FALSE);
4334 res = LISTVIEW_FindItemW(infoPtr, nStart, &fiw);
4335 if (hasText) textfreeT((LPWSTR)fiw.psz, FALSE);
4336 return res;
4337 }
4338
4339 /***
4340 * DESCRIPTION:
4341 * Retrieves the background image of the listview control.
4342 *
4343 * PARAMETER(S):
4344 * [I] infoPtr : valid pointer to the listview structure
4345 * [O] LPLVMKBIMAGE : background image attributes
4346 *
4347 * RETURN:
4348 * SUCCESS : TRUE
4349 * FAILURE : FALSE
4350 */
4351 /* static LRESULT LISTVIEW_GetBkImage(LISTVIEW_INFO *infoPtr, LPLVBKIMAGE lpBkImage) */
4352 /* { */
4353 /* FIXME (listview, "empty stub!\n"); */
4354 /* return FALSE; */
4355 /* } */
4356
4357 /***
4358 * DESCRIPTION:
4359 * Retrieves column attributes.
4360 *
4361 * PARAMETER(S):
4362 * [I] infoPtr : valid pointer to the listview structure
4363 * [I] INT : column index
4364 * [IO] LPLVCOLUMNW : column information
4365 * [I] isW : if TRUE, then lpColumn is a LPLVCOLUMNW
4366 * otherwise it is in fact a LPLVCOLUMNA
4367 *
4368 * RETURN:
4369 * SUCCESS : TRUE
4370 * FAILURE : FALSE
4371 */
4372 static LRESULT LISTVIEW_GetColumnT(LISTVIEW_INFO *infoPtr, INT nItem, LPLVCOLUMNW lpColumn, BOOL isW)
4373 {
4374 HDITEMW hdi;
4375 BOOL bResult = FALSE;
4376
4377 if (lpColumn != NULL)
4378 {
4379
4380 /* initialize memory */
4381 ZeroMemory(&hdi, sizeof(hdi));
4382
4383 if (lpColumn->mask & LVCF_FMT)
4384 hdi.mask |= HDI_FORMAT;
4385
4386 if (lpColumn->mask & LVCF_WIDTH)
4387 hdi.mask |= HDI_WIDTH;
4388
4389 if (lpColumn->mask & LVCF_TEXT)
4390 {
4391 hdi.mask |= HDI_TEXT;
4392 hdi.cchTextMax = lpColumn->cchTextMax;
4393 hdi.pszText = lpColumn->pszText;
4394 }
4395
4396 if (lpColumn->mask & LVCF_IMAGE)
4397 hdi.mask |= HDI_IMAGE;
4398
4399 if (lpColumn->mask & LVCF_ORDER)
4400 hdi.mask |= HDI_ORDER;
4401
4402 if (isW)
4403 bResult = Header_GetItemW(infoPtr->hwndHeader, nItem, &hdi);
4404 else
4405 bResult = Header_GetItemA(infoPtr->hwndHeader, nItem, &hdi);
4406
4407 if (bResult)
4408 {
4409 if (lpColumn->mask & LVCF_FMT)
4410 {
4411 lpColumn->fmt = 0;
4412
4413 if (hdi.fmt & HDF_LEFT)
4414 lpColumn->fmt |= LVCFMT_LEFT;
4415 else if (hdi.fmt & HDF_RIGHT)
4416 lpColumn->fmt |= LVCFMT_RIGHT;
4417 else if (hdi.fmt & HDF_CENTER)
4418 lpColumn->fmt |= LVCFMT_CENTER;
4419
4420 if (hdi.fmt & HDF_IMAGE)
4421 lpColumn->fmt |= LVCFMT_COL_HAS_IMAGES;
4422
4423 if (hdi.fmt & HDF_BITMAP_ON_RIGHT)
4424 lpColumn->fmt |= LVCFMT_BITMAP_ON_RIGHT;
4425 }
4426
4427 if (lpColumn->mask & LVCF_WIDTH)
4428 lpColumn->cx = hdi.cxy;
4429
4430 if (lpColumn->mask & LVCF_IMAGE)
4431 lpColumn->iImage = hdi.iImage;
4432
4433 if (lpColumn->mask & LVCF_ORDER)
4434 lpColumn->iOrder = hdi.iOrder;
4435
4436 TRACE("(col=%d, lpColumn=%s, isW=%d)\n",
4437 nItem, debuglvcolumn_t(lpColumn, isW), isW);
4438
4439 }
4440 }
4441
4442 return bResult;
4443 }
4444
4445
4446 static LRESULT LISTVIEW_GetColumnOrderArray(LISTVIEW_INFO *infoPtr, INT iCount, LPINT lpiArray)
4447 {
4448 INT i;
4449
4450 if (!lpiArray)
4451 return FALSE;
4452
4453 /* FIXME: little hack */
4454 for (i = 0; i < iCount; i++)
4455 lpiArray[i] = i;
4456
4457 return TRUE;
4458 }
4459
4460 /***
4461 * DESCRIPTION:
4462 * Retrieves the column width.
4463 *
4464 * PARAMETER(S):
4465 * [I] infoPtr : valid pointer to the listview structure
4466 * [I] int : column index
4467 *
4468 * RETURN:
4469 * SUCCESS : column width
4470 * FAILURE : zero
4471 */
4472 static LRESULT LISTVIEW_GetColumnWidth(LISTVIEW_INFO *infoPtr, INT nColumn)
4473 {
4474 UINT uView = LISTVIEW_GetType(infoPtr);
4475 INT nColumnWidth = 0;
4476 HDITEMW hdi;
4477
4478 if (uView == LVS_LIST)
4479 {
4480 nColumnWidth = infoPtr->nItemWidth;
4481 }
4482 else if (uView == LVS_REPORT)
4483 {
4484 /* get column width from header */
4485 ZeroMemory(&hdi, sizeof(hdi));
4486 hdi.mask = HDI_WIDTH;
4487 if (Header_GetItemW(infoPtr->hwndHeader, nColumn, &hdi))
4488 nColumnWidth = hdi.cxy;
4489 }
4490
4491 return nColumnWidth;
4492 }
4493
4494 /***
4495 * DESCRIPTION:
4496 * In list or report display mode, retrieves the number of items that can fit
4497 * vertically in the visible area. In icon or small icon display mode,
4498 * retrieves the total number of visible items.
4499 *
4500 * PARAMETER(S):
4501 * [I] infoPtr : valid pointer to the listview structure
4502 *
4503 * RETURN:
4504 * Number of fully visible items.
4505 */
4506 static LRESULT LISTVIEW_GetCountPerPage(LISTVIEW_INFO *infoPtr)
4507 {
4508 UINT uView = LISTVIEW_GetType(infoPtr);
4509 INT nItemCount = 0;
4510
4511 if (uView == LVS_LIST)
4512 {
4513 if (infoPtr->rcList.right > infoPtr->nItemWidth)
4514 {
4515 nItemCount = LISTVIEW_GetCountPerRow(infoPtr) *
4516 LISTVIEW_GetCountPerColumn(infoPtr);
4517 }
4518 }
4519 else if (uView == LVS_REPORT)
4520 {
4521 nItemCount = LISTVIEW_GetCountPerColumn(infoPtr);
4522 }
4523 else
4524 {
4525 nItemCount = GETITEMCOUNT(infoPtr);
4526 }
4527
4528 return nItemCount;
4529 }
4530
4531
4532 /***
4533 * DESCRIPTION:
4534 * Retrieves an image list handle.
4535 *
4536 * PARAMETER(S):
4537 * [I] infoPtr : valid pointer to the listview structure
4538 * [I] INT : image list identifier
4539 *
4540 * RETURN:
4541 * SUCCESS : image list handle
4542 * FAILURE : NULL
4543 */
4544 static LRESULT LISTVIEW_GetImageList(LISTVIEW_INFO *infoPtr, INT nImageList)
4545 {
4546 HIMAGELIST himl = NULL;
4547
4548 switch (nImageList)
4549 {
4550 case LVSIL_NORMAL:
4551 himl = infoPtr->himlNormal;
4552 break;
4553 case LVSIL_SMALL:
4554 himl = infoPtr->himlSmall;
4555 break;
4556 case LVSIL_STATE:
4557 himl = infoPtr->himlState;
4558 break;
4559 }
4560
4561 return (LRESULT)himl;
4562 }
4563
4564 /* LISTVIEW_GetISearchString */
4565
4566 /***
4567 * Helper function for LISTVIEW_GetItemT *only*. Tests if an item is selected.
4568 * It is important that no other functions call this because of callbacks.
4569 */
4570 static inline BOOL is_item_selected(LISTVIEW_INFO *infoPtr, INT nItem)
4571 {
4572 LISTVIEW_SELECTION selection = { nItem, nItem };
4573
4574 return DPA_Search(infoPtr->hdpaSelectionRanges, &selection, 0,
4575 LISTVIEW_CompareSelectionRanges, 0, DPAS_SORTED) != -1;
4576 }
4577
4578 /***
4579 * DESCRIPTION:
4580 * Retrieves item attributes.
4581 *
4582 * PARAMETER(S):
4583 * [I] hwnd : window handle
4584 * [IO] lpLVItem : item info
4585 * [I] internal : if true then we will use tricks that avoid copies
4586 * but are not compatible with the regular interface
4587 * [I] isW : if TRUE, then lpLVItem is a LPLVITEMW,
4588 * if FALSE, the lpLVItem is a LPLVITEMA.
4589 *
4590 * RETURN:
4591 * SUCCESS : TRUE
4592 * FAILURE : FALSE
4593 */
4594 static LRESULT LISTVIEW_GetItemT(LISTVIEW_INFO *infoPtr, LPLVITEMW lpLVItem, BOOL internal, BOOL isW)
4595 {
4596 NMLVDISPINFOW dispInfo;
4597 LISTVIEW_ITEM *lpItem;
4598 ITEMHDR* pItemHdr;
4599 HDPA hdpaSubItems;
4600
4601 if (internal && !isW)
4602 {
4603 ERR("We can't have internal non-Unicode GetItem!\n");
4604 return FALSE;
4605 }
4606
4607 /* In the following:
4608 * lpLVItem describes the information requested by the user
4609 * lpItem is what we have
4610 * dispInfo is a structure we use to request the missing
4611 * information from the application
4612 */
4613
4614 TRACE("(lpLVItem=%s, internal=%d, isW=%d)\n",
4615 debuglvitem_t(lpLVItem, isW), internal, isW);
4616
4617 if (!lpLVItem || (lpLVItem->iItem < 0) ||
4618 (lpLVItem->iItem >= GETITEMCOUNT(infoPtr)))
4619 return FALSE;
4620
4621 /* a quick optimization if all we're asked is the focus state
4622 * these queries are worth optimising since they are common,
4623 * and can be answered in constant time, without the heavy accesses */
4624 if ( (lpLVItem->mask == LVIF_STATE) && (lpLVItem->stateMask == LVIF_STATE) &&
4625 !(infoPtr->uCallbackMask & LVIS_FOCUSED) )
4626 {
4627 lpLVItem->state = 0;
4628 if (infoPtr->nFocusedItem == lpLVItem->iItem)
4629 lpLVItem->state |= LVIS_FOCUSED;
4630 return TRUE;
4631 }
4632
4633 ZeroMemory(&dispInfo, sizeof(dispInfo));
4634
4635 /* if the app stores all the data, handle it separately */
4636 if (GetWindowLongW(infoPtr->hwndSelf, GWL_STYLE) & LVS_OWNERDATA)
4637 {
4638 dispInfo.item.state = 0;
4639
4640 /* if we need to callback, do it now */
4641 if ((lpLVItem->mask & ~LVIF_STATE) || infoPtr->uCallbackMask)
4642 {
4643 memcpy(&dispInfo.item, lpLVItem, sizeof(LVITEMW));
4644 dispInfo.item.stateMask &= infoPtr->uCallbackMask;
4645 dispinfo_notifyT(infoPtr, LVN_GETDISPINFOW, &dispInfo, isW);
4646 memcpy(lpLVItem, &dispInfo.item, sizeof(LVITEMW));
4647 TRACE(" getdispinfo(1):lpLVItem=%s\n", debuglvitem_t(lpLVItem, isW));
4648 }
4649
4650 /* we store only a little state, so if we're not asked, we're done */
4651 if (!(lpLVItem->mask & LVIF_STATE) || lpLVItem->iSubItem) return FALSE;
4652
4653 /* if focus is handled by us, report it */
4654 if ( !(infoPtr->uCallbackMask & LVIS_FOCUSED) )
4655 {
4656 lpLVItem->state &= ~LVIS_FOCUSED;
4657 if (infoPtr->nFocusedItem == lpLVItem->iItem)
4658 lpLVItem->state |= LVIS_FOCUSED;
4659 }
4660
4661 /* and do the same for selection, if we handle it */
4662 if ( !(infoPtr->uCallbackMask & LVIS_SELECTED) )
4663 {
4664 lpLVItem->state &= ~LVIS_SELECTED;
4665 if ((lpLVItem->stateMask & LVIS_SELECTED) &&
4666 is_item_selected(infoPtr, lpLVItem->iItem))
4667 lpLVItem->state |= LVIS_SELECTED;
4668 }
4669
4670 return TRUE;
4671 }
4672
4673 /* find the item and subitem structures before we proceed */
4674 hdpaSubItems = (HDPA)DPA_GetPtr(infoPtr->hdpaItems, lpLVItem->iItem);
4675 if (hdpaSubItems == NULL) return FALSE;
4676
4677 if ( !(lpItem = (LISTVIEW_ITEM *)DPA_GetPtr(hdpaSubItems, 0)) )
4678 return FALSE;
4679
4680 if (lpLVItem->iSubItem)
4681 {
4682 LISTVIEW_SUBITEM *lpSubItem = LISTVIEW_GetSubItemPtr(hdpaSubItems, lpLVItem->iSubItem);
4683 if(!lpSubItem) return FALSE;
4684 pItemHdr = &lpSubItem->hdr;
4685 }
4686 else
4687 pItemHdr = &lpItem->hdr;
4688
4689 /* Do we need to query the state from the app? */
4690 if ((lpLVItem->mask & LVIF_STATE) && infoPtr->uCallbackMask && lpLVItem->iSubItem == 0)
4691 {
4692 dispInfo.item.mask |= LVIF_STATE;
4693 dispInfo.item.stateMask = infoPtr->uCallbackMask;
4694 }
4695
4696 /* Do we need to enquire about the image? */
4697 if ((lpLVItem->mask & LVIF_IMAGE) && (pItemHdr->iImage==I_IMAGECALLBACK))
4698 dispInfo.item.mask |= LVIF_IMAGE;
4699
4700 /* Do we need to enquire about the text? */
4701 if ((lpLVItem->mask & LVIF_TEXT) && !is_textW(pItemHdr->pszText))
4702 {
4703 dispInfo.item.mask |= LVIF_TEXT;
4704 dispInfo.item.pszText = lpLVItem->pszText;
4705 dispInfo.item.cchTextMax = lpLVItem->cchTextMax;
4706 if (dispInfo.item.pszText && dispInfo.item.cchTextMax > 0)
4707 *dispInfo.item.pszText = '\0';
4708 }
4709
4710 /* If we don't have all the requested info, query the application */
4711 if (dispInfo.item.mask != 0)
4712 {
4713 dispInfo.item.iItem = lpLVItem->iItem;
4714 dispInfo.item.iSubItem = lpLVItem->iSubItem;
4715 dispInfo.item.lParam = lpItem->lParam;
4716 dispinfo_notifyT(infoPtr, LVN_GETDISPINFOW, &dispInfo, isW);
4717 TRACE(" getdispinfo(2):item=%s\n", debuglvitem_t(&dispInfo.item, isW));
4718 }
4719
4720 /* Now, handle the iImage field */
4721 if (dispInfo.item.mask & LVIF_IMAGE)
4722 {
4723 lpLVItem->iImage = dispInfo.item.iImage;
4724 if ((dispInfo.item.mask & LVIF_DI_SETITEM) && (pItemHdr->iImage==I_IMAGECALLBACK))
4725 pItemHdr->iImage = dispInfo.item.iImage;
4726 }
4727 else if (lpLVItem->mask & LVIF_IMAGE)
4728 lpLVItem->iImage = pItemHdr->iImage;
4729
4730 /* The pszText field */
4731 if (dispInfo.item.mask & LVIF_TEXT)
4732 {
4733 if ((dispInfo.item.mask & LVIF_DI_SETITEM) && pItemHdr->pszText)
4734 textsetptrT(&pItemHdr->pszText, dispInfo.item.pszText, isW);
4735
4736 /* If lpLVItem->pszText==dispInfo.item.pszText a copy is unnecessary, but */
4737 /* some apps give a new pointer in ListView_Notify so we can't be sure. */
4738 if (lpLVItem->pszText != dispInfo.item.pszText)
4739 textcpynT(lpLVItem->pszText, isW, dispInfo.item.pszText, isW, lpLVItem->cchTextMax);
4740 }
4741 else if (lpLVItem->mask & LVIF_TEXT)
4742 {
4743 if (internal) lpLVItem->pszText = pItemHdr->pszText;
4744 else textcpynT(lpLVItem->pszText, isW, pItemHdr->pszText, TRUE, lpLVItem->cchTextMax);
4745 }
4746
4747 /* if this is a subitem, we're done*/
4748 if (lpLVItem->iSubItem) return TRUE;
4749
4750 /* Next is the lParam field */
4751 if (dispInfo.item.mask & LVIF_PARAM)
4752 {
4753 lpLVItem->lParam = dispInfo.item.lParam;
4754 if ((dispInfo.item.mask & LVIF_DI_SETITEM))
4755 lpItem->lParam = dispInfo.item.lParam;
4756 }
4757 else if (lpLVItem->mask & LVIF_PARAM)
4758 lpLVItem->lParam = lpItem->lParam;
4759
4760 /* ... the state field (this one is different due to uCallbackmask) */
4761 if (lpLVItem->mask & LVIF_STATE)
4762 {
4763 lpLVItem->state = lpItem->state;
4764 if (dispInfo.item.mask & LVIF_STATE)
4765 {
4766 lpLVItem->state &= ~dispInfo.item.stateMask;
4767 lpLVItem->state |= (dispInfo.item.state & dispInfo.item.stateMask);
4768 }
4769 if ( !(infoPtr->uCallbackMask & LVIS_FOCUSED) )
4770 {
4771 lpLVItem->state &= ~LVIS_FOCUSED;
4772 if (infoPtr->nFocusedItem == lpLVItem->iItem)
4773 lpLVItem->state |= LVIS_FOCUSED;
4774 }
4775 if ( !(infoPtr->uCallbackMask & LVIS_SELECTED) )
4776 {
4777 lpLVItem->state &= ~LVIS_SELECTED;
4778 if ((lpLVItem->stateMask & LVIS_SELECTED) &&
4779 is_item_selected(infoPtr, lpLVItem->iItem))
4780 lpLVItem->state |= LVIS_SELECTED;
4781 }
4782 }
4783
4784 /* and last, but not least, the indent field */
4785 if (lpLVItem->mask & LVIF_INDENT)
4786 lpLVItem->iIndent = lpItem->iIndent;
4787
4788 return TRUE;
4789 }
4790
4791
4792 /***
4793 * DESCRIPTION:
4794 * Retrieves the rectangle enclosing the item icon and text.
4795 *
4796 * PARAMETER(S):
4797 * [I] infoPtr : valid pointer to the listview structure
4798 * [I] INT : item index
4799 * [O] LPRECT : coordinate information
4800 *
4801 * RETURN:
4802 * SUCCESS : TRUE
4803 * FAILURE : FALSE
4804 */
4805 static BOOL LISTVIEW_GetItemBoundBox(LISTVIEW_INFO *infoPtr, INT nItem, LPRECT lpRect)
4806 {
4807 LONG lStyle = GetWindowLongW(infoPtr->hwndSelf, GWL_STYLE);
4808 UINT uView = lStyle & LVS_TYPEMASK;
4809 BOOL bResult = FALSE;
4810 HDPA hdpaSubItems;
4811 LISTVIEW_ITEM *lpItem;
4812 INT nCountPerColumn;
4813 INT nRow;
4814
4815 TRACE("(nItem=%d,lpRect=%p)\n", nItem, lpRect);
4816
4817 if ((nItem >= 0) && (nItem < GETITEMCOUNT(infoPtr)) &&
4818 (lpRect != NULL))
4819 {
4820 if (uView == LVS_LIST)
4821 {
4822 bResult = TRUE;
4823 nItem = nItem - ListView_GetTopIndex(infoPtr->hwndSelf);
4824 nCountPerColumn = LISTVIEW_GetCountPerColumn(infoPtr);
4825 if (nItem < 0)
4826 {
4827 nRow = nItem % nCountPerColumn;
4828 if (nRow == 0)
4829 {
4830 lpRect->left = nItem / nCountPerColumn * infoPtr->nItemWidth;
4831 lpRect->top = 0;
4832 }
4833 else
4834 {
4835 lpRect->left = (nItem / nCountPerColumn -1) * infoPtr->nItemWidth;
4836 lpRect->top = (nRow + nCountPerColumn) * infoPtr->nItemHeight;
4837 }
4838 }
4839 else
4840 {
4841 lpRect->left = nItem / nCountPerColumn * infoPtr->nItemWidth;
4842 lpRect->top = nItem % nCountPerColumn * infoPtr->nItemHeight;
4843 }
4844 }
4845 else if (uView == LVS_REPORT)
4846 {
4847 bResult = TRUE;
4848 lpRect->left = REPORT_MARGINX;
4849 lpRect->top = ((nItem - ListView_GetTopIndex(infoPtr->hwndSelf)) *
4850 infoPtr->nItemHeight) + infoPtr->rcList.top;
4851
4852 if (!(lStyle & LVS_NOSCROLL))
4853 {
4854 SCROLLINFO scrollInfo;
4855 /* Adjust position by scrollbar offset */
4856 ZeroMemory(&scrollInfo, sizeof(SCROLLINFO));
4857 scrollInfo.cbSize = sizeof(SCROLLINFO);
4858 scrollInfo.fMask = SIF_POS;
4859 GetScrollInfo(infoPtr->hwndSelf, SB_HORZ, &scrollInfo);
4860 lpRect->left -= scrollInfo.nPos;
4861 }
4862 }
4863 else /* either LVS_ICON or LVS_SMALLICON */
4864 {
4865 if ((hdpaSubItems = (HDPA)DPA_GetPtr(infoPtr->hdpaItems, nItem)))
4866 {
4867 if ((lpItem = (LISTVIEW_ITEM *)DPA_GetPtr(hdpaSubItems, 0)))
4868 {
4869 bResult = TRUE;
4870 lpRect->left = lpItem->ptPosition.x;
4871 lpRect->top = lpItem->ptPosition.y;
4872 }
4873 }
4874 }
4875 }
4876 lpRect->right = lpRect->left + infoPtr->nItemWidth;
4877 lpRect->bottom = lpRect->top + infoPtr->nItemHeight;
4878 TRACE("result %s: (%d,%d)-(%d,%d)\n", bResult ? "TRUE" : "FALSE",
4879 lpRect->left, lpRect->top, lpRect->right, lpRect->bottom);
4880 return bResult;
4881 }
4882
4883 /***
4884 * DESCRIPTION:
4885 * Retrieves the position (upper-left) of the listview control item.
4886 * Note that for LVS_ICON style, the upper-left is that of the icon
4887 * and not the bounding box.
4888 *
4889 * PARAMETER(S):
4890 * [I] infoPtr : valid pointer to the listview structure
4891 * [I] INT : item index
4892 * [O] LPPOINT : coordinate information
4893 *
4894 * RETURN:
4895 * SUCCESS : TRUE
4896 * FAILURE : FALSE
4897 */
4898 static BOOL LISTVIEW_GetItemPosition(LISTVIEW_INFO *infoPtr, INT nItem, LPPOINT lpptPosition)
4899 {
4900 UINT uView = LISTVIEW_GetType(infoPtr);
4901 BOOL bResult = FALSE;
4902 RECT rcBounding;
4903
4904 TRACE("(nItem=%d, lpptPosition=%p)\n", nItem, lpptPosition);
4905
4906 if ((nItem >= 0) && (nItem < GETITEMCOUNT(infoPtr)) &&
4907 (lpptPosition != NULL))
4908 {
4909 bResult = LISTVIEW_GetItemBoundBox(infoPtr, nItem, &rcBounding);
4910 lpptPosition->x = rcBounding.left;
4911 lpptPosition->y = rcBounding.top;
4912 if (uView == LVS_ICON)
4913 {
4914 lpptPosition->y += ICON_TOP_PADDING;
4915 lpptPosition->x += (infoPtr->iconSpacing.cx - infoPtr->iconSize.cx) / 2;
4916 }
4917 TRACE("result %s (%ld,%ld)\n", bResult ? "TRUE" : "FALSE",
4918 lpptPosition->x, lpptPosition->y);
4919 }
4920 return bResult;
4921 }
4922
4923 /***
4924 * Adjust a text rectangle to an integral number of text lines.
4925 */
4926 static void LISTVIEW_GetIntegralLines(
4927 const LISTVIEW_INFO *infoPtr,
4928 RECT *rcText)
4929 {
4930 INT i, j, k, l;
4931
4932 /*
4933 * We need to have the bottom to be an intergal number of
4934 * text lines (ntmHeight) below text top that is less than
4935 * or equal to the nItemHeight.
4936 */
4937 i = infoPtr->nItemHeight - infoPtr->iconSize.cy -
4938 ICON_TOP_PADDING - ICON_BOTTOM_PADDING;
4939 j = i / infoPtr->ntmHeight;
4940 k = j * infoPtr->ntmHeight;
4941 l = rcText->top + k;
4942 rcText->bottom = min(rcText->bottom, l);
4943 rcText->bottom += 1;
4944
4945 TRACE("integral lines, nitemH=%d, ntmH=%d, icon.cy=%ld, i=%d, j=%d, k=%d, rect=(%d,%d)-(%d,%d)\n",
4946 infoPtr->nItemHeight, infoPtr->ntmHeight, infoPtr->iconSize.cy,
4947 i, j, k,
4948 rcText->left, rcText->top, rcText->right, rcText->bottom);
4949 }
4950
4951
4952 /***
4953 * DESCRIPTION: [INTERNAL]
4954 * Update the bounding rectangle around the text under a large icon.
4955 * This depends on whether it has the focus or not.
4956 * On entry the rectangle's top, left and right should be set.
4957 * On return the bottom will also be set and the width may have been
4958 * modified.
4959 *
4960 * PARAMETER
4961 * [I] infoPtr : pointer to the listview structure
4962 * [I] nItem : the item for which we are calculating this
4963 * [I] rect : the rectangle to be updated
4964 *
4965 * This appears to be weird, even in the Microsoft implementation.
4966 */
4967 static void LISTVIEW_UpdateLargeItemLabelRect (LISTVIEW_INFO *infoPtr, int nItem, RECT *rect)
4968 {
4969 HDC hdc = GetDC (infoPtr->hwndSelf);
4970 HFONT hOldFont = SelectObject (hdc, infoPtr->hFont);
4971 UINT uFormat = LISTVIEW_DTFLAGS | DT_CALCRECT;
4972 RECT rcText = *rect;
4973 RECT rcBack = *rect;
4974 BOOL focused, selected;
4975 int dx, dy, old_wid, new_wid;
4976
4977 TRACE("%s, focus item=%d, cur item=%d\n",
4978 (infoPtr->bFocus) ? "Window has focus" : "Window not focused",
4979 infoPtr->nFocusedItem, nItem);
4980
4981
4982 focused = infoPtr->bFocus && LISTVIEW_GetItemState(infoPtr, nItem, LVIS_FOCUSED);
4983 selected = LISTVIEW_GetItemState(infoPtr, nItem, LVIS_SELECTED);
4984
4985 uFormat |= (focused) ? DT_NOCLIP : DT_WORD_ELLIPSIS | DT_END_ELLIPSIS;
4986
4987 if (focused || selected)
4988 {
4989 /* We (aim to) display the full text. In Windows 95 it appears to
4990 * calculate the size assuming the specified font and then it draws
4991 * the text in that region with the specified font except scaled to
4992 * 10 point (or the height of the system font or ...). Thus if the
4993 * window has 24 point Helvetica the highlit rectangle will be
4994 * taller than the text and if it is 7 point Helvetica then the text
4995 * will be clipped.
4996 * For now we will simply say that it is the correct size to display
4997 * the text in the specified font.
4998 */
4999 LVITEMW lvItem;
5000 lvItem.mask = LVIF_TEXT;
5001 lvItem.iItem = nItem;
5002 lvItem.iSubItem = 0;
5003 /* We will specify INTERNAL and so will receive back a const
5004 * pointer to the text, rather than specifying a buffer to which
5005 * to copy it.
5006 */
5007 LISTVIEW_GetItemW (infoPtr, &lvItem, TRUE);
5008
5009 InflateRect(&rcText, -2, 0);
5010 DrawTextW (hdc, lvItem.pszText, -1, &rcText, uFormat);
5011 /* Microsoft, in their great wisdom, have decided that the rectangle
5012 * returned by DrawText on DT_CALCRECT will only guarantee the dimension,
5013 * not the location. So we have to do the centring ourselves (and take
5014 * responsibility for agreeing off-by-one consistency with them).
5015 */
5016
5017 old_wid = rcText.right - rcText.left;
5018 new_wid = rcBack.right - rcBack.left;
5019 dx = rcBack.left - rcText.left + (new_wid-old_wid)/2;
5020 dy = rcBack.top - rcText.top;
5021 OffsetRect (&rcText, dx, dy);
5022
5023 if (!focused)
5024 {
5025 LISTVIEW_GetIntegralLines(infoPtr, &rcText);
5026 }
5027 else
5028 {
5029 rcText.bottom += LABEL_VERT_PADDING - 2;
5030 }
5031 *rect = rcBack;
5032 rect->bottom = rcText.bottom;
5033 }
5034 else
5035 {
5036 /* As far as I can see the text region seems to be trying to be
5037 * "tall enough for two lines of text". Once again (comctl32.dll ver
5038 * 5.81?) it measures this on the basis of the selected font and then
5039 * draws it with the same font except in 10 point size. This can lead
5040 * to more or less than the two rows appearing.
5041 * Question; are we supposed to be including DT_EXTERNALLEADING?
5042 * Question; should the width be shrunk to the space required to
5043 * display the two lines?
5044 */
5045 LISTVIEW_GetIntegralLines(infoPtr, &rcText);
5046 rect->bottom = rcText.bottom;
5047 }
5048
5049 TRACE("%s and %s, bounding rect=(%d,%d)-(%d,%d)\n",
5050 (focused) ? "focused(full text)" : "not focused",
5051 (selected) ? "selected" : "not selected",
5052 rect->left, rect->top, rect->right, rect->bottom);
5053
5054 SelectObject (hdc, hOldFont);
5055 ReleaseDC (infoPtr->hwndSelf, hdc);
5056 }
5057
5058 /***
5059 * DESCRIPTION:
5060 * Retrieves the bounding rectangle for a listview control item.
5061 *
5062 * PARAMETER(S):
5063 * [I] infoPtr : valid pointer to the listview structure
5064 * [I] INT : item index
5065 * [IO] LPRECT : bounding rectangle coordinates
5066 * lprc->left specifies the portion of the item for which the bounding
5067 * rectangle will be retrieved.
5068 *
5069 * LVIR_BOUNDS Returns the bounding rectangle of the entire item,
5070 * including the icon and label.
5071 * *
5072 * * For LVS_ICON
5073 * * Experiment shows that native control returns:
5074 * * width = min (48, length of text line)
5075 * * .left = position.x - (width - iconsize.cx)/2
5076 * * .right = .left + width
5077 * * height = #lines of text * ntmHeight + icon height + 8
5078 * * .top = position.y - 2
5079 * * .bottom = .top + height
5080 * * separation between items .y = itemSpacing.cy - height
5081 * * .x = itemSpacing.cx - width
5082 * LVIR_ICON Returns the bounding rectangle of the icon or small icon.
5083 * *
5084 * * For LVS_ICON
5085 * * Experiment shows that native control returns:
5086 * * width = iconSize.cx + 16
5087 * * .left = position.x - (width - iconsize.cx)/2
5088 * * .right = .left + width
5089 * * height = iconSize.cy + 4
5090 * * .top = position.y - 2
5091 * * .bottom = .top + height
5092 * * separation between items .y = itemSpacing.cy - height
5093 * * .x = itemSpacing.cx - width
5094 * LVIR_LABEL Returns the bounding rectangle of the item text.
5095 * *
5096 * * For LVS_ICON
5097 * * Experiment shows that native control returns:
5098 * * width = text length
5099 * * .left = position.x - width/2
5100 * * .right = .left + width
5101 * * height = ntmH * linecount + 2
5102 * * .top = position.y + iconSize.cy + 6
5103 * * .bottom = .top + height
5104 * * separation between items .y = itemSpacing.cy - height
5105 * * .x = itemSpacing.cx - width
5106 * LVIR_SELECTBOUNDS Returns the union of the LVIR_ICON and LVIR_LABEL
5107 * rectangles, but excludes columns in report view.
5108 *
5109 * RETURN:
5110 * SUCCESS : TRUE
5111 * FAILURE : FALSE
5112 *
5113 * NOTES
5114 * Note that the bounding rectangle of the label in the LVS_ICON view depends
5115 * upon whether the window has the focus currently and on whether the item
5116 * is the one with the focus. Ensure that the control's record of which
5117 * item has the focus agrees with the items' records.
5118 */
5119 static LRESULT LISTVIEW_GetItemRect(LISTVIEW_INFO *infoPtr, INT nItem, LPRECT lprc)
5120 {
5121 UINT uView = LISTVIEW_GetType(infoPtr);
5122 BOOL bResult = FALSE;
5123 POINT ptOrigin;
5124 POINT ptItem;
5125 INT nLeftPos;
5126 INT nLabelWidth;
5127 INT nIndent;
5128 LVITEMW lvItem;
5129 RECT rcInternal;
5130
5131 TRACE("(hwnd=%x, nItem=%d, lprc=%p, uview=%d)\n",
5132 infoPtr->hwndSelf, nItem, lprc, uView);
5133
5134 if (uView & LVS_REPORT)
5135 {
5136 ZeroMemory(&lvItem, sizeof(lvItem));
5137 lvItem.mask = LVIF_INDENT;
5138 lvItem.iItem = nItem;
5139 lvItem.iSubItem = 0;
5140 LISTVIEW_GetItemW(infoPtr, &lvItem, TRUE);
5141
5142 /* do indent */
5143 if (lvItem.iIndent>0 && infoPtr->iconSize.cx > 0)
5144 nIndent = infoPtr->iconSize.cx * lvItem.iIndent;
5145 else
5146 nIndent = 0;
5147 }
5148 else
5149 nIndent = 0;
5150
5151 if ((nItem >= 0) && (nItem < GETITEMCOUNT(infoPtr)) && (lprc != NULL))
5152 {
5153 switch(lprc->left)
5154 {
5155 case LVIR_ICON:
5156 if (!LISTVIEW_GetItemPosition(infoPtr, nItem, &ptItem)) break;
5157 if (uView == LVS_ICON)
5158 {
5159 if (infoPtr->himlNormal != NULL)
5160 {
5161 if (LISTVIEW_GetOrigin(infoPtr, &ptOrigin))
5162 {
5163 bResult = TRUE;
5164 lprc->left = ptItem.x + ptOrigin.x - 8;
5165 lprc->top = ptItem.y + ptOrigin.y - ICON_TOP_PADDING;
5166 lprc->right = lprc->left + infoPtr->iconSize.cx + 16;
5167 lprc->bottom = lprc->top + infoPtr->iconSize.cy +
5168 ICON_TOP_PADDING;
5169 }
5170 }
5171 }
5172 else if (uView == LVS_SMALLICON)
5173 {
5174 if (LISTVIEW_GetOrigin(infoPtr, &ptOrigin))
5175 {
5176 bResult = TRUE;
5177 lprc->left = ptItem.x + ptOrigin.x;
5178 lprc->top = ptItem.y + ptOrigin.y;
5179 lprc->bottom = lprc->top + infoPtr->nItemHeight;
5180
5181 if (infoPtr->himlState != NULL)
5182 lprc->left += infoPtr->iconSize.cx;
5183
5184 if (infoPtr->himlSmall != NULL)
5185 lprc->right = lprc->left + infoPtr->iconSize.cx;
5186 else
5187 lprc->right = lprc->left;
5188 }
5189 }
5190 else
5191 {
5192 bResult = TRUE;
5193 lprc->left = ptItem.x;
5194 if (uView & LVS_REPORT)
5195 lprc->left += nIndent;
5196 lprc->top = ptItem.y;
5197 lprc->bottom = lprc->top + infoPtr->nItemHeight;
5198
5199 if (infoPtr->himlState != NULL)
5200 lprc->left += infoPtr->iconSize.cx;
5201
5202 if (infoPtr->himlSmall != NULL)
5203 lprc->right = lprc->left + infoPtr->iconSize.cx;
5204 else
5205 lprc->right = lprc->left;
5206 }
5207 break;
5208
5209 case LVIR_LABEL:
5210 if (!LISTVIEW_GetItemPosition(infoPtr, nItem, &ptItem)) break;
5211 if (uView == LVS_ICON)
5212 {
5213 if (infoPtr->himlNormal != NULL)
5214 {
5215 if (LISTVIEW_GetOrigin(infoPtr, &ptOrigin))
5216 {
5217 bResult = TRUE;
5218
5219 /* Correct ptItem to icon upper-left */
5220 ptItem.x -= (infoPtr->nItemWidth - infoPtr->iconSize.cx)/2;
5221 ptItem.y -= ICON_TOP_PADDING;
5222
5223 lprc->left = ptItem.x + ptOrigin.x;
5224 lprc->top = ptItem.y + ptOrigin.y + infoPtr->iconSize.cy +
5225 6;
5226 nLabelWidth = LISTVIEW_GetLabelWidth(infoPtr, nItem);
5227 if (infoPtr->iconSpacing.cx - nLabelWidth > 1)
5228 {
5229 lprc->left += (infoPtr->iconSpacing.cx - nLabelWidth) / 2;
5230 lprc->right = lprc->left + nLabelWidth;
5231 lprc->bottom = lprc->top + infoPtr->ntmHeight + 1;
5232 InflateRect(lprc, 2, 0);
5233 }
5234 else
5235 {
5236 lprc->right = lprc->left + infoPtr->iconSpacing.cx - 1;
5237 lprc->bottom = lprc->top + infoPtr->nItemHeight;
5238 LISTVIEW_UpdateLargeItemLabelRect (infoPtr, nItem, lprc);
5239 }
5240 lprc->bottom += HEIGHT_PADDING;
5241 }
5242 }
5243 }
5244 else if (uView == LVS_SMALLICON)
5245 {
5246 if (LISTVIEW_GetOrigin(infoPtr, &ptOrigin))
5247 {
5248 bResult = TRUE;
5249 nLeftPos = lprc->left = ptItem.x + ptOrigin.x;
5250 lprc->top = ptItem.y + ptOrigin.y;
5251 lprc->bottom = lprc->top + infoPtr->nItemHeight;
5252
5253 if (infoPtr->himlState != NULL)
5254 lprc->left += infoPtr->iconSize.cx;
5255
5256 if (infoPtr->himlSmall != NULL)
5257 lprc->left += infoPtr->iconSize.cx;
5258
5259 nLabelWidth = LISTVIEW_GetLabelWidth(infoPtr, nItem);
5260 nLabelWidth += TRAILING_PADDING;
5261 if (lprc->left + nLabelWidth < nLeftPos + infoPtr->nItemWidth)
5262 lprc->right = lprc->left + nLabelWidth;
5263 else
5264 lprc->right = nLeftPos + infoPtr->nItemWidth;
5265 }
5266 }
5267 else
5268 {
5269 bResult = TRUE;
5270 if (uView == LVS_REPORT)
5271 nLeftPos = lprc->left = ptItem.x + nIndent;
5272 else
5273 nLeftPos = lprc->left = ptItem.x;
5274 lprc->top = ptItem.y;
5275 lprc->bottom = lprc->top + infoPtr->nItemHeight;
5276
5277 if (infoPtr->himlState != NULL)
5278 lprc->left += infoPtr->iconSize.cx;
5279
5280 if (infoPtr->himlSmall != NULL)
5281 lprc->left += infoPtr->iconSize.cx;
5282
5283 if (uView != LVS_REPORT)
5284 {
5285 nLabelWidth = LISTVIEW_GetLabelWidth(infoPtr, nItem);
5286 nLabelWidth += TRAILING_PADDING;
5287 if (infoPtr->himlSmall)
5288 nLabelWidth += IMAGE_PADDING;
5289 }
5290 else
5291 nLabelWidth = LISTVIEW_GetColumnWidth(infoPtr, 0)-lprc->left;
5292 if (lprc->left + nLabelWidth < nLeftPos + infoPtr->nItemWidth)
5293 lprc->right = lprc->left + nLabelWidth;
5294 else
5295 lprc->right = nLeftPos + infoPtr->nItemWidth;
5296 }
5297 break;
5298
5299 case LVIR_BOUNDS:
5300 if (!LISTVIEW_GetItemBoundBox(infoPtr, nItem, &rcInternal)) break;
5301 ptItem.x = rcInternal.left;
5302 ptItem.y = rcInternal.top;
5303 if (uView == LVS_ICON)
5304 {
5305 if (infoPtr->himlNormal != NULL)
5306 {
5307 if (LISTVIEW_GetOrigin(infoPtr, &ptOrigin))
5308 {
5309 RECT label_rect, icon_rect;
5310
5311 if (!LISTVIEW_GetItemPosition(infoPtr, nItem, &ptItem)) break;
5312
5313 /* make icon rectangle */
5314 icon_rect.left = ptItem.x + ptOrigin.x - 8;
5315 icon_rect.top = ptItem.y + ptOrigin.y - ICON_TOP_PADDING;
5316 icon_rect.right = icon_rect.left + infoPtr->iconSize.cx + 16;
5317 icon_rect.bottom = icon_rect.top + infoPtr->iconSize.cy +
5318 ICON_TOP_PADDING;
5319
5320 /* make label rectangle */
5321 /* Correct ptItem to icon upper-left */
5322 ptItem.x -= (infoPtr->nItemWidth - infoPtr->iconSize.cx)/2;
5323 ptItem.y -= ICON_TOP_PADDING;
5324
5325 label_rect.left = ptItem.x + ptOrigin.x;
5326 label_rect.top = ptItem.y + ptOrigin.y + infoPtr->iconSize.cy +
5327 6;
5328 nLabelWidth = LISTVIEW_GetLabelWidth(infoPtr, nItem);
5329 if (infoPtr->iconSpacing.cx - nLabelWidth > 1)
5330 {
5331 label_rect.left += (infoPtr->iconSpacing.cx - nLabelWidth) / 2;
5332 label_rect.right = label_rect.left + nLabelWidth;
5333 label_rect.bottom = label_rect.top + infoPtr->ntmHeight + 1;
5334 InflateRect(&label_rect, 2, 0);
5335 }
5336 else
5337 {
5338 label_rect.right = label_rect.left + infoPtr->iconSpacing.cx - 1;
5339 label_rect.bottom = label_rect.top + infoPtr->nItemHeight;
5340 LISTVIEW_UpdateLargeItemLabelRect (infoPtr, nItem, &label_rect);
5341 }
5342 label_rect.bottom += HEIGHT_PADDING;
5343 bResult = TRUE;
5344 UnionRect (lprc, &icon_rect, &label_rect);
5345 }
5346 }
5347 }
5348 else if (uView == LVS_SMALLICON)
5349 {
5350 if (LISTVIEW_GetOrigin(infoPtr, &ptOrigin))
5351 {
5352 bResult = TRUE;
5353 lprc->left = ptItem.x + ptOrigin.x;
5354 lprc->right = lprc->left;
5355 lprc->top = ptItem.y + ptOrigin.y;
5356 lprc->bottom = lprc->top + infoPtr->nItemHeight;
5357 if (infoPtr->himlState != NULL)
5358 lprc->right += infoPtr->iconSize.cx;
5359 if (infoPtr->himlSmall != NULL)
5360 lprc->right += infoPtr->iconSize.cx;
5361
5362 nLabelWidth = LISTVIEW_GetLabelWidth(infoPtr, nItem);
5363 nLabelWidth += TRAILING_PADDING;
5364 if (infoPtr->himlSmall)
5365 nLabelWidth += IMAGE_PADDING;
5366 if (lprc->right + nLabelWidth < lprc->left + infoPtr->nItemWidth)
5367 lprc->right += nLabelWidth;
5368 else
5369 lprc->right = lprc->left + infoPtr->nItemWidth;
5370 }
5371 }
5372 else
5373 {
5374 bResult = TRUE;
5375 lprc->left = ptItem.x;
5376 if (!(infoPtr->dwExStyle&LVS_EX_FULLROWSELECT) && uView&LVS_REPORT)
5377 lprc->left += nIndent;
5378 lprc->right = lprc->left;
5379 lprc->top = ptItem.y;
5380 lprc->bottom = lprc->top + infoPtr->nItemHeight;
5381
5382 if ((infoPtr->dwExStyle & LVS_EX_FULLROWSELECT) || (uView == LVS_REPORT))
5383 {
5384 RECT br;
5385 int nColumnCount = Header_GetItemCount(infoPtr->hwndHeader);
5386 Header_GetItemRect(infoPtr->hwndHeader, nColumnCount-1, &br);
5387
5388 lprc->right = max(lprc->left, br.right - REPORT_MARGINX);
5389 }
5390 else
5391 {
5392 if (infoPtr->himlState != NULL)
5393 lprc->right += infoPtr->iconSize.cx;
5394
5395 if (infoPtr->himlSmall != NULL)
5396 lprc->right += infoPtr->iconSize.cx;
5397
5398 nLabelWidth = LISTVIEW_GetLabelWidth(infoPtr, nItem);
5399 nLabelWidth += TRAILING_PADDING;
5400 if (lprc->right + nLabelWidth < lprc->left + infoPtr->nItemWidth)
5401 lprc->right += nLabelWidth;
5402 else
5403 lprc->right = lprc->left + infoPtr->nItemWidth;
5404 }
5405 }
5406 break;
5407
5408 case LVIR_SELECTBOUNDS:
5409 if (!LISTVIEW_GetItemPosition(infoPtr, nItem, &ptItem)) break;
5410 if (uView == LVS_ICON)
5411 {
5412 if (infoPtr->himlNormal != NULL)
5413 {
5414 if (LISTVIEW_GetOrigin(infoPtr, &ptOrigin))
5415 {
5416 bResult = TRUE;
5417 lprc->left = ptItem.x + ptOrigin.x;
5418 lprc->top = ptItem.y + ptOrigin.y;
5419 lprc->right = lprc->left + infoPtr->iconSpacing.cx;
5420 lprc->bottom = lprc->top + infoPtr->iconSpacing.cy;
5421 }
5422 }
5423 }
5424 else if (uView == LVS_SMALLICON)
5425 {
5426 if (LISTVIEW_GetOrigin(infoPtr, &ptOrigin))
5427 {
5428 bResult = TRUE;
5429 nLeftPos= lprc->left = ptItem.x + ptOrigin.x;
5430 lprc->top = ptItem.y + ptOrigin.y;
5431 lprc->bottom = lprc->top + infoPtr->nItemHeight;
5432
5433 if (infoPtr->himlState != NULL)
5434 lprc->left += infoPtr->iconSize.cx;
5435
5436 lprc->right = lprc->left;
5437
5438 if (infoPtr->himlSmall != NULL)
5439 lprc->right += infoPtr->iconSize.cx;
5440
5441 nLabelWidth = LISTVIEW_GetLabelWidth(infoPtr, nItem);
5442 nLabelWidth += TRAILING_PADDING;
5443 if (lprc->right + nLabelWidth < nLeftPos + infoPtr->nItemWidth)
5444 lprc->right += nLabelWidth;
5445 else
5446 lprc->right = nLeftPos + infoPtr->nItemWidth;
5447 }
5448 }
5449 else
5450 {
5451 bResult = TRUE;
5452 if (!(infoPtr->dwExStyle&LVS_EX_FULLROWSELECT) && (uView&LVS_REPORT))
5453 nLeftPos = lprc->left = ptItem.x + nIndent;
5454 else
5455 nLeftPos = lprc->left = ptItem.x;
5456 lprc->top = ptItem.y;
5457 lprc->bottom = lprc->top + infoPtr->nItemHeight;
5458
5459 if (infoPtr->himlState != NULL)
5460 lprc->left += infoPtr->iconSize.cx;
5461
5462 lprc->right = lprc->left;
5463
5464 if (infoPtr->dwExStyle & LVS_EX_FULLROWSELECT)
5465 {
5466 RECT br;
5467 int nColumnCount = Header_GetItemCount(infoPtr->hwndHeader);
5468 Header_GetItemRect(infoPtr->hwndHeader, nColumnCount-1, &br);
5469
5470 lprc->right = max(lprc->left, br.right - REPORT_MARGINX);
5471 }
5472 else
5473 {
5474 if (infoPtr->himlSmall != NULL)
5475 lprc->right += infoPtr->iconSize.cx;
5476
5477 nLabelWidth = LISTVIEW_GetLabelWidth(infoPtr, nItem);
5478 nLabelWidth += TRAILING_PADDING;
5479 if (infoPtr->himlSmall)
5480 nLabelWidth += IMAGE_PADDING;
5481 if (lprc->right + nLabelWidth < nLeftPos + infoPtr->nItemWidth)
5482 lprc->right += nLabelWidth;
5483 else
5484 lprc->right = nLeftPos + infoPtr->nItemWidth;
5485 }
5486 }
5487 break;
5488 }
5489 }
5490
5491 TRACE("result %s (%d,%d)-(%d,%d)\n", bResult ? "TRUE" : "FALSE",
5492 lprc->left, lprc->top, lprc->right, lprc->bottom);
5493
5494 return bResult;
5495 }
5496
5497
5498 static LRESULT LISTVIEW_GetSubItemRect(LISTVIEW_INFO *infoPtr, INT nItem, INT nSubItem, INT
5499 flags, LPRECT lprc)
5500 {
5501 UINT uView = LISTVIEW_GetType(infoPtr);
5502 INT count;
5503
5504 TRACE("(nItem=%d, nSubItem=%d lprc=%p)\n", nItem, nSubItem,
5505 lprc);
5506
5507 if (!(uView & LVS_REPORT))
5508 return FALSE;
5509
5510 if (flags & LVIR_ICON)
5511 {
5512 FIXME("Unimplemented LVIR_ICON\n");
5513 return FALSE;
5514 }
5515 else
5516 {
5517 int top = min(infoPtr->nColumnCount, nSubItem - 1);
5518
5519 LISTVIEW_GetItemRect(infoPtr,nItem,lprc);
5520 for (count = 0; count < top; count++)
5521 lprc->left += LISTVIEW_GetColumnWidth(infoPtr,count);
5522
5523 lprc->right = LISTVIEW_GetColumnWidth(infoPtr,(nSubItem-1)) +
5524 lprc->left;
5525 }
5526 return TRUE;
5527 }
5528
5529
5530 /***
5531 * DESCRIPTION:
5532 * Retrieves the width of a label.
5533 *
5534 * PARAMETER(S):
5535 * [I] infoPtr : valid pointer to the listview structure
5536 *
5537 * RETURN:
5538 * SUCCESS : string width (in pixels)
5539 * FAILURE : zero
5540 */
5541 static INT LISTVIEW_GetLabelWidth(LISTVIEW_INFO *infoPtr, INT nItem)
5542 {
5543 WCHAR szDispText[DISP_TEXT_SIZE] = { '\0' };
5544 INT nLabelWidth = 0;
5545 LVITEMW lvItem;
5546
5547 TRACE("(nItem=%d)\n", nItem);
5548
5549 ZeroMemory(&lvItem, sizeof(lvItem));
5550 lvItem.mask = LVIF_TEXT;
5551 lvItem.iItem = nItem;
5552 lvItem.cchTextMax = DISP_TEXT_SIZE;
5553 lvItem.pszText = szDispText;
5554 if (LISTVIEW_GetItemW(infoPtr, &lvItem, TRUE))
5555 nLabelWidth = LISTVIEW_GetStringWidthT(infoPtr, lvItem.pszText, TRUE);
5556
5557 return nLabelWidth;
5558 }
5559
5560 /***
5561 * DESCRIPTION:
5562 * Retrieves the spacing between listview control items.
5563 *
5564 * PARAMETER(S):
5565 * [I] infoPtr : valid pointer to the listview structure
5566 * [I] BOOL : flag for small or large icon
5567 *
5568 * RETURN:
5569 * Horizontal + vertical spacing
5570 */
5571 static LRESULT LISTVIEW_GetItemSpacing(LISTVIEW_INFO *infoPtr, BOOL bSmall)
5572 {
5573 LONG lResult;
5574
5575 if (!bSmall)
5576 {
5577 lResult = MAKELONG(infoPtr->iconSpacing.cx, infoPtr->iconSpacing.cy);
5578 }
5579 else
5580 {
5581 if (LISTVIEW_GetType(infoPtr) == LVS_ICON)
5582 lResult = MAKELONG(DEFAULT_COLUMN_WIDTH, GetSystemMetrics(SM_CXSMICON)+HEIGHT_PADDING);
5583 else
5584 lResult = MAKELONG(infoPtr->nItemWidth, infoPtr->nItemHeight);
5585 }
5586 return lResult;
5587 }
5588
5589 /***
5590 * DESCRIPTION:
5591 * Retrieves the state of a listview control item.
5592 *
5593 * PARAMETER(S):
5594 * [I] infoPtr : valid pointer to the listview structure
5595 * [I] INT : item index
5596 * [I] UINT : state mask
5597 *
5598 * RETURN:
5599 * State specified by the mask.
5600 */
5601 static LRESULT LISTVIEW_GetItemState(LISTVIEW_INFO *infoPtr, INT nItem, UINT uMask)
5602 {
5603 LVITEMW lvItem;
5604 UINT uState = 0;
5605
5606 if ((nItem >= 0) && (nItem < GETITEMCOUNT(infoPtr)))
5607 {
5608 ZeroMemory(&lvItem, sizeof(lvItem));
5609 lvItem.iItem = nItem;
5610 lvItem.stateMask = uMask;
5611 lvItem.mask = LVIF_STATE;
5612 if (LISTVIEW_GetItemW(infoPtr, &lvItem, TRUE))
5613 uState = lvItem.state & uMask;
5614 }
5615
5616 return uState;
5617 }
5618
5619 /***
5620 * DESCRIPTION:
5621 * Retrieves the text of a listview control item or subitem.
5622 *
5623 * PARAMETER(S):
5624 * [I] hwnd : window handle
5625 * [I] nItem : item index
5626 * [IO] lpLVItem : item information
5627 * [I] isW : TRUE if lpLVItem is Unicode
5628 *
5629 * RETURN:
5630 * SUCCESS : string length
5631 * FAILURE : 0
5632 */
5633 static LRESULT LISTVIEW_GetItemTextT(LISTVIEW_INFO *infoPtr, INT nItem, LPLVITEMW lpLVItem, BOOL isW)
5634 {
5635 INT nLength = 0;
5636
5637 if (lpLVItem != NULL)
5638 {
5639 if ((nItem >= 0) && (nItem < GETITEMCOUNT(infoPtr)))
5640 {
5641 lpLVItem->mask = LVIF_TEXT;
5642 lpLVItem->iItem = nItem;
5643 if (LISTVIEW_GetItemT(infoPtr, lpLVItem, FALSE, isW))
5644 nLength = textlenT(lpLVItem->pszText, isW);
5645 }
5646 }
5647
5648 return nLength;
5649 }
5650
5651 /***
5652 * DESCRIPTION:
5653 * Searches for an item based on properties + relationships.
5654 *
5655 * PARAMETER(S):
5656 * [I] infoPtr : valid pointer to the listview structure
5657 * [I] INT : item index
5658 * [I] INT : relationship flag
5659 *
5660 * RETURN:
5661 * SUCCESS : item index
5662 * FAILURE : -1
5663 */
5664 static LRESULT LISTVIEW_GetNextItem(LISTVIEW_INFO *infoPtr, INT nItem, UINT uFlags)
5665 {
5666 UINT uView = LISTVIEW_GetType(infoPtr);
5667 UINT uMask = 0;
5668 LVFINDINFOW lvFindInfo;
5669 INT nCountPerColumn;
5670 INT i;
5671
5672 if ((nItem >= -1) && (nItem < GETITEMCOUNT(infoPtr)))
5673 {
5674 ZeroMemory(&lvFindInfo, sizeof(lvFindInfo));
5675
5676 if (uFlags & LVNI_CUT)
5677 uMask |= LVIS_CUT;
5678
5679 if (uFlags & LVNI_DROPHILITED)
5680 uMask |= LVIS_DROPHILITED;
5681
5682 if (uFlags & LVNI_FOCUSED)
5683 uMask |= LVIS_FOCUSED;
5684
5685 if (uFlags & LVNI_SELECTED)
5686 uMask |= LVIS_SELECTED;
5687
5688 if (uFlags & LVNI_ABOVE)
5689 {
5690 if ((uView == LVS_LIST) || (uView == LVS_REPORT))
5691 {
5692 while (nItem >= 0)
5693 {
5694 nItem--;
5695 if ((ListView_GetItemState(infoPtr->hwndSelf, nItem, uMask) & uMask) == uMask)
5696 return nItem;
5697 }
5698 }
5699 else
5700 {
5701 lvFindInfo.flags = LVFI_NEARESTXY;
5702 lvFindInfo.vkDirection = VK_UP;
5703 ListView_GetItemPosition(infoPtr->hwndSelf, nItem, &lvFindInfo.pt);
5704 while ((nItem = ListView_FindItemW(infoPtr->hwndSelf, nItem, &lvFindInfo)) != -1)
5705 {
5706 if ((ListView_GetItemState(infoPtr->hwndSelf, nItem, uMask) & uMask) == uMask)
5707 return nItem;
5708 }
5709 }
5710 }
5711 else if (uFlags & LVNI_BELOW)
5712 {
5713 if ((uView == LVS_LIST) || (uView == LVS_REPORT))
5714 {
5715 while (nItem < GETITEMCOUNT(infoPtr))
5716 {
5717 nItem++;
5718 if ((ListView_GetItemState(infoPtr->hwndSelf, nItem, uMask) & uMask) == uMask)
5719 return nItem;
5720 }
5721 }
5722 else
5723 {
5724 lvFindInfo.flags = LVFI_NEARESTXY;
5725 lvFindInfo.vkDirection = VK_DOWN;
5726 ListView_GetItemPosition(infoPtr->hwndSelf, nItem, &lvFindInfo.pt);
5727 while ((nItem = ListView_FindItemW(infoPtr->hwndSelf, nItem, &lvFindInfo)) != -1)
5728 {
5729 if ((ListView_GetItemState(infoPtr->hwndSelf, nItem, uMask) & uMask) == uMask)
5730 return nItem;
5731 }
5732 }
5733 }
5734 else if (uFlags & LVNI_TOLEFT)
5735 {
5736 if (uView == LVS_LIST)
5737 {
5738 nCountPerColumn = LISTVIEW_GetCountPerColumn(infoPtr);
5739 while (nItem - nCountPerColumn >= 0)
5740 {
5741 nItem -= nCountPerColumn;
5742 if ((ListView_GetItemState(infoPtr->hwndSelf, nItem, uMask) & uMask) == uMask)
5743 return nItem;
5744 }
5745 }
5746 else if ((uView == LVS_SMALLICON) || (uView == LVS_ICON))
5747 {
5748 lvFindInfo.flags = LVFI_NEARESTXY;
5749 lvFindInfo.vkDirection = VK_LEFT;
5750 ListView_GetItemPosition(infoPtr->hwndSelf, nItem, &lvFindInfo.pt);
5751 while ((nItem = ListView_FindItemW(infoPtr->hwndSelf, nItem, &lvFindInfo)) != -1)
5752 {
5753 if ((ListView_GetItemState(infoPtr->hwndSelf, nItem, uMask) & uMask) == uMask)
5754 return nItem;
5755 }
5756 }
5757 }
5758 else if (uFlags & LVNI_TORIGHT)
5759 {
5760 if (uView == LVS_LIST)
5761 {
5762 nCountPerColumn = LISTVIEW_GetCountPerColumn(infoPtr);
5763 while (nItem + nCountPerColumn < GETITEMCOUNT(infoPtr))
5764 {
5765 nItem += nCountPerColumn;
5766 if ((ListView_GetItemState(infoPtr->hwndSelf, nItem, uMask) & uMask) == uMask)
5767 return nItem;
5768 }
5769 }
5770 else if ((uView == LVS_SMALLICON) || (uView == LVS_ICON))
5771 {
5772 lvFindInfo.flags = LVFI_NEARESTXY;
5773 lvFindInfo.vkDirection = VK_RIGHT;
5774 ListView_GetItemPosition(infoPtr->hwndSelf, nItem, &lvFindInfo.pt);
5775 while ((nItem = ListView_FindItemW(infoPtr->hwndSelf, nItem, &lvFindInfo)) != -1)
5776 {
5777 if ((ListView_GetItemState(infoPtr->hwndSelf, nItem, uMask) & uMask) == uMask)
5778 return nItem;
5779 }
5780 }
5781 }
5782 else
5783 {
5784 nItem++;
5785
5786 /* search by index */
5787 for (i = nItem; i < GETITEMCOUNT(infoPtr); i++)
5788 {
5789 if ((ListView_GetItemState(infoPtr->hwndSelf, i, uMask) & uMask) == uMask)
5790 return i;
5791 }
5792 }
5793 }
5794
5795 return -1;
5796 }
5797
5798 /* LISTVIEW_GetNumberOfWorkAreas */
5799
5800 /***
5801 * DESCRIPTION:
5802 * Retrieves the origin coordinates when in icon or small icon display mode.
5803 *
5804 * PARAMETER(S):
5805 * [I] infoPtr : valid pointer to the listview structure
5806 * [O] LPPOINT : coordinate information
5807 *
5808 * RETURN:
5809 * SUCCESS : TRUE
5810 * FAILURE : FALSE
5811 */
5812 static LRESULT LISTVIEW_GetOrigin(LISTVIEW_INFO *infoPtr, LPPOINT lpptOrigin)
5813 {
5814 LONG lStyle = GetWindowLongW(infoPtr->hwndSelf, GWL_STYLE);
5815 UINT uView = lStyle & LVS_TYPEMASK;
5816 BOOL bResult = FALSE;
5817
5818 TRACE("(lpptOrigin=%p)\n", lpptOrigin);
5819
5820 if ((uView == LVS_SMALLICON) || (uView == LVS_ICON))
5821 {
5822 SCROLLINFO scrollInfo;
5823 ZeroMemory(lpptOrigin, sizeof(POINT));
5824 ZeroMemory(&scrollInfo, sizeof(SCROLLINFO));
5825 scrollInfo.cbSize = sizeof(SCROLLINFO);
5826
5827 if (lStyle & WS_HSCROLL)
5828 {
5829 scrollInfo.fMask = SIF_POS;
5830 if (GetScrollInfo(infoPtr->hwndSelf, SB_HORZ, &scrollInfo))
5831 lpptOrigin->x = -scrollInfo.nPos;
5832 }
5833
5834 if (lStyle & WS_VSCROLL)
5835 {
5836 scrollInfo.fMask = SIF_POS;
5837 if (GetScrollInfo(infoPtr->hwndSelf, SB_VERT, &scrollInfo))
5838 lpptOrigin->y = -scrollInfo.nPos;
5839 }
5840
5841 bResult = TRUE;
5842
5843 TRACE("(pt=(%ld,%ld))\n", lpptOrigin->x, lpptOrigin->y);
5844
5845 }
5846
5847 return bResult;
5848 }
5849
5850 /***
5851 * DESCRIPTION:
5852 * Retrieves the number of items that are marked as selected.
5853 *
5854 * PARAMETER(S):
5855 * [I] infoPtr : valid pointer to the listview structure
5856 *
5857 * RETURN:
5858 * Number of items selected.
5859 */
5860 static LRESULT LISTVIEW_GetSelectedCount(LISTVIEW_INFO *infoPtr)
5861 {
5862 /* REDO THIS */
5863 INT nSelectedCount = 0;
5864 INT i;
5865
5866 for (i = 0; i < GETITEMCOUNT(infoPtr); i++)
5867 {
5868 if (ListView_GetItemState(infoPtr->hwndSelf, i, LVIS_SELECTED) & LVIS_SELECTED)
5869 nSelectedCount++;
5870 }
5871
5872 return nSelectedCount;
5873 }
5874
5875 /***
5876 * DESCRIPTION:
5877 * Retrieves the width of a string.
5878 *
5879 * PARAMETER(S):
5880 * [I] hwnd : window handle
5881 * [I] lpszText : text string to process
5882 * [I] isW : TRUE if lpszText is Unicode, FALSE otherwise
5883 *
5884 * RETURN:
5885 * SUCCESS : string width (in pixels)
5886 * FAILURE : zero
5887 */
5888 static LRESULT LISTVIEW_GetStringWidthT(LISTVIEW_INFO *infoPtr, LPCWSTR lpszText, BOOL isW)
5889 {
5890 if (is_textT(lpszText, isW))
5891 {
5892 HFONT hFont = infoPtr->hFont ? infoPtr->hFont : infoPtr->hDefaultFont;
5893 HDC hdc = GetDC(infoPtr->hwndSelf);
5894 HFONT hOldFont = SelectObject(hdc, hFont);
5895 SIZE stringSize;
5896 ZeroMemory(&stringSize, sizeof(SIZE));
5897 if (isW)
5898 GetTextExtentPointW(hdc, lpszText, lstrlenW(lpszText), &stringSize);
5899 else
5900 GetTextExtentPointA(hdc, (LPCSTR)lpszText, lstrlenA((LPCSTR)lpszText), &stringSize);
5901 SelectObject(hdc, hOldFont);
5902 ReleaseDC(infoPtr->hwndSelf, hdc);
5903 return stringSize.cx;
5904 }
5905 return 0;
5906 }
5907
5908 /***
5909 * DESCRIPTION:
5910 * Retrieves the text backgound color.
5911 *
5912 * PARAMETER(S):
5913 * [I] infoPtr : valid pointer to the listview structure
5914 *
5915 * RETURN:
5916 * COLORREF associated with the the background.
5917 */
5918 static LRESULT LISTVIEW_GetTextBkColor(LISTVIEW_INFO *infoPtr)
5919 {
5920 return infoPtr->clrTextBk;
5921 }
5922
5923 /***
5924 * DESCRIPTION:
5925 * Retrieves the text color.
5926 *
5927 * PARAMETER(S):
5928 * [I] infoPtr : valid pointer to the listview structure
5929 *
5930 * RETURN:
5931 * COLORREF associated with the text.
5932 */
5933 static LRESULT LISTVIEW_GetTextColor(LISTVIEW_INFO *infoPtr)
5934 {
5935 return infoPtr->clrText;
5936 }
5937
5938 /***
5939 * DESCRIPTION:
5940 * Determines item if a hit or closest if not
5941 *
5942 * PARAMETER(S):
5943 * [I] infoPtr : valid pointer to the listview structure
5944 * [IO] LPLV_INTHIT : hit test information
5945 * [I] subitem : fill out iSubItem.
5946 *
5947 * RETURN:
5948 * SUCCESS : item index of hit
5949 * FAILURE : -1
5950 */
5951 static INT LISTVIEW_SuperHitTestItem(LISTVIEW_INFO *infoPtr, LPLV_INTHIT lpInt, BOOL subitem)
5952 {
5953 LONG lStyle = GetWindowLongW(infoPtr->hwndSelf, GWL_STYLE);
5954 UINT uView = lStyle & LVS_TYPEMASK;
5955 INT i,j,topindex,bottomindex;
5956 RECT rcItem,rcSubItem;
5957 DWORD xterm, yterm, dist;
5958
5959 TRACE("(x=%ld, y=%ld)\n", lpInt->ht.pt.x, lpInt->ht.pt.y);
5960
5961 topindex = LISTVIEW_GetTopIndex(infoPtr);
5962 if (uView == LVS_REPORT)
5963 {
5964 bottomindex = topindex + LISTVIEW_GetCountPerColumn(infoPtr) + 1;
5965 bottomindex = min(bottomindex,GETITEMCOUNT(infoPtr));
5966 }
5967 else
5968 {
5969 bottomindex = GETITEMCOUNT(infoPtr);
5970 }
5971
5972 lpInt->distance = 0x7fffffff;
5973 lpInt->iDistItem = -1;
5974
5975 for (i = topindex; i < bottomindex; i++)
5976 {
5977 rcItem.left = LVIR_BOUNDS;
5978 if (LISTVIEW_GetItemRect(infoPtr, i, &rcItem))
5979 {
5980 if (PtInRect(&rcItem, lpInt->ht.pt))
5981 {
5982 rcSubItem = rcItem;
5983 rcItem.left = LVIR_ICON;
5984 if (LISTVIEW_GetItemRect(infoPtr, i, &rcItem))
5985 {
5986 if (PtInRect(&rcItem, lpInt->ht.pt))
5987 {
5988 lpInt->ht.flags = LVHT_ONITEMICON;
5989 lpInt->ht.iItem = i;
5990 goto set_subitem;
5991 }
5992 }
5993
5994 rcItem.left = LVIR_LABEL;
5995 if (LISTVIEW_GetItemRect(infoPtr, i, &rcItem))
5996 {
5997 if (PtInRect(&rcItem, lpInt->ht.pt))
5998 {
5999 lpInt->ht.flags = LVHT_ONITEMLABEL;
6000 lpInt->ht.iItem = i;
6001 goto set_subitem;
6002 }
6003 }
6004
6005 lpInt->ht.flags = LVHT_ONITEMSTATEICON;
6006 lpInt->ht.iItem = i;
6007 set_subitem:
6008 if (subitem)
6009 {
6010 lpInt->ht.iSubItem = 0;
6011 rcSubItem.right = rcSubItem.left;
6012 for (j = 0; j < infoPtr->nColumnCount; j++)
6013 {
6014 rcSubItem.left = rcSubItem.right;
6015 rcSubItem.right += LISTVIEW_GetColumnWidth(infoPtr, j);
6016 if (PtInRect(&rcSubItem, lpInt->ht.pt))
6017 {
6018 lpInt->ht.iSubItem = j;
6019 break;
6020 }
6021 }
6022 }
6023 return i;
6024 }
6025 else
6026 {
6027 /*
6028 * Now compute distance from point to center of boundary
6029 * box. Since we are only interested in the relative
6030 * distance, we can skip the nasty square root operation
6031 */
6032 xterm = rcItem.left + (rcItem.right - rcItem.left)/2 - lpInt->ht.pt.x;
6033 yterm = rcItem.top + (rcItem.bottom - rcItem.top)/2 - lpInt->ht.pt.y;
6034 dist = xterm * xterm + yterm * yterm;
6035 if (dist < lpInt->distance)
6036 {
6037 lpInt->distance = dist;
6038 lpInt->iDistItem = i;
6039 }
6040 }
6041 }
6042 }
6043
6044 lpInt->ht.flags = LVHT_NOWHERE;
6045 TRACE("no hit, closest item %d, distance %ld\n", lpInt->iDistItem, lpInt->distance);
6046
6047 return -1;
6048 }
6049
6050 /***
6051 * DESCRIPTION:
6052 * Determines which section of the item was selected (if any).
6053 *
6054 * PARAMETER(S):
6055 * [I] infoPtr : valid pointer to the listview structure
6056 * [IO] LPLVHITTESTINFO : hit test information
6057 * [I] subitem : fill out iSubItem.
6058 *
6059 * RETURN:
6060 * SUCCESS : item index
6061 * FAILURE : -1
6062 */
6063 static INT LISTVIEW_HitTestItem(LISTVIEW_INFO *infoPtr, LPLVHITTESTINFO lpHitTestInfo, BOOL subitem)
6064 {
6065 INT ret;
6066 LV_INTHIT lv_inthit;
6067
6068 TRACE("(x=%ld, y=%ld)\n", lpHitTestInfo->pt.x,
6069 lpHitTestInfo->pt.y);
6070
6071 memcpy(&lv_inthit, lpHitTestInfo, sizeof(LVHITTESTINFO));
6072 ret = LISTVIEW_SuperHitTestItem(infoPtr, &lv_inthit, subitem);
6073 memcpy(lpHitTestInfo, &lv_inthit, sizeof(LVHITTESTINFO));
6074 return ret;
6075 }
6076
6077 /***
6078 * DESCRIPTION:
6079 * Determines which listview item is located at the specified position.
6080 *
6081 * PARAMETER(S):
6082 * [I] infoPtr : valid pointer to the listview structure
6083 * [IO} LPLVHITTESTINFO : hit test information
6084 *
6085 * RETURN:
6086 * SUCCESS : item index
6087 * FAILURE : -1
6088 */
6089 static LRESULT LISTVIEW_HitTest(LISTVIEW_INFO *infoPtr, LPLVHITTESTINFO lpHitTestInfo)
6090 {
6091 INT nItem = -1;
6092
6093 lpHitTestInfo->flags = 0;
6094
6095 if (infoPtr->rcList.left > lpHitTestInfo->pt.x)
6096 lpHitTestInfo->flags = LVHT_TOLEFT;
6097 else if (infoPtr->rcList.right < lpHitTestInfo->pt.x)
6098 lpHitTestInfo->flags = LVHT_TORIGHT;
6099 if (infoPtr->rcList.top > lpHitTestInfo->pt.y)
6100 lpHitTestInfo->flags |= LVHT_ABOVE;
6101 else if (infoPtr->rcList.bottom < lpHitTestInfo->pt.y)
6102 lpHitTestInfo->flags |= LVHT_BELOW;
6103
6104 if (lpHitTestInfo->flags == 0)
6105 {
6106 /* NOTE (mm 20001022): We must not allow iSubItem to be touched, for
6107 * an app might pass only a structure with space up to iItem!
6108 * (MS Office 97 does that for instance in the file open dialog)
6109 */
6110 nItem = LISTVIEW_HitTestItem(infoPtr, lpHitTestInfo, FALSE);
6111 }
6112
6113 return nItem;
6114 }
6115
6116 /***
6117 * DESCRIPTION:
6118 * Determines which listview subitem is located at the specified position.
6119 *
6120 * PARAMETER(S):
6121 * [I] infoPtr : valid pointer to the listview structure
6122 * [IO} LPLVHITTESTINFO : hit test information
6123 *
6124 * RETURN:
6125 * SUCCESS : item index
6126 * FAILURE : -1
6127 */
6128 static LRESULT LISTVIEW_SubItemHitTest(LISTVIEW_INFO *infoPtr, LPLVHITTESTINFO lpHitTestInfo)
6129 {
6130 INT nItem = -1;
6131
6132 lpHitTestInfo->flags = 0;
6133
6134 if (infoPtr->rcList.left > lpHitTestInfo->pt.x)
6135 lpHitTestInfo->flags = LVHT_TOLEFT;
6136 else if (infoPtr->rcList.right < lpHitTestInfo->pt.x)
6137 lpHitTestInfo->flags = LVHT_TORIGHT;
6138 if (infoPtr->rcList.top > lpHitTestInfo->pt.y)
6139 lpHitTestInfo->flags |= LVHT_ABOVE;
6140 else if (infoPtr->rcList.bottom < lpHitTestInfo->pt.y)
6141 lpHitTestInfo->flags |= LVHT_BELOW;
6142
6143 if (lpHitTestInfo->flags == 0)
6144 nItem = LISTVIEW_HitTestItem(infoPtr, lpHitTestInfo, TRUE);
6145
6146 return nItem;
6147 }
6148
6149 /***
6150 * DESCRIPTION:
6151 * Inserts a new column.
6152 *
6153 * PARAMETER(S):
6154 * [I] infoPtr : valid pointer to the listview structure
6155 * [I] INT : column index
6156 * [I] LPLVCOLUMNW : column information
6157 *
6158 * RETURN:
6159 * SUCCESS : new column index
6160 * FAILURE : -1
6161 */
6162 static LRESULT LISTVIEW_InsertColumnT(LISTVIEW_INFO *infoPtr, INT nColumn,
6163 LPLVCOLUMNW lpColumn, BOOL isW)
6164 {
6165 INT nNewColumn = -1;
6166 HDITEMW hdi;
6167
6168 TRACE("(nColumn=%d, lpColumn=%p)\n", nColumn, lpColumn);
6169
6170 if (lpColumn != NULL)
6171 {
6172 /* initialize memory */
6173 ZeroMemory(&hdi, sizeof(hdi));
6174
6175 if (lpColumn->mask & LVCF_FMT)
6176 {
6177 /* format member is valid */
6178 hdi.mask |= HDI_FORMAT;
6179
6180 /* set text alignment (leftmost column must be left-aligned) */
6181 if (nColumn == 0)
6182 {
6183 hdi.fmt |= HDF_LEFT;
6184 }
6185 else
6186 {
6187 if (lpColumn->fmt & LVCFMT_LEFT)
6188 {
6189 hdi.fmt |= HDF_LEFT;
6190 }
6191 else if (lpColumn->fmt & LVCFMT_RIGHT)
6192 {
6193 hdi.fmt |= HDF_RIGHT;
6194 }
6195 else if (lpColumn->fmt & LVCFMT_CENTER)
6196 {
6197 hdi.fmt |= HDF_CENTER;
6198 }
6199 }
6200
6201 if (lpColumn->fmt & LVCFMT_BITMAP_ON_RIGHT)
6202 {
6203 hdi.fmt |= HDF_BITMAP_ON_RIGHT;
6204 /* ??? */
6205 }
6206
6207 if (lpColumn->fmt & LVCFMT_COL_HAS_IMAGES)
6208 {
6209 /* ??? */
6210 }
6211
6212 if (lpColumn->fmt & LVCFMT_IMAGE)
6213 {
6214 hdi.fmt |= HDF_IMAGE;
6215 hdi.iImage = I_IMAGECALLBACK;
6216 }
6217 }
6218
6219 if (lpColumn->mask & LVCF_WIDTH)
6220 {
6221 hdi.mask |= HDI_WIDTH;
6222 if(lpColumn->cx == LVSCW_AUTOSIZE_USEHEADER)
6223 {
6224 /* make it fill the remainder of the controls width */
6225 HDITEMW hdit;
6226 RECT rcHeader;
6227 INT item_index;
6228
6229 ZeroMemory(&hdit, sizeof(hdit));
6230
6231 /* get the width of every item except the current one */
6232 hdit.mask = HDI_WIDTH;
6233 hdi.cxy = 0;
6234
6235 for(item_index = 0; item_index < (nColumn - 1); item_index++) {
6236 Header_GetItemW(infoPtr->hwndHeader, item_index, (LPARAM)(&hdit));
6237 hdi.cxy+=hdit.cxy;
6238 }
6239
6240 /* retrieve the layout of the header */
6241 GetClientRect(infoPtr->hwndSelf, &rcHeader);
6242 /* GetWindowRect(infoPtr->hwndHeader, &rcHeader);*/
6243 TRACE("start cxy=%d left=%d right=%d\n", hdi.cxy, rcHeader.left, rcHeader.right);
6244
6245 hdi.cxy = (rcHeader.right - rcHeader.left) - hdi.cxy;
6246 }
6247 else
6248 hdi.cxy = lpColumn->cx;
6249 }
6250
6251 if (lpColumn->mask & LVCF_TEXT)
6252 {
6253 hdi.mask |= HDI_TEXT | HDI_FORMAT;
6254 hdi.pszText = lpColumn->pszText;
6255 hdi.cchTextMax = textlenT(lpColumn->pszText, isW);
6256 hdi.fmt |= HDF_STRING;
6257 }
6258
6259 if (lpColumn->mask & LVCF_IMAGE)
6260 {
6261 hdi.mask |= HDI_IMAGE;
6262 hdi.iImage = lpColumn->iImage;
6263 }
6264
6265 if (lpColumn->mask & LVCF_ORDER)
6266 {
6267 hdi.mask |= HDI_ORDER;
6268 hdi.iOrder = lpColumn->iOrder;
6269 }
6270
6271 /* insert item in header control */
6272 nNewColumn = SendMessageW(infoPtr->hwndHeader,
6273 isW ? HDM_INSERTITEMW : HDM_INSERTITEMA,
6274 (WPARAM)nColumn, (LPARAM)&hdi);
6275
6276 /* Need to reset the item width when inserting a new column */
6277 infoPtr->nItemWidth = LISTVIEW_GetItemWidth(infoPtr);
6278
6279 LISTVIEW_UpdateScroll(infoPtr);
6280 InvalidateRect(infoPtr->hwndSelf, NULL, FALSE);
6281 }
6282
6283 return nNewColumn;
6284 }
6285
6286 /* LISTVIEW_InsertCompare: callback routine for comparing pszText members of the LV_ITEMS
6287 in a LISTVIEW on insert. Passed to DPA_Sort in LISTVIEW_InsertItem.
6288 This function should only be used for inserting items into a sorted list (LVM_INSERTITEM)
6289 and not during the processing of a LVM_SORTITEMS message. Applications should provide
6290 their own sort proc. when sending LVM_SORTITEMS.
6291 */
6292 /* Platform SDK:
6293 (remarks on LVITEM: LVM_INSERTITEM will insert the new item in the proper sort postion...
6294 if:
6295 LVS_SORTXXX must be specified,
6296 LVS_OWNERDRAW is not set,
6297 <item>.pszText is not LPSTR_TEXTCALLBACK.
6298
6299 (LVS_SORT* flags): "For the LVS_SORTASCENDING... styles, item indices
6300 are sorted based on item text..."
6301 */
6302 static INT WINAPI LISTVIEW_InsertCompare( LPVOID first, LPVOID second, LPARAM lParam)
6303 {
6304 LONG lStyle = GetWindowLongW((HWND) lParam, GWL_STYLE);
6305 LISTVIEW_ITEM* lv_first = (LISTVIEW_ITEM*) DPA_GetPtr( (HDPA)first, 0 );
6306 LISTVIEW_ITEM* lv_second = (LISTVIEW_ITEM*) DPA_GetPtr( (HDPA)second, 0 );
6307 INT cmpv = textcmpWT(lv_first->hdr.pszText, lv_second->hdr.pszText, TRUE);
6308
6309 /* if we're sorting descending, negate the return value */
6310 return (lStyle & LVS_SORTDESCENDING) ? -cmpv : cmpv;
6311 }
6312
6313 /***
6314 * nESCRIPTION:
6315 * Inserts a new item in the listview control.
6316 *
6317 * PARAMETER(S):
6318 * [I] infoPtr : valid pointer to the listview structure
6319 * [I] LPLVITEMW : item information
6320 * [I] isW : TRUE if lpLVItem is Unicode, FALSE if it's ANSI
6321 *
6322 * RETURN:
6323 * SUCCESS : new item index
6324 * FAILURE : -1
6325 */
6326 static LRESULT LISTVIEW_InsertItemT(LISTVIEW_INFO *infoPtr, LPLVITEMW lpLVItem, BOOL isW)
6327 {
6328 LONG lStyle = GetWindowLongW(infoPtr->hwndSelf, GWL_STYLE);
6329 UINT uView = lStyle & LVS_TYPEMASK;
6330 INT nItem = -1;
6331 HDPA hdpaSubItems;
6332 NMLISTVIEW nmlv;
6333 LISTVIEW_ITEM *lpItem;
6334 BOOL is_sorted;
6335
6336 TRACE("(lpLVItem=%s, isW=%d)\n", debuglvitem_t(lpLVItem, isW), isW);
6337
6338 if (lStyle & LVS_OWNERDATA)
6339 {
6340 nItem = infoPtr->hdpaItems->nItemCount;
6341 infoPtr->hdpaItems->nItemCount++;
6342 return nItem;
6343 }
6344
6345 /* make sure it's an item, and not a subitem; cannot insert a subitem */
6346 if (!lpLVItem || lpLVItem->iSubItem) return -1;
6347
6348 if (!is_assignable_item(lpLVItem, lStyle)) return -1;
6349
6350 if ( !(lpItem = (LISTVIEW_ITEM *)COMCTL32_Alloc(sizeof(LISTVIEW_ITEM))) )
6351 return -1;
6352
6353 ZeroMemory(lpItem, sizeof(LISTVIEW_ITEM));
6354
6355 /* insert item in listview control data structure */
6356 if ( (hdpaSubItems = DPA_Create(8)) )
6357 nItem = DPA_InsertPtr(hdpaSubItems, 0, lpItem);
6358 if (nItem == -1) goto fail;
6359
6360 is_sorted = (lStyle & (LVS_SORTASCENDING | LVS_SORTDESCENDING)) &&
6361 !(lStyle & LVS_OWNERDRAWFIXED) && (LPSTR_TEXTCALLBACKW != lpLVItem->pszText);
6362
6363 nItem = DPA_InsertPtr( infoPtr->hdpaItems,
6364 is_sorted ? GETITEMCOUNT( infoPtr ) + 1 : lpLVItem->iItem,
6365 hdpaSubItems );
6366 if (nItem == -1) goto fail;
6367
6368 if (!LISTVIEW_SetItemT(infoPtr, lpLVItem, isW)) goto fail;
6369
6370 /* if we're sorted, sort the list, and update the index */
6371 if (is_sorted)
6372 {
6373 DPA_Sort( infoPtr->hdpaItems, LISTVIEW_InsertCompare, (LPARAM)infoPtr->hwndSelf );
6374 nItem = DPA_GetPtrIndex( infoPtr->hdpaItems, hdpaSubItems );
6375 if (nItem == -1) goto fail;
6376 }
6377
6378 LISTVIEW_ShiftIndices(infoPtr, nItem, 1);
6379
6380 lpItem->valid = TRUE;
6381
6382 /* send LVN_INSERTITEM notification */
6383 ZeroMemory(&nmlv, sizeof(NMLISTVIEW));
6384 nmlv.iItem = nItem;
6385 nmlv.lParam = lpItem->lParam;
6386 listview_notify(infoPtr, LVN_INSERTITEM, &nmlv);
6387
6388 /* align items (set position of each item) */
6389 if ((uView == LVS_SMALLICON) || (uView == LVS_ICON))
6390 {
6391 if (lStyle & LVS_ALIGNLEFT) LISTVIEW_AlignLeft(infoPtr);
6392 else LISTVIEW_AlignTop(infoPtr);
6393 }
6394
6395 LISTVIEW_UpdateScroll(infoPtr);
6396
6397 /* FIXME: refresh client area */
6398 InvalidateRect(infoPtr->hwndSelf, NULL, FALSE);
6399
6400 return nItem;
6401
6402 fail:
6403 DPA_Destroy (hdpaSubItems);
6404 COMCTL32_Free (lpItem);
6405 return -1;
6406 }
6407
6408 /***
6409 * DESCRIPTION:
6410 * Redraws a range of items.
6411 *
6412 * PARAMETER(S):
6413 * [I] infoPtr : valid pointer to the listview structure
6414 * [I] INT : first item
6415 * [I] INT : last item
6416 *
6417 * RETURN:
6418 * SUCCESS : TRUE
6419 * FAILURE : FALSE
6420 */
6421 static LRESULT LISTVIEW_RedrawItems(LISTVIEW_INFO *infoPtr, INT nFirst, INT nLast)
6422 {
6423 RECT rcItem;
6424 INT i;
6425
6426 if (nLast < nFirst || min(nFirst, nLast) < 0 ||
6427 max(nFirst, nLast) >= GETITEMCOUNT(infoPtr))
6428 return FALSE;
6429
6430 for (i = nFirst; i <= nLast; i++)
6431 {
6432 rcItem.left = LVIR_BOUNDS;
6433 LISTVIEW_GetItemRect(infoPtr, i, &rcItem);
6434 InvalidateRect(infoPtr->hwndSelf, &rcItem, TRUE);
6435 }
6436
6437 return TRUE;
6438 }
6439
6440 /***
6441 * DESCRIPTION:
6442 * Scroll the content of a listview.
6443 *
6444 * PARAMETER(S):
6445 * [I] infoPtr : valid pointer to the listview structure
6446 * [I] INT : horizontal scroll amount in pixels
6447 * [I] INT : vertical scroll amount in pixels
6448 *
6449 * RETURN:
6450 * SUCCESS : TRUE
6451 * FAILURE : FALSE
6452 *
6453 * COMMENTS:
6454 * If the control is in report mode (LVS_REPORT) the control can
6455 * be scrolled only in line increments. "dy" will be rounded to the
6456 * nearest number of pixels that are a whole line. Ex: if line height
6457 * is 16 and an 8 is passed, the list will be scrolled by 16. If a 7
6458 * is passed the the scroll will be 0. (per MSDN 7/2002)
6459 *
6460 * For: (per experimentaion with native control and CSpy ListView)
6461 * LVS_ICON dy=1 = 1 pixel (vertical only)
6462 * dx ignored
6463 * LVS_SMALLICON dy=1 = 1 pixel (vertical only)
6464 * dx ignored
6465 * LVS_LIST dx=1 = 1 column (horizontal only)
6466 * but will only scroll 1 column per message
6467 * no matter what the value.
6468 * dy must be 0 or FALSE returned.
6469 * LVS_REPORT dx=1 = 1 pixel
6470 * dy= see above
6471 *
6472 */
6473 static LRESULT LISTVIEW_Scroll(LISTVIEW_INFO *infoPtr, INT dx, INT dy)
6474 {
6475 switch(LISTVIEW_GetType(infoPtr)) {
6476 case LVS_REPORT:
6477 dy += (dy < 0 ? -1 : 1) * infoPtr->nItemHeight/2;
6478 dy /= infoPtr->nItemHeight;
6479 break;
6480 case LVS_LIST:
6481 if (dy != 0) return FALSE;
6482 break;
6483 default: /* icon */
6484 dx = 0;
6485 break;
6486 }
6487
6488 if (dx != 0) LISTVIEW_HScroll(infoPtr, SB_INTERNAL, dx, 0);
6489 if (dy != 0) LISTVIEW_VScroll(infoPtr, SB_INTERNAL, dy, 0);
6490
6491 return TRUE;
6492 }
6493
6494 /***
6495 * DESCRIPTION:
6496 * Sets the background color.
6497 *
6498 * PARAMETER(S):
6499 * [I] infoPtr : valid pointer to the listview structure
6500 * [I] COLORREF : background color
6501 *
6502 * RETURN:
6503 * SUCCESS : TRUE
6504 * FAILURE : FALSE
6505 */
6506 static LRESULT LISTVIEW_SetBkColor(LISTVIEW_INFO *infoPtr, COLORREF clrBk)
6507 {
6508 if(infoPtr->clrBk != clrBk) {
6509 infoPtr->clrBk = clrBk;
6510 if (infoPtr->hBkBrush) DeleteObject(infoPtr->hBkBrush);
6511 infoPtr->hBkBrush = clrBk == CLR_NONE ? 0 : CreateSolidBrush(clrBk);
6512 InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
6513 }
6514
6515 return TRUE;
6516 }
6517
6518 /* LISTVIEW_SetBkImage */
6519
6520 /***
6521 * DESCRIPTION:
6522 * Sets the attributes of a header item.
6523 *
6524 * PARAMETER(S):
6525 * [I] infoPtr : valid pointer to the listview structure
6526 * [I] INT : column index
6527 * [I] LPLVCOLUMNW : column attributes
6528 * [I] isW: if TRUE, the lpColumn is a LPLVCOLUMNW,
6529 * otherwise it is in fact a LPLVCOLUMNA
6530 *
6531 * RETURN:
6532 * SUCCESS : TRUE
6533 * FAILURE : FALSE
6534 */
6535 static LRESULT LISTVIEW_SetColumnT(LISTVIEW_INFO *infoPtr, INT nColumn,
6536 LPLVCOLUMNW lpColumn, BOOL isW)
6537 {
6538 BOOL bResult = FALSE;
6539 HDITEMW hdi, hdiget;
6540
6541 if ((lpColumn != NULL) && (nColumn >= 0) &&
6542 (nColumn < Header_GetItemCount(infoPtr->hwndHeader)))
6543 {
6544 /* initialize memory */
6545 ZeroMemory(&hdi, sizeof(hdi));
6546
6547 if (lpColumn->mask & LVCF_FMT)
6548 {
6549 /* format member is valid */
6550 hdi.mask |= HDI_FORMAT;
6551
6552 /* get current format first */
6553 hdiget.mask = HDI_FORMAT;
6554 if (Header_GetItemW(infoPtr->hwndHeader, nColumn, &hdiget))
6555 /* preserve HDF_STRING if present */
6556 hdi.fmt = hdiget.fmt & HDF_STRING;
6557
6558 /* set text alignment (leftmost column must be left-aligned) */
6559 if (nColumn == 0)
6560 {
6561 hdi.fmt |= HDF_LEFT;
6562 }
6563 else
6564 {
6565 if (lpColumn->fmt & LVCFMT_LEFT)
6566 hdi.fmt |= HDF_LEFT;
6567 else if (lpColumn->fmt & LVCFMT_RIGHT)
6568 hdi.fmt |= HDF_RIGHT;
6569 else if (lpColumn->fmt & LVCFMT_CENTER)
6570 hdi.fmt |= HDF_CENTER;
6571 }
6572
6573 if (lpColumn->fmt & LVCFMT_BITMAP_ON_RIGHT)
6574 hdi.fmt |= HDF_BITMAP_ON_RIGHT;
6575
6576 if (lpColumn->fmt & LVCFMT_COL_HAS_IMAGES)
6577 hdi.fmt |= HDF_IMAGE;
6578
6579 if (lpColumn->fmt & LVCFMT_IMAGE)
6580 {
6581 hdi.fmt |= HDF_IMAGE;
6582 hdi.iImage = I_IMAGECALLBACK;
6583 }
6584 }
6585
6586 if (lpColumn->mask & LVCF_WIDTH)
6587 {
6588 hdi.mask |= HDI_WIDTH;
6589 hdi.cxy = lpColumn->cx;
6590 }
6591
6592 if (lpColumn->mask & LVCF_TEXT)
6593 {
6594 hdi.mask |= HDI_TEXT | HDI_FORMAT;
6595 hdi.pszText = lpColumn->pszText;
6596 hdi.cchTextMax = textlenT(lpColumn->pszText, isW);
6597 hdi.fmt |= HDF_STRING;
6598 }
6599
6600 if (lpColumn->mask & LVCF_IMAGE)
6601 {
6602 hdi.mask |= HDI_IMAGE;
6603 hdi.iImage = lpColumn->iImage;
6604 }
6605
6606 if (lpColumn->mask & LVCF_ORDER)
6607 {
6608 hdi.mask |= HDI_ORDER;
6609 hdi.iOrder = lpColumn->iOrder;
6610 }
6611
6612 /* set header item attributes */
6613 if (isW)
6614 bResult = Header_SetItemW(infoPtr->hwndHeader, nColumn, &hdi);
6615 else
6616 bResult = Header_SetItemA(infoPtr->hwndHeader, nColumn, &hdi);
6617 }
6618
6619 return bResult;
6620 }
6621
6622 /***
6623 * DESCRIPTION:
6624 * Sets the column order array
6625 *
6626 * PARAMETERS:
6627 * [I] infoPtr : valid pointer to the listview structure
6628 * [I] INT : number of elements in column order array
6629 * [I] INT : pointer to column order array
6630 *
6631 * RETURN:
6632 * SUCCESS : TRUE
6633 * FAILURE : FALSE
6634 */
6635 static LRESULT LISTVIEW_SetColumnOrderArray(LISTVIEW_INFO *infoPtr, INT iCount, LPINT lpiArray)
6636 {
6637 FIXME("iCount %d lpiArray %p\n", iCount, lpiArray);
6638
6639 if (!lpiArray)
6640 return FALSE;
6641
6642 return TRUE;
6643 }
6644
6645
6646 /***
6647 * DESCRIPTION:
6648 * Sets the width of a column
6649 *
6650 * PARAMETERS:
6651 * [I] infoPtr : valid pointer to the listview structure
6652 * [I] INT : column index
6653 * [I] INT : column width
6654 *
6655 * RETURN:
6656 * SUCCESS : TRUE
6657 * FAILURE : FALSE
6658 */
6659 static LRESULT LISTVIEW_SetColumnWidth(LISTVIEW_INFO *infoPtr, INT iCol, INT cx)
6660 {
6661 HDITEMW hdi;
6662 LRESULT lret;
6663 LONG lStyle = GetWindowLongW(infoPtr->hwndSelf, GWL_STYLE);
6664 UINT uView = lStyle & LVS_TYPEMASK;
6665 HDC hdc;
6666 HFONT header_font;
6667 HFONT old_font;
6668 SIZE size;
6669 WCHAR text_buffer[DISP_TEXT_SIZE];
6670 INT header_item_count;
6671 INT item_index;
6672 INT nLabelWidth;
6673 RECT rcHeader;
6674 LVITEMW lvItem;
6675 WCHAR szDispText[DISP_TEXT_SIZE];
6676
6677 if (!infoPtr->hwndHeader) /* make sure we have a header */
6678 return (FALSE);
6679
6680 /* set column width only if in report or list mode */
6681 if ((uView != LVS_REPORT) && (uView != LVS_LIST))
6682 return (FALSE);
6683
6684 TRACE("(iCol=%d, cx=%d\n", iCol, cx);
6685
6686 /* take care of invalid cx values */
6687 if((uView == LVS_REPORT) && (cx < -2))
6688 cx = LVSCW_AUTOSIZE;
6689 else if (uView == LVS_LIST && (cx < 1))
6690 return FALSE;
6691
6692 /* resize all columns if in LVS_LIST mode */
6693 if(uView == LVS_LIST) {
6694 infoPtr->nItemWidth = cx;
6695 InvalidateRect(infoPtr->hwndSelf, NULL, TRUE); /* force redraw of the listview */
6696 return TRUE;
6697 }
6698
6699 /* autosize based on listview items width */
6700 if(cx == LVSCW_AUTOSIZE)
6701 {
6702 /* set the width of the column to the width of the widest item */
6703 if (iCol == 0 || uView == LVS_LIST)
6704 {
6705 cx = 0;
6706 for(item_index = 0; item_index < GETITEMCOUNT(infoPtr); item_index++)
6707 {
6708 nLabelWidth = LISTVIEW_GetLabelWidth(infoPtr, item_index);
6709 cx = (nLabelWidth>cx)?nLabelWidth:cx;
6710 }
6711 if (infoPtr->himlSmall)
6712 cx += infoPtr->iconSize.cx + IMAGE_PADDING;
6713 }
6714 else
6715 {
6716 ZeroMemory(&lvItem, sizeof(lvItem));
6717 lvItem.iSubItem = iCol;
6718 lvItem.mask = LVIF_TEXT;
6719 lvItem.cchTextMax = DISP_TEXT_SIZE;
6720 lvItem.pszText = szDispText;
6721 *lvItem.pszText = '\0';
6722 cx = 0;
6723 for(item_index = 0; item_index < GETITEMCOUNT(infoPtr); item_index++)
6724 {
6725 lvItem.iItem = item_index;
6726 LISTVIEW_GetItemT(infoPtr, &lvItem, FALSE, TRUE);
6727 nLabelWidth = LISTVIEW_GetStringWidthT(infoPtr, lvItem.pszText, TRUE);
6728 cx = (nLabelWidth>cx)?nLabelWidth:cx;
6729 }
6730 }
6731 cx += TRAILING_PADDING;
6732 } /* autosize based on listview header width */
6733 else if(cx == LVSCW_AUTOSIZE_USEHEADER)
6734 {
6735 header_item_count = Header_GetItemCount(infoPtr->hwndHeader);
6736
6737 /* if iCol is the last column make it fill the remainder of the controls width */
6738 if(iCol == (header_item_count - 1)) {
6739 /* get the width of every item except the current one */
6740 hdi.mask = HDI_WIDTH;
6741 cx = 0;
6742
6743 for(item_index = 0; item_index < (header_item_count - 1); item_index++) {
6744 Header_GetItemW(infoPtr->hwndHeader, item_index, (LPARAM)(&hdi));
6745 cx+=hdi.cxy;
6746 }
6747
6748 /* retrieve the layout of the header */
6749 GetWindowRect(infoPtr->hwndHeader, &rcHeader);
6750
6751 cx = (rcHeader.right - rcHeader.left) - cx;
6752 }
6753 else
6754 {
6755 /* Despite what the MS docs say, if this is not the last
6756 column, then MS resizes the column to the width of the
6757 largest text string in the column, including headers
6758 and items. This is different from LVSCW_AUTOSIZE in that
6759 LVSCW_AUTOSIZE ignores the header string length.
6760 */
6761
6762 /* retrieve header font */
6763 header_font = SendMessageW(infoPtr->hwndHeader, WM_GETFONT, 0L, 0L);
6764
6765 /* retrieve header text */
6766 hdi.mask = HDI_TEXT;
6767 hdi.cchTextMax = sizeof(text_buffer)/sizeof(text_buffer[0]);
6768 hdi.pszText = text_buffer;
6769
6770 Header_GetItemW(infoPtr->hwndHeader, iCol, (LPARAM)(&hdi));
6771
6772 /* determine the width of the text in the header */
6773 hdc = GetDC(infoPtr->hwndSelf);
6774 old_font = SelectObject(hdc, header_font); /* select the font into hdc */
6775
6776 GetTextExtentPoint32W(hdc, text_buffer, lstrlenW(text_buffer), &size);
6777
6778 SelectObject(hdc, old_font); /* restore the old font */
6779 ReleaseDC(infoPtr->hwndSelf, hdc);
6780
6781 ZeroMemory(&lvItem, sizeof(lvItem));
6782 lvItem.iSubItem = iCol;
6783 lvItem.mask = LVIF_TEXT;
6784 lvItem.cchTextMax = DISP_TEXT_SIZE;
6785 lvItem.pszText = szDispText;
6786 *lvItem.pszText = '\0';
6787 cx = size.cx;
6788 for(item_index = 0; item_index < GETITEMCOUNT(infoPtr); item_index++)
6789 {
6790 lvItem.iItem = item_index;
6791 LISTVIEW_GetItemT(infoPtr, &lvItem, FALSE, TRUE);
6792 nLabelWidth = LISTVIEW_GetStringWidthT(infoPtr, lvItem.pszText, TRUE);
6793 nLabelWidth += TRAILING_PADDING;
6794 /* While it is possible for subitems to have icons, even MS messes
6795 up the positioning, so I suspect no applications actually use
6796 them. */
6797 if (item_index == 0 && infoPtr->himlSmall)
6798 nLabelWidth += infoPtr->iconSize.cx + IMAGE_PADDING;
6799 cx = (nLabelWidth>cx)?nLabelWidth:cx;
6800 }
6801 }
6802 }
6803
6804 /* call header to update the column change */
6805 hdi.mask = HDI_WIDTH;
6806
6807 hdi.cxy = cx;
6808 lret = Header_SetItemW(infoPtr->hwndHeader, (WPARAM)iCol, (LPARAM)&hdi);
6809
6810 InvalidateRect(infoPtr->hwndSelf, NULL, TRUE); /* force redraw of the listview */
6811
6812 return lret;
6813 }
6814
6815 /***
6816 * DESCRIPTION:
6817 * Sets the extended listview style.
6818 *
6819 * PARAMETERS:
6820 * [I] infoPtr : valid pointer to the listview structure
6821 * [I] DWORD : mask
6822 * [I] DWORD : style
6823 *
6824 * RETURN:
6825 * SUCCESS : previous style
6826 * FAILURE : 0
6827 */
6828 static LRESULT LISTVIEW_SetExtendedListViewStyle(LISTVIEW_INFO *infoPtr, DWORD dwMask, DWORD dwStyle)
6829 {
6830 DWORD dwOldStyle = infoPtr->dwExStyle;
6831
6832 /* set new style */
6833 if (dwMask)
6834 infoPtr->dwExStyle = (dwOldStyle & ~dwMask) | (dwStyle & dwMask);
6835 else
6836 infoPtr->dwExStyle = dwStyle;
6837
6838 return dwOldStyle;
6839 }
6840
6841 /***
6842 * DESCRIPTION:
6843 * Sets the new hot cursor used during hot tracking and hover selection.
6844 *
6845 * PARAMETER(S):
6846 * [I] infoPtr : valid pointer to the listview structure
6847 * [I} hCurosr : the new hot cursor handle
6848 *
6849 * RETURN:
6850 * Returns the previous hot cursor
6851 */
6852 static HCURSOR LISTVIEW_SetHotCursor(LISTVIEW_INFO *infoPtr, HCURSOR hCursor)
6853 {
6854 HCURSOR oldCursor = infoPtr->hHotCursor;
6855 infoPtr->hHotCursor = hCursor;
6856 return oldCursor;
6857 }
6858
6859
6860 /***
6861 * DESCRIPTION:
6862 * Sets the hot item index.
6863 *
6864 * PARAMETERS:
6865 * [I] infoPtr : valid pointer to the listview structure
6866 * [I] INT : index
6867 *
6868 * RETURN:
6869 * SUCCESS : previous hot item index
6870 * FAILURE : -1 (no hot item)
6871 */
6872 static LRESULT LISTVIEW_SetHotItem(LISTVIEW_INFO *infoPtr, INT iIndex)
6873 {
6874 INT iOldIndex = infoPtr->nHotItem;
6875 infoPtr->nHotItem = iIndex;
6876 return iOldIndex;
6877 }
6878
6879
6880 /***
6881 * DESCRIPTION:
6882 * Sets the amount of time the cursor must hover over an item before it is selected.
6883 *
6884 * PARAMETER(S):
6885 * [I] infoPtr : valid pointer to the listview structure
6886 * [I] DWORD : dwHoverTime, if -1 the hover time is set to the default
6887 *
6888 * RETURN:
6889 * Returns the previous hover time
6890 */
6891 static LRESULT LISTVIEW_SetHoverTime(LISTVIEW_INFO *infoPtr, DWORD dwHoverTime)
6892 {
6893 DWORD oldHoverTime = infoPtr->dwHoverTime;
6894 infoPtr->dwHoverTime = dwHoverTime;
6895 return oldHoverTime;
6896 }
6897
6898 /***
6899 * DESCRIPTION:
6900 * Sets spacing for icons of LVS_ICON style.
6901 *
6902 * PARAMETER(S):
6903 * [I] infoPtr : valid pointer to the listview structure
6904 * [I] DWORD : MAKELONG(cx, cy)
6905 *
6906 * RETURN:
6907 * MAKELONG(oldcx, oldcy)
6908 */
6909 static LRESULT LISTVIEW_SetIconSpacing(LISTVIEW_INFO *infoPtr, DWORD spacing)
6910 {
6911 INT cy = HIWORD(spacing);
6912 INT cx = LOWORD(spacing);
6913 DWORD oldspacing;
6914 LONG lStyle = GetWindowLongA(infoPtr->hwndSelf, GWL_STYLE);
6915 UINT uView = lStyle & LVS_TYPEMASK;
6916
6917 oldspacing = MAKELONG(infoPtr->iconSpacing.cx, infoPtr->iconSpacing.cy);
6918 if (cx == -1) /* set to default */
6919 cx = GetSystemMetrics(SM_CXICONSPACING);
6920 if (cy == -1) /* set to default */
6921 cy = GetSystemMetrics(SM_CYICONSPACING);
6922
6923 if (cx)
6924 infoPtr->iconSpacing.cx = cx;
6925 else
6926 { /* if 0 then compute width */
6927 if (uView == LVS_ICON)
6928 FIXME("width computation not yet done\n");
6929 /*
6930 * Should scan each item and determine max width of
6931 * icon or label, then make that the width
6932 */
6933 else /* FIXME: unknown computation for non LVS_ICON - this is a guess */
6934 infoPtr->iconSpacing.cx = LISTVIEW_GetItemWidth(infoPtr);
6935 }
6936 if (cy)
6937 infoPtr->iconSpacing.cy = cy;
6938 else
6939 { /* if 0 then compute height */
6940 if (uView == LVS_ICON)
6941 infoPtr->iconSpacing.cy = infoPtr->iconSize.cy + 2 * infoPtr->ntmHeight
6942 + ICON_BOTTOM_PADDING + ICON_TOP_PADDING + LABEL_VERT_PADDING;
6943
6944 else /* FIXME: unknown computation for non LVS_ICON - this is a guess */
6945 infoPtr->iconSpacing.cy = LISTVIEW_GetItemHeight(infoPtr);
6946 }
6947
6948 TRACE("old=(%d,%d), new=(%ld,%ld), iconSize=(%ld,%ld), ntmH=%d\n",
6949 LOWORD(oldspacing), HIWORD(oldspacing),
6950 infoPtr->iconSpacing.cx, infoPtr->iconSpacing.cy,
6951 infoPtr->iconSize.cx, infoPtr->iconSize.cy,
6952 infoPtr->ntmHeight);
6953
6954 /* these depend on the iconSpacing */
6955 infoPtr->nItemWidth = LISTVIEW_GetItemWidth(infoPtr);
6956 infoPtr->nItemHeight = LISTVIEW_GetItemHeight(infoPtr);
6957
6958 return oldspacing;
6959 }
6960
6961 /***
6962 * DESCRIPTION:
6963 * Sets image lists.
6964 *
6965 * PARAMETER(S):
6966 * [I] infoPtr : valid pointer to the listview structure
6967 * [I] INT : image list type
6968 * [I] HIMAGELIST : image list handle
6969 *
6970 * RETURN:
6971 * SUCCESS : old image list
6972 * FAILURE : NULL
6973 */
6974 static HIMAGELIST LISTVIEW_SetImageList(LISTVIEW_INFO *infoPtr, INT nType, HIMAGELIST himl)
6975 {
6976 HIMAGELIST himlOld = 0;
6977 INT oldHeight;
6978 UINT uView = LISTVIEW_GetType(infoPtr);
6979
6980 switch (nType)
6981 {
6982 case LVSIL_NORMAL:
6983 himlOld = infoPtr->himlNormal;
6984 infoPtr->himlNormal = himl;
6985 if(himl && (LVS_ICON == uView))
6986 {
6987 INT cx, cy;
6988 ImageList_GetIconSize(himl, &cx, &cy);
6989 TRACE("icon old size=(%ld,%ld), new size=(%d,%d)\n",
6990 infoPtr->iconSize.cx, infoPtr->iconSize.cy, cx, cy);
6991 infoPtr->iconSize.cx = cx;
6992 infoPtr->iconSize.cy = cy;
6993 LISTVIEW_SetIconSpacing(infoPtr,0);
6994 }
6995 break;
6996
6997 case LVSIL_SMALL:
6998 himlOld = infoPtr->himlSmall;
6999 infoPtr->himlSmall = himl;
7000 break;
7001
7002 case LVSIL_STATE:
7003 himlOld = infoPtr->himlState;
7004 infoPtr->himlState = himl;
7005 ImageList_SetBkColor(infoPtr->himlState, CLR_NONE);
7006 break;
7007 }
7008
7009 oldHeight = infoPtr->nItemHeight;
7010 infoPtr->nItemHeight = LISTVIEW_GetItemHeight(infoPtr);
7011 if (infoPtr->nItemHeight != oldHeight)
7012 LISTVIEW_UpdateScroll(infoPtr);
7013
7014 return himlOld;
7015 }
7016
7017 /***
7018 * DESCRIPTION:
7019 * Preallocates memory (does *not* set the actual count of items !)
7020 *
7021 * PARAMETER(S):
7022 * [I] infoPtr : valid pointer to the listview structure
7023 * [I] INT : item count (projected number of items to allocate)
7024 * [I] DWORD : update flags
7025 *
7026 * RETURN:
7027 * SUCCESS : TRUE
7028 * FAILURE : FALSE
7029 */
7030 static BOOL LISTVIEW_SetItemCount(LISTVIEW_INFO *infoPtr, INT nItems, DWORD dwFlags)
7031 {
7032 TRACE("(nItems=%d, dwFlags=%lx)\n", nItems, dwFlags);
7033
7034 if (GetWindowLongW(infoPtr->hwndSelf, GWL_STYLE) & LVS_OWNERDATA)
7035 {
7036 int precount,topvisible;
7037
7038 TRACE("LVS_OWNERDATA is set!\n");
7039 if (dwFlags & (LVSICF_NOINVALIDATEALL | LVSICF_NOSCROLL))
7040 FIXME("flags %s %s not implemented\n",
7041 (dwFlags & LVSICF_NOINVALIDATEALL) ? "LVSICF_NOINVALIDATEALL"
7042 : "",
7043 (dwFlags & LVSICF_NOSCROLL) ? "LVSICF_NOSCROLL" : "");
7044
7045 /*
7046 * Internally remove all the selections.
7047 */
7048 do
7049 {
7050 LISTVIEW_SELECTION *selection;
7051 selection = DPA_GetPtr(infoPtr->hdpaSelectionRanges,0);
7052 if (selection)
7053 LISTVIEW_RemoveSelectionRange(infoPtr,selection->lower,
7054 selection->upper);
7055 }
7056 while (infoPtr->hdpaSelectionRanges->nItemCount>0);
7057
7058 precount = infoPtr->hdpaItems->nItemCount;
7059 topvisible = ListView_GetTopIndex(infoPtr->hwndSelf) +
7060 LISTVIEW_GetCountPerColumn(infoPtr) + 1;
7061
7062 infoPtr->hdpaItems->nItemCount = nItems;
7063
7064 infoPtr->nItemWidth = max(LISTVIEW_GetItemWidth(infoPtr),
7065 DEFAULT_COLUMN_WIDTH);
7066
7067 LISTVIEW_UpdateSize(infoPtr);
7068 LISTVIEW_UpdateScroll(infoPtr);
7069
7070 if (min(precount,infoPtr->hdpaItems->nItemCount)<topvisible)
7071 InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
7072 }
7073 else
7074 {
7075 /* According to MSDN for non-LVS_OWNERDATA this is just
7076 * a performance issue. The control allocates its internal
7077 * data structures for the number of items specified. It
7078 * cuts down on the number of memory allocations. Therefore
7079 * we will just issue a WARN here
7080 */
7081 WARN("for non-ownerdata performance option not implemented.\n");
7082 }
7083
7084 return TRUE;
7085 }
7086
7087 /***
7088 * DESCRIPTION:
7089 * Sets the position of an item.
7090 *
7091 * PARAMETER(S):
7092 * [I] infoPtr : valid pointer to the listview structure
7093 * [I] INT : item index
7094 * [I] LONG : x coordinate
7095 * [I] LONG : y coordinate
7096 *
7097 * RETURN:
7098 * SUCCESS : TRUE
7099 * FAILURE : FALSE
7100 */
7101 static BOOL LISTVIEW_SetItemPosition(LISTVIEW_INFO *infoPtr, INT nItem,
7102 LONG nPosX, LONG nPosY)
7103 {
7104 UINT lStyle = GetWindowLongW(infoPtr->hwndSelf, GWL_STYLE);
7105 UINT uView = lStyle & LVS_TYPEMASK;
7106 LISTVIEW_ITEM *lpItem;
7107 HDPA hdpaSubItems;
7108 BOOL bResult = FALSE;
7109
7110 TRACE("(nItem=%d, X=%ld, Y=%ld)\n", nItem, nPosX, nPosY);
7111
7112 if (lStyle & LVS_OWNERDATA)
7113 return FALSE;
7114
7115 if ((nItem >= 0) || (nItem < GETITEMCOUNT(infoPtr)))
7116 {
7117 if ((uView == LVS_ICON) || (uView == LVS_SMALLICON))
7118 {
7119 if ( (hdpaSubItems = (HDPA)DPA_GetPtr(infoPtr->hdpaItems, nItem)) )
7120 {
7121 if ( (lpItem = (LISTVIEW_ITEM *)DPA_GetPtr(hdpaSubItems, 0)) )
7122 {
7123 POINT orig;
7124 bResult = TRUE;
7125 orig = lpItem->ptPosition;
7126 if ((nPosX == -1) && (nPosY == -1))
7127 {
7128 /* This point value seems to be an undocumented feature. The
7129 * best guess is that it means either at the origin, or at
7130 * the true beginning of the list. I will assume the origin.
7131 */
7132 POINT pt1;
7133 if (!LISTVIEW_GetOrigin(infoPtr, &pt1))
7134 {
7135 pt1.x = 0;
7136 pt1.y = 0;
7137 }
7138 nPosX = pt1.x;
7139 nPosY = pt1.y;
7140 if (uView == LVS_ICON)
7141 {
7142 nPosX += (infoPtr->iconSpacing.cx - infoPtr->iconSize.cx) / 2;
7143 nPosY += ICON_TOP_PADDING;
7144 }
7145 TRACE("requested special (-1,-1), set to origin (%ld,%ld)\n",
7146 nPosX, nPosY);
7147 }
7148
7149 lpItem->ptPosition.x = nPosX;
7150 lpItem->ptPosition.y = nPosY;
7151 if (uView == LVS_ICON)
7152 {
7153 lpItem->ptPosition.y -= ICON_TOP_PADDING;
7154 lpItem->ptPosition.x -= (infoPtr->iconSpacing.cx - infoPtr->iconSize.cx) / 2;
7155 if ((lpItem->ptPosition.y < 0) || (lpItem->ptPosition.x < 0))
7156 {
7157 FIXME("failed orig (%ld,%ld), intent (%ld,%ld), is (%ld, %ld), setting neg to 0\n",
7158 orig.x, orig.y, nPosX, nPosY, lpItem->ptPosition.x, lpItem->ptPosition.y);
7159
7160 /*
7161 if (lpItem->ptPosition.x < 0) lpItem->ptPosition.x = 0;
7162 if (lpItem->ptPosition.y < 0) lpItem->ptPosition.y = 0;
7163 */
7164 }
7165 else
7166 {
7167 TRACE("orig (%ld,%ld), intent (%ld,%ld), is (%ld,%ld)\n",
7168 orig.x, orig.y, nPosX, nPosY, lpItem->ptPosition.x, lpItem->ptPosition.y);
7169 }
7170 }
7171 }
7172 }
7173 }
7174 }
7175
7176 return bResult;
7177 }
7178
7179 /***
7180 * DESCRIPTION:
7181 * Sets the state of one or many items.
7182 *
7183 * PARAMETER(S):
7184 * [I] infoPtr : valid pointer to the listview structure
7185 * [I]INT : item index
7186 * [I] LPLVITEM : item or subitem info
7187 *
7188 * RETURN:
7189 * SUCCESS : TRUE
7190 * FAILURE : FALSE
7191 */
7192 static LRESULT LISTVIEW_SetItemState(LISTVIEW_INFO *infoPtr, INT nItem, LPLVITEMW lpLVItem)
7193 {
7194 BOOL bResult = TRUE;
7195 LVITEMW lvItem;
7196
7197 TRACE("(nItem=%d, lpLVItem=%s)\n",
7198 nItem, debuglvitem_t(lpLVItem, TRUE));
7199
7200 ZeroMemory(&lvItem, sizeof(lvItem));
7201 lvItem.mask = LVIF_STATE;
7202 lvItem.state = lpLVItem->state;
7203 lvItem.stateMask = lpLVItem->stateMask ;
7204 lvItem.iItem = nItem;
7205
7206 if (nItem == -1)
7207 {
7208 /* apply to all items */
7209 for (lvItem.iItem = 0; lvItem.iItem < GETITEMCOUNT(infoPtr); lvItem.iItem++)
7210 if (!LISTVIEW_SetItemT(infoPtr, &lvItem, TRUE)) bResult = FALSE;
7211 }
7212 else
7213 bResult = LISTVIEW_SetItemT(infoPtr, &lvItem, TRUE);
7214
7215 return bResult;
7216 }
7217
7218 /***
7219 * DESCRIPTION:
7220 * Sets the text of an item or subitem.
7221 *
7222 * PARAMETER(S):
7223 * [I] hwnd : window handle
7224 * [I] nItem : item index
7225 * [I] lpLVItem : item or subitem info
7226 * [I] isW : TRUE if input is Unicode
7227 *
7228 * RETURN:
7229 * SUCCESS : TRUE
7230 * FAILURE : FALSE
7231 */
7232 static BOOL LISTVIEW_SetItemTextT(LISTVIEW_INFO *infoPtr, INT nItem, LPLVITEMW lpLVItem, BOOL isW)
7233 {
7234 BOOL bResult = FALSE;
7235 LVITEMW lvItem;
7236
7237 TRACE("(nItem=%d, lpLVItem=%s, isW=%d)\n",
7238 nItem, debuglvitem_t(lpLVItem, isW), isW);
7239
7240 if ((nItem >= 0) && (nItem < GETITEMCOUNT(infoPtr)))
7241 {
7242 ZeroMemory(&lvItem, sizeof(LVITEMW));
7243 lvItem.mask = LVIF_TEXT;
7244 lvItem.pszText = lpLVItem->pszText;
7245 lvItem.iItem = nItem;
7246 lvItem.iSubItem = lpLVItem->iSubItem;
7247 if(isW) bResult = ListView_SetItemW(infoPtr->hwndSelf, &lvItem);
7248 else bResult = ListView_SetItemA(infoPtr->hwndSelf, &lvItem);
7249 }
7250
7251 return bResult;
7252 }
7253
7254 /***
7255 * DESCRIPTION:
7256 * Set item index that marks the start of a multiple selection.
7257 *
7258 * PARAMETER(S):
7259 * [I] infoPtr : valid pointer to the listview structure
7260 * [I] INT : index
7261 *
7262 * RETURN:
7263 * Index number or -1 if there is no selection mark.
7264 */
7265 static LRESULT LISTVIEW_SetSelectionMark(LISTVIEW_INFO *infoPtr, INT nIndex)
7266 {
7267 INT nOldIndex = infoPtr->nSelectionMark;
7268
7269 TRACE("(nIndex=%d)\n", nIndex);
7270
7271 infoPtr->nSelectionMark = nIndex;
7272
7273 return nOldIndex;
7274 }
7275
7276 /***
7277 * DESCRIPTION:
7278 * Sets the text background color.
7279 *
7280 * PARAMETER(S):
7281 * [I] infoPtr : valid pointer to the listview structure
7282 * [I] COLORREF : text background color
7283 *
7284 * RETURN:
7285 * SUCCESS : TRUE
7286 * FAILURE : FALSE
7287 */
7288 static LRESULT LISTVIEW_SetTextBkColor(LISTVIEW_INFO *infoPtr, COLORREF clrTextBk)
7289 {
7290 TRACE("(clrTextBk=%lx)\n", clrTextBk);
7291
7292 if (infoPtr->clrTextBk != clrTextBk)
7293 {
7294 infoPtr->clrTextBk = clrTextBk;
7295 InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
7296 }
7297
7298 return TRUE;
7299 }
7300
7301 /***
7302 * DESCRIPTION:
7303 * Sets the text foreground color.
7304 *
7305 * PARAMETER(S):
7306 * [I] infoPtr : valid pointer to the listview structure
7307 * [I] COLORREF : text color
7308 *
7309 * RETURN:
7310 * SUCCESS : TRUE
7311 * FAILURE : FALSE
7312 */
7313 static LRESULT LISTVIEW_SetTextColor (LISTVIEW_INFO *infoPtr, COLORREF clrText)
7314 {
7315 TRACE("(clrText=%lx)\n", clrText);
7316
7317 if (infoPtr->clrText != clrText)
7318 {
7319 infoPtr->clrText = clrText;
7320 InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
7321 }
7322
7323 return TRUE;
7324 }
7325
7326 /* LISTVIEW_SetToolTips */
7327 /* LISTVIEW_SetUnicodeFormat */
7328 /* LISTVIEW_SetWorkAreas */
7329
7330 /***
7331 * DESCRIPTION:
7332 * Callback internally used by LISTVIEW_SortItems()
7333 *
7334 * PARAMETER(S):
7335 * [I] LPVOID : first LISTVIEW_ITEM to compare
7336 * [I] LPVOID : second LISTVIEW_ITEM to compare
7337 * [I] LPARAM : HWND of control
7338 *
7339 * RETURN:
7340 * if first comes before second : negative
7341 * if first comes after second : positive
7342 * if first and second are equivalent : zero
7343 */
7344 static INT WINAPI LISTVIEW_CallBackCompare(LPVOID first, LPVOID second, LPARAM lParam)
7345 {
7346 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongW((HWND)lParam, 0);
7347 LISTVIEW_ITEM* lv_first = (LISTVIEW_ITEM*) DPA_GetPtr( (HDPA)first, 0 );
7348 LISTVIEW_ITEM* lv_second = (LISTVIEW_ITEM*) DPA_GetPtr( (HDPA)second, 0 );
7349
7350 /* Forward the call to the client defined callback */
7351 return (infoPtr->pfnCompare)( lv_first->lParam , lv_second->lParam, infoPtr->lParamSort );
7352 }
7353
7354 /***
7355 * DESCRIPTION:
7356 * Sorts the listview items.
7357 *
7358 * PARAMETER(S):
7359 * [I] infoPtr : valid pointer to the listview structure
7360 * [I] WPARAM : application-defined value
7361 * [I] LPARAM : pointer to comparision callback
7362 *
7363 * RETURN:
7364 * SUCCESS : TRUE
7365 * FAILURE : FALSE
7366 */
7367 static LRESULT LISTVIEW_SortItems(LISTVIEW_INFO *infoPtr, PFNLVCOMPARE pfnCompare, LPARAM lParamSort)
7368 {
7369 UINT lStyle = GetWindowLongW(infoPtr->hwndSelf, GWL_STYLE);
7370 HDPA hdpaSubItems;
7371 LISTVIEW_ITEM *lpItem;
7372 LPVOID selectionMarkItem;
7373 int i;
7374
7375 TRACE("(pfnCompare=%p, lParamSort=%lx)\n", pfnCompare, lParamSort);
7376
7377 if (lStyle & LVS_OWNERDATA) return FALSE;
7378
7379 if (!infoPtr->hdpaItems) return FALSE;
7380
7381 /* if there are 0 or 1 items, there is no need to sort */
7382 if (GETITEMCOUNT(infoPtr) < 2) return TRUE;
7383
7384 if (infoPtr->nFocusedItem >= 0)
7385 {
7386 hdpaSubItems = (HDPA)DPA_GetPtr(infoPtr->hdpaItems, infoPtr->nFocusedItem);
7387 lpItem = (LISTVIEW_ITEM *)DPA_GetPtr(hdpaSubItems, 0);
7388 if (lpItem) lpItem->state |= LVIS_FOCUSED;
7389 }
7390
7391 infoPtr->pfnCompare = pfnCompare;
7392 infoPtr->lParamSort = lParamSort;
7393 DPA_Sort(infoPtr->hdpaItems, LISTVIEW_CallBackCompare, (LPARAM)infoPtr->hwndSelf);
7394
7395 /* Adjust selections and indices so that they are the way they should
7396 * be after the sort (otherwise, the list items move around, but
7397 * whatever is at the item's previous original position will be
7398 * selected instead)
7399 */
7400 selectionMarkItem=(infoPtr->nSelectionMark>=0)?DPA_GetPtr(infoPtr->hdpaItems, infoPtr->nSelectionMark):NULL;
7401 for (i=0; i < GETITEMCOUNT(infoPtr); i++)
7402 {
7403 hdpaSubItems = (HDPA)DPA_GetPtr(infoPtr->hdpaItems, i);
7404 lpItem = (LISTVIEW_ITEM *)DPA_GetPtr(hdpaSubItems, 0);
7405
7406 if (lpItem->state & LVIS_SELECTED)
7407 LISTVIEW_AddSelectionRange(infoPtr, i, i);
7408 else
7409 LISTVIEW_RemoveSelectionRange(infoPtr, i, i);
7410 if (lpItem->state & LVIS_FOCUSED)
7411 {
7412 infoPtr->nFocusedItem = i;
7413 lpItem->state &= ~LVIS_FOCUSED;
7414 }
7415 }
7416 if (selectionMarkItem != NULL)
7417 infoPtr->nSelectionMark = DPA_GetPtrIndex(infoPtr->hdpaItems, selectionMarkItem);
7418 /* I believe nHotItem should be left alone, see LISTVIEW_ShiftIndices */
7419
7420 /* align the items */
7421 LISTVIEW_AlignTop(infoPtr);
7422
7423 /* refresh the display */
7424 InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
7425
7426 return TRUE;
7427 }
7428
7429 /* LISTVIEW_SubItemHitTest */
7430
7431 /***
7432 * DESCRIPTION:
7433 * Updates an items or rearranges the listview control.
7434 *
7435 * PARAMETER(S):
7436 * [I] infoPtr : valid pointer to the listview structure
7437 * [I] INT : item index
7438 *
7439 * RETURN:
7440 * SUCCESS : TRUE
7441 * FAILURE : FALSE
7442 */
7443 static LRESULT LISTVIEW_Update(LISTVIEW_INFO *infoPtr, INT nItem)
7444 {
7445 LONG lStyle = GetWindowLongW(infoPtr->hwndSelf, GWL_STYLE);
7446 BOOL bResult = FALSE;
7447 RECT rc;
7448
7449 TRACE("(nItem=%d)\n", nItem);
7450
7451 if ((nItem >= 0) && (nItem < GETITEMCOUNT(infoPtr)))
7452 {
7453 bResult = TRUE;
7454
7455 /* rearrange with default alignment style */
7456 if ((lStyle & LVS_AUTOARRANGE) && (((lStyle & LVS_TYPEMASK) == LVS_ICON) ||
7457 ((lStyle & LVS_TYPEMASK) == LVS_SMALLICON)))
7458 {
7459 ListView_Arrange(infoPtr->hwndSelf, 0);
7460 }
7461 else
7462 {
7463 /* get item bounding rectangle */
7464 ListView_GetItemRect(infoPtr->hwndSelf, nItem, &rc, LVIR_BOUNDS);
7465 InvalidateRect(infoPtr->hwndSelf, &rc, TRUE);
7466 }
7467 }
7468
7469 return bResult;
7470 }
7471
7472 /***
7473 * DESCRIPTION:
7474 * Creates the listview control.
7475 *
7476 * PARAMETER(S):
7477 * [I] hwnd : window handle
7478 * [I] lpcs : the create parameters
7479 *
7480 * RETURN:
7481 * Success: 0
7482 * Failure: -1
7483 */
7484 static LRESULT LISTVIEW_Create(HWND hwnd, LPCREATESTRUCTW lpcs)
7485 {
7486 LISTVIEW_INFO *infoPtr;
7487 UINT uView = lpcs->style & LVS_TYPEMASK;
7488 LOGFONTW logFont;
7489
7490 TRACE("(lpcs=%p)\n", lpcs);
7491
7492 /* initialize info pointer */
7493 infoPtr = (LISTVIEW_INFO *)COMCTL32_Alloc(sizeof(LISTVIEW_INFO));
7494 if (!infoPtr) return -1;
7495
7496 SetWindowLongW(hwnd, 0, (LONG)infoPtr);
7497 ZeroMemory(infoPtr, sizeof(LISTVIEW_INFO));
7498
7499 infoPtr->hwndSelf = hwnd;
7500 /* determine the type of structures to use */
7501 infoPtr->notifyFormat = SendMessageW(GetParent(infoPtr->hwndSelf), WM_NOTIFYFORMAT,
7502 (WPARAM)infoPtr->hwndSelf, (LPARAM)NF_QUERY);
7503
7504 /* initialize color information */
7505 infoPtr->clrBk = comctl32_color.clrWindow;
7506 infoPtr->clrText = comctl32_color.clrWindowText;
7507 infoPtr->clrTextBk = CLR_DEFAULT;
7508 infoPtr->hBkBrush = CreateSolidBrush(infoPtr->clrBk);
7509
7510 /* set default values */
7511 infoPtr->uCallbackMask = 0;
7512 infoPtr->nFocusedItem = -1;
7513 infoPtr->nSelectionMark = -1;
7514 infoPtr->nHotItem = -1;
7515 infoPtr->iconSpacing.cx = GetSystemMetrics(SM_CXICONSPACING);
7516 infoPtr->iconSpacing.cy = GetSystemMetrics(SM_CYICONSPACING);
7517 infoPtr->hwndEdit = 0;
7518 infoPtr->bEditing = FALSE;
7519 infoPtr->nEditLabelItem = -1;
7520 infoPtr->bIsDrawing = FALSE;
7521
7522 /* get default font (icon title) */
7523 SystemParametersInfoW(SPI_GETICONTITLELOGFONT, 0, &logFont, 0);
7524 infoPtr->hDefaultFont = CreateFontIndirectW(&logFont);
7525 infoPtr->hFont = infoPtr->hDefaultFont;
7526 LISTVIEW_SaveTextMetrics(infoPtr);
7527
7528 /* create header */
7529 infoPtr->hwndHeader = CreateWindowW(WC_HEADERW, (LPCWSTR)NULL,
7530 WS_CHILD | HDS_HORZ | (DWORD)((LVS_NOSORTHEADER & lpcs->style)?0:HDS_BUTTONS),
7531 0, 0, 0, 0, hwnd, (HMENU)0,
7532 lpcs->hInstance, NULL);
7533
7534 /* set header unicode format */
7535 SendMessageW(infoPtr->hwndHeader, HDM_SETUNICODEFORMAT,(WPARAM)TRUE,(LPARAM)NULL);
7536
7537 /* set header font */
7538 SendMessageW(infoPtr->hwndHeader, WM_SETFONT, (WPARAM)infoPtr->hFont,
7539 (LPARAM)TRUE);
7540
7541 if (uView == LVS_ICON)
7542 {
7543 infoPtr->iconSize.cx = GetSystemMetrics(SM_CXICON);
7544 infoPtr->iconSize.cy = GetSystemMetrics(SM_CYICON);
7545 }
7546 else if (uView == LVS_REPORT)
7547 {
7548 if (!(LVS_NOCOLUMNHEADER & lpcs->style))
7549 {
7550 ShowWindow(infoPtr->hwndHeader, SW_SHOWNORMAL);
7551 }
7552 else
7553 {
7554 /* set HDS_HIDDEN flag to hide the header bar */
7555 SetWindowLongW(infoPtr->hwndHeader, GWL_STYLE,
7556 GetWindowLongW(infoPtr->hwndHeader, GWL_STYLE) | HDS_HIDDEN);
7557 }
7558
7559
7560 infoPtr->iconSize.cx = GetSystemMetrics(SM_CXSMICON);
7561 infoPtr->iconSize.cy = GetSystemMetrics(SM_CYSMICON);
7562 }
7563 else
7564 {
7565 infoPtr->iconSize.cx = GetSystemMetrics(SM_CXSMICON);
7566 infoPtr->iconSize.cy = GetSystemMetrics(SM_CYSMICON);
7567 }
7568
7569 /* display unsupported listview window styles */
7570 LISTVIEW_UnsupportedStyles(lpcs->style);
7571
7572 /* allocate memory for the data structure */
7573 infoPtr->hdpaItems = DPA_Create(10);
7574
7575 /* allocate memory for the selection ranges */
7576 infoPtr->hdpaSelectionRanges = DPA_Create(10);
7577
7578 /* initialize size of items */
7579 infoPtr->nItemWidth = LISTVIEW_GetItemWidth(infoPtr);
7580 infoPtr->nItemHeight = LISTVIEW_GetItemHeight(infoPtr);
7581
7582 /* initialize the hover time to -1(indicating the default system hover time) */
7583 infoPtr->dwHoverTime = -1;
7584
7585 return 0;
7586 }
7587
7588 /***
7589 * DESCRIPTION:
7590 * Erases the background of the listview control.
7591 *
7592 * PARAMETER(S):
7593 * [I] infoPtr : valid pointer to the listview structure
7594 * [I] WPARAM : device context handle
7595 * [I] LPARAM : not used
7596 *
7597 * RETURN:
7598 * SUCCESS : TRUE
7599 * FAILURE : FALSE
7600 */
7601 static LRESULT LISTVIEW_EraseBackground(LISTVIEW_INFO *infoPtr, WPARAM wParam,
7602 LPARAM lParam)
7603 {
7604 RECT rc;
7605
7606 TRACE("(wParam=%x, lParam=%lx)\n", wParam, lParam);
7607
7608 if (infoPtr->clrBk == CLR_NONE)
7609 return SendMessageW(GetParent(infoPtr->hwndSelf), WM_ERASEBKGND, wParam, lParam);
7610
7611 GetClientRect(infoPtr->hwndSelf, &rc);
7612 FillRect((HDC)wParam, &rc, infoPtr->hBkBrush);
7613
7614 return 0;
7615 }
7616
7617 /***
7618 * DESCRIPTION:
7619 * Helper function for LISTVIEW_[HV]Scroll *only*.
7620 * Performs vertical/horizontal scrolling by a give amount.
7621 *
7622 * PARAMETER(S):
7623 * [I] infoPtr : valid pointer to the listview structure
7624 * [I] dx : amount of horizontal scroll
7625 * [I] dy : amount of vertical scroll
7626 */
7627 static void scroll_list(LISTVIEW_INFO *infoPtr, INT dx, INT dy)
7628 {
7629 /* if we have a focus rectagle, we have to erase it before we scroll */
7630 if (infoPtr->bFocus) LISTVIEW_ToggleFocusRect(infoPtr);
7631
7632 /* now we can scroll the list */
7633 ScrollWindowEx( infoPtr->hwndSelf, dx, dy, &infoPtr->rcList,
7634 &infoPtr->rcList, 0, 0, SW_INVALIDATE);
7635
7636 /* if we have focus, adjust rect, and redraw the rectangle */
7637 if (infoPtr->bFocus)
7638 {
7639 OffsetRect(&infoPtr->rcFocus, dx, dy);
7640 LISTVIEW_ToggleFocusRect(infoPtr);
7641 }
7642 }
7643
7644 /***
7645 * DESCRIPTION:
7646 * Performs vertical scrolling.
7647 *
7648 * PARAMETER(S):
7649 * [I] infoPtr : valid pointer to the listview structure
7650 * [I] nScrollCode : scroll code
7651 * [I] nScrollDiff : units to scroll in SB_INTERNAL mode, 0 otherwise
7652 * [I] hScrollWnd : scrollbar control window handle
7653 *
7654 * RETURN:
7655 * Zero
7656 *
7657 * NOTES:
7658 * SB_LINEUP/SB_LINEDOWN:
7659 * for LVS_ICON, LVS_SMALLICON is 37 by experiment
7660 * for LVS_REPORT is 1 line
7661 * for LVS_LIST cannot occur
7662 *
7663 */
7664 static LRESULT LISTVIEW_VScroll(LISTVIEW_INFO *infoPtr, INT nScrollCode,
7665 INT nScrollDiff, HWND hScrollWnd)
7666 {
7667 UINT uView = LISTVIEW_GetType(infoPtr);
7668 INT nOldScrollPos, nNewScrollPos;
7669 SCROLLINFO scrollInfo;
7670 BOOL is_an_icon;
7671
7672 TRACE("(nScrollCode=%d, nScrollDiff=%d)\n", nScrollCode, nScrollDiff);
7673
7674 SendMessageW(infoPtr->hwndEdit, WM_KILLFOCUS, 0, 0);
7675
7676 ZeroMemory(&scrollInfo, sizeof(SCROLLINFO));
7677 scrollInfo.cbSize = sizeof(SCROLLINFO);
7678 scrollInfo.fMask = SIF_PAGE | SIF_POS | SIF_RANGE | SIF_TRACKPOS;
7679
7680 is_an_icon = ((uView == LVS_ICON) || (uView == LVS_SMALLICON));
7681
7682 if (!GetScrollInfo(infoPtr->hwndSelf, SB_VERT, &scrollInfo)) return 1;
7683
7684 nOldScrollPos = scrollInfo.nPos;
7685 switch (nScrollCode)
7686 {
7687 case SB_INTERNAL:
7688 break;
7689
7690 case SB_LINEUP:
7691 nScrollDiff = (is_an_icon) ? -LISTVIEW_SCROLL_ICON_LINE_SIZE : -1;
7692 break;
7693
7694 case SB_LINEDOWN:
7695 nScrollDiff = (is_an_icon) ? LISTVIEW_SCROLL_ICON_LINE_SIZE : 1;
7696 break;
7697
7698 case SB_PAGEUP:
7699 nScrollDiff = -scrollInfo.nPage;
7700 break;
7701
7702 case SB_PAGEDOWN:
7703 nScrollDiff = scrollInfo.nPage;
7704 break;
7705
7706 case SB_THUMBPOSITION:
7707 case SB_THUMBTRACK:
7708 nScrollDiff = scrollInfo.nTrackPos - scrollInfo.nPos;
7709 break;
7710
7711 default:
7712 nScrollDiff = 0;
7713 }
7714
7715 /* quit right away if pos isn't changing */
7716 if (nScrollDiff == 0) return 0;
7717
7718 /* calculate new position, and handle overflows */
7719 nNewScrollPos = scrollInfo.nPos + nScrollDiff;
7720 if (nScrollDiff > 0) {
7721 if (nNewScrollPos < nOldScrollPos ||
7722 nNewScrollPos > scrollInfo.nMax)
7723 nNewScrollPos = scrollInfo.nMax;
7724 } else {
7725 if (nNewScrollPos > nOldScrollPos ||
7726 nNewScrollPos < scrollInfo.nMin)
7727 nNewScrollPos = scrollInfo.nMin;
7728 }
7729
7730 /* set the new position, and reread in case it changed */
7731 scrollInfo.fMask = SIF_POS;
7732 scrollInfo.nPos = nNewScrollPos;
7733 nNewScrollPos = SetScrollInfo(infoPtr->hwndSelf, SB_VERT, &scrollInfo, TRUE);
7734
7735 /* carry on only if it really changed */
7736 if (nNewScrollPos == nOldScrollPos) return 0;
7737
7738 /* now adjust to client coordinates */
7739 nScrollDiff = nOldScrollPos - nNewScrollPos;
7740 if (uView == LVS_REPORT) nScrollDiff *= infoPtr->nItemHeight;
7741
7742 /* and scroll the window */
7743 scroll_list(infoPtr, 0, nScrollDiff);
7744
7745 return 0;
7746 }
7747
7748 /***
7749 * DESCRIPTION:
7750 * Performs horizontal scrolling.
7751 *
7752 * PARAMETER(S):
7753 * [I] infoPtr : valid pointer to the listview structure
7754 * [I] nScrollCode : scroll code
7755 * [I] nScrollDiff : units to scroll in SB_INTERNAL mode, 0 otherwise
7756 * [I] hScrollWnd : scrollbar control window handle
7757 *
7758 * RETURN:
7759 * Zero
7760 *
7761 * NOTES:
7762 * SB_LINELEFT/SB_LINERIGHT:
7763 * for LVS_ICON, LVS_SMALLICON 1 pixel
7764 * for LVS_REPORT is 1 pixel
7765 * for LVS_LIST is 1 column --> which is a 1 because the
7766 * scroll is based on columns not pixels
7767 *
7768 */
7769 static LRESULT LISTVIEW_HScroll(LISTVIEW_INFO *infoPtr, INT nScrollCode,
7770 INT nScrollDiff, HWND hScrollWnd)
7771 {
7772 UINT uView = LISTVIEW_GetType(infoPtr);
7773 INT nOldScrollPos, nNewScrollPos;
7774 SCROLLINFO scrollInfo;
7775
7776 TRACE("(nScrollCode=%d, nScrollDiff=%d)\n", nScrollCode, nScrollDiff);
7777
7778 SendMessageW(infoPtr->hwndEdit, WM_KILLFOCUS, 0, 0);
7779
7780 ZeroMemory(&scrollInfo, sizeof(SCROLLINFO));
7781 scrollInfo.cbSize = sizeof(SCROLLINFO);
7782 scrollInfo.fMask = SIF_PAGE | SIF_POS | SIF_RANGE | SIF_TRACKPOS;
7783
7784 if (!GetScrollInfo(infoPtr->hwndSelf, SB_HORZ, &scrollInfo)) return 1;
7785
7786 nOldScrollPos = scrollInfo.nPos;
7787
7788 switch (nScrollCode)
7789 {
7790 case SB_INTERNAL:
7791 break;
7792
7793 case SB_LINELEFT:
7794 nScrollDiff = -1;
7795 break;
7796
7797 case SB_LINERIGHT:
7798 nScrollDiff = 1;
7799 break;
7800
7801 case SB_PAGELEFT:
7802 nScrollDiff = -scrollInfo.nPage;
7803 break;
7804
7805 case SB_PAGERIGHT:
7806 nScrollDiff = scrollInfo.nPage;
7807 break;
7808
7809 case SB_THUMBPOSITION:
7810 case SB_THUMBTRACK:
7811 nScrollDiff = scrollInfo.nTrackPos - scrollInfo.nPos;
7812 break;
7813
7814 default:
7815 nScrollDiff = 0;
7816 }
7817
7818 /* quit right away if pos isn't changing */
7819 if (nScrollDiff == 0) return 0;
7820
7821 /* calculate new position, and handle overflows */
7822 nNewScrollPos = scrollInfo.nPos + nScrollDiff;
7823 if (nScrollDiff > 0) {
7824 if (nNewScrollPos < nOldScrollPos ||
7825 nNewScrollPos > scrollInfo.nMax)
7826 nNewScrollPos = scrollInfo.nMax;
7827 } else {
7828 if (nNewScrollPos > nOldScrollPos ||
7829 nNewScrollPos < scrollInfo.nMin)
7830 nNewScrollPos = scrollInfo.nMin;
7831 }
7832
7833 /* set the new position, and reread in case it changed */
7834 scrollInfo.fMask = SIF_POS;
7835 scrollInfo.nPos = nNewScrollPos;
7836 nNewScrollPos = SetScrollInfo(infoPtr->hwndSelf, SB_HORZ, &scrollInfo, TRUE);
7837
7838 /* carry on only if it really changed */
7839 if (nNewScrollPos == nOldScrollPos) return 0;
7840
7841 if(uView == LVS_REPORT)
7842 LISTVIEW_UpdateHeaderSize(infoPtr, nNewScrollPos);
7843
7844 /* now adjust to client coordinates */
7845 nScrollDiff = nOldScrollPos - nNewScrollPos;
7846 if (uView == LVS_LIST) nScrollDiff *= infoPtr->nItemWidth;
7847
7848 /* and scroll the window */
7849 scroll_list(infoPtr, nScrollDiff, 0);
7850
7851 return 0;
7852 }
7853
7854 static LRESULT LISTVIEW_MouseWheel(LISTVIEW_INFO *infoPtr, INT wheelDelta)
7855 {
7856 UINT uView = LISTVIEW_GetType(infoPtr);
7857 INT gcWheelDelta = 0;
7858 UINT pulScrollLines = 3;
7859 SCROLLINFO scrollInfo;
7860
7861 TRACE("(wheelDelta=%d)\n", wheelDelta);
7862
7863 SystemParametersInfoW(SPI_GETWHEELSCROLLLINES,0, &pulScrollLines, 0);
7864 gcWheelDelta -= wheelDelta;
7865
7866 ZeroMemory(&scrollInfo, sizeof(SCROLLINFO));
7867 scrollInfo.cbSize = sizeof(SCROLLINFO);
7868 scrollInfo.fMask = SIF_POS | SIF_RANGE;
7869
7870 switch(uView)
7871 {
7872 case LVS_ICON:
7873 case LVS_SMALLICON:
7874 /*
7875 * listview should be scrolled by a multiple of 37 dependently on its dimension or its visible item number
7876 * should be fixed in the future.
7877 */
7878 if (GetScrollInfo(infoPtr->hwndSelf, SB_VERT, &scrollInfo))
7879 LISTVIEW_VScroll(infoPtr, SB_THUMBPOSITION,
7880 scrollInfo.nPos + (gcWheelDelta < 0) ?
7881 LISTVIEW_SCROLL_ICON_LINE_SIZE :
7882 -LISTVIEW_SCROLL_ICON_LINE_SIZE, 0);
7883 break;
7884
7885 case LVS_REPORT:
7886 if (abs(gcWheelDelta) >= WHEEL_DELTA && pulScrollLines)
7887 {
7888 if (GetScrollInfo(infoPtr->hwndSelf, SB_VERT, &scrollInfo))
7889 {
7890 int cLineScroll = min(LISTVIEW_GetCountPerColumn(infoPtr), pulScrollLines);
7891 cLineScroll *= (gcWheelDelta / WHEEL_DELTA);
7892 LISTVIEW_VScroll(infoPtr, SB_THUMBPOSITION, scrollInfo.nPos + cLineScroll, 0);
7893 }
7894 }
7895 break;
7896
7897 case LVS_LIST:
7898 LISTVIEW_HScroll(infoPtr, (gcWheelDelta < 0) ? SB_LINELEFT : SB_LINERIGHT, 0, 0);
7899 break;
7900 }
7901 return 0;
7902 }
7903
7904 /***
7905 * DESCRIPTION:
7906 * ???
7907 *
7908 * PARAMETER(S):
7909 * [I] infoPtr : valid pointer to the listview structure
7910 * [I] INT : virtual key
7911 * [I] LONG : key data
7912 *
7913 * RETURN:
7914 * Zero
7915 */
7916 static LRESULT LISTVIEW_KeyDown(LISTVIEW_INFO *infoPtr, INT nVirtualKey, LONG lKeyData)
7917 {
7918 UINT uView = LISTVIEW_GetType(infoPtr);
7919 INT nItem = -1;
7920 NMLVKEYDOWN nmKeyDown;
7921
7922 TRACE("(nVirtualKey=%d, lKeyData=%ld)\n", nVirtualKey, lKeyData);
7923
7924 /* send LVN_KEYDOWN notification */
7925 nmKeyDown.wVKey = nVirtualKey;
7926 nmKeyDown.flags = 0;
7927 notify(infoPtr, LVN_KEYDOWN, &nmKeyDown.hdr);
7928
7929 switch (nVirtualKey)
7930 {
7931 case VK_RETURN:
7932 if ((GETITEMCOUNT(infoPtr) > 0) && (infoPtr->nFocusedItem != -1))
7933 {
7934 notify_return(infoPtr);
7935 notify_itemactivate(infoPtr);
7936 }
7937 break;
7938
7939 case VK_HOME:
7940 if (GETITEMCOUNT(infoPtr) > 0)
7941 nItem = 0;
7942 break;
7943
7944 case VK_END:
7945 if (GETITEMCOUNT(infoPtr) > 0)
7946 nItem = GETITEMCOUNT(infoPtr) - 1;
7947 break;
7948
7949 case VK_LEFT:
7950 nItem = ListView_GetNextItem(infoPtr->hwndSelf, infoPtr->nFocusedItem, LVNI_TOLEFT);
7951 break;
7952
7953 case VK_UP:
7954 nItem = ListView_GetNextItem(infoPtr->hwndSelf, infoPtr->nFocusedItem, LVNI_ABOVE);
7955 break;
7956
7957 case VK_RIGHT:
7958 nItem = ListView_GetNextItem(infoPtr->hwndSelf, infoPtr->nFocusedItem, LVNI_TORIGHT);
7959 break;
7960
7961 case VK_DOWN:
7962 nItem = ListView_GetNextItem(infoPtr->hwndSelf, infoPtr->nFocusedItem, LVNI_BELOW);
7963 break;
7964
7965 case VK_PRIOR:
7966 if (uView == LVS_REPORT)
7967 nItem = infoPtr->nFocusedItem - LISTVIEW_GetCountPerColumn(infoPtr);
7968 else
7969 nItem = infoPtr->nFocusedItem - LISTVIEW_GetCountPerColumn(infoPtr)
7970 * LISTVIEW_GetCountPerRow(infoPtr);
7971 if(nItem < 0) nItem = 0;
7972 break;
7973
7974 case VK_NEXT:
7975 if (uView == LVS_REPORT)
7976 nItem = infoPtr->nFocusedItem + LISTVIEW_GetCountPerColumn(infoPtr);
7977 else
7978 nItem = infoPtr->nFocusedItem + LISTVIEW_GetCountPerColumn(infoPtr)
7979 * LISTVIEW_GetCountPerRow(infoPtr);
7980 if(nItem >= GETITEMCOUNT(infoPtr)) nItem = GETITEMCOUNT(infoPtr) - 1;
7981 break;
7982 }
7983
7984 if ((nItem != -1) && (nItem != infoPtr->nFocusedItem))
7985 LISTVIEW_KeySelection(infoPtr, nItem);
7986
7987 return 0;
7988 }
7989
7990 /***
7991 * DESCRIPTION:
7992 * Kills the focus.
7993 *
7994 * PARAMETER(S):
7995 * [I] infoPtr : valid pointer to the listview structure
7996 *
7997 * RETURN:
7998 * Zero
7999 */
8000 static LRESULT LISTVIEW_KillFocus(LISTVIEW_INFO *infoPtr)
8001 {
8002 TRACE("()\n");
8003
8004 /* if we did not have the focus, there's nothing to do */
8005 if (!infoPtr->bFocus) return 0;
8006
8007 /* send NM_KILLFOCUS notification */
8008 notify_killfocus(infoPtr);
8009
8010 /* if we have a focus rectagle, get rid of it */
8011 LISTVIEW_ToggleFocusRect(infoPtr);
8012
8013 /* set window focus flag */
8014 infoPtr->bFocus = FALSE;
8015
8016 /* redraw the selected items */
8017 LISTVIEW_InvalidateSelectedItems(infoPtr);
8018
8019 return 0;
8020 }
8021
8022 /***
8023 * DESCRIPTION:
8024 * Processes double click messages (left mouse button).
8025 *
8026 * PARAMETER(S):
8027 * [I] infoPtr : valid pointer to the listview structure
8028 * [I] wKey : key flag
8029 * [I] pts : mouse coordinate
8030 *
8031 * RETURN:
8032 * Zero
8033 */
8034 static LRESULT LISTVIEW_LButtonDblClk(LISTVIEW_INFO *infoPtr, WORD wKey, POINTS pts)
8035 {
8036 LVHITTESTINFO htInfo;
8037 NMLISTVIEW nmlv;
8038
8039 TRACE("(key=%hu, X=%hu, Y=%hu)\n", wKey, pts.x, pts.y);
8040
8041 htInfo.pt.x = pts.x;
8042 htInfo.pt.y = pts.y;
8043
8044 /* send NM_DBLCLK notification */
8045 ZeroMemory(&nmlv, sizeof(NMLISTVIEW));
8046 if (LISTVIEW_HitTestItem(infoPtr, &htInfo, TRUE) != -1)
8047 {
8048 nmlv.iItem = htInfo.iItem;
8049 nmlv.iSubItem = htInfo.iSubItem;
8050 }
8051 else
8052 {
8053 nmlv.iItem = -1;
8054 nmlv.iSubItem = 0;
8055 }
8056 nmlv.ptAction.x = pts.x;
8057 nmlv.ptAction.y = pts.y;
8058 listview_notify(infoPtr, NM_DBLCLK, &nmlv);
8059
8060
8061 /* To send the LVN_ITEMACTIVATE, it must be on an Item */
8062 if(nmlv.iItem != -1)
8063 notify_itemactivate(infoPtr);
8064
8065 return 0;
8066 }
8067
8068 /***
8069 * DESCRIPTION:
8070 * Processes mouse down messages (left mouse button).
8071 *
8072 * PARAMETER(S):
8073 * [I] infoPtr : valid pointer to the listview structure
8074 * [I] wKey : key flag
8075 * [I] pts : mouse coordinate
8076 *
8077 * RETURN:
8078 * Zero
8079 */
8080 static LRESULT LISTVIEW_LButtonDown(LISTVIEW_INFO *infoPtr, WORD wKey, POINTS pts)
8081 {
8082 LONG lStyle = GetWindowLongW(infoPtr->hwndSelf, GWL_STYLE);
8083 static BOOL bGroupSelect = TRUE;
8084 POINT pt = { pts.x, pts.y };
8085 INT nItem;
8086
8087 TRACE("(key=%hu, X=%hu, Y=%hu)\n", wKey, pts.x, pts.y);
8088
8089 /* send NM_RELEASEDCAPTURE notification */
8090 notify_releasedcapture(infoPtr);
8091
8092 if (!infoPtr->bFocus) SetFocus(infoPtr->hwndSelf);
8093
8094 /* set left button down flag */
8095 infoPtr->bLButtonDown = TRUE;
8096
8097 nItem = LISTVIEW_GetItemAtPt(infoPtr, pt);
8098 if ((nItem >= 0) && (nItem < GETITEMCOUNT(infoPtr)))
8099 {
8100 if (lStyle & LVS_SINGLESEL)
8101 {
8102 if ((LISTVIEW_GetItemState(infoPtr, nItem, LVIS_SELECTED) & LVIS_SELECTED)
8103 && infoPtr->nEditLabelItem == -1)
8104 infoPtr->nEditLabelItem = nItem;
8105 else
8106 LISTVIEW_SetSelection(infoPtr, nItem);
8107 }
8108 else
8109 {
8110 if ((wKey & MK_CONTROL) && (wKey & MK_SHIFT))
8111 {
8112 if (bGroupSelect)
8113 LISTVIEW_AddGroupSelection(infoPtr, nItem);
8114 else
8115 LISTVIEW_AddSelection(infoPtr, nItem);
8116 }
8117 else if (wKey & MK_CONTROL)
8118 {
8119 LVITEMW item;
8120
8121 bGroupSelect = (LISTVIEW_GetItemState(infoPtr, nItem, LVIS_SELECTED) == 0);
8122
8123 ZeroMemory(&item, sizeof(item));
8124 item.stateMask = LVIS_SELECTED;
8125 if(bGroupSelect) item.state = LVIS_SELECTED;
8126 LISTVIEW_SetItemState(infoPtr, nItem, &item);
8127
8128 LISTVIEW_SetItemFocus(infoPtr, nItem);
8129 infoPtr->nSelectionMark = nItem;
8130 }
8131 else if (wKey & MK_SHIFT)
8132 {
8133 LISTVIEW_SetGroupSelection(infoPtr, nItem);
8134 }
8135 else
8136 {
8137 BOOL was_selected =
8138 (LISTVIEW_GetItemState(infoPtr, nItem, LVIS_SELECTED) & LVIS_SELECTED);
8139
8140 /* set selection (clears other pre-existing selections) */
8141 LISTVIEW_SetSelection(infoPtr, nItem);
8142
8143 if (was_selected && infoPtr->nEditLabelItem == -1)
8144 infoPtr->nEditLabelItem = nItem;
8145 }
8146 }
8147 }
8148 else
8149 {
8150 /* remove all selections */
8151 LISTVIEW_RemoveAllSelections(infoPtr);
8152 }
8153
8154 /* redraw if we could have possibly selected something */
8155 if(!GETITEMCOUNT(infoPtr)) InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
8156
8157 return 0;
8158 }
8159
8160 /***
8161 * DESCRIPTION:
8162 * Processes mouse up messages (left mouse button).
8163 *
8164 * PARAMETER(S):
8165 * [I] infoPtr : valid pointer to the listview structure
8166 * [I] wKey : key flag
8167 * [I] pts : mouse coordinate
8168 *
8169 * RETURN:
8170 * Zero
8171 */
8172 static LRESULT LISTVIEW_LButtonUp(LISTVIEW_INFO *infoPtr, WORD wKey, POINTS pts)
8173 {
8174 TRACE("(key=%hu, X=%hu, Y=%hu)\n", wKey, pts.x, pts.y);
8175
8176 if (infoPtr->bLButtonDown)
8177 {
8178 LVHITTESTINFO lvHitTestInfo;
8179 NMLISTVIEW nmlv;
8180
8181 lvHitTestInfo.pt.x = pts.x;
8182 lvHitTestInfo.pt.y = pts.y;
8183
8184 /* send NM_CLICK notification */
8185 ZeroMemory(&nmlv, sizeof(NMLISTVIEW));
8186 if (LISTVIEW_HitTestItem(infoPtr, &lvHitTestInfo, TRUE) != -1)
8187 {
8188 nmlv.iItem = lvHitTestInfo.iItem;
8189 nmlv.iSubItem = lvHitTestInfo.iSubItem;
8190 }
8191 else
8192 {
8193 nmlv.iItem = -1;
8194 nmlv.iSubItem = 0;
8195 }
8196 nmlv.ptAction.x = pts.x;
8197 nmlv.ptAction.y = pts.y;
8198 listview_notify(infoPtr, NM_CLICK, &nmlv);
8199
8200 /* set left button flag */
8201 infoPtr->bLButtonDown = FALSE;
8202
8203 if(infoPtr->nEditLabelItem != -1)
8204 {
8205 if(lvHitTestInfo.iItem == infoPtr->nEditLabelItem && lvHitTestInfo.flags & LVHT_ONITEMLABEL) {
8206 LISTVIEW_EditLabelT(infoPtr, lvHitTestInfo.iItem, TRUE);
8207 }
8208 infoPtr->nEditLabelItem = -1;
8209 }
8210 }
8211
8212 return 0;
8213 }
8214
8215 /***
8216 * DESCRIPTION:
8217 * Destroys the listview control (called after WM_DESTROY).
8218 *
8219 * PARAMETER(S):
8220 * [I] infoPtr : valid pointer to the listview structure
8221 *
8222 * RETURN:
8223 * Zero
8224 */
8225 static LRESULT LISTVIEW_NCDestroy(LISTVIEW_INFO *infoPtr)
8226 {
8227 LONG lStyle = GetWindowLongW(infoPtr->hwndSelf, GWL_STYLE);
8228
8229 TRACE("()\n");
8230
8231 /* delete all items */
8232 LISTVIEW_DeleteAllItems(infoPtr);
8233
8234 /* destroy data structure */
8235 DPA_Destroy(infoPtr->hdpaItems);
8236 DPA_Destroy(infoPtr->hdpaSelectionRanges);
8237
8238 /* destroy image lists */
8239 if (!(lStyle & LVS_SHAREIMAGELISTS))
8240 {
8241 #if 0
8242 /* FIXME: If the caller does a ImageList_Destroy and then we
8243 * do this code the area will be freed twice. Currently
8244 * this generates an "err:heap:HEAP_ValidateInUseArena
8245 * Heap xxxxxxxx: in-use arena yyyyyyyy next block
8246 * has PREV_FREE flag" sometimes.
8247 *
8248 * We will leak the memory till we figure out how to fix
8249 */
8250 if (infoPtr->himlNormal)
8251 ImageList_Destroy(infoPtr->himlNormal);
8252 if (infoPtr->himlSmall)
8253 ImageList_Destroy(infoPtr->himlSmall);
8254 if (infoPtr->himlState)
8255 ImageList_Destroy(infoPtr->himlState);
8256 #endif
8257 }
8258
8259 /* destroy font, bkgnd brush */
8260 infoPtr->hFont = 0;
8261 if (infoPtr->hDefaultFont) DeleteObject(infoPtr->hDefaultFont);
8262 if (infoPtr->hBkBrush) DeleteObject(infoPtr->hBkBrush);
8263
8264 /* free listview info pointer*/
8265 COMCTL32_Free(infoPtr);
8266
8267 SetWindowLongW(infoPtr->hwndSelf, 0, 0);
8268 return 0;
8269 }
8270
8271 /***
8272 * DESCRIPTION:
8273 * Handles notifications from children.
8274 *
8275 * PARAMETER(S):
8276 * [I] infoPtr : valid pointer to the listview structure
8277 * [I] INT : control identifier
8278 * [I] LPNMHDR : notification information
8279 *
8280 * RETURN:
8281 * Zero
8282 */
8283 static LRESULT LISTVIEW_Notify(LISTVIEW_INFO *infoPtr, INT nCtrlId, LPNMHDR lpnmh)
8284 {
8285 TRACE("(nCtrlId=%d, lpnmh=%p)\n", nCtrlId, lpnmh);
8286
8287 if (lpnmh->hwndFrom == infoPtr->hwndHeader)
8288 {
8289 /* handle notification from header control */
8290 if (lpnmh->code == HDN_ENDTRACKW)
8291 {
8292 infoPtr->nItemWidth = LISTVIEW_GetItemWidth(infoPtr);
8293 InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
8294 }
8295 else if(lpnmh->code == HDN_ITEMCLICKW || lpnmh->code == HDN_ITEMCLICKA)
8296 {
8297 /* Handle sorting by Header Column */
8298 NMLISTVIEW nmlv;
8299
8300 ZeroMemory(&nmlv, sizeof(NMLISTVIEW));
8301 nmlv.iItem = -1;
8302 nmlv.iSubItem = ((LPNMHEADERW)lpnmh)->iItem;
8303 listview_notify(infoPtr, LVN_COLUMNCLICK, &nmlv);
8304 }
8305 else if(lpnmh->code == NM_RELEASEDCAPTURE)
8306 {
8307 /* Idealy this should be done in HDN_ENDTRACKA
8308 * but since SetItemBounds in Header.c is called after
8309 * the notification is sent, it is neccessary to handle the
8310 * update of the scroll bar here (Header.c works fine as it is,
8311 * no need to disturb it)
8312 */
8313 infoPtr->nItemWidth = LISTVIEW_GetItemWidth(infoPtr);
8314 LISTVIEW_UpdateScroll(infoPtr);
8315 InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
8316 }
8317
8318 }
8319
8320 return 0;
8321 }
8322
8323 /***
8324 * DESCRIPTION:
8325 * Determines the type of structure to use.
8326 *
8327 * PARAMETER(S):
8328 * [I] infoPtr : valid pointer to the listview structureof the sender
8329 * [I] HWND : listview window handle
8330 * [I] INT : command specifying the nature of the WM_NOTIFYFORMAT
8331 *
8332 * RETURN:
8333 * Zero
8334 */
8335 static LRESULT LISTVIEW_NotifyFormat(LISTVIEW_INFO *infoPtr, HWND hwndFrom, INT nCommand)
8336 {
8337 TRACE("(hwndFrom=%x, nCommand=%d)\n", hwndFrom, nCommand);
8338
8339 if (nCommand == NF_REQUERY)
8340 infoPtr->notifyFormat = SendMessageW(hwndFrom, WM_NOTIFYFORMAT,
8341 (WPARAM)infoPtr->hwndSelf, (LPARAM)NF_QUERY);
8342 return 0;
8343 }
8344
8345 /***
8346 * DESCRIPTION:
8347 * Paints/Repaints the listview control.
8348 *
8349 * PARAMETER(S):
8350 * [I] infoPtr : valid pointer to the listview structure
8351 * [I] HDC : device context handle
8352 *
8353 * RETURN:
8354 * Zero
8355 */
8356 static LRESULT LISTVIEW_Paint(LISTVIEW_INFO *infoPtr, HDC hdc)
8357 {
8358 PAINTSTRUCT ps;
8359
8360 TRACE("(hdc=%x)\n", hdc);
8361
8362 if (hdc == 0)
8363 {
8364 hdc = BeginPaint(infoPtr->hwndSelf, &ps);
8365 TRACE("ps erase=%s, rect=(%d,%d)-(%d,%d)\n",
8366 ps.fErase ? "TRUE" : "FALSE",
8367 ps.rcPaint.left, ps.rcPaint.top, ps.rcPaint.right, ps.rcPaint.bottom);
8368 if (ps.fErase)
8369 LISTVIEW_EraseBackground(infoPtr, (WPARAM)hdc, 0);
8370 LISTVIEW_Refresh(infoPtr, hdc);
8371 EndPaint(infoPtr->hwndSelf, &ps);
8372 }
8373 else
8374 {
8375 LISTVIEW_Refresh(infoPtr, hdc);
8376 }
8377
8378 return 0;
8379 }
8380
8381 /***
8382 * DESCRIPTION:
8383 * Processes double click messages (right mouse button).
8384 *
8385 * PARAMETER(S):
8386 * [I] infoPtr : valid pointer to the listview structure
8387 * [I] wKey : key flag
8388 * [I] pts : mouse coordinate
8389 *
8390 * RETURN:
8391 * Zero
8392 */
8393 static LRESULT LISTVIEW_RButtonDblClk(LISTVIEW_INFO *infoPtr, WORD wKey, POINTS pts)
8394 {
8395 TRACE("(key=%hu,X=%hu,Y=%hu)\n", wKey, pts.x, pts.y);
8396
8397 /* send NM_RELEASEDCAPTURE notification */
8398 notify_releasedcapture(infoPtr);
8399
8400 /* send NM_RDBLCLK notification */
8401 notify_rdblclk(infoPtr);
8402
8403 return 0;
8404 }
8405
8406 /***
8407 * DESCRIPTION:
8408 * Processes mouse down messages (right mouse button).
8409 *
8410 * PARAMETER(S):
8411 * [I] infoPtr : valid pointer to the listview structure
8412 * [I] wKey : key flag
8413 * [I] pts : mouse coordinate
8414 *
8415 * RETURN:
8416 * Zero
8417 */
8418 static LRESULT LISTVIEW_RButtonDown(LISTVIEW_INFO *infoPtr, WORD wKey, POINTS pts)
8419 {
8420 INT nItem;
8421 NMLISTVIEW nmlv;
8422 LVHITTESTINFO lvHitTestInfo;
8423 POINT pt = { pts.x, pts.y };
8424
8425 TRACE("(key=%hu,X=%hu,Y=%hu)\n", wKey, pts.x, pts.y);
8426
8427 /* send NM_RELEASEDCAPTURE notification */
8428 notify_releasedcapture(infoPtr);
8429
8430 /* make sure the listview control window has the focus */
8431 if (!infoPtr->bFocus) SetFocus(infoPtr->hwndSelf);
8432
8433 /* set right button down flag */
8434 infoPtr->bRButtonDown = TRUE;
8435
8436 /* determine the index of the selected item */
8437 nItem = LISTVIEW_GetItemAtPt(infoPtr, pt);
8438 if ((nItem >= 0) && (nItem < GETITEMCOUNT(infoPtr)))
8439 {
8440 LISTVIEW_SetItemFocus(infoPtr,nItem);
8441 if (!((wKey & MK_SHIFT) || (wKey & MK_CONTROL)) &&
8442 !LISTVIEW_GetItemState(infoPtr, nItem, LVIS_SELECTED))
8443 LISTVIEW_SetSelection(infoPtr, nItem);
8444 }
8445 else
8446 {
8447 LISTVIEW_RemoveAllSelections(infoPtr);
8448 }
8449
8450 lvHitTestInfo.pt.x = pts.x;
8451 lvHitTestInfo.pt.y = pts.y;
8452
8453 /* Send NM_RClICK notification */
8454 ZeroMemory(&nmlv, sizeof(nmlv));
8455 if (LISTVIEW_HitTestItem(infoPtr, &lvHitTestInfo, TRUE) != -1)
8456 {
8457 nmlv.iItem = lvHitTestInfo.iItem;
8458 nmlv.iSubItem = lvHitTestInfo.iSubItem;
8459 }
8460 else
8461 {
8462 nmlv.iItem = -1;
8463 nmlv.iSubItem = 0;
8464 }
8465 nmlv.ptAction.x = pts.x;
8466 nmlv.ptAction.y = pts.y;
8467 listview_notify(infoPtr, NM_RCLICK, &nmlv);
8468
8469 return 0;
8470 }
8471
8472 /***
8473 * DESCRIPTION:
8474 * Processes mouse up messages (right mouse button).
8475 *
8476 * PARAMETER(S):
8477 * [I] infoPtr : valid pointer to the listview structure
8478 * [I] wKey : key flag
8479 * [I] pts : mouse coordinate
8480 *
8481 * RETURN:
8482 * Zero
8483 */
8484 static LRESULT LISTVIEW_RButtonUp(LISTVIEW_INFO *infoPtr, WORD wKey, POINTS pts)
8485 {
8486 TRACE("(key=%hu,X=%hu,Y=%hu)\n", wKey, pts.x, pts.y);
8487
8488 if (infoPtr->bRButtonDown)
8489 {
8490 POINT pt = { pts.x, pts.y };
8491
8492 /* set button flag */
8493 infoPtr->bRButtonDown = FALSE;
8494
8495 /* Change to screen coordinate for WM_CONTEXTMENU */
8496 ClientToScreen(infoPtr->hwndSelf, &pt);
8497
8498 /* Send a WM_CONTEXTMENU message in response to the RBUTTONUP */
8499 SendMessageW(infoPtr->hwndSelf, WM_CONTEXTMENU,
8500 (WPARAM)infoPtr->hwndSelf, MAKELPARAM(pt.x, pt.y));
8501 }
8502
8503 return 0;
8504 }
8505
8506
8507 /***
8508 * DESCRIPTION:
8509 * Sets the cursor.
8510 *
8511 * PARAMETER(S):
8512 * [I] infoPtr : valid pointer to the listview structure
8513 * [I] hwnd : window handle of window containing the cursor
8514 * [I] nHittest : hit-test code
8515 * [I] wMouseMsg : ideintifier of the mouse message
8516 *
8517 * RETURN:
8518 * TRUE if cursor is set
8519 * FALSE otherwise
8520 */
8521 static BOOL LISTVIEW_SetCursor(LISTVIEW_INFO *infoPtr, HWND hwnd, UINT nHittest, UINT wMouseMsg)
8522 {
8523 POINT pt;
8524
8525 if(!(infoPtr->dwExStyle & LVS_EX_TRACKSELECT)) return FALSE;
8526
8527 if(!infoPtr->hHotCursor) return FALSE;
8528
8529 GetCursorPos(&pt);
8530 if (LISTVIEW_GetItemAtPt(infoPtr, pt) < 0) return FALSE;
8531
8532 SetCursor(infoPtr->hHotCursor);
8533
8534 return TRUE;
8535 }
8536
8537 /***
8538 * DESCRIPTION:
8539 * Sets the focus.
8540 *
8541 * PARAMETER(S):
8542 * [I] infoPtr : valid pointer to the listview structure
8543 * [I] infoPtr : handle of previously focused window
8544 *
8545 * RETURN:
8546 * Zero
8547 */
8548 static LRESULT LISTVIEW_SetFocus(LISTVIEW_INFO *infoPtr, HWND hwndLoseFocus)
8549 {
8550 TRACE("(hwndLoseFocus=%x)\n", hwndLoseFocus);
8551
8552 /* if we have the focus already, there's nothing to do */
8553 if (infoPtr->bFocus) return 0;
8554
8555 /* send NM_SETFOCUS notification */
8556 notify_setfocus(infoPtr);
8557
8558 /* put the focus rect back on */
8559 LISTVIEW_ToggleFocusRect(infoPtr);
8560
8561 /* set window focus flag */
8562 infoPtr->bFocus = TRUE;
8563
8564 /* redraw all visible selected items */
8565 LISTVIEW_InvalidateSelectedItems(infoPtr);
8566
8567 return 0;
8568 }
8569
8570 /***
8571 * DESCRIPTION:
8572 * Sets the font.
8573 *
8574 * PARAMETER(S):
8575 * [I] infoPtr : valid pointer to the listview structure
8576 * [I] HFONT : font handle
8577 * [I] WORD : redraw flag
8578 *
8579 * RETURN:
8580 * Zero
8581 */
8582 static LRESULT LISTVIEW_SetFont(LISTVIEW_INFO *infoPtr, HFONT hFont, WORD fRedraw)
8583 {
8584 UINT uView = LISTVIEW_GetType(infoPtr);
8585
8586 TRACE("(hfont=%x,redraw=%hu)\n", hFont, fRedraw);
8587
8588 infoPtr->hFont = hFont ? hFont : infoPtr->hDefaultFont;
8589 LISTVIEW_SaveTextMetrics(infoPtr);
8590
8591 if (uView == LVS_REPORT)
8592 {
8593 /* set header font */
8594 SendMessageW(infoPtr->hwndHeader, WM_SETFONT, (WPARAM)hFont,
8595 MAKELPARAM(fRedraw, 0));
8596 }
8597
8598 /* invalidate listview control client area */
8599 InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
8600
8601 if (fRedraw) UpdateWindow(infoPtr->hwndSelf);
8602
8603 return 0;
8604 }
8605
8606 /***
8607 * DESCRIPTION:
8608 * Message handling for WM_SETREDRAW.
8609 * For the Listview, it invalidates the entire window (the doc specifies otherwise)
8610 *
8611 * PARAMETER(S):
8612 * [I] infoPtr : valid pointer to the listview structure
8613 * [I] bRedraw: state of redraw flag
8614 *
8615 * RETURN:
8616 * DefWinProc return value
8617 */
8618 static LRESULT LISTVIEW_SetRedraw(LISTVIEW_INFO *infoPtr, BOOL bRedraw)
8619 {
8620 LRESULT lResult = DefWindowProcW(infoPtr->hwndSelf, WM_SETREDRAW, bRedraw, 0);
8621 if(bRedraw)
8622 RedrawWindow(infoPtr->hwndSelf, NULL, 0,
8623 RDW_INVALIDATE | RDW_FRAME | RDW_ERASE | RDW_ALLCHILDREN | RDW_ERASENOW);
8624 return lResult;
8625 }
8626
8627 /***
8628 * DESCRIPTION:
8629 * Resizes the listview control. This function processes WM_SIZE
8630 * messages. At this time, the width and height are not used.
8631 *
8632 * PARAMETER(S):
8633 * [I] infoPtr : valid pointer to the listview structure
8634 * [I] WORD : new width
8635 * [I] WORD : new height
8636 *
8637 * RETURN:
8638 * Zero
8639 */
8640 static LRESULT LISTVIEW_Size(LISTVIEW_INFO *infoPtr, int Width, int Height)
8641 {
8642 LONG lStyle = GetWindowLongW(infoPtr->hwndSelf, GWL_STYLE);
8643 UINT uView = lStyle & LVS_TYPEMASK;
8644
8645 TRACE("(width=%d, height=%d)\n", Width, Height);
8646
8647 if (LISTVIEW_UpdateSize(infoPtr))
8648 {
8649 if ((uView == LVS_SMALLICON) || (uView == LVS_ICON))
8650 {
8651 if (lStyle & LVS_ALIGNLEFT)
8652 LISTVIEW_AlignLeft(infoPtr);
8653 else
8654 LISTVIEW_AlignTop(infoPtr);
8655 }
8656
8657 LISTVIEW_UpdateScroll(infoPtr);
8658
8659 /* invalidate client area + erase background */
8660 InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
8661 }
8662
8663 return 0;
8664 }
8665
8666 /***
8667 * DESCRIPTION:
8668 * Sets the size information.
8669 *
8670 * PARAMETER(S):
8671 * [I] infoPtr : valid pointer to the listview structure
8672 *
8673 * RETURN:
8674 * Zero if no size change
8675 * 1 of size changed
8676 */
8677 static BOOL LISTVIEW_UpdateSize(LISTVIEW_INFO *infoPtr)
8678 {
8679 LONG lStyle = GetWindowLongW(infoPtr->hwndSelf, GWL_STYLE);
8680 UINT uView = lStyle & LVS_TYPEMASK;
8681 RECT rcList;
8682 RECT rcOld;
8683
8684 GetClientRect(infoPtr->hwndSelf, &rcList);
8685 CopyRect(&rcOld,&(infoPtr->rcList));
8686 infoPtr->rcList.left = 0;
8687 infoPtr->rcList.right = max(rcList.right - rcList.left, 1);
8688 infoPtr->rcList.top = 0;
8689 infoPtr->rcList.bottom = max(rcList.bottom - rcList.top, 1);
8690
8691 if (uView == LVS_LIST)
8692 {
8693 /* Apparently the "LIST" style is supposed to have the same
8694 * number of items in a column even if there is no scroll bar.
8695 * Since if a scroll bar already exists then the bottom is already
8696 * reduced, only reduce if the scroll bar does not currently exist.
8697 * The "2" is there to mimic the native control. I think it may be
8698 * related to either padding or edges. (GLA 7/2002)
8699 */
8700 if (!(lStyle & WS_HSCROLL))
8701 {
8702 INT nHScrollHeight = GetSystemMetrics(SM_CYHSCROLL);
8703 if (infoPtr->rcList.bottom > nHScrollHeight)
8704 infoPtr->rcList.bottom -= (nHScrollHeight + 2);
8705 }
8706 else
8707 {
8708 if (infoPtr->rcList.bottom > 2)
8709 infoPtr->rcList.bottom -= 2;
8710 }
8711 }
8712 else if (uView == LVS_REPORT)
8713 {
8714 HDLAYOUT hl;
8715 WINDOWPOS wp;
8716
8717 hl.prc = &rcList;
8718 hl.pwpos = &wp;
8719 Header_Layout(infoPtr->hwndHeader, &hl);
8720
8721 SetWindowPos(wp.hwnd, wp.hwndInsertAfter, wp.x, wp.y, wp.cx, wp.cy, wp.flags);
8722
8723 if (!(LVS_NOCOLUMNHEADER & lStyle))
8724 infoPtr->rcList.top = max(wp.cy, 0);
8725 }
8726 return (EqualRect(&rcOld,&(infoPtr->rcList)));
8727 }
8728
8729 /***
8730 * DESCRIPTION:
8731 * Processes WM_STYLECHANGED messages.
8732 *
8733 * PARAMETER(S):
8734 * [I] infoPtr : valid pointer to the listview structure
8735 * [I] WPARAM : window style type (normal or extended)
8736 * [I] LPSTYLESTRUCT : window style information
8737 *
8738 * RETURN:
8739 * Zero
8740 */
8741 static INT LISTVIEW_StyleChanged(LISTVIEW_INFO *infoPtr, WPARAM wStyleType,
8742 LPSTYLESTRUCT lpss)
8743 {
8744 UINT uNewView = lpss->styleNew & LVS_TYPEMASK;
8745 UINT uOldView = lpss->styleOld & LVS_TYPEMASK;
8746 RECT rcList = infoPtr->rcList;
8747
8748 TRACE("(styletype=%x, styleOld=0x%08lx, styleNew=0x%08lx)\n",
8749 wStyleType, lpss->styleOld, lpss->styleNew);
8750
8751 if (wStyleType == GWL_STYLE)
8752 {
8753 if (uOldView == LVS_REPORT)
8754 ShowWindow(infoPtr->hwndHeader, SW_HIDE);
8755
8756 if (((lpss->styleOld & WS_HSCROLL) != 0)&&
8757 ((lpss->styleNew & WS_HSCROLL) == 0))
8758 ShowScrollBar(infoPtr->hwndSelf, SB_HORZ, FALSE);
8759
8760 if (((lpss->styleOld & WS_VSCROLL) != 0)&&
8761 ((lpss->styleNew & WS_VSCROLL) == 0))
8762 ShowScrollBar(infoPtr->hwndSelf, SB_VERT, FALSE);
8763
8764 /* If switching modes, then start with no scroll bars and then
8765 * decide.
8766 */
8767 if (uNewView != uOldView)
8768 ShowScrollBar(infoPtr->hwndSelf, SB_BOTH, FALSE);
8769
8770 if (uNewView == LVS_ICON)
8771 {
8772 INT oldcx, oldcy;
8773
8774 /* First readjust the iconSize and if necessary the iconSpacing */
8775 oldcx = infoPtr->iconSize.cx;
8776 oldcy = infoPtr->iconSize.cy;
8777 infoPtr->iconSize.cx = GetSystemMetrics(SM_CXICON);
8778 infoPtr->iconSize.cy = GetSystemMetrics(SM_CYICON);
8779 if (infoPtr->himlNormal != NULL)
8780 {
8781 INT cx, cy;
8782 ImageList_GetIconSize(infoPtr->himlNormal, &cx, &cy);
8783 infoPtr->iconSize.cx = cx;
8784 infoPtr->iconSize.cy = cy;
8785 }
8786 if ((infoPtr->iconSize.cx != oldcx) || (infoPtr->iconSize.cy != oldcy))
8787 {
8788 TRACE("icon old size=(%d,%d), new size=(%ld,%ld)\n",
8789 oldcx, oldcy, infoPtr->iconSize.cx, infoPtr->iconSize.cy);
8790 LISTVIEW_SetIconSpacing(infoPtr,0);
8791 }
8792
8793 /* Now update the full item width and height */
8794 infoPtr->nItemWidth = LISTVIEW_GetItemWidth(infoPtr);
8795 infoPtr->nItemHeight = LISTVIEW_GetItemHeight(infoPtr);
8796 if (lpss->styleNew & LVS_ALIGNLEFT)
8797 LISTVIEW_AlignLeft(infoPtr);
8798 else
8799 LISTVIEW_AlignTop(infoPtr);
8800 }
8801 else if (uNewView == LVS_REPORT)
8802 {
8803 HDLAYOUT hl;
8804 WINDOWPOS wp;
8805
8806 hl.prc = &rcList;
8807 hl.pwpos = &wp;
8808 Header_Layout(infoPtr->hwndHeader, &hl);
8809 SetWindowPos(infoPtr->hwndHeader, infoPtr->hwndSelf, wp.x, wp.y, wp.cx, wp.cy,
8810 wp.flags);
8811 if (!(LVS_NOCOLUMNHEADER & lpss->styleNew))
8812 ShowWindow(infoPtr->hwndHeader, SW_SHOWNORMAL);
8813
8814 infoPtr->iconSize.cx = GetSystemMetrics(SM_CXSMICON);
8815 infoPtr->iconSize.cy = GetSystemMetrics(SM_CYSMICON);
8816 infoPtr->nItemWidth = LISTVIEW_GetItemWidth(infoPtr);
8817 infoPtr->nItemHeight = LISTVIEW_GetItemHeight(infoPtr);
8818 }
8819 else if (uNewView == LVS_LIST)
8820 {
8821 infoPtr->iconSize.cx = GetSystemMetrics(SM_CXSMICON);
8822 infoPtr->iconSize.cy = GetSystemMetrics(SM_CYSMICON);
8823 infoPtr->nItemWidth = LISTVIEW_GetItemWidth(infoPtr);
8824 infoPtr->nItemHeight = LISTVIEW_GetItemHeight(infoPtr);
8825 }
8826 else
8827 {
8828 infoPtr->iconSize.cx = GetSystemMetrics(SM_CXSMICON);
8829 infoPtr->iconSize.cy = GetSystemMetrics(SM_CYSMICON);
8830 infoPtr->nItemWidth = LISTVIEW_GetItemWidth(infoPtr);
8831 infoPtr->nItemHeight = LISTVIEW_GetItemHeight(infoPtr);
8832 if (lpss->styleNew & LVS_ALIGNLEFT)
8833 LISTVIEW_AlignLeft(infoPtr);
8834 else
8835 LISTVIEW_AlignTop(infoPtr);
8836 }
8837
8838 /* update the size of the client area */
8839 LISTVIEW_UpdateSize(infoPtr);
8840
8841 /* add scrollbars if needed */
8842 LISTVIEW_UpdateScroll(infoPtr);
8843
8844 /* invalidate client area + erase background */
8845 InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
8846
8847 /* print the list of unsupported window styles */
8848 LISTVIEW_UnsupportedStyles(lpss->styleNew);
8849 }
8850
8851 /* If they change the view and we have an active edit control
8852 we will need to kill the control since the redraw will
8853 misplace the edit control.
8854 */
8855 if (infoPtr->bEditing &&
8856 ((uNewView & (LVS_ICON|LVS_LIST|LVS_SMALLICON)) !=
8857 ((LVS_ICON|LVS_LIST|LVS_SMALLICON) & uOldView)))
8858 {
8859 SendMessageW(infoPtr->hwndEdit, WM_KILLFOCUS, 0, 0);
8860 }
8861
8862 return 0;
8863 }
8864
8865 /***
8866 * DESCRIPTION:
8867 * Window procedure of the listview control.
8868 *
8869 */
8870 static LRESULT WINAPI
8871 LISTVIEW_WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
8872 {
8873 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongW(hwnd, 0);
8874
8875 TRACE("(uMsg=%x wParam=%x lParam=%lx)\n", uMsg, wParam, lParam);
8876
8877 if (!infoPtr && (uMsg != WM_CREATE))
8878 return DefWindowProcW(hwnd, uMsg, wParam, lParam);
8879
8880 switch (uMsg)
8881 {
8882 case LVM_APPROXIMATEVIEWRECT:
8883 return LISTVIEW_ApproximateViewRect(infoPtr, (INT)wParam,
8884 LOWORD(lParam), HIWORD(lParam));
8885 case LVM_ARRANGE:
8886 return LISTVIEW_Arrange(infoPtr, (INT)wParam);
8887
8888 /* case LVN_CANCELEDITLABEL */
8889
8890 /* case LVM_CREATEDRAGIMAGE: */
8891
8892 case LVM_DELETEALLITEMS:
8893 return LISTVIEW_DeleteAllItems(infoPtr);
8894
8895 case LVM_DELETECOLUMN:
8896 return LISTVIEW_DeleteColumn(infoPtr, (INT)wParam);
8897
8898 case LVM_DELETEITEM:
8899 return LISTVIEW_DeleteItem(infoPtr, (INT)wParam);
8900
8901 case LVM_EDITLABELW:
8902 return (LRESULT)LISTVIEW_EditLabelT(infoPtr, (INT)wParam, TRUE);
8903
8904 case LVM_EDITLABELA:
8905 return (LRESULT)LISTVIEW_EditLabelT(infoPtr, (INT)wParam, FALSE);
8906
8907 /* case LVN_ENABLEGROUPVIEW: */
8908
8909 case LVM_ENSUREVISIBLE:
8910 return LISTVIEW_EnsureVisible(infoPtr, (INT)wParam, (BOOL)lParam);
8911
8912 case LVM_FINDITEMW:
8913 return LISTVIEW_FindItemW(infoPtr, (INT)wParam, (LPLVFINDINFOW)lParam);
8914
8915 case LVM_FINDITEMA:
8916 return LISTVIEW_FindItemA(infoPtr, (INT)wParam, (LPLVFINDINFOA)lParam);
8917
8918 case LVM_GETBKCOLOR:
8919 return infoPtr->clrBk;
8920
8921 /* case LVM_GETBKIMAGE: */
8922
8923 case LVM_GETCALLBACKMASK:
8924 return infoPtr->uCallbackMask;
8925
8926 case LVM_GETCOLUMNA:
8927 return LISTVIEW_GetColumnT(infoPtr, (INT)wParam, (LPLVCOLUMNW)lParam, FALSE);
8928
8929 case LVM_GETCOLUMNW:
8930 return LISTVIEW_GetColumnT(infoPtr, (INT)wParam, (LPLVCOLUMNW)lParam, TRUE);
8931
8932 case LVM_GETCOLUMNORDERARRAY:
8933 return LISTVIEW_GetColumnOrderArray(infoPtr, (INT)wParam, (LPINT)lParam);
8934
8935 case LVM_GETCOLUMNWIDTH:
8936 return LISTVIEW_GetColumnWidth(infoPtr, (INT)wParam);
8937
8938 case LVM_GETCOUNTPERPAGE:
8939 return LISTVIEW_GetCountPerPage(infoPtr);
8940
8941 case LVM_GETEDITCONTROL:
8942 return (LRESULT)infoPtr->hwndEdit;
8943
8944 case LVM_GETEXTENDEDLISTVIEWSTYLE:
8945 return infoPtr->dwExStyle;
8946
8947 case LVM_GETHEADER:
8948 return (LRESULT)infoPtr->hwndHeader;
8949
8950 case LVM_GETHOTCURSOR:
8951 return infoPtr->hHotCursor;
8952
8953 case LVM_GETHOTITEM:
8954 return infoPtr->nHotItem;
8955
8956 case LVM_GETHOVERTIME:
8957 return infoPtr->dwHoverTime;
8958
8959 case LVM_GETIMAGELIST:
8960 return LISTVIEW_GetImageList(infoPtr, (INT)wParam);
8961
8962 /* case LVN_GETINSERTMARK: */
8963
8964 /* case LVN_GETINSERTMARKCOLOR: */
8965
8966 /* case LVN_GETINSERTMARKRECT: */
8967
8968 case LVM_GETISEARCHSTRINGA:
8969 case LVM_GETISEARCHSTRINGW:
8970 FIXME("LVM_GETISEARCHSTRING: unimplemented\n");
8971 return FALSE;
8972
8973 case LVM_GETITEMA:
8974 return LISTVIEW_GetItemT(infoPtr, (LPLVITEMW)lParam, FALSE, FALSE);
8975
8976 case LVM_GETITEMW:
8977 return LISTVIEW_GetItemT(infoPtr, (LPLVITEMW)lParam, FALSE, TRUE);
8978
8979 case LVM_GETITEMCOUNT:
8980 return GETITEMCOUNT(infoPtr);
8981
8982 case LVM_GETITEMPOSITION:
8983 return LISTVIEW_GetItemPosition(infoPtr, (INT)wParam, (LPPOINT)lParam);
8984
8985 case LVM_GETITEMRECT:
8986 return LISTVIEW_GetItemRect(infoPtr, (INT)wParam, (LPRECT)lParam);
8987
8988 case LVM_GETITEMSPACING:
8989 return LISTVIEW_GetItemSpacing(infoPtr, (BOOL)wParam);
8990
8991 case LVM_GETITEMSTATE:
8992 return LISTVIEW_GetItemState(infoPtr, (INT)wParam, (UINT)lParam);
8993
8994 case LVM_GETITEMTEXTA:
8995 return LISTVIEW_GetItemTextT(infoPtr, (INT)wParam, (LPLVITEMW)lParam, FALSE);
8996
8997 case LVM_GETITEMTEXTW:
8998 return LISTVIEW_GetItemTextT(infoPtr, (INT)wParam, (LPLVITEMW)lParam, TRUE);
8999
9000 case LVM_GETNEXTITEM:
9001 return LISTVIEW_GetNextItem(infoPtr, (INT)wParam, LOWORD(lParam));
9002
9003 case LVM_GETNUMBEROFWORKAREAS:
9004 FIXME("LVM_GETNUMBEROFWORKAREAS: unimplemented\n");
9005 return 1;
9006
9007 case LVM_GETORIGIN:
9008 return LISTVIEW_GetOrigin(infoPtr, (LPPOINT)lParam);
9009
9010 /* case LVN_GETOUTLINECOLOR: */
9011
9012 /* case LVM_GETSELECTEDCOLUMN: */
9013
9014 case LVM_GETSELECTEDCOUNT:
9015 return LISTVIEW_GetSelectedCount(infoPtr);
9016
9017 case LVM_GETSELECTIONMARK:
9018 return infoPtr->nSelectionMark;
9019
9020 case LVM_GETSTRINGWIDTHA:
9021 return LISTVIEW_GetStringWidthT(infoPtr, (LPCWSTR)lParam, FALSE);
9022
9023 case LVM_GETSTRINGWIDTHW:
9024 return LISTVIEW_GetStringWidthT(infoPtr, (LPCWSTR)lParam, TRUE);
9025
9026 case LVM_GETSUBITEMRECT:
9027 return LISTVIEW_GetSubItemRect(infoPtr, (UINT)wParam, ((LPRECT)lParam)->top,
9028 ((LPRECT)lParam)->left, (LPRECT)lParam);
9029
9030 case LVM_GETTEXTBKCOLOR:
9031 return LISTVIEW_GetTextBkColor(infoPtr);
9032
9033 case LVM_GETTEXTCOLOR:
9034 return LISTVIEW_GetTextColor(infoPtr);
9035
9036 /* case LVN_GETTILEINFO: */
9037
9038 /* case LVN_GETTILEVIEWINFO: */
9039
9040 case LVM_GETTOOLTIPS:
9041 FIXME("LVM_GETTOOLTIPS: unimplemented\n");
9042 return FALSE;
9043
9044 case LVM_GETTOPINDEX:
9045 return LISTVIEW_GetTopIndex(infoPtr);
9046
9047 /*case LVM_GETUNICODEFORMAT:
9048 FIXME("LVM_GETUNICODEFORMAT: unimplemented\n");
9049 return FALSE;*/
9050
9051 case LVM_GETVIEWRECT:
9052 return LISTVIEW_GetViewRect(infoPtr, (LPRECT)lParam);
9053
9054 case LVM_GETWORKAREAS:
9055 FIXME("LVM_GETWORKAREAS: unimplemented\n");
9056 return FALSE;
9057
9058 /* case LVN_HASGROUP: */
9059
9060 case LVM_HITTEST:
9061 return LISTVIEW_HitTest(infoPtr, (LPLVHITTESTINFO)lParam);
9062
9063 case LVM_INSERTCOLUMNA:
9064 return LISTVIEW_InsertColumnT(infoPtr, (INT)wParam, (LPLVCOLUMNW)lParam, FALSE);
9065
9066 case LVM_INSERTCOLUMNW:
9067 return LISTVIEW_InsertColumnT(infoPtr, (INT)wParam, (LPLVCOLUMNW)lParam, TRUE);
9068
9069 /* case LVN_INSERTGROUP: */
9070
9071 /* case LVN_INSERTGROUPSORTED: */
9072
9073 case LVM_INSERTITEMA:
9074 return LISTVIEW_InsertItemT(infoPtr, (LPLVITEMW)lParam, FALSE);
9075
9076 case LVM_INSERTITEMW:
9077 return LISTVIEW_InsertItemT(infoPtr, (LPLVITEMW)lParam, TRUE);
9078
9079 /* case LVN_INSERTMARKHITTEST: */
9080
9081 /* case LVN_ISGROUPVIEWENABLED: */
9082
9083 /* case LVN_MAPIDTOINDEX: */
9084
9085 /* case LVN_INEDXTOID: */
9086
9087 /* case LVN_MOVEGROUP: */
9088
9089 /* case LVN_MOVEITEMTOGROUP: */
9090
9091 case LVM_REDRAWITEMS:
9092 return LISTVIEW_RedrawItems(infoPtr, (INT)wParam, (INT)lParam);
9093
9094 /* case LVN_REMOVEALLGROUPS: */
9095
9096 /* case LVN_REMOVEGROUP: */
9097
9098 case LVM_SCROLL:
9099 return LISTVIEW_Scroll(infoPtr, (INT)wParam, (INT)lParam);
9100
9101 case LVM_SETBKCOLOR:
9102 return LISTVIEW_SetBkColor(infoPtr, (COLORREF)lParam);
9103
9104 /* case LVM_SETBKIMAGE: */
9105
9106 case LVM_SETCALLBACKMASK:
9107 infoPtr->uCallbackMask = (UINT)wParam;
9108 return TRUE;
9109
9110 case LVM_SETCOLUMNA:
9111 return LISTVIEW_SetColumnT(infoPtr, (INT)wParam, (LPLVCOLUMNW)lParam, FALSE);
9112
9113 case LVM_SETCOLUMNW:
9114 return LISTVIEW_SetColumnT(infoPtr, (INT)wParam, (LPLVCOLUMNW)lParam, TRUE);
9115
9116 case LVM_SETCOLUMNORDERARRAY:
9117 return LISTVIEW_SetColumnOrderArray(infoPtr, (INT)wParam, (LPINT)lParam);
9118
9119 case LVM_SETCOLUMNWIDTH:
9120 return LISTVIEW_SetColumnWidth(infoPtr, (INT)wParam, SLOWORD(lParam));
9121
9122 case LVM_SETEXTENDEDLISTVIEWSTYLE:
9123 return LISTVIEW_SetExtendedListViewStyle(infoPtr, (DWORD)wParam, (DWORD)lParam);
9124
9125 /* case LVN_SETGROUPINFO: */
9126
9127 /* case LVN_SETGROUPMETRICS: */
9128
9129 case LVM_SETHOTCURSOR:
9130 return LISTVIEW_SetHotCursor(infoPtr, (HCURSOR)lParam);
9131
9132 case LVM_SETHOTITEM:
9133 return LISTVIEW_SetHotItem(infoPtr, (INT)wParam);
9134
9135 case LVM_SETHOVERTIME:
9136 return LISTVIEW_SetHoverTime(infoPtr, (DWORD)wParam);
9137
9138 case LVM_SETICONSPACING:
9139 return LISTVIEW_SetIconSpacing(infoPtr, (DWORD)lParam);
9140
9141 case LVM_SETIMAGELIST:
9142 return (LRESULT)LISTVIEW_SetImageList(infoPtr, (INT)wParam, (HIMAGELIST)lParam);
9143
9144 /* case LVN_SETINFOTIP: */
9145
9146 /* case LVN_SETINSERTMARK: */
9147
9148 /* case LVN_SETINSERTMARKCOLOR: */
9149
9150 case LVM_SETITEMA:
9151 return LISTVIEW_SetItemT(infoPtr, (LPLVITEMW)lParam, FALSE);
9152
9153 case LVM_SETITEMW:
9154 return LISTVIEW_SetItemT(infoPtr, (LPLVITEMW)lParam, TRUE);
9155
9156 case LVM_SETITEMCOUNT:
9157 return LISTVIEW_SetItemCount(infoPtr, (INT)wParam, (DWORD)lParam);
9158
9159 case LVM_SETITEMPOSITION:
9160 return LISTVIEW_SetItemPosition(infoPtr, (INT)wParam, (INT)LOWORD(lParam),
9161 (INT)HIWORD(lParam));
9162
9163 case LVM_SETITEMPOSITION32:
9164 return LISTVIEW_SetItemPosition(infoPtr, (INT)wParam, ((POINT*)lParam)->x,
9165 ((POINT*)lParam)->y);
9166
9167 case LVM_SETITEMSTATE:
9168 return LISTVIEW_SetItemState(infoPtr, (INT)wParam, (LPLVITEMW)lParam);
9169
9170 case LVM_SETITEMTEXTA:
9171 return LISTVIEW_SetItemTextT(infoPtr, (INT)wParam, (LPLVITEMW)lParam, FALSE);
9172
9173 case LVM_SETITEMTEXTW:
9174 return LISTVIEW_SetItemTextT(infoPtr, (INT)wParam, (LPLVITEMW)lParam, TRUE);
9175
9176 /* case LVN_SETOUTLINECOLOR: */
9177
9178 /* case LVN_SETSELECTEDCOLUMN: */
9179
9180 case LVM_SETSELECTIONMARK:
9181 return LISTVIEW_SetSelectionMark(infoPtr, (INT)lParam);
9182
9183 case LVM_SETTEXTBKCOLOR:
9184 return LISTVIEW_SetTextBkColor(infoPtr, (COLORREF)lParam);
9185
9186 case LVM_SETTEXTCOLOR:
9187 return LISTVIEW_SetTextColor(infoPtr, (COLORREF)lParam);
9188
9189 /* case LVN_SETTILEINFO: */
9190
9191 /* case LVN_SETTILEVIEWINFO: */
9192
9193 /* case LVN_SETTILEWIDTH: */
9194
9195 /* case LVM_SETTOOLTIPS: */
9196
9197 /* case LVM_SETUNICODEFORMAT: */
9198
9199 /* case LVN_SETVIEW: */
9200
9201 /* case LVM_SETWORKAREAS: */
9202
9203 /* case LVN_SORTGROUPS: */
9204
9205 case LVM_SORTITEMS:
9206 return LISTVIEW_SortItems(infoPtr, (PFNLVCOMPARE)lParam, (LPARAM)wParam);
9207
9208 case LVM_SUBITEMHITTEST:
9209 return LISTVIEW_SubItemHitTest(infoPtr, (LPLVHITTESTINFO)lParam);
9210
9211 case LVM_UPDATE:
9212 return LISTVIEW_Update(infoPtr, (INT)wParam);
9213
9214 case WM_CHAR:
9215 return LISTVIEW_ProcessLetterKeys( infoPtr, wParam, lParam );
9216
9217 case WM_COMMAND:
9218 return LISTVIEW_Command(infoPtr, wParam, lParam);
9219
9220 case WM_CREATE:
9221 return LISTVIEW_Create(hwnd, (LPCREATESTRUCTW)lParam);
9222
9223 case WM_ERASEBKGND:
9224 return LISTVIEW_EraseBackground(infoPtr, wParam, lParam);
9225
9226 case WM_GETDLGCODE:
9227 return DLGC_WANTCHARS | DLGC_WANTARROWS;
9228
9229 case WM_GETFONT:
9230 return infoPtr->hFont;
9231
9232 case WM_HSCROLL:
9233 return LISTVIEW_HScroll(infoPtr, (INT)LOWORD(wParam), 0, (HWND)lParam);
9234
9235 case WM_KEYDOWN:
9236 return LISTVIEW_KeyDown(infoPtr, (INT)wParam, (LONG)lParam);
9237
9238 case WM_KILLFOCUS:
9239 return LISTVIEW_KillFocus(infoPtr);
9240
9241 case WM_LBUTTONDBLCLK:
9242 return LISTVIEW_LButtonDblClk(infoPtr, (WORD)wParam, MAKEPOINTS(lParam));
9243
9244 case WM_LBUTTONDOWN:
9245 return LISTVIEW_LButtonDown(infoPtr, (WORD)wParam, MAKEPOINTS(lParam));
9246
9247 case WM_LBUTTONUP:
9248 return LISTVIEW_LButtonUp(infoPtr, (WORD)wParam, MAKEPOINTS(lParam));
9249
9250 case WM_MOUSEMOVE:
9251 return LISTVIEW_MouseMove (infoPtr, (WORD)wParam, MAKEPOINTS(lParam));
9252
9253 case WM_MOUSEHOVER:
9254 return LISTVIEW_MouseHover(infoPtr, (WORD)wParam, MAKEPOINTS(lParam));
9255
9256 case WM_NCDESTROY:
9257 return LISTVIEW_NCDestroy(infoPtr);
9258
9259 case WM_NOTIFY:
9260 return LISTVIEW_Notify(infoPtr, (INT)wParam, (LPNMHDR)lParam);
9261
9262 case WM_NOTIFYFORMAT:
9263 return LISTVIEW_NotifyFormat(infoPtr, (HWND)wParam, (INT)lParam);
9264
9265 case WM_PAINT:
9266 return LISTVIEW_Paint(infoPtr, (HDC)wParam);
9267
9268 case WM_RBUTTONDBLCLK:
9269 return LISTVIEW_RButtonDblClk(infoPtr, (WORD)wParam, MAKEPOINTS(lParam));
9270
9271 case WM_RBUTTONDOWN:
9272 return LISTVIEW_RButtonDown(infoPtr, (WORD)wParam, MAKEPOINTS(lParam));
9273
9274 case WM_RBUTTONUP:
9275 return LISTVIEW_RButtonUp(infoPtr, (WORD)wParam, MAKEPOINTS(lParam));
9276
9277 case WM_SETCURSOR:
9278 return LISTVIEW_SetCursor(infoPtr, (HWND)wParam, LOWORD(lParam), HIWORD(lParam));
9279
9280 case WM_SETFOCUS:
9281 return LISTVIEW_SetFocus(infoPtr, (HWND)wParam);
9282
9283 case WM_SETFONT:
9284 return LISTVIEW_SetFont(infoPtr, (HFONT)wParam, (WORD)lParam);
9285
9286 case WM_SETREDRAW:
9287 return LISTVIEW_SetRedraw(infoPtr, (BOOL)wParam);
9288
9289 case WM_SIZE:
9290 return LISTVIEW_Size(infoPtr, (int)SLOWORD(lParam), (int)SHIWORD(lParam));
9291
9292 case WM_STYLECHANGED:
9293 return LISTVIEW_StyleChanged(infoPtr, wParam, (LPSTYLESTRUCT)lParam);
9294
9295 case WM_SYSCOLORCHANGE:
9296 COMCTL32_RefreshSysColors();
9297 return 0;
9298
9299 /* case WM_TIMER: */
9300
9301 case WM_VSCROLL:
9302 return LISTVIEW_VScroll(infoPtr, (INT)LOWORD(wParam), 0, (HWND)lParam);
9303
9304 case WM_MOUSEWHEEL:
9305 if (wParam & (MK_SHIFT | MK_CONTROL))
9306 return DefWindowProcW(hwnd, uMsg, wParam, lParam);
9307 return LISTVIEW_MouseWheel(infoPtr, (short int)HIWORD(wParam));
9308
9309 case WM_WINDOWPOSCHANGED:
9310 if (!(((WINDOWPOS *)lParam)->flags & SWP_NOSIZE)) {
9311 SetWindowPos(infoPtr->hwndSelf, 0, 0, 0, 0, 0, SWP_FRAMECHANGED | SWP_NOACTIVATE |
9312 SWP_NOZORDER | SWP_NOMOVE | SWP_NOSIZE);
9313 LISTVIEW_UpdateSize(infoPtr);
9314 LISTVIEW_UpdateScroll(infoPtr);
9315 }
9316 return DefWindowProcW(hwnd, uMsg, wParam, lParam);
9317
9318 /* case WM_WININICHANGE: */
9319
9320 default:
9321 if ((uMsg >= WM_USER) && (uMsg < WM_APP))
9322 ERR("unknown msg %04x wp=%08x lp=%08lx\n", uMsg, wParam, lParam);
9323
9324 /* call default window procedure */
9325 return DefWindowProcW(hwnd, uMsg, wParam, lParam);
9326 }
9327
9328 return 0;
9329 }
9330
9331 /***
9332 * DESCRIPTION:
9333 * Registers the window class.
9334 *
9335 * PARAMETER(S):
9336 * None
9337 *
9338 * RETURN:
9339 * None
9340 */
9341 void LISTVIEW_Register(void)
9342 {
9343 WNDCLASSW wndClass;
9344
9345 ZeroMemory(&wndClass, sizeof(WNDCLASSW));
9346 wndClass.style = CS_GLOBALCLASS | CS_DBLCLKS;
9347 wndClass.lpfnWndProc = (WNDPROC)LISTVIEW_WindowProc;
9348 wndClass.cbClsExtra = 0;
9349 wndClass.cbWndExtra = sizeof(LISTVIEW_INFO *);
9350 wndClass.hCursor = LoadCursorW(0, IDC_ARROWW);
9351 wndClass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
9352 wndClass.lpszClassName = WC_LISTVIEWW;
9353 RegisterClassW(&wndClass);
9354 }
9355
9356 /***
9357 * DESCRIPTION:
9358 * Unregisters the window class.
9359 *
9360 * PARAMETER(S):
9361 * None
9362 *
9363 * RETURN:
9364 * None
9365 */
9366 void LISTVIEW_Unregister(void)
9367 {
9368 UnregisterClassW(WC_LISTVIEWW, (HINSTANCE)NULL);
9369 }
9370
9371 /***
9372 * DESCRIPTION:
9373 * Handle any WM_COMMAND messages
9374 *
9375 * PARAMETER(S):
9376 *
9377 * RETURN:
9378 */
9379 static LRESULT LISTVIEW_Command(LISTVIEW_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
9380 {
9381 switch (HIWORD(wParam))
9382 {
9383 case EN_UPDATE:
9384 {
9385 /*
9386 * Adjust the edit window size
9387 */
9388 WCHAR buffer[1024];
9389 HDC hdc = GetDC(infoPtr->hwndEdit);
9390 HFONT hFont, hOldFont = 0;
9391 RECT rect;
9392 SIZE sz;
9393 int len;
9394
9395 len = GetWindowTextW(infoPtr->hwndEdit, buffer, sizeof(buffer)/sizeof(buffer[0]));
9396 GetWindowRect(infoPtr->hwndEdit, &rect);
9397
9398 /* Select font to get the right dimension of the string */
9399 hFont = SendMessageW(infoPtr->hwndEdit, WM_GETFONT, 0, 0);
9400 if(hFont != 0)
9401 {
9402 hOldFont = SelectObject(hdc, hFont);
9403 }
9404
9405 if (GetTextExtentPoint32W(hdc, buffer, lstrlenW(buffer), &sz))
9406 {
9407 TEXTMETRICW textMetric;
9408
9409 /* Add Extra spacing for the next character */
9410 GetTextMetricsW(hdc, &textMetric);
9411 sz.cx += (textMetric.tmMaxCharWidth * 2);
9412
9413 SetWindowPos (
9414 infoPtr->hwndEdit,
9415 HWND_TOP,
9416 0,
9417 0,
9418 sz.cx,
9419 rect.bottom - rect.top,
9420 SWP_DRAWFRAME|SWP_NOMOVE);
9421 }
9422 if(hFont != 0)
9423 SelectObject(hdc, hOldFont);
9424
9425 ReleaseDC(infoPtr->hwndSelf, hdc);
9426
9427 break;
9428 }
9429
9430 default:
9431 return SendMessageW (GetParent (infoPtr->hwndSelf), WM_COMMAND, wParam, lParam);
9432 }
9433
9434 return 0;
9435 }
9436
9437
9438 /***
9439 * DESCRIPTION:
9440 * Subclassed edit control windproc function
9441 *
9442 * PARAMETER(S):
9443 *
9444 * RETURN:
9445 */
9446 static LRESULT EditLblWndProcT(HWND hwnd, UINT uMsg,
9447 WPARAM wParam, LPARAM lParam, BOOL isW)
9448 {
9449 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongW(GetParent(hwnd), 0);
9450 static BOOL bIgnoreKillFocus = FALSE;
9451 BOOL cancel = FALSE;
9452
9453 TRACE("(hwnd=%x, uMsg=%x, wParam=%x, lParam=%lx, isW=%d)\n",
9454 hwnd, uMsg, wParam, lParam, isW);
9455
9456 switch (uMsg)
9457 {
9458 case WM_GETDLGCODE:
9459 return DLGC_WANTARROWS | DLGC_WANTALLKEYS;
9460
9461 case WM_KILLFOCUS:
9462 if(bIgnoreKillFocus) return TRUE;
9463 break;
9464
9465 case WM_DESTROY:
9466 {
9467 WNDPROC editProc = infoPtr->EditWndProc;
9468 infoPtr->EditWndProc = 0;
9469 SetWindowLongW(hwnd, GWL_WNDPROC, (LONG)editProc);
9470 return CallWindowProcT(editProc, hwnd, uMsg, wParam, lParam, isW);
9471 }
9472
9473 case WM_KEYDOWN:
9474 if (VK_ESCAPE == (INT)wParam)
9475 {
9476 cancel = TRUE;
9477 break;
9478 }
9479 else if (VK_RETURN == (INT)wParam)
9480 break;
9481
9482 default:
9483 return CallWindowProcT(infoPtr->EditWndProc, hwnd, uMsg, wParam, lParam, isW);
9484 }
9485
9486 if (infoPtr->bEditing)
9487 {
9488 LPWSTR buffer = NULL;
9489
9490 if (!cancel)
9491 {
9492 DWORD len = isW ? GetWindowTextLengthW(hwnd) : GetWindowTextLengthA(hwnd);
9493
9494 if (len)
9495 {
9496 if ( (buffer = COMCTL32_Alloc((len+1) * (isW ? sizeof(WCHAR) : sizeof(CHAR)))) )
9497 {
9498 if (isW) GetWindowTextW(hwnd, buffer, len+1);
9499 else GetWindowTextA(hwnd, (CHAR*)buffer, len+1);
9500 }
9501 }
9502 }
9503 /* Processing LVN_ENDLABELEDIT message could kill the focus */
9504 /* eg. Using a messagebox */
9505 bIgnoreKillFocus = TRUE;
9506 LISTVIEW_EndEditLabelT(infoPtr, buffer, isW);
9507
9508 if (buffer) COMCTL32_Free(buffer);
9509
9510 bIgnoreKillFocus = FALSE;
9511 }
9512
9513 SendMessageW(hwnd, WM_CLOSE, 0, 0);
9514 return TRUE;
9515 }
9516
9517 /***
9518 * DESCRIPTION:
9519 * Subclassed edit control windproc function
9520 *
9521 * PARAMETER(S):
9522 *
9523 * RETURN:
9524 */
9525 LRESULT CALLBACK EditLblWndProcW(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
9526 {
9527 return EditLblWndProcT(hwnd, uMsg, wParam, lParam, TRUE);
9528 }
9529
9530 /***
9531 * DESCRIPTION:
9532 * Subclassed edit control windproc function
9533 *
9534 * PARAMETER(S):
9535 *
9536 * RETURN:
9537 */
9538 LRESULT CALLBACK EditLblWndProcA(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
9539 {
9540 return EditLblWndProcT(hwnd, uMsg, wParam, lParam, FALSE);
9541 }
9542
9543 /***
9544 * DESCRIPTION:
9545 * Creates a subclassed edit cotrol
9546 *
9547 * PARAMETER(S):
9548 *
9549 * RETURN:
9550 */
9551 static HWND CreateEditLabelT(LISTVIEW_INFO *infoPtr, LPCWSTR text, DWORD style,
9552 INT x, INT y, INT width, INT height, BOOL isW)
9553 {
9554 WCHAR editName[5] = { 'E', 'd', 'i', 't', '\0' };
9555 HWND hedit;
9556 SIZE sz;
9557 HDC hdc;
9558 HDC hOldFont=0;
9559 TEXTMETRICW textMetric;
9560 HINSTANCE hinst = GetWindowLongW(infoPtr->hwndSelf, GWL_HINSTANCE);
9561
9562 TRACE("(text=%s, ..., isW=%d)\n", debugtext_t(text, isW), isW);
9563
9564 style |= WS_CHILDWINDOW|WS_CLIPSIBLINGS|ES_LEFT|WS_BORDER;
9565 hdc = GetDC(infoPtr->hwndSelf);
9566
9567 /* Select the font to get appropriate metric dimensions */
9568 if(infoPtr->hFont != 0)
9569 hOldFont = SelectObject(hdc, infoPtr->hFont);
9570
9571 /*Get String Lenght in pixels */
9572 GetTextExtentPoint32W(hdc, text, lstrlenW(text), &sz);
9573
9574 /*Add Extra spacing for the next character */
9575 GetTextMetricsW(hdc, &textMetric);
9576 sz.cx += (textMetric.tmMaxCharWidth * 2);
9577
9578 if(infoPtr->hFont != 0)
9579 SelectObject(hdc, hOldFont);
9580
9581 ReleaseDC(infoPtr->hwndSelf, hdc);
9582 if (isW)
9583 hedit = CreateWindowW(editName, text, style, x, y, sz.cx, height, infoPtr->hwndSelf, 0, hinst, 0);
9584 else
9585 hedit = CreateWindowA("Edit", (LPCSTR)text, style, x, y, sz.cx, height, infoPtr->hwndSelf, 0, hinst, 0);
9586
9587 if (!hedit) return 0;
9588
9589 infoPtr->EditWndProc = (WNDPROC)
9590 (isW ? SetWindowLongW(hedit, GWL_WNDPROC, (LONG)EditLblWndProcW) :
9591 SetWindowLongA(hedit, GWL_WNDPROC, (LONG)EditLblWndProcA) );
9592
9593 SendMessageW(hedit, WM_SETFONT, infoPtr->hFont, FALSE);
9594
9595 return hedit;
9596 }
Windows API implementation