?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Some more messages.
[wine/multimedia.git] / dlls / comctl32 / listview.c
blob2950b4b6ce3621ae81fbb603c8d8782fdd81cd3a
1 /*
2 * Listview control
3 *
4 * Copyright 1998, 1999 Eric Kohl
5 * Copyright 1999 Luc Tourangeau
6 *
7 * NOTES
8 * Listview control implementation.
9 *
10 * TODO:
11 * 1. No horizontal scrolling when header is larger than the client area.
12 * 2. Drawing optimizations.
13 * 3. Hot item handling.
14 *
15 * Notifications:
16 * LISTVIEW_Notify : most notifications from children (editbox and header)
17 *
18 * Data structure:
19 * LISTVIEW_SetItemCount : empty stub
20 *
21 * Unicode:
22 * LISTVIEW_SetItemW : no unicode support
23 * LISTVIEW_InsertItemW : no unicode support
24 * LISTVIEW_InsertColumnW : no unicode support
25 * LISTVIEW_GetColumnW : no unicode support
26 * LISTVIEW_SetColumnW : no unicode support
27 *
28 * Advanced functionality:
29 * LISTVIEW_GetNumberOfWorkAreas : not implemented
30 * LISTVIEW_GetHotCursor : not implemented
31 * LISTVIEW_GetHoverTime : not implemented
32 * LISTVIEW_GetISearchString : not implemented
33 * LISTVIEW_GetBkImage : not implemented
34 * LISTVIEW_EditLabel : REPORT (need to implement a timer)
35 * LISTVIEW_GetColumnOrderArray : not implemented
36 * LISTVIEW_SetColumnOrderArray : not implemented
37 * LISTVIEW_Arrange : empty stub
38 * LISTVIEW_ApproximateViewRect : incomplete
39 * LISTVIEW_Scroll : not implemented
40 * LISTVIEW_RedrawItems : empty stub
41 * LISTVIEW_Update : not completed
42 */
43
44 #include <string.h>
45 #include "winbase.h"
46 #include "commctrl.h"
47 #include "listview.h"
48 #include "debugtools.h"
49
50 DEFAULT_DEBUG_CHANNEL(listview)
51
52 /*
53 * constants
54 */
55
56 /* maximum size of a label */
57 #define DISP_TEXT_SIZE 128
58
59 /* padding for items in list and small icon display modes */
60 #define WIDTH_PADDING 12
61
62 /* padding for items in list, report and small icon display modes */
63 #define HEIGHT_PADDING 1
64
65 /* offset of items in report display mode */
66 #define REPORT_MARGINX 2
67
68 /* padding for icon in large icon display mode */
69 #define ICON_TOP_PADDING 2
70 #define ICON_BOTTOM_PADDING 2
71
72 /* padding for label in large icon display mode */
73 #define LABEL_VERT_OFFSET 2
74
75 /* default label width for items in list and small icon display modes */
76 #define DEFAULT_LABEL_WIDTH 40
77
78 /* default column width for items in list display mode */
79 #define DEFAULT_COLUMN_WIDTH 96
80
81 /*
82 * macros
83 */
84 #define GETITEMCOUNT(infoPtr) ((infoPtr)->hdpaItems->nItemCount)
85 #define ListView_LVNotify(hwnd,lCtrlId,plvnm) \
86 (BOOL)SendMessageA((hwnd),WM_NOTIFY,(WPARAM)(INT)lCtrlId,(LPARAM)(LPNMLISTVIEW)(plvnm))
87 #define ListView_Notify(hwnd,lCtrlId,pnmh) \
88 (BOOL)SendMessageA((hwnd),WM_NOTIFY,(WPARAM)(INT)lCtrlId,(LPARAM)(LPNMHDR)(pnmh))
89 /* retrieve the number of items in the listview */
90 #define GETITEMCOUNT(infoPtr) ((infoPtr)->hdpaItems->nItemCount)
91
92 /*
93 * forward declarations
94 */
95 static INT LISTVIEW_HitTestItem(HWND, LPLVHITTESTINFO);
96 static INT LISTVIEW_GetCountPerRow(HWND);
97 static INT LISTVIEW_GetCountPerColumn(HWND);
98 static VOID LISTVIEW_AlignLeft(HWND);
99 static VOID LISTVIEW_AlignTop(HWND);
100 static VOID LISTVIEW_AddGroupSelection(HWND, INT);
101 static VOID LISTVIEW_AddSelection(HWND, INT);
102 static BOOL LISTVIEW_AddSubItem(HWND, LPLVITEMA);
103 static INT LISTVIEW_FindInsertPosition(HDPA, INT);
104 static INT LISTVIEW_GetItemHeight(HWND);
105 static BOOL LISTVIEW_GetItemPosition(HWND, INT, LPPOINT);
106 static LRESULT LISTVIEW_GetItemRect(HWND, INT, LPRECT);
107 static INT LISTVIEW_GetItemWidth(HWND);
108 static INT LISTVIEW_GetLabelWidth(HWND, INT);
109 static LRESULT LISTVIEW_GetOrigin(HWND, LPPOINT);
110 static LISTVIEW_SUBITEM* LISTVIEW_GetSubItem(HDPA, INT);
111 static LRESULT LISTVIEW_GetViewRect(HWND, LPRECT);
112 static BOOL LISTVIEW_InitItem(HWND, LISTVIEW_ITEM *, LPLVITEMA);
113 static BOOL LISTVIEW_InitSubItem(HWND, LISTVIEW_SUBITEM *, LPLVITEMA);
114 static LRESULT LISTVIEW_MouseSelection(HWND, POINT);
115 static BOOL LISTVIEW_RemoveColumn(HDPA, INT);
116 static VOID LISTVIEW_RemoveSelections(HWND, INT, INT);
117 static BOOL LISTVIEW_RemoveSubItem(HDPA, INT);
118 static VOID LISTVIEW_SetGroupSelection(HWND, INT);
119 static BOOL LISTVIEW_SetItem(HWND, LPLVITEMA);
120 static BOOL LISTVIEW_SetItemFocus(HWND, INT);
121 static BOOL LISTVIEW_SetItemPosition(HWND, INT, INT, INT);
122 static VOID LISTVIEW_UpdateScroll(HWND);
123 static VOID LISTVIEW_SetSelection(HWND, INT);
124 static VOID LISTVIEW_UpdateSize(HWND);
125 static BOOL LISTVIEW_SetSubItem(HWND, LPLVITEMA);
126 static LRESULT LISTVIEW_SetViewRect(HWND, LPRECT);
127 static BOOL LISTVIEW_ToggleSelection(HWND, INT);
128 static VOID LISTVIEW_UnsupportedStyles(LONG lStyle);
129
130 /***
131 * DESCRIPTION:
132 * Update the scrollbars. This functions should be called whenever
133 * the content, size or view changes.
134 *
135 * PARAMETER(S):
136 * [I] HWND : window handle
137 *
138 * RETURN:
139 * None
140 */
141 static VOID LISTVIEW_UpdateScroll(HWND hwnd)
142 {
143 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
144 LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
145 UINT uView = lStyle & LVS_TYPEMASK;
146 INT nListHeight = infoPtr->rcList.bottom - infoPtr->rcList.top;
147 INT nListWidth = infoPtr->rcList.right - infoPtr->rcList.left;
148 SCROLLINFO scrollInfo;
149
150 ZeroMemory(&scrollInfo, sizeof(SCROLLINFO));
151 scrollInfo.cbSize = sizeof(SCROLLINFO);
152
153 if (uView == LVS_LIST)
154 {
155 INT nCountPerColumn = LISTVIEW_GetCountPerColumn(hwnd);
156 INT nCountPerPage = LISTVIEW_GetCountPerRow(hwnd) * nCountPerColumn;
157 if (nCountPerPage < GETITEMCOUNT(infoPtr))
158 {
159 /* calculate new scrollbar range */
160 INT nHiddenItemCount = GETITEMCOUNT(infoPtr) - nCountPerPage;
161 if (nHiddenItemCount % nCountPerColumn == 0)
162 {
163 scrollInfo.nMax = nHiddenItemCount / nCountPerColumn;
164 }
165 else
166 {
167 scrollInfo.nMax = nHiddenItemCount / nCountPerColumn + 1;
168 }
169
170 scrollInfo.nPos = ListView_GetTopIndex(hwnd) / nCountPerColumn;
171 /*scrollInfo.nPage = LISTVIEW_GetCountPerRow(hwnd);*/
172 scrollInfo.fMask = SIF_RANGE | SIF_POS /*| SIF_PAGE*/;
173 SetScrollInfo(hwnd, SB_HORZ, &scrollInfo, TRUE);
174 }
175 else
176 {
177 /* hide scrollbar */
178 if (lStyle & WS_HSCROLL)
179 {
180 ShowScrollBar(hwnd, SB_HORZ, FALSE);
181 }
182 }
183 }
184 else if (uView == LVS_REPORT)
185 {
186 /* update vertical scrollbar */
187 scrollInfo.nMin = 0;
188 scrollInfo.nMax = GETITEMCOUNT(infoPtr) - LISTVIEW_GetCountPerColumn(hwnd);
189 scrollInfo.nPos = ListView_GetTopIndex(hwnd);
190 /*scrollInfo.nPage = nCountPerColumn;*/
191 scrollInfo.fMask = SIF_RANGE | SIF_POS /*| SIF_PAGE*/;
192 SetScrollInfo(hwnd, SB_VERT, &scrollInfo, TRUE);
193
194 /* update horizontal scrollbar */
195 /* if (infoPtr->nItemWidth > nListWidth) */
196 /* { */
197 /* scrollInfo.fMask = SIF_RANGE | SIF_POS | SIF_PAGE; */
198 /* SetScrollInfo(hwnd, SB_HORZ, &scrollInfo, TRUE); */
199 /* } */
200
201 /* horizontal scrolling has not been implemented yet! I experienced some
202 problems when performing child window scrolling. */
203 }
204 else
205 {
206 RECT rcView;
207
208 if (LISTVIEW_GetViewRect(hwnd, &rcView) != FALSE)
209 {
210 INT nViewWidth = rcView.right - rcView.left;
211 INT nViewHeight = rcView.bottom - rcView.top;
212
213 if (nViewWidth > nListWidth)
214 {
215 INT nHiddenWidth;
216 INT nScrollPosWidth = nListWidth / 10;
217
218 if (nScrollPosWidth == 0)
219 {
220 nScrollPosWidth = 1;
221 nHiddenWidth = nViewWidth - nListWidth;
222 }
223 else
224 {
225 nHiddenWidth = nViewWidth - nScrollPosWidth * 10;
226 }
227
228 scrollInfo.fMask = SIF_POS;
229 if (GetScrollInfo(hwnd, SB_HORZ, &scrollInfo) == FALSE)
230 {
231 scrollInfo.nPos = 0;
232 }
233
234 if (nHiddenWidth % nScrollPosWidth == 0)
235 {
236 scrollInfo.nMax = nHiddenWidth / nScrollPosWidth;
237 }
238 else
239 {
240 scrollInfo.nMax = nHiddenWidth / nScrollPosWidth + 1;
241 }
242
243 scrollInfo.nMin = 0;
244 /*scrollInfo.nPage = 10;*/
245 scrollInfo.fMask = SIF_RANGE | SIF_POS /*| SIF_PAGE*/;
246 SetScrollInfo(hwnd, SB_HORZ, &scrollInfo, TRUE);
247 }
248 else
249 {
250 if (lStyle & WS_HSCROLL)
251 {
252 ShowScrollBar(hwnd, SB_HORZ, FALSE);
253 }
254 }
255
256 if (nViewHeight > nListHeight)
257 {
258 INT nHiddenHeight;
259 INT nScrollPosHeight = nListHeight / 10;
260
261 if (nScrollPosHeight == 0)
262 {
263 nScrollPosHeight = 1;
264 nHiddenHeight = nViewHeight - nListHeight;
265 }
266 else
267 {
268 nHiddenHeight = nViewHeight - nScrollPosHeight * 10;
269 }
270
271 scrollInfo.fMask = SIF_POS;
272 if (GetScrollInfo(hwnd, SB_VERT, &scrollInfo) == FALSE)
273 {
274 scrollInfo.nPos = 0;
275 }
276
277 if (nHiddenHeight % nScrollPosHeight == 0)
278 {
279 scrollInfo.nMax = nHiddenHeight / nScrollPosHeight;
280 }
281 else
282 {
283 scrollInfo.nMax = nHiddenHeight / nScrollPosHeight + 1;
284 }
285
286 scrollInfo.nMin = 0;
287 /*scrollInfo.nPage = 10;*/
288 scrollInfo.fMask = SIF_RANGE | SIF_POS /*| SIF_PAGE*/;
289 SetScrollInfo(hwnd, SB_VERT, &scrollInfo, TRUE);
290 }
291 else
292 {
293 if (lStyle & WS_VSCROLL)
294 {
295 ShowScrollBar(hwnd, SB_VERT, FALSE);
296 }
297 }
298 }
299 }
300 }
301
302 /***
303 * DESCRIPTION:
304 * Prints a message for unsupported window styles.
305 * A kind of TODO list for window styles.
306 *
307 * PARAMETER(S):
308 * [I] LONG : window style
309 *
310 * RETURN:
311 * None
312 */
313 static VOID LISTVIEW_UnsupportedStyles(LONG lStyle)
314 {
315 if ((LVS_TYPEMASK & lStyle) == LVS_EDITLABELS)
316 {
317 FIXME(" LVS_EDITLABELS\n");
318 }
319
320 if ((LVS_TYPEMASK & lStyle) == LVS_NOLABELWRAP)
321 {
322 FIXME(" LVS_NOLABELWRAP\n");
323 }
324
325 if ((LVS_TYPEMASK & lStyle) == LVS_NOSCROLL)
326 {
327 FIXME(" LVS_NOSCROLL\n");
328 }
329
330 if ((LVS_TYPEMASK & lStyle) == LVS_NOSORTHEADER)
331 {
332 FIXME(" LVS_NOSORTHEADER\n");
333 }
334
335 if ((LVS_TYPEMASK & lStyle) == LVS_OWNERDRAWFIXED)
336 {
337 FIXME(" LVS_OWNERDRAWFIXED\n");
338 }
339
340 if ((LVS_TYPEMASK & lStyle) == LVS_SHAREIMAGELISTS)
341 {
342 FIXME(" LVS_SHAREIMAGELISTS\n");
343 }
344
345 if ((LVS_TYPEMASK & lStyle) == LVS_SORTASCENDING)
346 {
347 FIXME(" LVS_SORTASCENDING\n");
348 }
349
350 if ((LVS_TYPEMASK & lStyle) == LVS_SORTDESCENDING)
351 {
352 FIXME(" LVS_SORTDESCENDING\n");
353 }
354 }
355
356 /***
357 * DESCRIPTION:
358 * Aligns the items with the top edge of the window.
359 *
360 * PARAMETER(S):
361 * [I] HWND : window handle
362 *
363 * RETURN:
364 * None
365 */
366 static VOID LISTVIEW_AlignTop(HWND hwnd)
367 {
368 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
369 UINT uView = GetWindowLongA(hwnd, GWL_STYLE) & LVS_TYPEMASK;
370 INT nListWidth = infoPtr->rcList.right - infoPtr->rcList.left;
371 POINT ptItem;
372 RECT rcView;
373 INT i;
374
375 if ((uView == LVS_SMALLICON) || (uView == LVS_ICON))
376 {
377 ZeroMemory(&ptItem, sizeof(POINT));
378 ZeroMemory(&rcView, sizeof(RECT));
379
380 if (nListWidth > infoPtr->nItemWidth)
381 {
382 for (i = 0; i < GETITEMCOUNT(infoPtr); i++)
383 {
384 if (ptItem.x + infoPtr->nItemWidth > nListWidth)
385 {
386 ptItem.x = 0;
387 ptItem.y += infoPtr->nItemHeight;
388 }
389
390 ListView_SetItemPosition(hwnd, i, ptItem.x, ptItem.y);
391 ptItem.x += infoPtr->nItemWidth;
392 rcView.right = max(rcView.right, ptItem.x);
393 }
394
395 rcView.bottom = ptItem.y + infoPtr->nItemHeight;
396 }
397 else
398 {
399 for (i = 0; i < GETITEMCOUNT(infoPtr); i++)
400 {
401 ListView_SetItemPosition(hwnd, i, ptItem.x, ptItem.y);
402 ptItem.y += infoPtr->nItemHeight;
403 }
404
405 rcView.right = infoPtr->nItemWidth;
406 rcView.bottom = ptItem.y;
407 }
408
409 LISTVIEW_SetViewRect(hwnd, &rcView);
410 }
411 }
412
413 /***
414 * DESCRIPTION:
415 * Aligns the items with the left edge of the window.
416 *
417 * PARAMETER(S):
418 * [I] HWND : window handle
419 *
420 * RETURN:
421 * None
422 */
423 static VOID LISTVIEW_AlignLeft(HWND hwnd)
424 {
425 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
426 UINT uView = GetWindowLongA(hwnd, GWL_STYLE) & LVS_TYPEMASK;
427 INT nListHeight = infoPtr->rcList.bottom - infoPtr->rcList.top;
428 POINT ptItem;
429 RECT rcView;
430 INT i;
431
432 if ((uView == LVS_SMALLICON) || (uView == LVS_ICON))
433 {
434 ZeroMemory(&ptItem, sizeof(POINT));
435 ZeroMemory(&rcView, sizeof(RECT));
436
437 if (nListHeight > infoPtr->nItemHeight)
438 {
439 for (i = 0; i < GETITEMCOUNT(infoPtr); i++)
440 {
441 if (ptItem.y + infoPtr->nItemHeight > nListHeight)
442 {
443 ptItem.y = 0;
444 ptItem.x += infoPtr->nItemWidth;
445 }
446
447 ListView_SetItemPosition(hwnd, i, ptItem.x, ptItem.y);
448 ptItem.y += infoPtr->nItemHeight;
449 rcView.bottom = max(rcView.bottom, ptItem.y);
450 }
451
452 rcView.right = ptItem.x + infoPtr->nItemWidth;
453 }
454 else
455 {
456 for (i = 0; i < GETITEMCOUNT(infoPtr); i++)
457 {
458 ListView_SetItemPosition(hwnd, i, ptItem.x, ptItem.y);
459 ptItem.x += infoPtr->nItemWidth;
460 }
461
462 rcView.bottom = infoPtr->nItemHeight;
463 rcView.right = ptItem.x;
464 }
465
466 LISTVIEW_SetViewRect(hwnd, &rcView);
467 }
468 }
469
470 /***
471 * DESCRIPTION:
472 * Set the bounding rectangle of all the items.
473 *
474 * PARAMETER(S):
475 * [I] HWND : window handle
476 * [I] LPRECT : bounding rectangle
477 *
478 * RETURN:
479 * SUCCESS : TRUE
480 * FAILURE : FALSE
481 */
482 static LRESULT LISTVIEW_SetViewRect(HWND hwnd, LPRECT lprcView)
483 {
484 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO*)GetWindowLongA(hwnd, 0);
485 BOOL bResult = FALSE;
486
487 TRACE("(hwnd=%x, left=%d, top=%d, right=%d, bottom=%d)\n", hwnd,
488 lprcView->left, lprcView->top, lprcView->right, lprcView->bottom);
489
490 if (lprcView != NULL)
491 {
492 bResult = TRUE;
493 infoPtr->rcView.left = lprcView->left;
494 infoPtr->rcView.top = lprcView->top;
495 infoPtr->rcView.right = lprcView->right;
496 infoPtr->rcView.bottom = lprcView->bottom;
497 }
498
499 return bResult;
500 }
501
502 /***
503 * DESCRIPTION:
504 * Retrieves the bounding rectangle of all the items.
505 *
506 * PARAMETER(S):
507 * [I] HWND : window handle
508 * [O] LPRECT : bounding rectangle
509 *
510 * RETURN:
511 * SUCCESS : TRUE
512 * FAILURE : FALSE
513 */
514 static LRESULT LISTVIEW_GetViewRect(HWND hwnd, LPRECT lprcView)
515 {
516 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO*)GetWindowLongA(hwnd, 0);
517 BOOL bResult = FALSE;
518 POINT ptOrigin;
519
520 TRACE("(hwnd=%x, lprcView=%p)\n", hwnd, lprcView);
521
522 if (lprcView != NULL)
523 {
524 bResult = LISTVIEW_GetOrigin(hwnd, &ptOrigin);
525 if (bResult != FALSE)
526 {
527 lprcView->left = infoPtr->rcView.left + ptOrigin.x;
528 lprcView->top = infoPtr->rcView.top + ptOrigin.y;
529 lprcView->right = infoPtr->rcView.right + ptOrigin.x;
530 lprcView->bottom = infoPtr->rcView.bottom + ptOrigin.y;
531 }
532
533 TRACE("(left=%d, top=%d, right=%d, bottom=%d)\n",
534 lprcView->left, lprcView->top, lprcView->right, lprcView->bottom);
535 }
536
537 return bResult;
538 }
539
540 /***
541 * DESCRIPTION:
542 * Retrieves the subitem pointer associated with the subitem index.
543 *
544 * PARAMETER(S):
545 * [I] HDPA : DPA handle for a specific item
546 * [I] INT : index of subitem
547 *
548 * RETURN:
549 * SUCCESS : subitem pointer
550 * FAILURE : NULL
551 */
552 static LISTVIEW_SUBITEM* LISTVIEW_GetSubItemPtr(HDPA hdpaSubItems,
553 INT nSubItem)
554 {
555 LISTVIEW_SUBITEM *lpSubItem;
556 INT i;
557
558 for (i = 1; i < hdpaSubItems->nItemCount; i++)
559 {
560 lpSubItem = (LISTVIEW_SUBITEM *) DPA_GetPtr(hdpaSubItems, i);
561 if (lpSubItem != NULL)
562 {
563 if (lpSubItem->iSubItem == nSubItem)
564 {
565 return lpSubItem;
566 }
567 }
568 }
569
570 return NULL;
571 }
572
573 /***
574 * DESCRIPTION:
575 * Calculates the width of an item.
576 *
577 * PARAMETER(S):
578 * [I] HWND : window handle
579 * [I] LONG : window style
580 *
581 * RETURN:
582 * Returns item width.
583 */
584 static INT LISTVIEW_GetItemWidth(HWND hwnd)
585 {
586 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
587 UINT uView = GetWindowLongA(hwnd, GWL_STYLE) & LVS_TYPEMASK;
588 INT nHeaderItemCount;
589 RECT rcHeaderItem;
590 INT nItemWidth = 0;
591 INT nLabelWidth;
592 INT i;
593
594 TRACE("(hwnd=%x)\n", hwnd);
595
596 if (uView == LVS_ICON)
597 {
598 nItemWidth = infoPtr->iconSpacing.cx;
599 }
600 else if (uView == LVS_REPORT)
601 {
602 /* calculate width of header */
603 nHeaderItemCount = Header_GetItemCount(infoPtr->hwndHeader);
604 for (i = 0; i < nHeaderItemCount; i++)
605 {
606 if (Header_GetItemRect(infoPtr->hwndHeader, i, &rcHeaderItem) != 0)
607 {
608 nItemWidth += (rcHeaderItem.right - rcHeaderItem.left);
609 }
610 }
611 }
612 else
613 {
614 for (i = 0; i < GETITEMCOUNT(infoPtr); i++)
615 {
616 nLabelWidth = LISTVIEW_GetLabelWidth(hwnd, i);
617 nItemWidth = max(nItemWidth, nLabelWidth);
618 }
619
620 /* default label size */
621 if (GETITEMCOUNT(infoPtr) == 0)
622 {
623 nItemWidth = DEFAULT_COLUMN_WIDTH;
624 }
625 else
626 {
627 if (nItemWidth == 0)
628 {
629 nItemWidth = DEFAULT_LABEL_WIDTH;
630 }
631 else
632 {
633 /* add padding */
634 nItemWidth += WIDTH_PADDING;
635
636 if (infoPtr->himlSmall != NULL)
637 {
638 nItemWidth += infoPtr->iconSize.cx;
639 }
640
641 if (infoPtr->himlState != NULL)
642 {
643 nItemWidth += infoPtr->iconSize.cx;
644 }
645 }
646 }
647 }
648
649 return nItemWidth;
650 }
651
652 /***
653 * DESCRIPTION:
654 * Calculates the height of an item.
655 *
656 * PARAMETER(S):
657 * [I] HWND : window handle
658 * [I] LONG : window style
659 *
660 * RETURN:
661 * Returns item height.
662 */
663 static INT LISTVIEW_GetItemHeight(HWND hwnd)
664 {
665 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
666 UINT uView = GetWindowLongA(hwnd, GWL_STYLE) & LVS_TYPEMASK;
667 INT nItemHeight = 0;
668
669 if (uView == LVS_ICON)
670 {
671 nItemHeight = infoPtr->iconSpacing.cy;
672 }
673 else
674 {
675 TEXTMETRICA tm;
676 HDC hdc = GetDC(hwnd);
677 HFONT hOldFont = SelectObject(hdc, infoPtr->hFont);
678 GetTextMetricsA(hdc, &tm);
679 nItemHeight = max(tm.tmHeight, infoPtr->iconSize.cy) + HEIGHT_PADDING;
680 SelectObject(hdc, hOldFont);
681 ReleaseDC(hwnd, hdc);
682 }
683
684 return nItemHeight;
685 }
686
687 /***
688 * DESCRIPTION:
689 * Adds a block of selections.
690 *
691 * PARAMETER(S):
692 * [I] HWND : window handle
693 * [I] INT : item index
694 *
695 * RETURN:
696 * None
697 */
698 static VOID LISTVIEW_AddGroupSelection(HWND hwnd, INT nItem)
699 {
700 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
701 INT nFirst = min(infoPtr->nSelectionMark, nItem);
702 INT nLast = max(infoPtr->nSelectionMark, nItem);
703 LVITEMA lvItem;
704 INT i;
705
706 lvItem.state = LVIS_SELECTED;
707 lvItem.stateMask= LVIS_SELECTED;
708
709 for (i = nFirst; i <= nLast; i++)
710 {
711 ListView_SetItemState(hwnd, i, &lvItem);
712 }
713
714 LISTVIEW_SetItemFocus(hwnd, nItem);
715 infoPtr->nSelectionMark = nItem;
716 }
717
718 /***
719 * DESCRIPTION:
720 * Adds a single selection.
721 *
722 * PARAMETER(S):
723 * [I] HWND : window handle
724 * [I] INT : item index
725 *
726 * RETURN:
727 * None
728 */
729 static VOID LISTVIEW_AddSelection(HWND hwnd, INT nItem)
730 {
731 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
732 LVITEMA lvItem;
733
734 lvItem.state = LVIS_SELECTED;
735 lvItem.stateMask= LVIS_SELECTED;
736
737 ListView_SetItemState(hwnd, nItem, &lvItem);
738
739 LISTVIEW_SetItemFocus(hwnd, nItem);
740 infoPtr->nSelectionMark = nItem;
741 }
742
743 /***
744 * DESCRIPTION:
745 * Selects or unselects an item.
746 *
747 * PARAMETER(S):
748 * [I] HWND : window handle
749 * [I] INT : item index
750 *
751 * RETURN:
752 * SELECT: TRUE
753 * UNSELECT : FALSE
754 */
755 static BOOL LISTVIEW_ToggleSelection(HWND hwnd, INT nItem)
756 {
757 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
758 BOOL bResult;
759 LVITEMA lvItem;
760
761 lvItem.stateMask= LVIS_SELECTED;
762
763 if (ListView_GetItemState(hwnd, nItem, LVIS_SELECTED) & LVIS_SELECTED)
764 {
765 lvItem.state = 0;
766 ListView_SetItemState(hwnd, nItem, &lvItem);
767 bResult = FALSE;
768 }
769 else
770 {
771 lvItem.state = LVIS_SELECTED;
772 ListView_SetItemState(hwnd, nItem, &lvItem);
773 bResult = TRUE;
774 }
775
776 LISTVIEW_SetItemFocus(hwnd, nItem);
777 infoPtr->nSelectionMark = nItem;
778
779 return bResult;
780 }
781
782 /***
783 * DESCRIPTION:
784 * Selects items based on view coorddiantes.
785 *
786 * PARAMETER(S):
787 * [I] HWND : window handle
788 * [I] RECT : selection rectangle
789 *
790 * RETURN:
791 * None
792 */
793 static VOID LISTVIEW_SetSelectionRect(HWND hwnd, RECT rcSelRect)
794 {
795 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
796 LVITEMA lvItem;
797 POINT ptItem;
798 INT i;
799
800 lvItem.stateMask = LVIS_SELECTED;
801
802 for (i = 0; i < GETITEMCOUNT(infoPtr); i++)
803 {
804 LISTVIEW_GetItemPosition(hwnd, i, &ptItem);
805 if (PtInRect(&rcSelRect, ptItem) != FALSE)
806 {
807 lvItem.state = LVIS_SELECTED;
808 }
809 else
810 {
811 lvItem.state = 0;
812 }
813
814 ListView_SetItemState(hwnd, i, &lvItem);
815 }
816 }
817
818 /***
819 * DESCRIPTION:
820 * Sets a single group selection.
821 *
822 * PARAMETER(S):
823 * [I] HWND : window handle
824 * [I] INT : item index
825 *
826 * RETURN:
827 * None
828 */
829 static VOID LISTVIEW_SetGroupSelection(HWND hwnd, INT nItem)
830 {
831 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
832 UINT uView = GetWindowLongA(hwnd, GWL_STYLE) & LVS_TYPEMASK;
833 LVITEMA lvItem;
834
835 if ((uView == LVS_LIST) || (uView == LVS_REPORT))
836 {
837 INT i;
838 INT nFirst = min(infoPtr->nSelectionMark, nItem);
839 INT nLast = max(infoPtr->nSelectionMark, nItem);
840 lvItem.stateMask = LVIS_SELECTED;
841
842 for (i = 0; i <= GETITEMCOUNT(infoPtr); i++)
843 {
844 if ((i < nFirst) || (i > nLast))
845 {
846 lvItem.state = 0;
847 }
848 else
849 {
850 lvItem.state = LVIS_SELECTED;
851 }
852
853 ListView_SetItemState(hwnd, i, &lvItem);
854 }
855 }
856 else
857 {
858 POINT ptItem;
859 POINT ptSelMark;
860 RECT rcSel;
861 LISTVIEW_GetItemPosition(hwnd, nItem, &ptItem);
862 LISTVIEW_GetItemPosition(hwnd, infoPtr->nSelectionMark, &ptSelMark);
863 rcSel.left = min(ptSelMark.x, ptItem.x);
864 rcSel.top = min(ptSelMark.y, ptItem.y);
865 rcSel.right = max(ptSelMark.x, ptItem.x) + infoPtr->nItemWidth;
866 rcSel.bottom = max(ptSelMark.y, ptItem.y) + infoPtr->nItemHeight;
867 LISTVIEW_SetSelectionRect(hwnd, rcSel);
868 }
869
870 LISTVIEW_SetItemFocus(hwnd, nItem);
871 }
872
873 /***
874 * DESCRIPTION:
875 * Manages the item focus.
876 *
877 * PARAMETER(S):
878 * [I] HWND : window handle
879 * [I] INT : item index
880 *
881 * RETURN:
882 * TRUE : focused item changed
883 * FALSE : focused item has NOT changed
884 */
885 static BOOL LISTVIEW_SetItemFocus(HWND hwnd, INT nItem)
886 {
887 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
888 BOOL bResult = FALSE;
889 LVITEMA lvItem;
890
891 if (infoPtr->nFocusedItem != nItem)
892 {
893 bResult = TRUE;
894 ZeroMemory(&lvItem, sizeof(LVITEMA));
895 lvItem.stateMask = LVIS_FOCUSED;
896 ListView_SetItemState(hwnd, infoPtr->nFocusedItem, &lvItem);
897
898 lvItem.state = LVIS_FOCUSED;
899 lvItem.stateMask = LVIS_FOCUSED;
900 ListView_SetItemState(hwnd, nItem, &lvItem);
901
902 infoPtr->nFocusedItem = nItem;
903 ListView_EnsureVisible(hwnd, nItem, FALSE);
904 }
905
906 return bResult;
907 }
908
909 /***
910 * DESCRIPTION:
911 * Sets a single selection.
912 *
913 * PARAMETER(S):
914 * [I] HWND : window handle
915 * [I] INT : item index
916 *
917 * RETURN:
918 * None
919 */
920 static VOID LISTVIEW_SetSelection(HWND hwnd, INT nItem)
921 {
922 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
923 LVITEMA lvItem;
924
925 if (nItem > 0)
926 {
927 LISTVIEW_RemoveSelections(hwnd, 0, nItem - 1);
928 }
929
930 if (nItem < GETITEMCOUNT(infoPtr))
931 {
932 LISTVIEW_RemoveSelections(hwnd, nItem + 1, GETITEMCOUNT(infoPtr));
933 }
934
935 ZeroMemory(&lvItem, sizeof(LVITEMA));
936 lvItem.stateMask = LVIS_FOCUSED;
937 ListView_SetItemState(hwnd, infoPtr->nFocusedItem, &lvItem);
938
939 lvItem.state = LVIS_SELECTED | LVIS_FOCUSED;
940 lvItem.stateMask = LVIS_SELECTED | LVIS_FOCUSED;
941 ListView_SetItemState(hwnd, nItem, &lvItem);
942
943 infoPtr->nFocusedItem = nItem;
944 infoPtr->nSelectionMark = nItem;
945 }
946
947 /***
948 * DESCRIPTION:
949 * Set selection(s) with keyboard.
950 *
951 * PARAMETER(S):
952 * [I] HWND : window handle
953 * [I] INT : item index
954 *
955 * RETURN:
956 * SUCCESS : TRUE (needs to be repainted)
957 * FAILURE : FALSE (nothing has changed)
958 */
959 static BOOL LISTVIEW_KeySelection(HWND hwnd, INT nItem)
960 {
961 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
962 LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
963 WORD wShift = HIWORD(GetKeyState(VK_SHIFT));
964 WORD wCtrl = HIWORD(GetKeyState(VK_CONTROL));
965 BOOL bResult = FALSE;
966
967 if ((nItem >= 0) && (nItem < GETITEMCOUNT(infoPtr)))
968 {
969 if (lStyle & LVS_SINGLESEL)
970 {
971 bResult = TRUE;
972 LISTVIEW_SetSelection(hwnd, nItem);
973 ListView_EnsureVisible(hwnd, nItem, FALSE);
974 }
975 else
976 {
977 if (wShift)
978 {
979 bResult = TRUE;
980 LISTVIEW_SetGroupSelection(hwnd, nItem);
981 }
982 else if (wCtrl)
983 {
984 bResult = LISTVIEW_SetItemFocus(hwnd, nItem);
985 }
986 else
987 {
988 bResult = TRUE;
989 LISTVIEW_SetSelection(hwnd, nItem);
990 ListView_EnsureVisible(hwnd, nItem, FALSE);
991 }
992 }
993 }
994
995 return bResult;
996 }
997
998 /***
999 * DESCRIPTION:
1000 * Selects an item based on coordinates.
1001 *
1002 * PARAMETER(S):
1003 * [I] HWND : window handle
1004 * [I] POINT : mouse click ccordinates
1005 *
1006 * RETURN:
1007 * SUCCESS : item index
1008 * FAILURE : -1
1009 */
1010 static LRESULT LISTVIEW_MouseSelection(HWND hwnd, POINT pt)
1011 {
1012 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
1013 RECT rcItem;
1014 INT i;
1015
1016 for (i = 0; i < GETITEMCOUNT(infoPtr); i++)
1017 {
1018 rcItem.left = LVIR_SELECTBOUNDS;
1019 if (LISTVIEW_GetItemRect(hwnd, i, &rcItem) == TRUE)
1020 {
1021 if (PtInRect(&rcItem, pt) != FALSE)
1022 {
1023 return i;
1024 }
1025 }
1026 }
1027
1028 return -1;
1029 }
1030
1031 /***
1032 * DESCRIPTION:
1033 * Removes all selection states.
1034 *
1035 * PARAMETER(S):
1036 * [I] HWND : window handle
1037 * [I] INT : item index
1038 *
1039 * RETURN:
1040 * SUCCCESS : TRUE
1041 * FAILURE : FALSE
1042 */
1043 static VOID LISTVIEW_RemoveSelections(HWND hwnd, INT nFirst, INT nLast)
1044 {
1045 LVITEMA lvItem;
1046 INT i;
1047
1048 lvItem.state = 0;
1049 lvItem.stateMask = LVIS_SELECTED;
1050
1051 for (i = nFirst; i <= nLast; i++)
1052 {
1053 ListView_SetItemState(hwnd, i, &lvItem);
1054 }
1055 }
1056
1057 /***
1058 * DESCRIPTION:
1059 * Removes a column.
1060 *
1061 * PARAMETER(S):
1062 * [IO] HDPA : dynamic pointer array handle
1063 * [I] INT : column index (subitem index)
1064 *
1065 * RETURN:
1066 * SUCCCESS : TRUE
1067 * FAILURE : FALSE
1068 */
1069 static BOOL LISTVIEW_RemoveColumn(HDPA hdpaItems, INT nSubItem)
1070 {
1071 BOOL bResult = TRUE;
1072 HDPA hdpaSubItems;
1073 INT i;
1074
1075 for (i = 0; i < hdpaItems->nItemCount; i++)
1076 {
1077 hdpaSubItems = (HDPA)DPA_GetPtr(hdpaItems, i);
1078 if (hdpaSubItems != NULL)
1079 {
1080 if (LISTVIEW_RemoveSubItem(hdpaSubItems, nSubItem) == FALSE)
1081 {
1082 bResult = FALSE;
1083 }
1084 }
1085 }
1086
1087 return bResult;
1088 }
1089
1090 /***
1091 * DESCRIPTION:
1092 * Removes a subitem at a given position.
1093 *
1094 * PARAMETER(S):
1095 * [IO] HDPA : dynamic pointer array handle
1096 * [I] INT : subitem index
1097 *
1098 * RETURN:
1099 * SUCCCESS : TRUE
1100 * FAILURE : FALSE
1101 */
1102 static BOOL LISTVIEW_RemoveSubItem(HDPA hdpaSubItems, INT nSubItem)
1103 {
1104 LISTVIEW_SUBITEM *lpSubItem;
1105 INT i;
1106
1107 for (i = 1; i < hdpaSubItems->nItemCount; i++)
1108 {
1109 lpSubItem = (LISTVIEW_SUBITEM *)DPA_GetPtr(hdpaSubItems, i);
1110 if (lpSubItem != NULL)
1111 {
1112 if (lpSubItem->iSubItem == nSubItem)
1113 {
1114 /* free string */
1115 if ((lpSubItem->pszText != NULL) &&
1116 (lpSubItem->pszText != LPSTR_TEXTCALLBACKA))
1117 {
1118 COMCTL32_Free(lpSubItem->pszText);
1119 }
1120
1121 /* free item */
1122 COMCTL32_Free(lpSubItem);
1123
1124 /* free dpa memory */
1125 if (DPA_DeletePtr(hdpaSubItems, i) == NULL)
1126 {
1127 return FALSE;
1128 }
1129 }
1130 else if (lpSubItem->iSubItem > nSubItem)
1131 {
1132 return TRUE;
1133 }
1134 }
1135 }
1136
1137 return TRUE;
1138 }
1139
1140 /***
1141 * DESCRIPTION:
1142 * Compares the item information.
1143 *
1144 * PARAMETER(S):
1145 * [I] LISTVIEW_ITEM *: destination item
1146 * [I] LPLVITEM : source item
1147 *
1148 * RETURN:
1149 * SUCCCESS : TRUE (EQUAL)
1150 * FAILURE : FALSE (NOT EQUAL)
1151 */
1152 static UINT LISTVIEW_GetItemChanges(LISTVIEW_ITEM *lpItem, LPLVITEMA lpLVItem)
1153 {
1154 UINT uChanged = 0;
1155
1156 if ((lpItem != NULL) && (lpLVItem != NULL))
1157 {
1158 if (lpLVItem->mask & LVIF_STATE)
1159 {
1160 if ((lpItem->state & lpLVItem->stateMask) !=
1161 (lpLVItem->state & lpLVItem->stateMask))
1162 {
1163 uChanged |= LVIF_STATE;
1164 }
1165 }
1166
1167 if (lpLVItem->mask & LVIF_IMAGE)
1168 {
1169 if (lpItem->iImage != lpLVItem->iImage)
1170 {
1171 uChanged |= LVIF_IMAGE;
1172 }
1173 }
1174
1175 if (lpLVItem->mask & LVIF_PARAM)
1176 {
1177 if (lpItem->lParam != lpLVItem->lParam)
1178 {
1179 uChanged |= LVIF_PARAM;
1180 }
1181 }
1182
1183 if (lpLVItem->mask & LVIF_INDENT)
1184 {
1185 if (lpItem->iIndent != lpLVItem->iIndent)
1186 {
1187 uChanged |= LVIF_INDENT;
1188 }
1189 }
1190
1191 if (lpLVItem->mask & LVIF_TEXT)
1192 {
1193 if (lpLVItem->pszText == LPSTR_TEXTCALLBACKA)
1194 {
1195 if (lpItem->pszText != LPSTR_TEXTCALLBACKA)
1196 {
1197 uChanged |= LVIF_TEXT;
1198 }
1199 }
1200 else
1201 {
1202 if (lpItem->pszText == LPSTR_TEXTCALLBACKA)
1203 {
1204 uChanged |= LVIF_TEXT;
1205 }
1206 else
1207 {
1208 if (lpLVItem->pszText)
1209 {
1210 if (lpItem->pszText)
1211 {
1212 if (strcmp(lpLVItem->pszText, lpItem->pszText) != 0)
1213 {
1214 uChanged |= LVIF_TEXT;
1215 }
1216 }
1217 else
1218 {
1219 uChanged |= LVIF_TEXT;
1220 }
1221 }
1222 else
1223 {
1224 if (lpItem->pszText)
1225 {
1226 uChanged |= LVIF_TEXT;
1227 }
1228 }
1229 }
1230 }
1231 }
1232 }
1233 return uChanged;
1234 }
1235
1236 /***
1237 * DESCRIPTION:
1238 * Initializes item attributes.
1239 *
1240 * PARAMETER(S):
1241 * [I] HWND : window handle
1242 * [O] LISTVIEW_ITEM *: destination item
1243 * [I] LPLVITEM : source item
1244 *
1245 * RETURN:
1246 * SUCCCESS : TRUE
1247 * FAILURE : FALSE
1248 */
1249 static BOOL LISTVIEW_InitItem(HWND hwnd, LISTVIEW_ITEM *lpItem,
1250 LPLVITEMA lpLVItem)
1251 {
1252 LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
1253 BOOL bResult = FALSE;
1254
1255 if ((lpItem != NULL) && (lpLVItem != NULL))
1256 {
1257 bResult = TRUE;
1258
1259 if (lpLVItem->mask & LVIF_STATE)
1260 {
1261 lpItem->state &= ~lpLVItem->stateMask;
1262 lpItem->state |= (lpLVItem->state & lpLVItem->stateMask);
1263 }
1264
1265 if (lpLVItem->mask & LVIF_IMAGE)
1266 {
1267 lpItem->iImage = lpLVItem->iImage;
1268 }
1269
1270 if (lpLVItem->mask & LVIF_PARAM)
1271 {
1272 lpItem->lParam = lpLVItem->lParam;
1273 }
1274
1275 if (lpLVItem->mask & LVIF_INDENT)
1276 {
1277 lpItem->iIndent = lpLVItem->iIndent;
1278 }
1279
1280 if (lpLVItem->mask & LVIF_TEXT)
1281 {
1282 if (lpLVItem->pszText == LPSTR_TEXTCALLBACKA)
1283 {
1284 if ((lStyle & LVS_SORTASCENDING) || (lStyle & LVS_SORTDESCENDING))
1285 {
1286 return FALSE;
1287 }
1288
1289 if ((lpItem->pszText != NULL) &&
1290 (lpItem->pszText != LPSTR_TEXTCALLBACKA))
1291 {
1292 COMCTL32_Free(lpItem->pszText);
1293 }
1294
1295 lpItem->pszText = LPSTR_TEXTCALLBACKA;
1296 }
1297 else
1298 {
1299 if (lpItem->pszText == LPSTR_TEXTCALLBACKA)
1300 {
1301 lpItem->pszText = NULL;
1302 }
1303
1304 bResult = Str_SetPtrA(&lpItem->pszText, lpLVItem->pszText);
1305 }
1306 }
1307 }
1308
1309 return bResult;
1310 }
1311
1312 /***
1313 * DESCRIPTION:
1314 * Initializes subitem attributes.
1315 *
1316 * NOTE: The documentation specifies that the operation fails if the user
1317 * tries to set the indent of a subitem.
1318 *
1319 * PARAMETER(S):
1320 * [I] HWND : window handle
1321 * [O] LISTVIEW_SUBITEM *: destination subitem
1322 * [I] LPLVITEM : source subitem
1323 *
1324 * RETURN:
1325 * SUCCCESS : TRUE
1326 * FAILURE : FALSE
1327 */
1328 static BOOL LISTVIEW_InitSubItem(HWND hwnd, LISTVIEW_SUBITEM *lpSubItem,
1329 LPLVITEMA lpLVItem)
1330 {
1331 LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
1332 BOOL bResult = FALSE;
1333
1334 if ((lpSubItem != NULL) && (lpLVItem != NULL))
1335 {
1336 if (!(lpLVItem->mask & LVIF_INDENT))
1337 {
1338 bResult = TRUE;
1339 ZeroMemory(lpSubItem, sizeof(LISTVIEW_SUBITEM));
1340
1341 lpSubItem->iSubItem = lpLVItem->iSubItem;
1342
1343 if (lpLVItem->mask & LVIF_IMAGE)
1344 {
1345 lpSubItem->iImage = lpLVItem->iImage;
1346 }
1347
1348 if (lpLVItem->mask & LVIF_TEXT)
1349 {
1350 if (lpLVItem->pszText == LPSTR_TEXTCALLBACKA)
1351 {
1352 if ((lStyle & LVS_SORTASCENDING) || (lStyle & LVS_SORTDESCENDING))
1353 {
1354 return FALSE;
1355 }
1356
1357 if ((lpSubItem->pszText != NULL) &&
1358 (lpSubItem->pszText != LPSTR_TEXTCALLBACKA))
1359 {
1360 COMCTL32_Free(lpSubItem->pszText);
1361 }
1362
1363 lpSubItem->pszText = LPSTR_TEXTCALLBACKA;
1364 }
1365 else
1366 {
1367 if (lpSubItem->pszText == LPSTR_TEXTCALLBACKA)
1368 {
1369 lpSubItem->pszText = NULL;
1370 }
1371
1372 bResult = Str_SetPtrA(&lpSubItem->pszText, lpLVItem->pszText);
1373 }
1374 }
1375 }
1376 }
1377
1378 return bResult;
1379 }
1380
1381 /***
1382 * DESCRIPTION:
1383 * Adds a subitem at a given position (column index).
1384 *
1385 * PARAMETER(S):
1386 * [I] HWND : window handle
1387 * [I] LPLVITEM : new subitem atttributes
1388 *
1389 * RETURN:
1390 * SUCCESS : TRUE
1391 * FAILURE : FALSE
1392 */
1393 static BOOL LISTVIEW_AddSubItem(HWND hwnd, LPLVITEMA lpLVItem)
1394 {
1395 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
1396 LISTVIEW_SUBITEM *lpSubItem = NULL;
1397 BOOL bResult = FALSE;
1398 HDPA hdpaSubItems;
1399 INT nPosition, nItem;
1400
1401 if (lpLVItem != NULL)
1402 {
1403 hdpaSubItems = (HDPA)DPA_GetPtr(infoPtr->hdpaItems, lpLVItem->iItem);
1404 if (hdpaSubItems != NULL)
1405 {
1406 lpSubItem = (LISTVIEW_SUBITEM *)COMCTL32_Alloc(sizeof(LISTVIEW_SUBITEM));
1407 if (lpSubItem != NULL)
1408 {
1409 if (LISTVIEW_InitSubItem(hwnd, lpSubItem, lpLVItem) != FALSE)
1410 {
1411 nPosition = LISTVIEW_FindInsertPosition(hdpaSubItems,
1412 lpSubItem->iSubItem);
1413 nItem = DPA_InsertPtr(hdpaSubItems, nPosition, lpSubItem);
1414 if (nItem != -1)
1415 {
1416 bResult = TRUE;
1417 }
1418 }
1419 }
1420 }
1421 }
1422
1423 /* cleanup if unsuccessful */
1424 if ((bResult == FALSE) && (lpSubItem != NULL))
1425 {
1426 COMCTL32_Free(lpSubItem);
1427 }
1428
1429 return bResult;
1430 }
1431
1432 /***
1433 * DESCRIPTION:
1434 * Finds the dpa insert position (array index).
1435 *
1436 * PARAMETER(S):
1437 * [I] HWND : window handle
1438 * [I] INT : subitem index
1439 *
1440 * RETURN:
1441 * SUCCESS : TRUE
1442 * FAILURE : FALSE
1443 */
1444 static INT LISTVIEW_FindInsertPosition(HDPA hdpaSubItems, INT nSubItem)
1445 {
1446 LISTVIEW_SUBITEM *lpSubItem;
1447 INT i;
1448
1449 for (i = 1; i < hdpaSubItems->nItemCount; i++)
1450 {
1451 lpSubItem = (LISTVIEW_SUBITEM *)DPA_GetPtr(hdpaSubItems, i);
1452 if (lpSubItem != NULL)
1453 {
1454 if (lpSubItem->iSubItem > nSubItem)
1455 {
1456 return i;
1457 }
1458 }
1459 }
1460
1461 return hdpaSubItems->nItemCount;
1462 }
1463
1464 /***
1465 * DESCRIPTION:
1466 * Retrieves a listview subitem at a given position (column index).
1467 *
1468 * PARAMETER(S):
1469 * [I] HWND : window handle
1470 * [I] INT : subitem index
1471 *
1472 * RETURN:
1473 * SUCCESS : TRUE
1474 * FAILURE : FALSE
1475 */
1476 static LISTVIEW_SUBITEM* LISTVIEW_GetSubItem(HDPA hdpaSubItems, INT nSubItem)
1477 {
1478 LISTVIEW_SUBITEM *lpSubItem;
1479 INT i;
1480
1481 for (i = 1; i < hdpaSubItems->nItemCount; i++)
1482 {
1483 lpSubItem = (LISTVIEW_SUBITEM *)DPA_GetPtr(hdpaSubItems, i);
1484 if (lpSubItem != NULL)
1485 {
1486 if (lpSubItem->iSubItem == nSubItem)
1487 {
1488 return lpSubItem;
1489 }
1490 else if (lpSubItem->iSubItem > nSubItem)
1491 {
1492 return NULL;
1493 }
1494 }
1495 }
1496
1497 return NULL;
1498 }
1499
1500 /***
1501 * DESCRIPTION:
1502 * Sets item attributes.
1503 *
1504 * PARAMETER(S):
1505 * [I] HWND : window handle
1506 * [I] LPLVITEM : new item atttributes
1507 *
1508 * RETURN:
1509 * SUCCESS : TRUE
1510 * FAILURE : FALSE
1511 */
1512 static BOOL LISTVIEW_SetItem(HWND hwnd, LPLVITEMA lpLVItem)
1513 {
1514 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
1515 BOOL bResult = FALSE;
1516 HDPA hdpaSubItems;
1517 LISTVIEW_ITEM *lpItem;
1518 NMLISTVIEW nmlv;
1519 UINT uChanged;
1520 LONG lCtrlId = GetWindowLongA(hwnd, GWL_ID);
1521
1522 if (lpLVItem != NULL)
1523 {
1524 if (lpLVItem->iSubItem == 0)
1525 {
1526 hdpaSubItems = (HDPA)DPA_GetPtr(infoPtr->hdpaItems, lpLVItem->iItem);
1527 if (hdpaSubItems != NULL)
1528 {
1529 lpItem = (LISTVIEW_ITEM *)DPA_GetPtr(hdpaSubItems, lpLVItem->iSubItem);
1530 if (lpItem != NULL)
1531 {
1532 ZeroMemory(&nmlv, sizeof(NMLISTVIEW));
1533 nmlv.hdr.hwndFrom = hwnd;
1534 nmlv.hdr.idFrom = lCtrlId;
1535 nmlv.hdr.code = LVN_ITEMCHANGING;
1536 nmlv.lParam = lpItem->lParam;
1537 uChanged = LISTVIEW_GetItemChanges(lpItem, lpLVItem);
1538 if (uChanged != 0)
1539 {
1540 if (uChanged & LVIF_STATE)
1541 {
1542 nmlv.uNewState = lpLVItem->state & lpLVItem->stateMask;
1543 nmlv.uOldState = lpItem->state & lpLVItem->stateMask;
1544 }
1545
1546 nmlv.uChanged = uChanged;
1547 nmlv.iItem = lpLVItem->iItem;
1548 nmlv.lParam = lpItem->lParam;
1549 /* send LVN_ITEMCHANGING notification */
1550 ListView_LVNotify(GetParent(hwnd), lCtrlId, &nmlv);
1551
1552 /* copy information */
1553 bResult = LISTVIEW_InitItem(hwnd, lpItem, lpLVItem);
1554
1555 /* send LVN_ITEMCHANGED notification */
1556 nmlv.hdr.code = LVN_ITEMCHANGED;
1557 ListView_LVNotify(GetParent(hwnd), lCtrlId, &nmlv);
1558 }
1559 else
1560 {
1561 bResult = TRUE;
1562 }
1563
1564 InvalidateRect(hwnd, NULL, FALSE);
1565 }
1566 }
1567 }
1568 }
1569
1570 return bResult;
1571 }
1572
1573 /***
1574 * DESCRIPTION:
1575 * Sets subitem attributes.
1576 *
1577 * PARAMETER(S):
1578 * [I] HWND : window handle
1579 * [I] LPLVITEM : new subitem atttributes
1580 *
1581 * RETURN:
1582 * SUCCESS : TRUE
1583 * FAILURE : FALSE
1584 */
1585 static BOOL LISTVIEW_SetSubItem(HWND hwnd, LPLVITEMA lpLVItem)
1586 {
1587 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
1588 BOOL bResult = FALSE;
1589 HDPA hdpaSubItems;
1590 LISTVIEW_SUBITEM *lpSubItem;
1591
1592 if (lpLVItem != NULL)
1593 {
1594 if (lpLVItem->iSubItem > 0)
1595 {
1596 hdpaSubItems = (HDPA)DPA_GetPtr(infoPtr->hdpaItems, lpLVItem->iItem);
1597 if (hdpaSubItems != NULL)
1598 {
1599 /* set subitem only if column is present */
1600 if (Header_GetItemCount(infoPtr->hwndHeader) > lpLVItem->iSubItem)
1601 {
1602 lpSubItem = LISTVIEW_GetSubItem(hdpaSubItems, lpLVItem->iSubItem);
1603 if (lpSubItem != NULL)
1604 {
1605 bResult = LISTVIEW_InitSubItem(hwnd, lpSubItem, lpLVItem);
1606 }
1607 else
1608 {
1609 bResult = LISTVIEW_AddSubItem(hwnd, lpLVItem);
1610 }
1611
1612 InvalidateRect(hwnd, NULL, FALSE);
1613 }
1614 }
1615 }
1616 }
1617
1618 return bResult;
1619 }
1620
1621 /***
1622 * DESCRIPTION:
1623 * Retrieves the index of the item at coordinate (0, 0) of the client area.
1624 *
1625 * PARAMETER(S):
1626 * [I] HWND : window handle
1627 *
1628 * RETURN:
1629 * item index
1630 */
1631 static INT LISTVIEW_GetTopIndex(HWND hwnd)
1632 {
1633 LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
1634 UINT uView = lStyle & LVS_TYPEMASK;
1635 INT nItem = 0;
1636 SCROLLINFO scrollInfo;
1637
1638 ZeroMemory(&scrollInfo, sizeof(SCROLLINFO));
1639 scrollInfo.cbSize = sizeof(SCROLLINFO);
1640 scrollInfo.fMask = SIF_POS;
1641
1642 if (uView == LVS_LIST)
1643 {
1644 if (lStyle & WS_HSCROLL)
1645 {
1646 if (GetScrollInfo(hwnd, SB_HORZ, &scrollInfo) != FALSE)
1647 {
1648 nItem = scrollInfo.nPos * LISTVIEW_GetCountPerColumn(hwnd);
1649 }
1650 }
1651 }
1652 else if (uView == LVS_REPORT)
1653 {
1654 if (lStyle & WS_VSCROLL)
1655 {
1656 if (GetScrollInfo(hwnd, SB_VERT, &scrollInfo) != FALSE)
1657 {
1658 nItem = scrollInfo.nPos;
1659 }
1660 }
1661 }
1662
1663 return nItem;
1664 }
1665
1666 /***
1667 * DESCRIPTION:
1668 * Draws a subitem.
1669 *
1670 * PARAMETER(S):
1671 * [I] HWND : window handle
1672 * [I] HDC : device context handle
1673 * [I] INT : item index
1674 * [I] INT : subitem index
1675 * [I] RECT * : clipping rectangle
1676 *
1677 * RETURN:
1678 * None
1679 */
1680 static VOID LISTVIEW_DrawSubItem(HWND hwnd, HDC hdc, INT nItem, INT nSubItem,
1681 RECT rcItem)
1682 {
1683 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
1684 CHAR szDispText[DISP_TEXT_SIZE];
1685 LVITEMA lvItem;
1686
1687 TRACE("(hwnd=%x, hdc=%x, nItem=%d, nSubItem=%d\n", hwnd, hdc,
1688 nItem, nSubItem);
1689
1690 /* get information needed for drawing the item */
1691 ZeroMemory(&lvItem, sizeof(LVITEMA));
1692 lvItem.mask = LVIF_TEXT;
1693 lvItem.iItem = nItem;
1694 lvItem.iSubItem = nSubItem;
1695 lvItem.cchTextMax = DISP_TEXT_SIZE;
1696 lvItem.pszText = szDispText;
1697 ListView_GetItemA(hwnd, &lvItem);
1698
1699 /* set item colors */
1700 SetBkColor(hdc, infoPtr->clrTextBk);
1701 SetTextColor(hdc, infoPtr->clrText);
1702
1703 ExtTextOutA(hdc, rcItem.left, rcItem.top, ETO_OPAQUE | ETO_CLIPPED,
1704 &rcItem, lvItem.pszText, lstrlenA(lvItem.pszText), NULL);
1705 }
1706
1707
1708 /***
1709 * DESCRIPTION:
1710 * Draws an item.
1711 *
1712 * PARAMETER(S):
1713 * [I] HWND : window handle
1714 * [I] HDC : device context handle
1715 * [I] INT : item index
1716 * [I] RECT * : clipping rectangle
1717 *
1718 * RETURN:
1719 * None
1720 */
1721 static VOID LISTVIEW_DrawItem(HWND hwnd, HDC hdc, INT nItem, RECT rcItem)
1722 {
1723 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
1724 CHAR szDispText[DISP_TEXT_SIZE];
1725 INT nLabelWidth;
1726 LVITEMA lvItem;
1727 INT nMixMode;
1728 DWORD dwBkColor;
1729 DWORD dwTextColor;
1730
1731 TRACE("(hwnd=%x, hdc=%x, nItem=%d\n", hwnd, hdc, nItem);
1732
1733 /* get information needed for drawing the item */
1734 ZeroMemory(&lvItem, sizeof(LVITEMA));
1735 lvItem.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_STATE | LVIF_INDENT;
1736 lvItem.stateMask = LVIS_SELECTED | LVIS_FOCUSED | LVIS_STATEIMAGEMASK;
1737 lvItem.iItem = nItem;
1738 lvItem.iSubItem = 0;
1739 lvItem.cchTextMax = DISP_TEXT_SIZE;
1740 lvItem.pszText = szDispText;
1741 ListView_GetItemA(hwnd, &lvItem);
1742
1743 /* state icons */
1744 if (infoPtr->himlState != NULL)
1745 {
1746 UINT uStateImage = (lvItem.state & LVIS_STATEIMAGEMASK) >> 12;
1747 if (uStateImage != 0)
1748 {
1749 ImageList_Draw(infoPtr->himlState, uStateImage - 1, hdc, rcItem.left,
1750 rcItem.top, ILD_NORMAL);
1751 }
1752
1753 rcItem.left += infoPtr->iconSize.cx;
1754 }
1755
1756 /* small icons */
1757 if (infoPtr->himlSmall != NULL)
1758 {
1759 if (lvItem.state & LVIS_SELECTED)
1760 {
1761 ImageList_SetBkColor(infoPtr->himlSmall, CLR_NONE);
1762 ImageList_Draw(infoPtr->himlSmall, lvItem.iImage, hdc, rcItem.left,
1763 rcItem.top, ILD_SELECTED);
1764 }
1765 else
1766 {
1767 ImageList_SetBkColor(infoPtr->himlSmall, CLR_NONE);
1768 ImageList_Draw(infoPtr->himlSmall, lvItem.iImage, hdc, rcItem.left,
1769 rcItem.top, ILD_NORMAL);
1770 }
1771
1772 rcItem.left += infoPtr->iconSize.cx;
1773 }
1774
1775 if ((lvItem.state & LVIS_SELECTED) && (infoPtr->bFocus != FALSE))
1776 {
1777 /* set item colors */
1778 dwBkColor = SetBkColor(hdc, GetSysColor(COLOR_HIGHLIGHT));
1779 dwTextColor = SetTextColor(hdc, GetSysColor(COLOR_HIGHLIGHTTEXT));
1780 /* set raster mode */
1781 nMixMode = SetROP2(hdc, R2_XORPEN);
1782 }
1783 else if ((GetWindowLongA(hwnd, GWL_STYLE) & LVS_SHOWSELALWAYS) &&
1784 (lvItem.state & LVIS_SELECTED) && (infoPtr->bFocus == FALSE))
1785 {
1786 dwBkColor = SetBkColor(hdc, GetSysColor(COLOR_3DFACE));
1787 dwTextColor = SetTextColor(hdc, GetSysColor(COLOR_BTNTEXT));
1788 /* set raster mode */
1789 nMixMode = SetROP2(hdc, R2_COPYPEN);
1790 }
1791 else
1792 {
1793 /* set item colors */
1794 dwBkColor = SetBkColor(hdc, infoPtr->clrTextBk);
1795 dwTextColor = SetTextColor(hdc, infoPtr->clrText);
1796 /* set raster mode */
1797 nMixMode = SetROP2(hdc, R2_COPYPEN);
1798 }
1799
1800 nLabelWidth = ListView_GetStringWidthA(hwnd, lvItem.pszText);
1801 if (rcItem.left + nLabelWidth < rcItem.right)
1802 {
1803 rcItem.right = rcItem.left + nLabelWidth;
1804 }
1805
1806 /* draw label */
1807 ExtTextOutA(hdc, rcItem.left, rcItem.top, ETO_OPAQUE | ETO_CLIPPED,
1808 &rcItem, lvItem.pszText, lstrlenA(lvItem.pszText), NULL);
1809
1810 if ((lvItem.state & LVIS_FOCUSED) && (infoPtr->bFocus == TRUE))
1811 {
1812 Rectangle(hdc, rcItem.left, rcItem.top, rcItem.right, rcItem.bottom);
1813 }
1814
1815 if (nMixMode != 0)
1816 {
1817 SetROP2(hdc, R2_COPYPEN);
1818 SetBkColor(hdc, infoPtr->clrTextBk);
1819 SetTextColor(hdc, infoPtr->clrText);
1820 }
1821 }
1822
1823 /***
1824 * DESCRIPTION:
1825 * Draws an item when in large icon display mode.
1826 *
1827 * PARAMETER(S):
1828 * [I] HWND : window handle
1829 * [I] HDC : device context handle
1830 * [I] LISTVIEW_ITEM * : item
1831 * [I] INT : item index
1832 * [I] RECT * : clipping rectangle
1833 *
1834 * RETURN:
1835 * None
1836 */
1837 static VOID LISTVIEW_DrawLargeItem(HWND hwnd, HDC hdc, INT nItem, RECT rcItem)
1838 {
1839 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
1840 CHAR szDispText[DISP_TEXT_SIZE];
1841 INT nDrawPosX = rcItem.left;
1842 INT nLabelWidth;
1843 TEXTMETRICA tm;
1844 LVITEMA lvItem;
1845
1846 TRACE("(hwnd=%x, hdc=%x, nItem=%d, left=%d, top=%d, right=%d, \
1847 bottom=%d)\n", hwnd, hdc, nItem, rcItem.left, rcItem.top, rcItem.right,
1848 rcItem.bottom);
1849
1850 /* get information needed for drawing the item */
1851 ZeroMemory(&lvItem, sizeof(LVITEMA));
1852 lvItem.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_STATE;
1853 lvItem.stateMask = LVIS_SELECTED | LVIS_FOCUSED;
1854 lvItem.iItem = nItem;
1855 lvItem.iSubItem = 0;
1856 lvItem.cchTextMax = DISP_TEXT_SIZE;
1857 lvItem.pszText = szDispText;
1858 ListView_GetItemA(hwnd, &lvItem);
1859
1860 if (lvItem.state & LVIS_SELECTED)
1861 {
1862 /* set item colors */
1863 SetBkColor(hdc, GetSysColor(COLOR_HIGHLIGHT));
1864 SetTextColor(hdc, GetSysColor(COLOR_HIGHLIGHTTEXT));
1865 /* set raster mode */
1866 SetROP2(hdc, R2_XORPEN);
1867 }
1868 else
1869 {
1870 /* set item colors */
1871 SetBkColor(hdc, infoPtr->clrTextBk);
1872 SetTextColor(hdc, infoPtr->clrText);
1873 /* set raster mode */
1874 SetROP2(hdc, R2_COPYPEN);
1875 }
1876
1877 if (infoPtr->himlNormal != NULL)
1878 {
1879 rcItem.top += ICON_TOP_PADDING;
1880 nDrawPosX += (infoPtr->iconSpacing.cx - infoPtr->iconSize.cx) / 2;
1881 if (lvItem.state & LVIS_SELECTED)
1882 {
1883 ImageList_Draw(infoPtr->himlNormal, lvItem.iImage, hdc, nDrawPosX,
1884 rcItem.top, ILD_SELECTED);
1885 }
1886 else
1887 {
1888 ImageList_Draw(infoPtr->himlNormal, lvItem.iImage, hdc, nDrawPosX,
1889 rcItem.top, ILD_NORMAL);
1890 }
1891 }
1892
1893 rcItem.top += infoPtr->iconSize.cy + ICON_BOTTOM_PADDING;
1894 nLabelWidth = ListView_GetStringWidthA(hwnd, lvItem.pszText);
1895 nDrawPosX = infoPtr->iconSpacing.cx - nLabelWidth;
1896 if (nDrawPosX > 1)
1897 {
1898 rcItem.left += nDrawPosX / 2;
1899 rcItem.right = rcItem.left + nLabelWidth;
1900 }
1901 else
1902 {
1903 rcItem.left += 1;
1904 rcItem.right = rcItem.left + infoPtr->iconSpacing.cx - 1;
1905 }
1906
1907 /* draw label */
1908 GetTextMetricsA(hdc, &tm);
1909 rcItem.bottom = rcItem.top + tm.tmHeight + HEIGHT_PADDING;
1910 ExtTextOutA(hdc, rcItem.left, rcItem.top, ETO_OPAQUE | ETO_CLIPPED,
1911 &rcItem, lvItem.pszText, lstrlenA(lvItem.pszText), NULL);
1912
1913 if (lvItem.state & LVIS_FOCUSED)
1914 {
1915 Rectangle(hdc, rcItem.left, rcItem.top, rcItem.right, rcItem.bottom);
1916 }
1917 }
1918
1919 /***
1920 * DESCRIPTION:
1921 * Draws listview items when in report display mode.
1922 *
1923 * PARAMETER(S):
1924 * [I] HWND : window handle
1925 * [I] HDC : device context handle
1926 *
1927 * RETURN:
1928 * None
1929 */
1930 static VOID LISTVIEW_RefreshReport(HWND hwnd, HDC hdc)
1931 {
1932 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd,0);
1933 INT nDrawPosY = infoPtr->rcList.top;
1934 INT nColumnCount;
1935 RECT rcItem;
1936 INT j;
1937 INT nItem;
1938 INT nLast;
1939
1940 nItem = ListView_GetTopIndex(hwnd);
1941
1942 /* add 1 for displaying a partial item at the bottom */
1943 nLast = nItem + LISTVIEW_GetCountPerColumn(hwnd) + 1;
1944 nLast = min(nLast, GETITEMCOUNT(infoPtr));
1945 for (; nItem < nLast; nItem++)
1946 {
1947 nColumnCount = Header_GetItemCount(infoPtr->hwndHeader);
1948 for (j = 0; j < nColumnCount; j++)
1949 {
1950 Header_GetItemRect(infoPtr->hwndHeader, j, &rcItem);
1951 rcItem.left += REPORT_MARGINX;
1952 rcItem.right = max(rcItem.left, rcItem.right - REPORT_MARGINX);
1953 rcItem.top = nDrawPosY;
1954 rcItem.bottom = rcItem.top + infoPtr->nItemHeight;
1955 if (j == 0)
1956 {
1957 LISTVIEW_DrawItem(hwnd, hdc, nItem, rcItem);
1958 }
1959 else
1960 {
1961 LISTVIEW_DrawSubItem(hwnd, hdc, nItem, j, rcItem);
1962 }
1963 }
1964
1965 nDrawPosY += infoPtr->nItemHeight;
1966 }
1967 }
1968
1969 /***
1970 * DESCRIPTION:
1971 * Retrieves the number of items that can fit vertically in the client area.
1972 *
1973 * PARAMETER(S):
1974 * [I] HWND : window handle
1975 *
1976 * RETURN:
1977 * Number of items per row.
1978 */
1979 static INT LISTVIEW_GetCountPerRow(HWND hwnd)
1980 {
1981 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd,0);
1982 UINT uView = GetWindowLongA(hwnd, GWL_STYLE) & LVS_TYPEMASK;
1983 INT nListWidth = infoPtr->rcList.right - infoPtr->rcList.left;
1984 INT nCountPerRow = 1;
1985
1986 if (nListWidth > 0)
1987 {
1988 if (uView == LVS_REPORT)
1989 {
1990 nCountPerRow = 1;
1991 }
1992 else
1993 {
1994 nCountPerRow = nListWidth / infoPtr->nItemWidth;
1995 if (nCountPerRow == 0)
1996 {
1997 nCountPerRow = 1;
1998 }
1999 }
2000 }
2001
2002 return nCountPerRow;
2003 }
2004
2005 /***
2006 * DESCRIPTION:
2007 * Retrieves the number of items that can fit horizontally in the client
2008 * area.
2009 *
2010 * PARAMETER(S):
2011 * [I] HWND : window handle
2012 *
2013 * RETURN:
2014 * Number of items per column.
2015 */
2016 static INT LISTVIEW_GetCountPerColumn(HWND hwnd)
2017 {
2018 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd,0);
2019 INT nListHeight = infoPtr->rcList.bottom - infoPtr->rcList.top;
2020 INT nCountPerColumn = 1;
2021
2022 if (nListHeight > 0)
2023 {
2024 nCountPerColumn = nListHeight / infoPtr->nItemHeight;
2025 if (nCountPerColumn == 0)
2026 {
2027 nCountPerColumn = 1;
2028 }
2029 }
2030
2031 return nCountPerColumn;
2032 }
2033
2034 /***
2035 * DESCRIPTION:
2036 * Retrieves the number of columns needed to display all the items when in
2037 * list display mode.
2038 *
2039 * PARAMETER(S):
2040 * [I] HWND : window handle
2041 *
2042 * RETURN:
2043 * Number of columns.
2044 */
2045 static INT LISTVIEW_GetColumnCount(HWND hwnd)
2046 {
2047 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
2048 LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
2049 INT nColumnCount = 0;
2050
2051 if ((lStyle & LVS_TYPEMASK) == LVS_LIST)
2052 {
2053 if (infoPtr->rcList.right % infoPtr->nItemWidth == 0)
2054 {
2055 nColumnCount = infoPtr->rcList.right / infoPtr->nItemWidth;
2056 }
2057 else
2058 {
2059 nColumnCount = infoPtr->rcList.right / infoPtr->nItemWidth + 1;
2060 }
2061 }
2062
2063 return nColumnCount;
2064 }
2065
2066
2067 /***
2068 * DESCRIPTION:
2069 * Draws listview items when in list display mode.
2070 *
2071 * PARAMETER(S):
2072 * [I] HWND : window handle
2073 * [I] HDC : device context handle
2074 *
2075 * RETURN:
2076 * None
2077 */
2078 static VOID LISTVIEW_RefreshList(HWND hwnd, HDC hdc)
2079 {
2080 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
2081 RECT rcItem;
2082 INT i, j;
2083 INT nItem;
2084 INT nColumnCount;
2085 INT nCountPerColumn;
2086
2087 /* get number of fully visible columns */
2088 nColumnCount = LISTVIEW_GetColumnCount(hwnd);
2089 nCountPerColumn = LISTVIEW_GetCountPerColumn(hwnd);
2090 nItem = ListView_GetTopIndex(hwnd);
2091
2092 for (i = 0; i < nColumnCount; i++)
2093 {
2094 for (j = 0; j < nCountPerColumn; j++, nItem++)
2095 {
2096 if (nItem >= GETITEMCOUNT(infoPtr))
2097 return;
2098
2099 rcItem.top = j * infoPtr->nItemHeight;
2100 rcItem.left = i * infoPtr->nItemWidth;
2101 rcItem.bottom = rcItem.top + infoPtr->nItemHeight;
2102 rcItem.right = rcItem.left + infoPtr->nItemWidth;
2103 LISTVIEW_DrawItem(hwnd, hdc, nItem, rcItem);
2104 }
2105 }
2106 }
2107
2108 /***
2109 * DESCRIPTION:
2110 * Draws listview items when in icon or small icon display mode.
2111 *
2112 * PARAMETER(S):
2113 * [I] HWND : window handle
2114 * [I] HDC : device context handle
2115 *
2116 * RETURN:
2117 * None
2118 */
2119 static VOID LISTVIEW_RefreshIcon(HWND hwnd, HDC hdc, BOOL bSmall)
2120 {
2121 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
2122 POINT ptPosition;
2123 POINT ptOrigin;
2124 RECT rcItem;
2125 INT i;
2126
2127 LISTVIEW_GetOrigin(hwnd, &ptOrigin);
2128 for (i = 0; i < GETITEMCOUNT(infoPtr); i++)
2129 {
2130 LISTVIEW_GetItemPosition(hwnd, i, &ptPosition);
2131 ptPosition.x += ptOrigin.x;
2132 ptPosition.y += ptOrigin.y;
2133
2134 if (ptPosition.y + infoPtr->nItemHeight > infoPtr->rcList.top)
2135 {
2136 if (ptPosition.x + infoPtr->nItemWidth > infoPtr->rcList.left)
2137 {
2138 if (ptPosition.y < infoPtr->rcList.bottom)
2139 {
2140 if (ptPosition.x < infoPtr->rcList.right)
2141 {
2142 rcItem.top = ptPosition.y;
2143 rcItem.left = ptPosition.x;
2144 rcItem.bottom = rcItem.top + infoPtr->nItemHeight;
2145 rcItem.right = rcItem.left + infoPtr->nItemWidth;
2146 if (bSmall == FALSE)
2147 {
2148 LISTVIEW_DrawLargeItem(hwnd, hdc, i, rcItem);
2149 }
2150 else
2151 {
2152 LISTVIEW_DrawItem(hwnd, hdc, i, rcItem);
2153 }
2154 }
2155 }
2156 }
2157 }
2158 }
2159 }
2160
2161 /***
2162 * DESCRIPTION:
2163 * Draws listview items.
2164 *
2165 * PARAMETER(S):
2166 * [I] HWND : window handle
2167 * [I] HDC : device context handle
2168 *
2169 * RETURN:
2170 * NoneX
2171 */
2172 static VOID LISTVIEW_Refresh(HWND hwnd, HDC hdc)
2173 {
2174 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
2175 UINT uView = GetWindowLongA(hwnd, GWL_STYLE) & LVS_TYPEMASK;
2176 HFONT hOldFont;
2177 HPEN hPen, hOldPen;
2178
2179 /* select font */
2180 hOldFont = SelectObject(hdc, infoPtr->hFont);
2181
2182 /* select the doted pen (for drawing the focus box) */
2183 hPen = CreatePen(PS_DOT, 1, 0);
2184 hOldPen = SelectObject(hdc, hPen);
2185
2186 /* select transparent brush (for drawing the focus box) */
2187 SelectObject(hdc, GetStockObject(NULL_BRUSH));
2188
2189 if (uView == LVS_LIST)
2190 {
2191 LISTVIEW_RefreshList(hwnd, hdc);
2192 }
2193 else if (uView == LVS_REPORT)
2194 {
2195 LISTVIEW_RefreshReport(hwnd, hdc);
2196 }
2197 else if (uView == LVS_SMALLICON)
2198 {
2199 LISTVIEW_RefreshIcon(hwnd, hdc, TRUE);
2200 }
2201 else if (uView == LVS_ICON)
2202 {
2203 LISTVIEW_RefreshIcon(hwnd, hdc, FALSE);
2204 }
2205
2206 /* unselect objects */
2207 SelectObject(hdc, hOldFont);
2208 SelectObject(hdc, hOldPen);
2209
2210 /* delete pen */
2211 DeleteObject(hPen);
2212 }
2213
2214
2215 /***
2216 * DESCRIPTION:
2217 * Calculates the approximate width and height of a given number of items.
2218 *
2219 * PARAMETER(S):
2220 * [I] HWND : window handle
2221 * [I] INT : number of items
2222 * [I] INT : width
2223 * [I] INT : height
2224 *
2225 * RETURN:
2226 * Returns a DWORD. The width in the low word and the height in high word.
2227 */
2228 static LRESULT LISTVIEW_ApproximateViewRect(HWND hwnd, INT nItemCount,
2229 WORD wWidth, WORD wHeight)
2230 {
2231 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
2232 UINT uView = GetWindowLongA(hwnd, GWL_STYLE) & LVS_TYPEMASK;
2233 INT nItemCountPerColumn = 1;
2234 INT nColumnCount = 0;
2235 DWORD dwViewRect = 0;
2236
2237 if (nItemCount == -1)
2238 {
2239 nItemCount = GETITEMCOUNT(infoPtr);
2240 }
2241
2242 if (uView == LVS_LIST)
2243 {
2244 if (wHeight == 0xFFFF)
2245 {
2246 /* use current height */
2247 wHeight = infoPtr->rcList.bottom - infoPtr->rcList.top;
2248 }
2249
2250 if (wHeight < infoPtr->nItemHeight)
2251 {
2252 wHeight = infoPtr->nItemHeight;
2253 }
2254
2255 if (nItemCount > 0)
2256 {
2257 if (infoPtr->nItemHeight > 0)
2258 {
2259 nItemCountPerColumn = wHeight / infoPtr->nItemHeight;
2260 if (nItemCountPerColumn == 0)
2261 {
2262 nItemCountPerColumn = 1;
2263 }
2264
2265 if (nItemCount % nItemCountPerColumn != 0)
2266 {
2267 nColumnCount = nItemCount / nItemCountPerColumn;
2268 }
2269 else
2270 {
2271 nColumnCount = nItemCount / nItemCountPerColumn + 1;
2272 }
2273 }
2274 }
2275
2276 /* Microsoft padding magic */
2277 wHeight = nItemCountPerColumn * infoPtr->nItemHeight + 2;
2278 wWidth = nColumnCount * infoPtr->nItemWidth + 2;
2279
2280 dwViewRect = MAKELONG(wWidth, wHeight);
2281 }
2282 else if (uView == LVS_REPORT)
2283 {
2284 /* TO DO */
2285 }
2286 else if (uView == LVS_SMALLICON)
2287 {
2288 /* TO DO */
2289 }
2290 else if (uView == LVS_ICON)
2291 {
2292 /* TO DO */
2293 }
2294
2295 return dwViewRect;
2296 }
2297
2298 /***
2299 * DESCRIPTION:
2300 * Arranges listview items in icon display mode.
2301 *
2302 * PARAMETER(S):
2303 * [I] HWND : window handle
2304 * [I] INT : alignment code
2305 *
2306 * RETURN:
2307 * SUCCESS : TRUE
2308 * FAILURE : FALSE
2309 */
2310 static LRESULT LISTVIEW_Arrange(HWND hwnd, INT nAlignCode)
2311 {
2312 UINT uView = GetWindowLongA(hwnd, GWL_STYLE) & LVS_TYPEMASK;
2313 BOOL bResult = FALSE;
2314
2315 if ((uView == LVS_ICON) || (uView == LVS_SMALLICON))
2316 {
2317 switch (nAlignCode)
2318 {
2319 case LVA_ALIGNLEFT:
2320 /* TO DO */
2321 break;
2322 case LVA_ALIGNTOP:
2323 /* TO DO */
2324 break;
2325 case LVA_DEFAULT:
2326 /* TO DO */
2327 break;
2328 case LVA_SNAPTOGRID:
2329 /* TO DO */
2330 break;
2331 }
2332 }
2333
2334 return bResult;
2335 }
2336
2337 /* << LISTVIEW_CreateDragImage >> */
2338
2339 /***
2340 * DESCRIPTION:
2341 * Removes all listview items and subitems.
2342 *
2343 * PARAMETER(S):
2344 * [I] HWND : window handle
2345 *
2346 * RETURN:
2347 * SUCCESS : TRUE
2348 * FAILURE : FALSE
2349 */
2350 static LRESULT LISTVIEW_DeleteAllItems(HWND hwnd)
2351 {
2352 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
2353 LONG lCtrlId = GetWindowLongA(hwnd, GWL_ID);
2354 LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
2355 UINT uView = lStyle & LVS_TYPEMASK;
2356 LISTVIEW_ITEM *lpItem;
2357 LISTVIEW_SUBITEM *lpSubItem;
2358 NMLISTVIEW nmlv;
2359 BOOL bSuppress;
2360 BOOL bResult = FALSE;
2361 INT i;
2362 INT j;
2363 HDPA hdpaSubItems;
2364
2365 TRACE("(hwnd=%x,)\n", hwnd);
2366
2367 if (GETITEMCOUNT(infoPtr) > 0)
2368 {
2369 /* initialize memory */
2370 ZeroMemory(&nmlv, sizeof(NMLISTVIEW));
2371
2372 /* send LVN_DELETEALLITEMS notification */
2373 nmlv.hdr.hwndFrom = hwnd;
2374 nmlv.hdr.idFrom = lCtrlId;
2375 nmlv.hdr.code = LVN_DELETEALLITEMS;
2376 nmlv.iItem = -1;
2377
2378 /* verify if subsequent LVN_DELETEITEM notifications should be
2379 suppressed */
2380 bSuppress = ListView_LVNotify(GetParent(hwnd), lCtrlId, &nmlv);
2381
2382 for (i = 0; i < GETITEMCOUNT(infoPtr); i++)
2383 {
2384 hdpaSubItems = (HDPA)DPA_GetPtr(infoPtr->hdpaItems, i);
2385 if (hdpaSubItems != NULL)
2386 {
2387 for (j = 1; j < hdpaSubItems->nItemCount; j++)
2388 {
2389 lpSubItem = (LISTVIEW_SUBITEM *)DPA_GetPtr(hdpaSubItems, j);
2390 if (lpSubItem != NULL)
2391 {
2392 /* free subitem string */
2393 if ((lpSubItem->pszText != NULL) &&
2394 (lpSubItem->pszText != LPSTR_TEXTCALLBACKA))
2395 {
2396 COMCTL32_Free(lpSubItem->pszText);
2397 }
2398
2399 /* free subitem */
2400 COMCTL32_Free(lpSubItem);
2401 }
2402 }
2403
2404 lpItem = (LISTVIEW_ITEM *)DPA_GetPtr(hdpaSubItems, 0);
2405 if (lpItem != NULL)
2406 {
2407 if (bSuppress == FALSE)
2408 {
2409 /* send LVN_DELETEITEM notification */
2410 nmlv.hdr.code = LVN_DELETEITEM;
2411 nmlv.iItem = i;
2412 nmlv.lParam = lpItem->lParam;
2413 ListView_LVNotify(GetParent(hwnd), lCtrlId, &nmlv);
2414 }
2415
2416 /* free item string */
2417 if ((lpItem->pszText != NULL) &&
2418 (lpItem->pszText != LPSTR_TEXTCALLBACKA))
2419 {
2420 COMCTL32_Free(lpItem->pszText);
2421 }
2422
2423 /* free item */
2424 COMCTL32_Free(lpItem);
2425 }
2426
2427 DPA_Destroy(hdpaSubItems);
2428 }
2429 }
2430
2431 /* reinitialize listview memory */
2432 bResult = DPA_DeleteAllPtrs(infoPtr->hdpaItems);
2433
2434 /* align items (set position of each item) */
2435 if ((uView == LVS_ICON) || (uView == LVS_SMALLICON))
2436 {
2437 if (lStyle & LVS_ALIGNLEFT)
2438 {
2439 LISTVIEW_AlignLeft(hwnd);
2440 }
2441 else
2442 {
2443 LISTVIEW_AlignTop(hwnd);
2444 }
2445 }
2446
2447 LISTVIEW_UpdateScroll(hwnd);
2448
2449 /* invalidate client area (optimization needed) */
2450 InvalidateRect(hwnd, NULL, TRUE);
2451 }
2452
2453 return bResult;
2454 }
2455
2456 /***
2457 * DESCRIPTION:
2458 * Removes a column from the listview control.
2459 *
2460 * PARAMETER(S):
2461 * [I] HWND : window handle
2462 * [I] INT : column index
2463 *
2464 * RETURN:
2465 * SUCCESS : TRUE
2466 * FAILURE : FALSE
2467 */
2468 static LRESULT LISTVIEW_DeleteColumn(HWND hwnd, INT nColumn)
2469 {
2470 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
2471 UINT uView = GetWindowLongA(hwnd, GWL_STYLE) & LVS_TYPEMASK;
2472 BOOL bResult = FALSE;
2473
2474 if (Header_DeleteItem(infoPtr->hwndHeader, nColumn) != FALSE)
2475 {
2476 bResult = LISTVIEW_RemoveColumn(infoPtr->hdpaItems, nColumn);
2477
2478 /* reset scroll parameters */
2479 if (uView == LVS_REPORT)
2480 {
2481 /* update scrollbar(s) */
2482 LISTVIEW_UpdateScroll(hwnd);
2483
2484 /* refresh client area */
2485 InvalidateRect(hwnd, NULL, FALSE);
2486 }
2487 }
2488
2489 return bResult;
2490 }
2491
2492 /***
2493 * DESCRIPTION:
2494 * Removes an item from the listview control.
2495 *
2496 * PARAMETER(S):
2497 * [I] HWND : window handle
2498 * [I] INT : item index
2499 *
2500 * RETURN:
2501 * SUCCESS : TRUE
2502 * FAILURE : FALSE
2503 */
2504 static LRESULT LISTVIEW_DeleteItem(HWND hwnd, INT nItem)
2505 {
2506 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
2507 LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
2508 UINT uView = lStyle & LVS_TYPEMASK;
2509 LONG lCtrlId = GetWindowLongA(hwnd, GWL_ID);
2510 NMLISTVIEW nmlv;
2511 BOOL bResult = FALSE;
2512 HDPA hdpaSubItems;
2513 LISTVIEW_ITEM *lpItem;
2514 LISTVIEW_SUBITEM *lpSubItem;
2515 INT i;
2516
2517 TRACE("(hwnd=%x,nItem=%d)\n", hwnd, nItem);
2518
2519 if ((nItem >= 0) && (nItem < GETITEMCOUNT(infoPtr)))
2520 {
2521 /* initialize memory */
2522 ZeroMemory(&nmlv, sizeof(NMLISTVIEW));
2523
2524 hdpaSubItems = (HDPA)DPA_DeletePtr(infoPtr->hdpaItems, nItem);
2525 if (hdpaSubItems != NULL)
2526 {
2527 for (i = 1; i < hdpaSubItems->nItemCount; i++)
2528 {
2529 lpSubItem = (LISTVIEW_SUBITEM *)DPA_GetPtr(hdpaSubItems, i);
2530 if (lpSubItem != NULL)
2531 {
2532 /* free item string */
2533 if ((lpSubItem->pszText != NULL) &&
2534 (lpSubItem->pszText != LPSTR_TEXTCALLBACKA))
2535 {
2536 COMCTL32_Free(lpSubItem->pszText);
2537 }
2538
2539 /* free item */
2540 COMCTL32_Free(lpSubItem);
2541 }
2542 }
2543
2544 lpItem = (LISTVIEW_ITEM *)DPA_GetPtr(hdpaSubItems, 0);
2545 if (lpItem != NULL)
2546 {
2547 /* send LVN_DELETEITEM notification */
2548 nmlv.hdr.hwndFrom = hwnd;
2549 nmlv.hdr.idFrom = lCtrlId;
2550 nmlv.hdr.code = LVN_DELETEITEM;
2551 nmlv.iItem = nItem;
2552 nmlv.lParam = lpItem->lParam;
2553 SendMessageA(GetParent(hwnd), WM_NOTIFY, (WPARAM)lCtrlId,
2554 (LPARAM)&nmlv);
2555
2556 /* free item string */
2557 if ((lpItem->pszText != NULL) &&
2558 (lpItem->pszText != LPSTR_TEXTCALLBACKA))
2559 {
2560 COMCTL32_Free(lpItem->pszText);
2561 }
2562
2563 /* free item */
2564 COMCTL32_Free(lpItem);
2565 }
2566
2567 bResult = DPA_Destroy(hdpaSubItems);
2568 }
2569
2570 /* align items (set position of each item) */
2571 if ((uView == LVS_SMALLICON) || (uView == LVS_ICON))
2572 {
2573 if (lStyle & LVS_ALIGNLEFT)
2574 {
2575 LISTVIEW_AlignLeft(hwnd);
2576 }
2577 else
2578 {
2579 LISTVIEW_AlignTop(hwnd);
2580 }
2581 }
2582
2583 LISTVIEW_UpdateScroll(hwnd);
2584
2585 /* refresh client area */
2586 InvalidateRect(hwnd, NULL, TRUE);
2587 }
2588
2589 return bResult;
2590 }
2591
2592 /* LISTVIEW_EditLabel */
2593
2594 /***
2595 * DESCRIPTION:
2596 * Ensures the specified item is visible, scrolling into view if necessary.
2597 *
2598 * PARAMETER(S):
2599 * [I] HWND : window handle
2600 * [I] INT : item index
2601 * [I] BOOL : partially or entirely visible
2602 *
2603 * RETURN:
2604 * SUCCESS : TRUE
2605 * FAILURE : FALSE
2606 */
2607 static BOOL LISTVIEW_EnsureVisible(HWND hwnd, INT nItem, BOOL bPartial)
2608 {
2609 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
2610 UINT uView = GetWindowLongA(hwnd, GWL_STYLE) & LVS_TYPEMASK;
2611 INT nListHeight = infoPtr->rcList.bottom - infoPtr->rcList.top;
2612 INT nListWidth = infoPtr->rcList.right - infoPtr->rcList.left;
2613 INT nScrollPosHeight = 0;
2614 INT nScrollPosWidth = 0;
2615 SCROLLINFO scrollInfo;
2616 RECT rcItem;
2617
2618 ZeroMemory(&scrollInfo, sizeof(SCROLLINFO));
2619 scrollInfo.cbSize = sizeof(SCROLLINFO);
2620 scrollInfo.fMask = SIF_POS;
2621
2622 /* ALWAYS bPartial == FALSE, FOR NOW! */
2623
2624 rcItem.left = LVIR_BOUNDS;
2625 if (LISTVIEW_GetItemRect(hwnd, nItem, &rcItem) != FALSE)
2626 {
2627 if (rcItem.left < infoPtr->rcList.left)
2628 {
2629 if (GetScrollInfo(hwnd, SB_HORZ, &scrollInfo) != FALSE)
2630 {
2631 /* scroll left */
2632 if (uView == LVS_LIST)
2633 {
2634 nScrollPosWidth = infoPtr->nItemWidth;
2635 rcItem.left += infoPtr->rcList.left;
2636 }
2637 else if ((uView == LVS_SMALLICON) || (uView == LVS_ICON))
2638 {
2639 nScrollPosWidth = max(1, nListWidth / 10);
2640 rcItem.left += infoPtr->rcList.left;
2641 }
2642
2643 if (rcItem.left % nScrollPosWidth == 0)
2644 {
2645 scrollInfo.nPos += rcItem.left / nScrollPosWidth;
2646 }
2647 else
2648 {
2649 scrollInfo.nPos += rcItem.left / nScrollPosWidth - 1;
2650 }
2651
2652 SetScrollInfo(hwnd, SB_HORZ, &scrollInfo, TRUE);
2653 }
2654 }
2655 else if (rcItem.right > infoPtr->rcList.right)
2656 {
2657 if (GetScrollInfo(hwnd, SB_HORZ, &scrollInfo) != FALSE)
2658 {
2659 /* scroll right */
2660 if (uView == LVS_LIST)
2661 {
2662 rcItem.right -= infoPtr->rcList.right;
2663 nScrollPosWidth = infoPtr->nItemWidth;
2664 }
2665 else if ((uView == LVS_SMALLICON) || (uView == LVS_ICON))
2666 {
2667 rcItem.right -= infoPtr->rcList.right;
2668 nScrollPosWidth = max(1, nListWidth / 10);
2669 }
2670
2671 if (rcItem.right % nScrollPosWidth == 0)
2672 {
2673 scrollInfo.nPos += rcItem.right / nScrollPosWidth;
2674 }
2675 else
2676 {
2677 scrollInfo.nPos += rcItem.right / nScrollPosWidth + 1;
2678 }
2679
2680 SetScrollInfo(hwnd, SB_HORZ, &scrollInfo, TRUE);
2681 }
2682 }
2683
2684 if (rcItem.top < infoPtr->rcList.top)
2685 {
2686 /* scroll up */
2687 if (GetScrollInfo(hwnd, SB_VERT, &scrollInfo) != FALSE)
2688 {
2689 if (uView == LVS_REPORT)
2690 {
2691 rcItem.top -= infoPtr->rcList.top;
2692 nScrollPosHeight = infoPtr->nItemHeight;
2693 }
2694 else if ((uView == LVS_ICON) || (uView == LVS_SMALLICON))
2695 {
2696 nScrollPosHeight = max(1, nListHeight / 10);
2697 rcItem.top += infoPtr->rcList.top;
2698 }
2699
2700 if (rcItem.top % nScrollPosHeight == 0)
2701 {
2702 scrollInfo.nPos += rcItem.top / nScrollPosHeight;
2703 }
2704 else
2705 {
2706 scrollInfo.nPos += rcItem.top / nScrollPosHeight - 1;
2707 }
2708
2709 SetScrollInfo(hwnd, SB_VERT, &scrollInfo, TRUE);
2710 }
2711 }
2712 else if (rcItem.bottom > infoPtr->rcList.bottom)
2713 {
2714 /* scroll down */
2715 if (GetScrollInfo(hwnd, SB_VERT, &scrollInfo) != FALSE)
2716 {
2717 if (uView == LVS_REPORT)
2718 {
2719 rcItem.bottom -= infoPtr->rcList.bottom;
2720 nScrollPosHeight = infoPtr->nItemHeight;
2721 }
2722 else if ((uView == LVS_ICON) || (uView == LVS_SMALLICON))
2723 {
2724 nScrollPosHeight = max(1, nListHeight / 10);
2725 rcItem.bottom -= infoPtr->rcList.bottom;
2726 }
2727
2728 if (rcItem.bottom % nScrollPosHeight == 0)
2729 {
2730 scrollInfo.nPos += rcItem.bottom / nScrollPosHeight;
2731 }
2732 else
2733 {
2734 scrollInfo.nPos += rcItem.bottom / nScrollPosHeight + 1;
2735 }
2736
2737 SetScrollInfo(hwnd, SB_VERT, &scrollInfo, TRUE);
2738 }
2739 }
2740 }
2741
2742 return TRUE;
2743 }
2744
2745 /***
2746 * DESCRIPTION:
2747 * Retrieves the nearest item, given a position and a direction.
2748 *
2749 * PARAMETER(S):
2750 * [I] HWND : window handle
2751 * [I] POINT : start position
2752 * [I] UINT : direction
2753 *
2754 * RETURN:
2755 * Item index if successdful, -1 otherwise.
2756 */
2757 static INT LISTVIEW_GetNearestItem(HWND hwnd, POINT pt, UINT vkDirection)
2758 {
2759 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
2760 LVHITTESTINFO lvHitTestInfo;
2761 INT nItem = -1;
2762 RECT rcView;
2763
2764 if (LISTVIEW_GetViewRect(hwnd, &rcView) != FALSE)
2765 {
2766 ZeroMemory(&lvHitTestInfo, sizeof(LVHITTESTINFO));
2767 LISTVIEW_GetOrigin(hwnd, &lvHitTestInfo.pt);
2768 lvHitTestInfo.pt.x += pt.x;
2769 lvHitTestInfo.pt.y += pt.y;
2770
2771 do
2772 {
2773 if (vkDirection == VK_DOWN)
2774 {
2775 lvHitTestInfo.pt.y += infoPtr->nItemHeight;
2776 }
2777 else if (vkDirection == VK_UP)
2778 {
2779 lvHitTestInfo.pt.y -= infoPtr->nItemHeight;
2780 }
2781 else if (vkDirection == VK_LEFT)
2782 {
2783 lvHitTestInfo.pt.x -= infoPtr->nItemWidth;
2784 }
2785 else if (vkDirection == VK_RIGHT)
2786 {
2787 lvHitTestInfo.pt.x += infoPtr->nItemWidth;
2788 }
2789
2790 if (PtInRect(&rcView, lvHitTestInfo.pt) == FALSE)
2791 {
2792 return -1;
2793 }
2794 else
2795 {
2796 nItem = LISTVIEW_HitTestItem(hwnd, &lvHitTestInfo);
2797 }
2798
2799 }
2800 while (nItem == -1);
2801 }
2802
2803 return nItem;
2804 }
2805
2806 /***
2807 * DESCRIPTION:
2808 * Searches for an item with specific characteristics.
2809 *
2810 * PARAMETER(S):
2811 * [I] HWND : window handle
2812 * [I] INT : base item index
2813 * [I] LPLVFINDINFO : item information to look for
2814 *
2815 * RETURN:
2816 * SUCCESS : index of item
2817 * FAILURE : -1
2818 */
2819 static LRESULT LISTVIEW_FindItem(HWND hwnd, INT nStart,
2820 LPLVFINDINFO lpFindInfo)
2821 {
2822 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
2823 POINT ptItem;
2824 CHAR szDispText[DISP_TEXT_SIZE];
2825 LVITEMA lvItem;
2826 BOOL bWrap = FALSE;
2827 INT nItem = nStart;
2828 INT nLast = GETITEMCOUNT(infoPtr);
2829
2830 if ((nItem >= -1) && (lpFindInfo != NULL))
2831 {
2832 ZeroMemory(&lvItem, sizeof(LVITEMA));
2833
2834 if (lpFindInfo->flags & LVFI_PARAM)
2835 {
2836 lvItem.mask |= LVIF_PARAM;
2837 }
2838
2839 if (lpFindInfo->flags & LVFI_STRING)
2840 {
2841 lvItem.mask |= LVIF_TEXT;
2842 lvItem.pszText = szDispText;
2843 lvItem.cchTextMax = DISP_TEXT_SIZE;
2844 }
2845
2846 if (lpFindInfo->flags & LVFI_PARTIAL)
2847 {
2848 lvItem.mask |= LVIF_TEXT;
2849 lvItem.pszText = szDispText;
2850 lvItem.cchTextMax = DISP_TEXT_SIZE;
2851 }
2852
2853 if (lpFindInfo->flags & LVFI_WRAP)
2854 {
2855 bWrap = TRUE;
2856 }
2857
2858 if (lpFindInfo->flags & LVFI_NEARESTXY)
2859 {
2860 ptItem.x = lpFindInfo->pt.x;
2861 ptItem.y = lpFindInfo->pt.y;
2862 }
2863
2864 while (1)
2865 {
2866 while (nItem < nLast)
2867 {
2868 if (lpFindInfo->flags & LVFI_NEARESTXY)
2869 {
2870 nItem = LISTVIEW_GetNearestItem(hwnd, ptItem,
2871 lpFindInfo->vkDirection);
2872 if (nItem != -1)
2873 {
2874 /* get position of the new item index */
2875 if (ListView_GetItemPosition(hwnd, nItem, &ptItem) == FALSE)
2876 return -1;
2877 }
2878 else
2879 return -1;
2880 }
2881 else
2882 {
2883 nItem++;
2884 }
2885
2886 lvItem.iItem = nItem;
2887 lvItem.iSubItem = 0;
2888 if (ListView_GetItemA(hwnd, &lvItem) != FALSE)
2889 {
2890 if (lvItem.mask & LVIF_TEXT)
2891 {
2892 if (lpFindInfo->flags & LVFI_PARTIAL)
2893 {
2894 if (strstr(lvItem.pszText, lpFindInfo->psz) == NULL)
2895 continue;
2896 }
2897 else
2898 {
2899 if (strcmp(lvItem.pszText, lpFindInfo->psz) != 0)
2900 continue;
2901 }
2902 }
2903
2904 if (lvItem.mask & LVIF_PARAM)
2905 {
2906 if (lpFindInfo->lParam != lvItem.lParam)
2907 continue;
2908 }
2909
2910 return nItem;
2911 }
2912 }
2913
2914 if (bWrap != FALSE)
2915 {
2916 nItem = -1;
2917 nLast = nStart + 1;
2918 bWrap = FALSE;
2919 }
2920 else
2921 {
2922 return -1;
2923 }
2924 }
2925 }
2926
2927 return -1;
2928 }
2929
2930 /***
2931 * DESCRIPTION:
2932 * Retrieves the background color of the listview control.
2933 *
2934 * PARAMETER(S):
2935 * [I] HWND : window handle
2936 *
2937 * RETURN:
2938 * COLORREF associated with the background.
2939 */
2940 static LRESULT LISTVIEW_GetBkColor(HWND hwnd)
2941 {
2942 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
2943
2944 return infoPtr->clrBk;
2945 }
2946
2947 /***
2948 * DESCRIPTION:
2949 * Retrieves the background image of the listview control.
2950 *
2951 * PARAMETER(S):
2952 * [I] HWND : window handle
2953 * [O] LPLVMKBIMAGE : background image attributes
2954 *
2955 * RETURN:
2956 * SUCCESS : TRUE
2957 * FAILURE : FALSE`
2958 */
2959 /* static LRESULT LISTVIEW_GetBkImage(HWND hwnd, LPLVBKIMAGE lpBkImage) */
2960 /* { */
2961 /* FIXME (listview, "empty stub!\n"); */
2962 /* return FALSE; */
2963 /* } */
2964
2965 /***
2966 * DESCRIPTION:
2967 * Retrieves the callback mask.
2968 *
2969 * PARAMETER(S):
2970 * [I] HWND : window handle
2971 *
2972 * RETURN:
2973 * Value of mask
2974 */
2975 static UINT LISTVIEW_GetCallbackMask(HWND hwnd)
2976 {
2977 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
2978
2979 return infoPtr->uCallbackMask;
2980 }
2981
2982 /***
2983 * DESCRIPTION:
2984 * Retrieves column attributes.
2985 *
2986 * PARAMETER(S):
2987 * [I] HWND : window handle
2988 * [I] INT : column index
2989 * [IO] LPLVCOLUMNA : column information
2990 *
2991 * RETURN:
2992 * SUCCESS : TRUE
2993 * FAILURE : FALSE
2994 */
2995 static LRESULT LISTVIEW_GetColumnA(HWND hwnd, INT nItem, LPLVCOLUMNA lpColumn)
2996 {
2997 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
2998 HDITEMA hdi;
2999 BOOL bResult = FALSE;
3000
3001 if (lpColumn != NULL)
3002 {
3003 /* initialize memory */
3004 ZeroMemory(&hdi, sizeof(HDITEMA));
3005
3006 if (lpColumn->mask & LVCF_FMT)
3007 {
3008 hdi.mask |= HDI_FORMAT;
3009 }
3010
3011 if (lpColumn->mask & LVCF_WIDTH)
3012 {
3013 hdi.mask |= HDI_WIDTH;
3014 }
3015
3016 if (lpColumn->mask & LVCF_TEXT)
3017 {
3018 hdi.mask |= (HDI_TEXT | HDI_FORMAT);
3019 }
3020
3021 if (lpColumn->mask & LVCF_IMAGE)
3022 {
3023 hdi.mask |= HDI_IMAGE;
3024 }
3025
3026 if (lpColumn->mask & LVCF_ORDER)
3027 {
3028 hdi.mask |= HDI_ORDER;
3029 }
3030
3031 bResult = Header_GetItemA(infoPtr->hwndHeader, nItem, &hdi);
3032 if (bResult != FALSE)
3033 {
3034 if (lpColumn->mask & LVCF_FMT)
3035 {
3036 lpColumn->fmt = 0;
3037
3038 if (hdi.fmt & HDF_LEFT)
3039 {
3040 lpColumn->fmt |= LVCFMT_LEFT;
3041 }
3042 else if (hdi.fmt & HDF_RIGHT)
3043 {
3044 lpColumn->fmt |= LVCFMT_RIGHT;
3045 }
3046 else if (hdi.fmt & HDF_CENTER)
3047 {
3048 lpColumn->fmt |= LVCFMT_CENTER;
3049 }
3050
3051 if (hdi.fmt & HDF_IMAGE)
3052 {
3053 lpColumn->fmt |= LVCFMT_COL_HAS_IMAGES;
3054 }
3055
3056 if (hdi.fmt & HDF_BITMAP_ON_RIGHT)
3057 {
3058 lpColumn->fmt |= LVCFMT_BITMAP_ON_RIGHT;
3059 }
3060 }
3061
3062 if (lpColumn->mask & LVCF_WIDTH)
3063 {
3064 lpColumn->cx = hdi.cxy;
3065 }
3066
3067 if ((lpColumn->mask & LVCF_TEXT) && (lpColumn->pszText) && (hdi.pszText))
3068 {
3069 lstrcpynA (lpColumn->pszText, hdi.pszText, lpColumn->cchTextMax);
3070 }
3071
3072 if (lpColumn->mask & LVCF_IMAGE)
3073 {
3074 lpColumn->iImage = hdi.iImage;
3075 }
3076
3077 if (lpColumn->mask & LVCF_ORDER)
3078 {
3079 lpColumn->iOrder = hdi.iOrder;
3080 }
3081 }
3082 }
3083
3084 return bResult;
3085 }
3086
3087 /* LISTVIEW_GetColumnW */
3088 /* LISTVIEW_GetColumnOrderArray */
3089
3090 /***
3091 * DESCRIPTION:
3092 * Retrieves the column width.
3093 *
3094 * PARAMETER(S):
3095 * [I] HWND : window handle
3096 * [I] int : column index
3097 *
3098 * RETURN:
3099 * SUCCESS : column width
3100 * FAILURE : zero
3101 */
3102 static LRESULT LISTVIEW_GetColumnWidth(HWND hwnd, INT nColumn)
3103 {
3104 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
3105 UINT uView = GetWindowLongA(hwnd, GWL_STYLE) & LVS_TYPEMASK;
3106 INT nColumnWidth = 0;
3107 HDITEMA hdi;
3108
3109 if (uView == LVS_LIST)
3110 {
3111 nColumnWidth = infoPtr->nItemWidth;
3112 }
3113 else if (uView == LVS_REPORT)
3114 {
3115 /* get column width from header */
3116 ZeroMemory(&hdi, sizeof(HDITEMA));
3117 hdi.mask = HDI_WIDTH;
3118 if (Header_GetItemA(infoPtr->hwndHeader, nColumn, &hdi) != FALSE)
3119 {
3120 nColumnWidth = hdi.cxy;
3121 }
3122 }
3123
3124 return nColumnWidth;
3125 }
3126
3127 /***
3128 * DESCRIPTION:
3129 * In list or report display mode, retrieves the number of items that can fit
3130 * vertically in the visible area. In icon or small icon display mode,
3131 * retrieves the total number of visible items.
3132 *
3133 * PARAMETER(S):
3134 * [I] HWND : window handle
3135 *
3136 * RETURN:
3137 * Number of fully visible items.
3138 */
3139 static LRESULT LISTVIEW_GetCountPerPage(HWND hwnd)
3140 {
3141 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
3142 UINT uView = GetWindowLongA(hwnd, GWL_STYLE) & LVS_TYPEMASK;
3143 INT nItemCount = 0;
3144
3145 if (uView == LVS_LIST)
3146 {
3147 if (infoPtr->rcList.right > infoPtr->nItemWidth)
3148 {
3149 nItemCount = LISTVIEW_GetCountPerRow(hwnd) *
3150 LISTVIEW_GetCountPerColumn(hwnd);
3151 }
3152 }
3153 else if (uView == LVS_REPORT)
3154 {
3155 nItemCount = LISTVIEW_GetCountPerColumn(hwnd);
3156 }
3157 else
3158 {
3159 nItemCount = GETITEMCOUNT(infoPtr);
3160 }
3161
3162 return nItemCount;
3163 }
3164
3165 /* LISTVIEW_GetEditControl */
3166
3167 /***
3168 * DESCRIPTION:
3169 * Retrieves the extended listview style.
3170 *
3171 * PARAMETERS:
3172 * [I] HWND : window handle
3173 *
3174 * RETURN:
3175 * SUCCESS : previous style
3176 * FAILURE : 0
3177 */
3178 static LRESULT LISTVIEW_GetExtendedListViewStyle(HWND hwnd)
3179 {
3180 LISTVIEW_INFO *infoPtr;
3181
3182 /* make sure we can get the listview info */
3183 if (!(infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0)))
3184 return (0);
3185
3186 return (infoPtr->dwExStyle);
3187 }
3188
3189 /***
3190 * DESCRIPTION:
3191 * Retrieves the handle to the header control.
3192 *
3193 * PARAMETER(S):
3194 * [I] HWND : window handle
3195 *
3196 * RETURN:
3197 * Header handle.
3198 */
3199 static LRESULT LISTVIEW_GetHeader(HWND hwnd)
3200 {
3201 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
3202
3203 return infoPtr->hwndHeader;
3204 }
3205
3206 /* LISTVIEW_GetHotCursor */
3207 /* LISTVIEW_GetHotItem */
3208 /* LISTVIEW_GetHoverTime */
3209
3210 /***
3211 * DESCRIPTION:
3212 * Retrieves an image list handle.
3213 *
3214 * PARAMETER(S):
3215 * [I] HWND : window handle
3216 * [I] INT : image list identifier
3217 *
3218 * RETURN:
3219 * SUCCESS : image list handle
3220 * FAILURE : NULL
3221 */
3222 static LRESULT LISTVIEW_GetImageList(HWND hwnd, INT nImageList)
3223 {
3224 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
3225 HIMAGELIST himl = NULL;
3226
3227 switch (nImageList)
3228 {
3229 case LVSIL_NORMAL:
3230 himl = infoPtr->himlNormal;
3231 break;
3232 case LVSIL_SMALL:
3233 himl = infoPtr->himlSmall;
3234 break;
3235 case LVSIL_STATE:
3236 himl = infoPtr->himlState;
3237 break;
3238 }
3239
3240 return (LRESULT)himl;
3241 }
3242
3243 /* LISTVIEW_GetISearchString */
3244
3245 /***
3246 * DESCRIPTION:
3247 * Retrieves item attributes.
3248 *
3249 * PARAMETER(S):
3250 * [I] HWND : window handle
3251 * [IO] LPLVITEMA : item info
3252 *
3253 * RETURN:
3254 * SUCCESS : TRUE
3255 * FAILURE : FALSE
3256 */
3257 static LRESULT LISTVIEW_GetItemA(HWND hwnd, LPLVITEMA lpLVItem)
3258 {
3259 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
3260 LONG lCtrlId = GetWindowLongA(hwnd, GWL_ID);
3261 BOOL bResult = FALSE;
3262 NMLVDISPINFOA dispInfo;
3263 LISTVIEW_SUBITEM *lpSubItem;
3264 LISTVIEW_ITEM *lpItem;
3265 HDPA hdpaSubItems;
3266
3267 TRACE("(hwnd=%x, lpLVItem=%p)\n", hwnd, lpLVItem);
3268
3269 if (lpLVItem != NULL)
3270 {
3271 if ((lpLVItem->iItem >= 0) && (lpLVItem->iItem < GETITEMCOUNT(infoPtr)))
3272 {
3273 ZeroMemory(&dispInfo, sizeof(NMLVDISPINFOA));
3274 hdpaSubItems = (HDPA)DPA_GetPtr(infoPtr->hdpaItems, lpLVItem->iItem);
3275 if (hdpaSubItems != NULL)
3276 {
3277 lpItem = (LISTVIEW_ITEM *)DPA_GetPtr(hdpaSubItems, 0);
3278 if (lpItem != NULL)
3279 {
3280 bResult = TRUE;
3281 if (lpLVItem->iSubItem == 0)
3282 {
3283 if ((lpItem->iImage == I_IMAGECALLBACK) &&
3284 (lpLVItem->mask & LVIF_IMAGE))
3285 {
3286 dispInfo.item.mask |= LVIF_IMAGE;
3287 }
3288
3289 if ((lpItem->pszText == LPSTR_TEXTCALLBACKA) &&
3290 (lpLVItem->mask & LVIF_TEXT))
3291 {
3292 dispInfo.item.mask |= LVIF_TEXT;
3293 ZeroMemory(lpLVItem->pszText, sizeof(CHAR)*lpLVItem->cchTextMax);
3294 dispInfo.item.pszText = lpLVItem->pszText;
3295 dispInfo.item.cchTextMax = lpLVItem->cchTextMax;
3296 }
3297
3298 if ((infoPtr->uCallbackMask != 0) && (lpLVItem->mask & LVIF_STATE))
3299 {
3300 dispInfo.item.mask |= LVIF_STATE;
3301 dispInfo.item.stateMask = infoPtr->uCallbackMask;
3302 }
3303
3304 if (dispInfo.item.mask != 0)
3305 {
3306 dispInfo.hdr.hwndFrom = hwnd;
3307 dispInfo.hdr.idFrom = lCtrlId;
3308 dispInfo.hdr.code = LVN_GETDISPINFOA;
3309 dispInfo.item.iItem = lpLVItem->iItem;
3310 dispInfo.item.iSubItem = 0;
3311 dispInfo.item.lParam = lpItem->lParam;
3312 ListView_Notify(GetParent(hwnd), lCtrlId, &dispInfo);
3313 }
3314
3315 if (dispInfo.item.mask & LVIF_IMAGE)
3316 {
3317 lpLVItem->iImage = dispInfo.item.iImage;
3318 }
3319 else if (lpLVItem->mask & LVIF_IMAGE)
3320 {
3321 lpLVItem->iImage = lpItem->iImage;
3322 }
3323
3324 if (dispInfo.item.mask & LVIF_TEXT)
3325 {
3326 if (dispInfo.item.mask & LVIF_DI_SETITEM)
3327 {
3328 Str_SetPtrA(&lpItem->pszText, dispInfo.item.pszText);
3329 }
3330 lpLVItem->pszText = dispInfo.item.pszText;
3331 }
3332 else if (lpLVItem->mask & LVIF_TEXT)
3333 {
3334 lpLVItem->pszText = lpItem->pszText;
3335 }
3336
3337 if (dispInfo.item.mask & LVIF_STATE)
3338 {
3339 lpLVItem->state = lpItem->state;
3340 lpLVItem->state &= ~dispInfo.item.stateMask;
3341 lpLVItem->state |= (dispInfo.item.state &
3342 dispInfo.item.stateMask);
3343 }
3344 else if (lpLVItem->mask & LVIF_STATE)
3345 {
3346 lpLVItem->state = lpItem->state & lpLVItem->stateMask;
3347 }
3348
3349 if (lpLVItem->mask & LVIF_PARAM)
3350 {
3351 lpLVItem->lParam = lpItem->lParam;
3352 }
3353
3354 if (lpLVItem->mask & LVIF_INDENT)
3355 {
3356 lpLVItem->iIndent = lpItem->iIndent;
3357 }
3358 }
3359 else
3360 {
3361 lpSubItem = LISTVIEW_GetSubItemPtr(hdpaSubItems,
3362 lpLVItem->iSubItem);
3363 if (lpSubItem != NULL)
3364 {
3365 if ((lpSubItem->iImage == I_IMAGECALLBACK) &&
3366 (lpLVItem->mask & LVIF_IMAGE))
3367 {
3368 dispInfo.item.mask |= LVIF_IMAGE;
3369 }
3370
3371 if ((lpSubItem->pszText == LPSTR_TEXTCALLBACKA) &&
3372 (lpLVItem->mask & LVIF_TEXT))
3373 {
3374 dispInfo.item.mask |= LVIF_TEXT;
3375 ZeroMemory(lpLVItem->pszText,
3376 sizeof(CHAR)*lpLVItem->cchTextMax);
3377 dispInfo.item.pszText = lpLVItem->pszText;
3378 dispInfo.item.cchTextMax = lpLVItem->cchTextMax;
3379 }
3380 }
3381 else
3382 {
3383 if (lpLVItem->mask & LVIF_IMAGE)
3384 {
3385 dispInfo.item.mask |= LVIF_IMAGE;
3386 }
3387
3388 if (lpLVItem->mask & LVIF_TEXT)
3389 {
3390 dispInfo.item.mask |= LVIF_TEXT;
3391 ZeroMemory(lpLVItem->pszText,
3392 sizeof(CHAR)*lpLVItem->cchTextMax);
3393 dispInfo.item.pszText = lpLVItem->pszText;
3394 dispInfo.item.cchTextMax = lpLVItem->cchTextMax;
3395 }
3396 }
3397
3398 if (dispInfo.item.mask != 0)
3399 {
3400 dispInfo.hdr.hwndFrom = hwnd;
3401 dispInfo.hdr.idFrom = lCtrlId;
3402 dispInfo.hdr.code = LVN_GETDISPINFOA;
3403 dispInfo.item.iItem = lpLVItem->iItem;
3404 dispInfo.item.iSubItem = lpLVItem->iSubItem;
3405 dispInfo.item.lParam = lpItem->lParam;
3406 ListView_Notify(GetParent(hwnd), lCtrlId, &dispInfo);
3407 }
3408
3409 if (dispInfo.item.mask & LVIF_IMAGE)
3410 {
3411 lpLVItem->iImage = dispInfo.item.iImage;
3412 }
3413 else if (lpLVItem->mask & LVIF_IMAGE)
3414 {
3415 lpLVItem->iImage = lpItem->iImage;
3416 }
3417
3418 if (dispInfo.item.mask & LVIF_TEXT)
3419 {
3420 if (dispInfo.item.mask & LVIF_DI_SETITEM)
3421 {
3422 if (lpSubItem)
3423 Str_SetPtrA(&lpSubItem->pszText, dispInfo.item.pszText);
3424 }
3425 lpLVItem->pszText = dispInfo.item.pszText;
3426 }
3427 else if (lpLVItem->mask & LVIF_TEXT)
3428 {
3429 lpLVItem->pszText = lpSubItem->pszText;
3430 }
3431 }
3432 }
3433 }
3434 }
3435 }
3436
3437 return bResult;
3438 }
3439
3440 /* LISTVIEW_GetItemW */
3441 /* LISTVIEW_GetHotCursor */
3442
3443 /***
3444 * DESCRIPTION:
3445 * Retrieves the index of the hot item.
3446 *
3447 * PARAMETERS:
3448 * [I] HWND : window handle
3449 *
3450 * RETURN:
3451 * SUCCESS : hot item index
3452 * FAILURE : -1 (no hot item)
3453 */
3454 static LRESULT LISTVIEW_GetHotItem(HWND hwnd)
3455 {
3456 LISTVIEW_INFO *infoPtr;
3457
3458 /* make sure we can get the listview info */
3459 if (!(infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0)))
3460 return (-1);
3461
3462 return (infoPtr->nHotItem);
3463 }
3464
3465 /* LISTVIEW_GetHoverTime */
3466
3467 /***
3468 * DESCRIPTION:
3469 * Retrieves the number of items in the listview control.
3470 *
3471 * PARAMETER(S):
3472 * [I] HWND : window handle
3473 *
3474 * RETURN:
3475 * Number of items.
3476 */
3477 static LRESULT LISTVIEW_GetItemCount(HWND hwnd)
3478 {
3479 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
3480
3481 return GETITEMCOUNT(infoPtr);
3482 }
3483
3484 /***
3485 * DESCRIPTION:
3486 * Retrieves the position (upper-left) of the listview control item.
3487 *
3488 * PARAMETER(S):
3489 * [I] HWND : window handle
3490 * [I] INT : item index
3491 * [O] LPPOINT : coordinate information
3492 *
3493 * RETURN:
3494 * SUCCESS : TRUE
3495 * FAILURE : FALSE
3496 */
3497 static BOOL LISTVIEW_GetItemPosition(HWND hwnd, INT nItem,
3498 LPPOINT lpptPosition)
3499 {
3500 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
3501 UINT uView = GetWindowLongA(hwnd, GWL_STYLE) & LVS_TYPEMASK;
3502 BOOL bResult = FALSE;
3503 HDPA hdpaSubItems;
3504 LISTVIEW_ITEM *lpItem;
3505 INT nCountPerColumn;
3506 INT nRow;
3507
3508 TRACE("(hwnd=%x,nItem=%d,lpptPosition=%p)\n", hwnd, nItem,
3509 lpptPosition);
3510
3511 if ((nItem >= 0) && (nItem < GETITEMCOUNT(infoPtr)) &&
3512 (lpptPosition != NULL))
3513 {
3514 if (uView == LVS_LIST)
3515 {
3516 bResult = TRUE;
3517 nItem = nItem - ListView_GetTopIndex(hwnd);
3518 nCountPerColumn = LISTVIEW_GetCountPerColumn(hwnd);
3519 if (nItem < 0)
3520 {
3521 nRow = nItem % nCountPerColumn;
3522 if (nRow == 0)
3523 {
3524 lpptPosition->x = nItem / nCountPerColumn * infoPtr->nItemWidth;
3525 lpptPosition->y = 0;
3526 }
3527 else
3528 {
3529 lpptPosition->x = (nItem / nCountPerColumn -1) * infoPtr->nItemWidth;
3530 lpptPosition->y = (nRow + nCountPerColumn) * infoPtr->nItemHeight;
3531 }
3532 }
3533 else
3534 {
3535 lpptPosition->x = nItem / nCountPerColumn * infoPtr->nItemWidth;
3536 lpptPosition->y = nItem % nCountPerColumn * infoPtr->nItemHeight;
3537 }
3538 }
3539 else if (uView == LVS_REPORT)
3540 {
3541 bResult = TRUE;
3542 lpptPosition->x = REPORT_MARGINX;
3543 lpptPosition->y = ((nItem - ListView_GetTopIndex(hwnd)) *
3544 infoPtr->nItemHeight) + infoPtr->rcList.top;
3545 }
3546 else
3547 {
3548 hdpaSubItems = (HDPA)DPA_GetPtr(infoPtr->hdpaItems, nItem);
3549 if (hdpaSubItems != NULL)
3550 {
3551 lpItem = (LISTVIEW_ITEM *)DPA_GetPtr(hdpaSubItems, 0);
3552 if (lpItem != NULL)
3553 {
3554 bResult = TRUE;
3555 lpptPosition->x = lpItem->ptPosition.x;
3556 lpptPosition->y = lpItem->ptPosition.y;
3557 }
3558 }
3559 }
3560 }
3561
3562 return bResult;
3563 }
3564
3565 /***
3566 * DESCRIPTION:
3567 * Retrieves the bounding rectangle for a listview control item.
3568 *
3569 * PARAMETER(S):
3570 * [I] HWND : window handle
3571 * [I] INT : item index
3572 * [IO] LPRECT : bounding rectangle coordinates
3573 *
3574 * RETURN:
3575 * SUCCESS : TRUE
3576 * FAILURE : FALSE
3577 */
3578 static LRESULT LISTVIEW_GetItemRect(HWND hwnd, INT nItem, LPRECT lprc)
3579 {
3580 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
3581 UINT uView = GetWindowLongA(hwnd, GWL_STYLE) & LVS_TYPEMASK;
3582 BOOL bResult = FALSE;
3583 POINT ptOrigin;
3584 POINT ptItem;
3585 HDC hdc;
3586 HFONT hOldFont;
3587 INT nMaxWidth;
3588 INT nLabelWidth;
3589 TEXTMETRICA tm;
3590
3591 TRACE("(hwnd=%x, nItem=%d, lprc=%p)\n", hwnd, nItem, lprc);
3592
3593 if ((nItem >= 0) && (nItem < GETITEMCOUNT(infoPtr)) && (lprc != NULL))
3594 {
3595 if (ListView_GetItemPosition(hwnd, nItem, &ptItem) != FALSE)
3596 {
3597 switch(lprc->left)
3598 {
3599 case LVIR_ICON:
3600 if (uView == LVS_ICON)
3601 {
3602 if (infoPtr->himlNormal != NULL)
3603 {
3604 if (LISTVIEW_GetOrigin(hwnd, &ptOrigin) != FALSE)
3605 {
3606 bResult = TRUE;
3607 lprc->left = ptItem.x + ptOrigin.x;
3608 lprc->top = ptItem.y + ptOrigin.y;
3609 lprc->right = lprc->left + infoPtr->iconSize.cx;
3610 lprc->bottom = (lprc->top + infoPtr->iconSize.cy +
3611 ICON_BOTTOM_PADDING + ICON_TOP_PADDING);
3612 }
3613 }
3614 }
3615 else if (uView == LVS_SMALLICON)
3616 {
3617 if (LISTVIEW_GetOrigin(hwnd, &ptOrigin) != FALSE)
3618 {
3619 bResult = TRUE;
3620 lprc->left = ptItem.x + ptOrigin.x;
3621 lprc->top = ptItem.y + ptOrigin.y;
3622 lprc->bottom = lprc->top + infoPtr->nItemHeight;
3623
3624 if (infoPtr->himlState != NULL)
3625 lprc->left += infoPtr->iconSize.cx;
3626
3627 if (infoPtr->himlSmall != NULL)
3628 lprc->right = lprc->left + infoPtr->iconSize.cx;
3629 else
3630 lprc->right = lprc->left;
3631 }
3632 }
3633 else
3634 {
3635 bResult = TRUE;
3636 lprc->left = ptItem.x;
3637 lprc->top = ptItem.y;
3638 lprc->bottom = lprc->top + infoPtr->nItemHeight;
3639
3640 if (infoPtr->himlState != NULL)
3641 {
3642 lprc->left += infoPtr->iconSize.cx;
3643 }
3644
3645 if (infoPtr->himlSmall != NULL)
3646 {
3647 lprc->right = lprc->left + infoPtr->iconSize.cx;
3648 }
3649 else
3650 {
3651 lprc->right = lprc->left;
3652 }
3653 }
3654 break;
3655
3656 case LVIR_LABEL:
3657 if (uView == LVS_ICON)
3658 {
3659 if (infoPtr->himlNormal != NULL)
3660 {
3661 if (LISTVIEW_GetOrigin(hwnd, &ptOrigin) != FALSE)
3662 {
3663 bResult = TRUE;
3664 lprc->left = ptItem.x + ptOrigin.x;
3665 lprc->top = (ptItem.y + ptOrigin.y + infoPtr->iconSize.cy +
3666 ICON_BOTTOM_PADDING + ICON_TOP_PADDING);
3667 nLabelWidth = LISTVIEW_GetLabelWidth(hwnd, nItem);
3668 if (infoPtr->iconSpacing.cx - nLabelWidth > 1)
3669 {
3670 lprc->left += (infoPtr->iconSpacing.cx - nLabelWidth) / 2;
3671 lprc->right = lprc->left + nLabelWidth;
3672 }
3673 else
3674 {
3675 lprc->left += 1;
3676 lprc->right = lprc->left + infoPtr->iconSpacing.cx - 1;
3677 }
3678
3679 hdc = GetDC(hwnd);
3680 hOldFont = SelectObject(hdc, infoPtr->hFont);
3681 GetTextMetricsA(hdc, &tm);
3682 lprc->bottom = lprc->top + tm.tmHeight + HEIGHT_PADDING;
3683 SelectObject(hdc, hOldFont);
3684 ReleaseDC(hwnd, hdc);
3685 }
3686 }
3687 }
3688 else if (uView == LVS_SMALLICON)
3689 {
3690 if (LISTVIEW_GetOrigin(hwnd, &ptOrigin) != FALSE)
3691 {
3692 bResult = TRUE;
3693 nMaxWidth = lprc->left = ptItem.x + ptOrigin.x;
3694 lprc->top = ptItem.y + ptOrigin.y;
3695 lprc->bottom = lprc->top + infoPtr->nItemHeight;
3696
3697 if (infoPtr->himlState != NULL)
3698 {
3699 lprc->left += infoPtr->iconSize.cx;
3700 }
3701
3702 if (infoPtr->himlSmall != NULL)
3703 {
3704 lprc->left += infoPtr->iconSize.cx;
3705 }
3706
3707 nLabelWidth = LISTVIEW_GetLabelWidth(hwnd, nItem);
3708 if (lprc->left + nLabelWidth < nMaxWidth + infoPtr->nItemWidth)
3709 {
3710 lprc->right = lprc->left + nLabelWidth;
3711 }
3712 else
3713 {
3714 lprc->right = nMaxWidth + infoPtr->nItemWidth;
3715 }
3716 }
3717 }
3718 else
3719 {
3720 bResult = TRUE;
3721 lprc->left = ptItem.x;
3722 lprc->top = ptItem.y;
3723 lprc->bottom = lprc->top + infoPtr->nItemHeight;
3724
3725 if (infoPtr->himlState != NULL)
3726 {
3727 lprc->left += infoPtr->iconSize.cx;
3728 }
3729
3730 if (infoPtr->himlSmall != NULL)
3731 {
3732 lprc->left += infoPtr->iconSize.cx;
3733 }
3734
3735 lprc->right = lprc->left + LISTVIEW_GetLabelWidth(hwnd, nItem);
3736 }
3737 break;
3738
3739 case LVIR_BOUNDS:
3740 if (uView == LVS_ICON)
3741 {
3742 if (infoPtr->himlNormal != NULL)
3743 {
3744 if (LISTVIEW_GetOrigin(hwnd, &ptOrigin) != FALSE)
3745 {
3746 bResult = TRUE;
3747 lprc->left = ptItem.x + ptOrigin.x;
3748 lprc->top = ptItem.y + ptOrigin.y;
3749 lprc->right = lprc->left + infoPtr->iconSpacing.cx;
3750 lprc->bottom = lprc->top + infoPtr->iconSpacing.cy;
3751 }
3752 }
3753 }
3754 else if (uView == LVS_SMALLICON)
3755 {
3756 if (LISTVIEW_GetOrigin(hwnd, &ptOrigin) != FALSE)
3757 {
3758 bResult = TRUE;
3759 lprc->left = ptItem.x + ptOrigin.x;
3760 lprc->right = lprc->left;
3761 lprc->top = ptItem.y + ptOrigin.y;
3762 lprc->bottom = lprc->top + infoPtr->nItemHeight;
3763 if (infoPtr->himlState != NULL)
3764 lprc->right += infoPtr->iconSize.cx;
3765 if (infoPtr->himlSmall != NULL)
3766 lprc->right += infoPtr->iconSize.cx;
3767 lprc->right += LISTVIEW_GetLabelWidth(hwnd, nItem);
3768 }
3769 }
3770 else
3771 {
3772 bResult = TRUE;
3773 lprc->left = ptItem.x;
3774 lprc->right = lprc->left;
3775 lprc->top = ptItem.y;
3776 lprc->bottom = lprc->top + infoPtr->nItemHeight;
3777
3778 if (infoPtr->himlState != NULL)
3779 {
3780 lprc->right += infoPtr->iconSize.cx;
3781 }
3782
3783 if (infoPtr->himlSmall != NULL)
3784 {
3785 lprc->right += infoPtr->iconSize.cx;
3786 }
3787
3788 lprc->right += LISTVIEW_GetLabelWidth(hwnd, nItem);
3789 }
3790 break;
3791
3792 case LVIR_SELECTBOUNDS:
3793 if (uView == LVS_ICON)
3794 {
3795 if (infoPtr->himlNormal != NULL)
3796 {
3797 if (LISTVIEW_GetOrigin(hwnd, &ptOrigin) != FALSE)
3798 {
3799 bResult = TRUE;
3800 lprc->left = ptItem.x + ptOrigin.x;
3801 lprc->top = ptItem.y + ptOrigin.y;
3802 lprc->right = lprc->left + infoPtr->iconSpacing.cx;
3803 lprc->bottom = lprc->top + infoPtr->iconSpacing.cy;
3804 }
3805 }
3806 }
3807 else if (uView == LVS_SMALLICON)
3808 {
3809 if (LISTVIEW_GetOrigin(hwnd, &ptOrigin) != FALSE)
3810 {
3811 bResult = TRUE;
3812 lprc->left = ptItem.x + ptOrigin.x;
3813 lprc->top = ptItem.y + ptOrigin.y;
3814 lprc->bottom = lprc->top + infoPtr->nItemHeight;
3815
3816 if (infoPtr->himlState != NULL)
3817 {
3818 lprc->left += infoPtr->iconSize.cx;
3819 }
3820
3821 lprc->right = lprc->left;
3822
3823 if (infoPtr->himlSmall != NULL)
3824 {
3825 lprc->right += infoPtr->iconSize.cx;
3826 }
3827
3828 lprc->right += LISTVIEW_GetLabelWidth(hwnd, nItem);
3829 }
3830 }
3831 else
3832 {
3833 bResult = TRUE;
3834 lprc->left = ptItem.x;
3835 lprc->top = ptItem.y;
3836 lprc->bottom = lprc->top + infoPtr->nItemHeight;
3837
3838 if (infoPtr->himlState != NULL)
3839 {
3840 lprc->left += infoPtr->iconSize.cx;
3841 }
3842
3843 lprc->right = lprc->left;
3844
3845 if (infoPtr->himlSmall != NULL)
3846 {
3847 lprc->right += infoPtr->iconSize.cx;
3848 }
3849
3850 lprc->right += LISTVIEW_GetLabelWidth(hwnd, nItem);
3851 }
3852 break;
3853 }
3854 }
3855 }
3856
3857 return bResult;
3858 }
3859
3860 /***
3861 * DESCRIPTION:
3862 * Retrieves the width of a label.
3863 *
3864 * PARAMETER(S):
3865 * [I] HWND : window handle
3866 *
3867 * RETURN:
3868 * SUCCESS : string width (in pixels)
3869 * FAILURE : zero
3870 */
3871 static INT LISTVIEW_GetLabelWidth(HWND hwnd, INT nItem)
3872 {
3873 CHAR szDispText[DISP_TEXT_SIZE];
3874 INT nLabelWidth = 0;
3875 LVITEMA lvItem;
3876
3877 TRACE("(hwnd=%x, nItem=%d)\n", hwnd, nItem);
3878
3879 ZeroMemory(&lvItem, sizeof(LVITEMA));
3880 lvItem.mask = LVIF_TEXT;
3881 lvItem.iItem = nItem;
3882 lvItem.cchTextMax = DISP_TEXT_SIZE;
3883 lvItem.pszText = szDispText;
3884 if (ListView_GetItemA(hwnd, &lvItem) != FALSE)
3885 {
3886 nLabelWidth = ListView_GetStringWidthA(hwnd, lvItem.pszText);
3887 }
3888
3889 return nLabelWidth;
3890 }
3891
3892 /***
3893 * DESCRIPTION:
3894 * Retrieves the spacing between listview control items.
3895 *
3896 * PARAMETER(S):
3897 * [I] HWND : window handle
3898 * [I] BOOL : flag for small or large icon
3899 *
3900 * RETURN:
3901 * Horizontal + vertical spacing
3902 */
3903 static LRESULT LISTVIEW_GetItemSpacing(HWND hwnd, BOOL bSmall)
3904 {
3905 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
3906 LONG lResult;
3907
3908 if (bSmall == FALSE)
3909 {
3910 lResult = MAKELONG(infoPtr->iconSpacing.cx, infoPtr->iconSpacing.cy);
3911 }
3912 else
3913 {
3914 /* TODO: need to store width of smallicon item */
3915 lResult = MAKELONG(0, infoPtr->nItemHeight);
3916 }
3917
3918 return lResult;
3919 }
3920
3921 /***
3922 * DESCRIPTION:
3923 * Retrieves the state of a listview control item.
3924 *
3925 * PARAMETER(S):
3926 * [I] HWND : window handle
3927 * [I] INT : item index
3928 * [I] UINT : state mask
3929 *
3930 * RETURN:
3931 * State specified by the mask.
3932 */
3933 static LRESULT LISTVIEW_GetItemState(HWND hwnd, INT nItem, UINT uMask)
3934 {
3935 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
3936 LVITEMA lvItem;
3937 UINT uState = 0;
3938
3939 if ((nItem >= 0) && (nItem < GETITEMCOUNT(infoPtr)))
3940 {
3941 ZeroMemory(&lvItem, sizeof(LVITEMA));
3942 lvItem.iItem = nItem;
3943 lvItem.stateMask = uMask;
3944 lvItem.mask = LVIF_STATE;
3945 if (ListView_GetItemA(hwnd, &lvItem) != FALSE)
3946 {
3947 uState = lvItem.state;
3948 }
3949 }
3950
3951 return uState;
3952 }
3953
3954 /***
3955 * DESCRIPTION:
3956 * Retrieves the text of a listview control item or subitem.
3957 *
3958 * PARAMETER(S):
3959 * [I] HWND : window handle
3960 * [I] INT : item index
3961 * [IO] LPLVITEMA : item information
3962 *
3963 * RETURN:
3964 * SUCCESS : string length
3965 * FAILURE : 0
3966 */
3967 static LRESULT LISTVIEW_GetItemTextA(HWND hwnd, INT nItem, LPLVITEMA lpLVItem)
3968 {
3969 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
3970 INT nLength = 0;
3971
3972 if (lpLVItem != NULL)
3973 {
3974 if ((nItem >= 0) && (nItem < GETITEMCOUNT(infoPtr)))
3975 {
3976 lpLVItem->mask = LVIF_TEXT;
3977 lpLVItem->iItem = nItem;
3978 if (ListView_GetItemA(hwnd, lpLVItem) != FALSE)
3979 {
3980 nLength = lstrlenA(lpLVItem->pszText);
3981 }
3982 }
3983 }
3984
3985 return nLength;
3986 }
3987
3988 /***
3989 * DESCRIPTION:
3990 * Searches for an item based on properties + relationships.
3991 *
3992 * PARAMETER(S):
3993 * [I] HWND : window handle
3994 * [I] INT : item index
3995 * [I] INT : relationship flag
3996 *
3997 * RETURN:
3998 * SUCCESS : item index
3999 * FAILURE : -1
4000 */
4001 static LRESULT LISTVIEW_GetNextItem(HWND hwnd, INT nItem, UINT uFlags)
4002 {
4003 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
4004 UINT uView = GetWindowLongA(hwnd, GWL_STYLE) & LVS_TYPEMASK;
4005 UINT uMask = 0;
4006 LVFINDINFO lvFindInfo;
4007 INT nCountPerColumn;
4008 INT i;
4009
4010 if ((nItem >= -1) && (nItem < GETITEMCOUNT(infoPtr)))
4011 {
4012 ZeroMemory(&lvFindInfo, sizeof(LVFINDINFO));
4013
4014 if (uFlags & LVNI_CUT)
4015 uMask |= LVIS_CUT;
4016
4017 if (uFlags & LVNI_DROPHILITED)
4018 uMask |= LVIS_DROPHILITED;
4019
4020 if (uFlags & LVNI_FOCUSED)
4021 uMask |= LVIS_FOCUSED;
4022
4023 if (uFlags & LVNI_SELECTED)
4024 uMask |= LVIS_SELECTED;
4025
4026 if (uFlags & LVNI_ABOVE)
4027 {
4028 if ((uView == LVS_LIST) || (uView == LVS_REPORT))
4029 {
4030 while (nItem >= 0)
4031 {
4032 nItem--;
4033 if ((ListView_GetItemState(hwnd, nItem, uMask) & uMask) == uMask)
4034 return nItem;
4035 }
4036 }
4037 else
4038 {
4039 lvFindInfo.flags = LVFI_NEARESTXY;
4040 lvFindInfo.vkDirection = VK_UP;
4041 ListView_GetItemPosition(hwnd, nItem, &lvFindInfo.pt);
4042 while ((nItem = ListView_FindItem(hwnd, nItem, &lvFindInfo)) != -1)
4043 {
4044 if ((ListView_GetItemState(hwnd, nItem, uMask) & uMask) == uMask)
4045 return nItem;
4046 }
4047 }
4048 }
4049 else if (uFlags & LVNI_BELOW)
4050 {
4051 if ((uView == LVS_LIST) || (uView == LVS_REPORT))
4052 {
4053 while (nItem < GETITEMCOUNT(infoPtr))
4054 {
4055 nItem++;
4056 if ((ListView_GetItemState(hwnd, nItem, uMask) & uMask) == uMask)
4057 return nItem;
4058 }
4059 }
4060 else
4061 {
4062 lvFindInfo.flags = LVFI_NEARESTXY;
4063 lvFindInfo.vkDirection = VK_DOWN;
4064 ListView_GetItemPosition(hwnd, nItem, &lvFindInfo.pt);
4065 while ((nItem = ListView_FindItem(hwnd, nItem, &lvFindInfo)) != -1)
4066 {
4067 if ((ListView_GetItemState(hwnd, nItem, uMask) & uMask) == uMask)
4068 return nItem;
4069 }
4070 }
4071 }
4072 else if (uFlags & LVNI_TOLEFT)
4073 {
4074 if (uView == LVS_LIST)
4075 {
4076 nCountPerColumn = LISTVIEW_GetCountPerColumn(hwnd);
4077 while (nItem - nCountPerColumn >= 0)
4078 {
4079 nItem -= nCountPerColumn;
4080 if ((ListView_GetItemState(hwnd, nItem, uMask) & uMask) == uMask)
4081 return nItem;
4082 }
4083 }
4084 else if ((uView == LVS_SMALLICON) || (uView == LVS_ICON))
4085 {
4086 lvFindInfo.flags = LVFI_NEARESTXY;
4087 lvFindInfo.vkDirection = VK_LEFT;
4088 ListView_GetItemPosition(hwnd, nItem, &lvFindInfo.pt);
4089 while ((nItem = ListView_FindItem(hwnd, nItem, &lvFindInfo)) != -1)
4090 {
4091 if ((ListView_GetItemState(hwnd, nItem, uMask) & uMask) == uMask)
4092 return nItem;
4093 }
4094 }
4095 }
4096 else if (uFlags & LVNI_TORIGHT)
4097 {
4098 if (uView == LVS_LIST)
4099 {
4100 nCountPerColumn = LISTVIEW_GetCountPerColumn(hwnd);
4101 while (nItem + nCountPerColumn < GETITEMCOUNT(infoPtr))
4102 {
4103 nItem += nCountPerColumn;
4104 if ((ListView_GetItemState(hwnd, nItem, uMask) & uMask) == uMask)
4105 return nItem;
4106 }
4107 }
4108 else if ((uView == LVS_SMALLICON) || (uView == LVS_ICON))
4109 {
4110 lvFindInfo.flags = LVFI_NEARESTXY;
4111 lvFindInfo.vkDirection = VK_RIGHT;
4112 ListView_GetItemPosition(hwnd, nItem, &lvFindInfo.pt);
4113 while ((nItem = ListView_FindItem(hwnd, nItem, &lvFindInfo)) != -1)
4114 {
4115 if ((ListView_GetItemState(hwnd, nItem, uMask) & uMask) == uMask)
4116 return nItem;
4117 }
4118 }
4119 }
4120 else
4121 {
4122 nItem++;
4123
4124 /* search by index */
4125 for (i = nItem; i < GETITEMCOUNT(infoPtr); i++)
4126 {
4127 if ((ListView_GetItemState(hwnd, i, uMask) & uMask) == uMask)
4128 return i;
4129 }
4130 }
4131 }
4132
4133 return -1;
4134 }
4135
4136 /* LISTVIEW_GetNumberOfWorkAreas */
4137
4138 /***
4139 * DESCRIPTION:
4140 * Retrieves the origin coordinates when in icon or small icon display mode.
4141 *
4142 * PARAMETER(S):
4143 * [I] HWND : window handle
4144 * [O] LPPOINT : coordinate information
4145 *
4146 * RETURN:
4147 * SUCCESS : TRUE
4148 * FAILURE : FALSE
4149 */
4150 static LRESULT LISTVIEW_GetOrigin(HWND hwnd, LPPOINT lpptOrigin)
4151 {
4152 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
4153 LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
4154 UINT uView = lStyle & LVS_TYPEMASK;
4155 INT nListWidth = infoPtr->rcList.right - infoPtr->rcList.left;
4156 INT nListHeight = infoPtr->rcList.bottom - infoPtr->rcList.top;
4157 BOOL bResult = FALSE;
4158
4159 TRACE("(hwnd=%x, lpptOrigin=%p)\n", hwnd, lpptOrigin);
4160
4161 if ((uView == LVS_SMALLICON) || (uView == LVS_ICON))
4162 {
4163 SCROLLINFO scrollInfo;
4164 ZeroMemory(lpptOrigin, sizeof(POINT));
4165 ZeroMemory(&scrollInfo, sizeof(SCROLLINFO));
4166 scrollInfo.cbSize = sizeof(SCROLLINFO);
4167
4168 if (lStyle & WS_HSCROLL)
4169 {
4170 scrollInfo.fMask = SIF_POS;
4171 if (GetScrollInfo(hwnd, SB_HORZ, &scrollInfo) != FALSE)
4172 {
4173 lpptOrigin->x = -scrollInfo.nPos * max(nListWidth / 10, 1);
4174 }
4175 }
4176
4177 if (lStyle & WS_VSCROLL)
4178 {
4179 scrollInfo.fMask = SIF_POS;
4180 if (GetScrollInfo(hwnd, SB_VERT, &scrollInfo) != FALSE)
4181 {
4182 lpptOrigin->y = -scrollInfo.nPos * max(nListHeight / 10, 1);
4183 }
4184 }
4185
4186 bResult = TRUE;
4187 }
4188
4189 return bResult;
4190 }
4191
4192 /***
4193 * DESCRIPTION:
4194 * Retrieves the number of items that are marked as selected.
4195 *
4196 * PARAMETER(S):
4197 * [I] HWND : window handle
4198 *
4199 * RETURN:
4200 * Number of items selected.
4201 */
4202 static LRESULT LISTVIEW_GetSelectedCount(HWND hwnd)
4203 {
4204 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
4205 INT nSelectedCount = 0;
4206 INT i;
4207
4208 for (i = 0; i < GETITEMCOUNT(infoPtr); i++)
4209 {
4210 if (ListView_GetItemState(hwnd, i, LVIS_SELECTED) & LVIS_SELECTED)
4211 {
4212 nSelectedCount++;
4213 }
4214 }
4215
4216 return nSelectedCount;
4217 }
4218
4219 /***
4220 * DESCRIPTION:
4221 * Retrieves item index that marks the start of a multiple selection.
4222 *
4223 * PARAMETER(S):
4224 * [I] HWND : window handle
4225 *
4226 * RETURN:
4227 * Index number or -1 if there is no selection mark.
4228 */
4229 static LRESULT LISTVIEW_GetSelectionMark(HWND hwnd)
4230 {
4231 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
4232
4233 return infoPtr->nSelectionMark;
4234 }
4235
4236 /***
4237 * DESCRIPTION:
4238 * Retrieves the width of a string.
4239 *
4240 * PARAMETER(S):
4241 * [I] HWND : window handle
4242 *
4243 * RETURN:
4244 * SUCCESS : string width (in pixels)
4245 * FAILURE : zero
4246 */
4247 static LRESULT LISTVIEW_GetStringWidthA(HWND hwnd, LPCSTR lpszText)
4248 {
4249 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
4250 HFONT hFont, hOldFont;
4251 SIZE stringSize;
4252 HDC hdc;
4253
4254 ZeroMemory(&stringSize, sizeof(SIZE));
4255 if (lpszText != NULL)
4256 {
4257 hFont = infoPtr->hFont ? infoPtr->hFont : infoPtr->hDefaultFont;
4258 hdc = GetDC(hwnd);
4259 hOldFont = SelectObject(hdc, hFont);
4260 GetTextExtentPointA(hdc, lpszText, lstrlenA(lpszText), &stringSize);
4261 SelectObject(hdc, hOldFont);
4262 ReleaseDC(hwnd, hdc);
4263 }
4264
4265 return stringSize.cx;
4266 }
4267
4268 /***
4269 * DESCRIPTION:
4270 * Retrieves the text backgound color.
4271 *
4272 * PARAMETER(S):
4273 * [I] HWND : window handle
4274 *
4275 * RETURN:
4276 * COLORREF associated with the the background.
4277 */
4278 static LRESULT LISTVIEW_GetTextBkColor(HWND hwnd)
4279 {
4280 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO*)GetWindowLongA(hwnd, 0);
4281
4282 return infoPtr->clrTextBk;
4283 }
4284
4285 /***
4286 * DESCRIPTION:
4287 * Retrieves the text color.
4288 *
4289 * PARAMETER(S):
4290 * [I] HWND : window handle
4291 *
4292 * RETURN:
4293 * COLORREF associated with the text.
4294 */
4295 static LRESULT LISTVIEW_GetTextColor(HWND hwnd)
4296 {
4297 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO*)GetWindowLongA(hwnd, 0);
4298
4299 return infoPtr->clrText;
4300 }
4301
4302 /***
4303 * DESCRIPTION:
4304 * Determines which section of the item was selected (if any).
4305 *
4306 * PARAMETER(S):
4307 * [I] HWND : window handle
4308 * [IO] LPLVHITTESTINFO : hit test information
4309 *
4310 * RETURN:
4311 * SUCCESS : item index
4312 * FAILURE : -1
4313 */
4314 static INT LISTVIEW_HitTestItem(HWND hwnd, LPLVHITTESTINFO lpHitTestInfo)
4315 {
4316 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
4317 RECT rcItem;
4318 INT i;
4319
4320 TRACE("(hwnd=%x, x=%ld, y=%ld)\n", hwnd, lpHitTestInfo->pt.x,
4321 lpHitTestInfo->pt.y);
4322
4323 for (i = 0; i < GETITEMCOUNT(infoPtr); i++)
4324 {
4325 rcItem.left = LVIR_BOUNDS;
4326 if (LISTVIEW_GetItemRect(hwnd, i, &rcItem) != FALSE)
4327 {
4328 if (PtInRect(&rcItem, lpHitTestInfo->pt) != FALSE)
4329 {
4330 rcItem.left = LVIR_ICON;
4331 if (LISTVIEW_GetItemRect(hwnd, i, &rcItem) != FALSE)
4332 {
4333 if (PtInRect(&rcItem, lpHitTestInfo->pt) != FALSE)
4334 {
4335 lpHitTestInfo->flags = LVHT_ONITEMICON;
4336 lpHitTestInfo->iItem = i;
4337 lpHitTestInfo->iSubItem = 0;
4338 return i;
4339 }
4340 }
4341
4342 rcItem.left = LVIR_LABEL;
4343 if (LISTVIEW_GetItemRect(hwnd, i, &rcItem) != FALSE)
4344 {
4345 if (PtInRect(&rcItem, lpHitTestInfo->pt) != FALSE)
4346 {
4347 lpHitTestInfo->flags = LVHT_ONITEMLABEL;
4348 lpHitTestInfo->iItem = i;
4349 lpHitTestInfo->iSubItem = 0;
4350 return i;
4351 }
4352 }
4353
4354 lpHitTestInfo->flags = LVHT_ONITEMSTATEICON;
4355 lpHitTestInfo->iItem = i;
4356 lpHitTestInfo->iSubItem = 0;
4357 return i;
4358 }
4359 }
4360 }
4361
4362 lpHitTestInfo->flags = LVHT_NOWHERE;
4363
4364 return -1;
4365 }
4366
4367 /***
4368 * DESCRIPTION:
4369 * Determines which listview item is located at the specified position.
4370 *
4371 * PARAMETER(S):
4372 * [I] HWND : window handle
4373 * [IO} LPLVHITTESTINFO : hit test information
4374 *
4375 * RETURN:
4376 * SUCCESS : item index
4377 * FAILURE : -1
4378 */
4379 static LRESULT LISTVIEW_HitTest(HWND hwnd, LPLVHITTESTINFO lpHitTestInfo)
4380 {
4381 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
4382 INT nItem = -1;
4383
4384 lpHitTestInfo->flags = 0;
4385
4386 if (infoPtr->rcList.left > lpHitTestInfo->pt.x)
4387 {
4388 lpHitTestInfo->flags = LVHT_TOLEFT;
4389 }
4390 else if (infoPtr->rcList.right < lpHitTestInfo->pt.x)
4391 {
4392 lpHitTestInfo->flags = LVHT_TORIGHT;
4393 }
4394 if (infoPtr->rcList.top > lpHitTestInfo->pt.y)
4395 {
4396 lpHitTestInfo->flags |= LVHT_ABOVE;
4397 }
4398 else if (infoPtr->rcList.bottom < lpHitTestInfo->pt.y)
4399 {
4400 lpHitTestInfo->flags |= LVHT_BELOW;
4401 }
4402
4403 if (lpHitTestInfo->flags == 0)
4404 {
4405 nItem = LISTVIEW_HitTestItem(hwnd, lpHitTestInfo);
4406 }
4407
4408 return nItem;
4409 }
4410
4411 /***
4412 * DESCRIPTION:
4413 * Inserts a new column.
4414 *
4415 * PARAMETER(S):
4416 * [I] HWND : window handle
4417 * [I] INT : column index
4418 * [I] LPLVCOLUMNA : column information
4419 *
4420 * RETURN:
4421 * SUCCESS : new column index
4422 * FAILURE : -1
4423 */
4424 static LRESULT LISTVIEW_InsertColumnA(HWND hwnd, INT nColumn,
4425 LPLVCOLUMNA lpColumn)
4426 {
4427 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
4428 HDITEMA hdi;
4429 INT nNewColumn = -1;
4430
4431 TRACE("(hwnd=%x, nColumn=%d, lpColumn=%p)\n",hwnd, nColumn,
4432 lpColumn);
4433
4434 if (lpColumn != NULL)
4435 {
4436 /* initialize memory */
4437 ZeroMemory(&hdi, sizeof(HDITEMA));
4438
4439 if (lpColumn->mask & LVCF_FMT)
4440 {
4441 /* format member is valid */
4442 hdi.mask |= HDI_FORMAT;
4443
4444 /* set text alignment (leftmost column must be left-aligned) */
4445 if (nColumn == 0)
4446 {
4447 hdi.fmt |= HDF_LEFT;
4448 }
4449 else
4450 {
4451 if (lpColumn->fmt & LVCFMT_LEFT)
4452 {
4453 hdi.fmt |= HDF_LEFT;
4454 }
4455 else if (lpColumn->fmt & LVCFMT_RIGHT)
4456 {
4457 hdi.fmt |= HDF_RIGHT;
4458 }
4459 else if (lpColumn->fmt & LVCFMT_CENTER)
4460 {
4461 hdi.fmt |= HDF_CENTER;
4462 }
4463 }
4464
4465 if (lpColumn->fmt & LVCFMT_BITMAP_ON_RIGHT)
4466 {
4467 hdi.fmt |= HDF_BITMAP_ON_RIGHT;
4468 /* ??? */
4469 }
4470
4471 if (lpColumn->fmt & LVCFMT_COL_HAS_IMAGES)
4472 {
4473 /* ??? */
4474 }
4475
4476 if (lpColumn->fmt & LVCFMT_IMAGE)
4477 {
4478 hdi.fmt |= HDF_IMAGE;
4479 hdi.iImage = I_IMAGECALLBACK;
4480 }
4481 }
4482
4483 if (lpColumn->mask & LVCF_WIDTH)
4484 {
4485 hdi.mask |= HDI_WIDTH;
4486 hdi.cxy = lpColumn->cx;
4487 }
4488
4489 if (lpColumn->mask & LVCF_TEXT)
4490 {
4491 hdi.mask |= HDI_TEXT | HDI_FORMAT;
4492 hdi.pszText = lpColumn->pszText;
4493 hdi.cchTextMax = lstrlenA(lpColumn->pszText);
4494 hdi.fmt |= HDF_STRING;
4495 }
4496
4497 if (lpColumn->mask & LVCF_IMAGE)
4498 {
4499 hdi.mask |= HDI_IMAGE;
4500 hdi.iImage = lpColumn->iImage;
4501 }
4502
4503 if (lpColumn->mask & LVCF_ORDER)
4504 {
4505 hdi.mask |= HDI_ORDER;
4506 hdi.iOrder = lpColumn->iOrder;
4507 }
4508
4509 /* insert item in header control */
4510 nNewColumn = SendMessageA(infoPtr->hwndHeader, HDM_INSERTITEMA,
4511 (WPARAM)nColumn, (LPARAM)&hdi);
4512
4513 LISTVIEW_UpdateScroll(hwnd);
4514 InvalidateRect(hwnd, NULL, FALSE);
4515 }
4516
4517 return nNewColumn;
4518 }
4519
4520 /* LISTVIEW_InsertColumnW */
4521
4522 /***
4523 * DESCRIPTION:
4524 * Inserts a new item in the listview control.
4525 *
4526 * PARAMETER(S):
4527 * [I] HWND : window handle
4528 * [I] LPLVITEMA : item information
4529 *
4530 * RETURN:
4531 * SUCCESS : new item index
4532 * FAILURE : -1
4533 */
4534 static LRESULT LISTVIEW_InsertItemA(HWND hwnd, LPLVITEMA lpLVItem)
4535 {
4536 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
4537 LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
4538 UINT uView = lStyle & LVS_TYPEMASK;
4539 LONG lCtrlId = GetWindowLongA(hwnd, GWL_ID);
4540 NMLISTVIEW nmlv;
4541 INT nItem = -1;
4542 HDPA hdpaSubItems;
4543 LISTVIEW_ITEM *lpItem = NULL;
4544
4545 TRACE("(hwnd=%x,lpLVItem=%p)\n", hwnd, lpLVItem);
4546
4547 if (lpLVItem != NULL)
4548 {
4549 /* make sure it's not a subitem; cannot insert a subitem */
4550 if (lpLVItem->iSubItem == 0)
4551 {
4552 lpItem = (LISTVIEW_ITEM *)COMCTL32_Alloc(sizeof(LISTVIEW_ITEM));
4553 if (lpItem != NULL)
4554 {
4555 ZeroMemory(lpItem, sizeof(LISTVIEW_ITEM));
4556 if (LISTVIEW_InitItem(hwnd, lpItem, lpLVItem) != FALSE)
4557 {
4558 /* insert item in listview control data structure */
4559 hdpaSubItems = DPA_Create(8);
4560 if (hdpaSubItems != NULL)
4561 {
4562 nItem = DPA_InsertPtr(hdpaSubItems, 0, lpItem);
4563 if (nItem != -1)
4564 {
4565 nItem = DPA_InsertPtr(infoPtr->hdpaItems, lpLVItem->iItem,
4566 hdpaSubItems);
4567 if (nItem != -1)
4568 {
4569 /* manage item focus */
4570 if (lpLVItem->mask & LVIF_STATE)
4571 {
4572 if (lpLVItem->stateMask & LVIS_FOCUSED)
4573 {
4574 LISTVIEW_SetItemFocus(hwnd, nItem);
4575 }
4576 }
4577
4578 /* send LVN_INSERTITEM notification */
4579 ZeroMemory(&nmlv, sizeof(NMLISTVIEW));
4580 nmlv.hdr.hwndFrom = hwnd;
4581 nmlv.hdr.idFrom = lCtrlId;
4582 nmlv.hdr.code = LVN_INSERTITEM;
4583 nmlv.iItem = nItem;
4584 nmlv.lParam = lpItem->lParam;;
4585 ListView_LVNotify(GetParent(hwnd), lCtrlId, &nmlv);
4586
4587 /* align items (set position of each item) */
4588 if ((uView == LVS_SMALLICON) || (uView == LVS_ICON))
4589 {
4590 if (lStyle & LVS_ALIGNLEFT)
4591 {
4592 LISTVIEW_AlignLeft(hwnd);
4593 }
4594 else
4595 {
4596 LISTVIEW_AlignTop(hwnd);
4597 }
4598 }
4599
4600 LISTVIEW_UpdateScroll(hwnd);
4601 /* refresh client area */
4602 InvalidateRect(hwnd, NULL, FALSE);
4603 }
4604 }
4605 }
4606 }
4607 }
4608 }
4609 }
4610
4611 /* free memory if unsuccessful */
4612 if ((nItem == -1) && (lpItem != NULL))
4613 {
4614 COMCTL32_Free(lpItem);
4615 }
4616
4617 return nItem;
4618 }
4619
4620 /* LISTVIEW_InsertItemW */
4621
4622 /***
4623 * DESCRIPTION:
4624 * Redraws a range of items.
4625 *
4626 * PARAMETER(S):
4627 * [I] HWND : window handle
4628 * [I] INT : first item
4629 * [I] INT : last item
4630 *
4631 * RETURN:
4632 * SUCCESS : TRUE
4633 * FAILURE : FALSE
4634 */
4635 static LRESULT LISTVIEW_RedrawItems(HWND hwnd, INT nFirst, INT nLast)
4636 {
4637 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
4638 BOOL bResult = FALSE;
4639 RECT rc;
4640
4641 if (nFirst <= nLast)
4642 {
4643 if ((nFirst >= 0) && (nFirst < GETITEMCOUNT(infoPtr)))
4644 {
4645 if ((nLast >= 0) && (nLast < GETITEMCOUNT(infoPtr)))
4646 {
4647 /* bResult = */
4648 InvalidateRect(hwnd, &rc, FALSE);
4649 }
4650 }
4651 }
4652
4653 return bResult;
4654 }
4655
4656 /* LISTVIEW_Scroll */
4657
4658 /***
4659 * DESCRIPTION:
4660 * Sets the background color.
4661 *
4662 * PARAMETER(S):
4663 * [I] HWND : window handle
4664 * [I] COLORREF : background color
4665 *
4666 * RETURN:
4667 * SUCCESS : TRUE
4668 * FAILURE : FALSE
4669 */
4670 static LRESULT LISTVIEW_SetBkColor(HWND hwnd, COLORREF clrBk)
4671 {
4672 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
4673
4674 infoPtr->clrBk = clrBk;
4675 InvalidateRect(hwnd, NULL, TRUE);
4676
4677 return TRUE;
4678 }
4679
4680 /* LISTVIEW_SetBkImage */
4681
4682 /***
4683 * DESCRIPTION:
4684 * Sets the callback mask. This mask will be used when the parent
4685 * window stores state information (some or all).
4686 *
4687 * PARAMETER(S):
4688 * [I] HWND : window handle
4689 * [I] UINT : state mask
4690 *
4691 * RETURN:
4692 * SUCCESS : TRUE
4693 * FAILURE : FALSE
4694 */
4695 static BOOL LISTVIEW_SetCallbackMask(HWND hwnd, UINT uMask)
4696 {
4697 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
4698
4699 infoPtr->uCallbackMask = uMask;
4700
4701 return TRUE;
4702 }
4703
4704 /***
4705 * DESCRIPTION:
4706 * Sets the attributes of a header item.
4707 *
4708 * PARAMETER(S):
4709 * [I] HWND : window handle
4710 * [I] INT : column index
4711 * [I] LPLVCOLUMNA : column attributes
4712 *
4713 * RETURN:
4714 * SUCCESS : TRUE
4715 * FAILURE : FALSE
4716 */
4717 static LRESULT LISTVIEW_SetColumnA(HWND hwnd, INT nColumn,
4718 LPLVCOLUMNA lpColumn)
4719 {
4720 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
4721 BOOL bResult = FALSE;
4722 HDITEMA hdi, hdiget;
4723
4724 if ((lpColumn != NULL) && (nColumn >= 0) &&
4725 (nColumn < Header_GetItemCount(infoPtr->hwndHeader)))
4726 {
4727 /* initialize memory */
4728 ZeroMemory(&hdi, sizeof(HDITEMA));
4729
4730 if (lpColumn->mask & LVCF_FMT)
4731 {
4732 /* format member is valid */
4733 hdi.mask |= HDI_FORMAT;
4734
4735 /* get current format first */
4736 hdiget.mask = HDI_FORMAT;
4737 if (Header_GetItemA(infoPtr->hwndHeader, nColumn, &hdiget))
4738 /* preserve HDF_STRING if present */
4739 hdi.fmt = hdiget.fmt & HDF_STRING;
4740
4741 /* set text alignment (leftmost column must be left-aligned) */
4742 if (nColumn == 0)
4743 {
4744 hdi.fmt |= HDF_LEFT;
4745 }
4746 else
4747 {
4748 if (lpColumn->fmt & LVCFMT_LEFT)
4749 {
4750 hdi.fmt |= HDF_LEFT;
4751 }
4752 else if (lpColumn->fmt & LVCFMT_RIGHT)
4753 {
4754 hdi.fmt |= HDF_RIGHT;
4755 }
4756 else if (lpColumn->fmt & LVCFMT_CENTER)
4757 {
4758 hdi.fmt |= HDF_CENTER;
4759 }
4760 }
4761
4762 if (lpColumn->fmt & LVCFMT_BITMAP_ON_RIGHT)
4763 {
4764 hdi.fmt |= HDF_BITMAP_ON_RIGHT;
4765 }
4766
4767 if (lpColumn->fmt & LVCFMT_COL_HAS_IMAGES)
4768 {
4769 hdi.fmt |= HDF_IMAGE;
4770 }
4771
4772 if (lpColumn->fmt & LVCFMT_IMAGE)
4773 {
4774 hdi.fmt |= HDF_IMAGE;
4775 hdi.iImage = I_IMAGECALLBACK;
4776 }
4777 }
4778
4779 if (lpColumn->mask & LVCF_WIDTH)
4780 {
4781 hdi.mask |= HDI_WIDTH;
4782 hdi.cxy = lpColumn->cx;
4783 }
4784
4785 if (lpColumn->mask & LVCF_TEXT)
4786 {
4787 hdi.mask |= HDI_TEXT | HDI_FORMAT;
4788 hdi.pszText = lpColumn->pszText;
4789 hdi.cchTextMax = lstrlenA(lpColumn->pszText);
4790 hdi.fmt |= HDF_STRING;
4791 }
4792
4793 if (lpColumn->mask & LVCF_IMAGE)
4794 {
4795 hdi.mask |= HDI_IMAGE;
4796 hdi.iImage = lpColumn->iImage;
4797 }
4798
4799 if (lpColumn->mask & LVCF_ORDER)
4800 {
4801 hdi.mask |= HDI_ORDER;
4802 hdi.iOrder = lpColumn->iOrder;
4803 }
4804
4805 /* set header item attributes */
4806 bResult = Header_SetItemA(infoPtr->hwndHeader, nColumn, &hdi);
4807 }
4808
4809 return bResult;
4810 }
4811
4812 /* LISTVIEW_SetColumnW */
4813 /* LISTVIEW_SetColumnOrderArray */
4814
4815 /***
4816 * DESCRIPTION:
4817 * Sets the width of a column
4818 *
4819 * PARAMETERS:
4820 * [I] HWND : window handle
4821 * [I] INT : column index
4822 * [I] INT : column width
4823 *
4824 * RETURN:
4825 * SUCCESS : TRUE
4826 * FAILURE : FALSE
4827 */
4828 static LRESULT LISTVIEW_SetColumnWidth(HWND hwnd, INT iCol, INT cx)
4829 {
4830 LISTVIEW_INFO *infoPtr;
4831 HDITEMA hdi;
4832 LRESULT lret;
4833 LONG lStyle;
4834
4835 /* set column width only if in report mode */
4836 lStyle = GetWindowLongA(hwnd, GWL_STYLE);
4837 if ((lStyle & LVS_TYPEMASK) != LVS_REPORT)
4838 return (FALSE);
4839
4840 /* make sure we can get the listview info */
4841 if (!(infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0)))
4842 return (FALSE);
4843 if (!infoPtr->hwndHeader) /* make sure we have a header */
4844 return (FALSE);
4845
4846 /* FIXME: currently ignoring LVSCW_AUTOSIZE (-1) and
4847 * LVSCV_AUTOSIZE_USEHEADER (-2)
4848 */
4849 if (cx < 0)
4850 return (FALSE);
4851
4852 hdi.mask = HDI_WIDTH;
4853 hdi.cxy = cx;
4854
4855 /* call header to update the column change */
4856 lret = Header_SetItemA(infoPtr->hwndHeader, (WPARAM)iCol, (LPARAM)&hdi);
4857
4858 infoPtr->nItemWidth = LISTVIEW_GetItemWidth(hwnd);
4859
4860 InvalidateRect(hwnd, NULL, TRUE); /* force redraw of the listview */
4861
4862 return lret;
4863 }
4864
4865 /***
4866 * DESCRIPTION:
4867 * Sets the extended listview style.
4868 *
4869 * PARAMETERS:
4870 * [I] HWND : window handle
4871 * [I] DWORD : mask
4872 * [I] DWORD : style
4873 *
4874 * RETURN:
4875 * SUCCESS : previous style
4876 * FAILURE : 0
4877 */
4878 static LRESULT LISTVIEW_SetExtendedListViewStyle(HWND hwnd, DWORD dwMask, DWORD dwStyle)
4879 {
4880 LISTVIEW_INFO *infoPtr;
4881 DWORD dwOldStyle;
4882
4883 /* make sure we can get the listview info */
4884 if (!(infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0)))
4885 return (0);
4886
4887 /* store previous style */
4888 dwOldStyle = infoPtr->dwExStyle;
4889
4890 /* set new style */
4891 infoPtr->dwExStyle = (dwOldStyle & ~dwMask) | (dwStyle & dwMask);
4892
4893 return (dwOldStyle);
4894 }
4895
4896 /* LISTVIEW_SetHotCursor */
4897
4898 /***
4899 * DESCRIPTION:
4900 * Sets the hot item index.
4901 *
4902 * PARAMETERS:
4903 * [I] HWND : window handle
4904 * [I] INT : index
4905 *
4906 * RETURN:
4907 * SUCCESS : previous hot item index
4908 * FAILURE : -1 (no hot item)
4909 */
4910 static LRESULT LISTVIEW_SetHotItem(HWND hwnd, INT iIndex)
4911 {
4912 LISTVIEW_INFO *infoPtr;
4913 INT iOldIndex;
4914
4915 /* make sure we can get the listview info */
4916 if (!(infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0)))
4917 return (-1);
4918
4919 /* store previous index */
4920 iOldIndex = infoPtr->nHotItem;
4921
4922 /* set new style */
4923 infoPtr->nHotItem = iIndex;
4924
4925 return (iOldIndex);
4926 }
4927
4928 /* LISTVIEW_SetIconSpacing */
4929
4930 /***
4931 * DESCRIPTION:
4932 * Sets image lists.
4933 *
4934 * PARAMETER(S):
4935 * [I] HWND : window handle
4936 * [I] INT : image list type
4937 * [I] HIMAGELIST : image list handle
4938 *
4939 * RETURN:
4940 * SUCCESS : old image list
4941 * FAILURE : NULL
4942 */
4943 static LRESULT LISTVIEW_SetImageList(HWND hwnd, INT nType, HIMAGELIST himl)
4944 {
4945 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
4946 HIMAGELIST himlTemp = 0;
4947
4948 switch (nType)
4949 {
4950 case LVSIL_NORMAL:
4951 himlTemp = infoPtr->himlNormal;
4952 infoPtr->himlNormal = himl;
4953 return (LRESULT)himlTemp;
4954
4955 case LVSIL_SMALL:
4956 himlTemp = infoPtr->himlSmall;
4957 infoPtr->himlSmall = himl;
4958 return (LRESULT)himlTemp;
4959
4960 case LVSIL_STATE:
4961 himlTemp = infoPtr->himlState;
4962 infoPtr->himlState = himl;
4963 ImageList_SetBkColor(infoPtr->himlState, CLR_NONE);
4964 return (LRESULT)himlTemp;
4965 }
4966
4967 return (LRESULT)NULL;
4968 }
4969
4970
4971 /***
4972 * DESCRIPTION:
4973 * Sets the attributes of an item.
4974 *
4975 * PARAMETER(S):
4976 * [I] HWND : window handle
4977 * [I] LPLVITEM : item information
4978 *
4979 * RETURN:
4980 * SUCCESS : TRUE
4981 * FAILURE : FALSE
4982 */
4983 static LRESULT LISTVIEW_SetItemA(HWND hwnd, LPLVITEMA lpLVItem)
4984 {
4985 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
4986 BOOL bResult = FALSE;
4987
4988 if (lpLVItem != NULL)
4989 {
4990 if ((lpLVItem->iItem >= 0) && (lpLVItem->iItem < GETITEMCOUNT(infoPtr)))
4991 {
4992 if (lpLVItem->iSubItem == 0)
4993 {
4994 bResult = LISTVIEW_SetItem(hwnd, lpLVItem);
4995 }
4996 else
4997 {
4998 bResult = LISTVIEW_SetSubItem(hwnd, lpLVItem);
4999 }
5000 }
5001 }
5002
5003
5004 return bResult;
5005 }
5006
5007 /* LISTVIEW_SetItemW */
5008
5009 /***
5010 * DESCRIPTION:
5011 * Preallocates memory.
5012 *
5013 * PARAMETER(S):
5014 * [I] HWND : window handle
5015 * [I] INT : item count (prjected number of items)
5016 * [I] DWORD : update flags
5017 *
5018 * RETURN:
5019 * SUCCESS : TRUE
5020 * FAILURE : FALSE
5021 */
5022 static BOOL LISTVIEW_SetItemCount(HWND hwnd, INT nItems, DWORD dwFlags)
5023 {
5024 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO*)GetWindowLongA(hwnd, 0);
5025
5026 FIXME("(%d %08lx)empty stub!\n", nItems, dwFlags);
5027
5028 if (nItems == 0)
5029 return LISTVIEW_DeleteAllItems (hwnd);
5030
5031 if (nItems > GETITEMCOUNT(infoPtr))
5032 {
5033 /* append items */
5034 FIXME("append items\n");
5035
5036 }
5037 else if (nItems < GETITEMCOUNT(infoPtr))
5038 {
5039 /* remove items */
5040 FIXME("remove items\n");
5041
5042 }
5043
5044 return TRUE;
5045 }
5046
5047 /***
5048 * DESCRIPTION:
5049 * Sets the position of an item.
5050 *
5051 * PARAMETER(S):
5052 * [I] HWND : window handle
5053 * [I] INT : item index
5054 * [I] INT : x coordinate
5055 * [I] INT : y coordinate
5056 *
5057 * RETURN:
5058 * SUCCESS : TRUE
5059 * FAILURE : FALSE
5060 */
5061 static BOOL LISTVIEW_SetItemPosition(HWND hwnd, INT nItem,
5062 INT nPosX, INT nPosY)
5063 {
5064 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO*)GetWindowLongA(hwnd, 0);
5065 UINT uView = GetWindowLongA(hwnd, GWL_STYLE) & LVS_TYPEMASK;
5066 LISTVIEW_ITEM *lpItem;
5067 HDPA hdpaSubItems;
5068 BOOL bResult = FALSE;
5069
5070 TRACE("(hwnd=%x,nItem=%d,X=%d,Y=%d)\n", hwnd, nItem, nPosX, nPosY);
5071
5072 if ((nItem >= 0) || (nItem < GETITEMCOUNT(infoPtr)))
5073 {
5074 if ((uView == LVS_ICON) || (uView == LVS_SMALLICON))
5075 {
5076 hdpaSubItems = (HDPA)DPA_GetPtr(infoPtr->hdpaItems, nItem);
5077 if (hdpaSubItems != NULL)
5078 {
5079 lpItem = (LISTVIEW_ITEM *)DPA_GetPtr(hdpaSubItems, 0);
5080 if (lpItem != NULL)
5081 {
5082 bResult = TRUE;
5083 lpItem->ptPosition.x = nPosX;
5084 lpItem->ptPosition.y = nPosY;
5085 }
5086 }
5087 }
5088 }
5089
5090 return bResult;
5091 }
5092
5093 /* LISTVIEW_SetItemPosition32 */
5094
5095 /***
5096 * DESCRIPTION:
5097 * Sets the state of one or many items.
5098 *
5099 * PARAMETER(S):
5100 * [I] HWND : window handle
5101 * [I]INT : item index
5102 * [I] LPLVITEM : item or subitem info
5103 *
5104 * RETURN:
5105 * SUCCESS : TRUE
5106 * FAILURE : FALSE
5107 */
5108 static LRESULT LISTVIEW_SetItemState(HWND hwnd, INT nItem, LPLVITEMA lpLVItem)
5109 {
5110 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
5111 BOOL bResult = FALSE;
5112 LVITEMA lvItem;
5113 INT i;
5114
5115 if (nItem == -1)
5116 {
5117 bResult = TRUE;
5118 ZeroMemory(&lvItem, sizeof(LVITEMA));
5119 lvItem.mask = LVIF_STATE;
5120 lvItem.state = lpLVItem->state;
5121 lvItem.stateMask = lpLVItem->stateMask ;
5122
5123 /* apply to all items */
5124 for (i = 0; i< GETITEMCOUNT(infoPtr); i++)
5125 {
5126 lvItem.iItem = i;
5127 if (ListView_SetItemA(hwnd, &lvItem) == FALSE)
5128 {
5129 bResult = FALSE;
5130 }
5131 }
5132 }
5133 else
5134 {
5135 ZeroMemory(&lvItem, sizeof(LVITEMA));
5136 lvItem.mask = LVIF_STATE;
5137 lvItem.state = lpLVItem->state;
5138 lvItem.stateMask = lpLVItem->stateMask;
5139 lvItem.iItem = nItem;
5140 bResult = ListView_SetItemA(hwnd, &lvItem);
5141 }
5142
5143 return bResult;
5144 }
5145
5146 /***
5147 * DESCRIPTION:
5148 * Sets the text of an item or subitem.
5149 *
5150 * PARAMETER(S):
5151 * [I] HWND : window handle
5152 * [I] INT : item index
5153 * [I] LPLVITEMA : item or subitem info
5154 *
5155 * RETURN:
5156 * SUCCESS : TRUE
5157 * FAILURE : FALSE
5158 */
5159 static BOOL LISTVIEW_SetItemTextA(HWND hwnd, INT nItem, LPLVITEMA lpLVItem)
5160 {
5161 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
5162 BOOL bResult = FALSE;
5163 LVITEMA lvItem;
5164
5165 if ((nItem >= 0) && (nItem < GETITEMCOUNT(infoPtr)))
5166 {
5167 ZeroMemory(&lvItem, sizeof(LVITEMA));
5168 lvItem.mask = LVIF_TEXT;
5169 lvItem.pszText = lpLVItem->pszText;
5170 lvItem.iItem = nItem;
5171 lvItem.iSubItem = lpLVItem->iSubItem;
5172 bResult = ListView_SetItemA(hwnd, &lvItem);
5173 }
5174
5175 return bResult;
5176 }
5177
5178 /* LISTVIEW_SetItemTextW */
5179
5180 /***
5181 * DESCRIPTION:
5182 * Set item index that marks the start of a multiple selection.
5183 *
5184 * PARAMETER(S):
5185 * [I] HWND : window handle
5186 * [I] INT : index
5187 *
5188 * RETURN:
5189 * Index number or -1 if there is no selection mark.
5190 */
5191 static LRESULT LISTVIEW_SetSelectionMark(HWND hwnd, INT nIndex)
5192 {
5193 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
5194 INT nOldIndex = infoPtr->nSelectionMark;
5195
5196 infoPtr->nSelectionMark = nIndex;
5197
5198 return nOldIndex;
5199 }
5200
5201 /***
5202 * DESCRIPTION:
5203 * Sets the text background color.
5204 *
5205 * PARAMETER(S):
5206 * [I] HWND : window handle
5207 * [I] COLORREF : text background color
5208 *
5209 * RETURN:
5210 * SUCCESS : TRUE
5211 * FAILURE : FALSE
5212 */
5213 static LRESULT LISTVIEW_SetTextBkColor(HWND hwnd, COLORREF clrTextBk)
5214 {
5215 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
5216
5217 infoPtr->clrTextBk = clrTextBk;
5218 InvalidateRect(hwnd, NULL, TRUE);
5219
5220 return TRUE;
5221 }
5222
5223 /***
5224 * DESCRIPTION:
5225 * Sets the text foreground color.
5226 *
5227 * PARAMETER(S):
5228 * [I] HWND : window handle
5229 * [I] COLORREF : text color
5230 *
5231 * RETURN:
5232 * SUCCESS : TRUE
5233 * FAILURE : FALSE
5234 */
5235 static LRESULT LISTVIEW_SetTextColor (HWND hwnd, COLORREF clrText)
5236 {
5237 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
5238
5239 infoPtr->clrText = clrText;
5240 InvalidateRect(hwnd, NULL, TRUE);
5241
5242 return TRUE;
5243 }
5244
5245 /* LISTVIEW_SetToolTips */
5246 /* LISTVIEW_SetUnicodeFormat */
5247 /* LISTVIEW_SetWorkAreas */
5248
5249 /***
5250 * DESCRIPTION:
5251 * Callback internally used by LISTVIEW_SortItems()
5252 *
5253 * PARAMETER(S):
5254 * [I] LPVOID : first LISTVIEW_ITEM to compare
5255 * [I] LPVOID : second LISTVIEW_ITEM to compare
5256 * [I] LPARAM : HWND of control
5257 *
5258 * RETURN:
5259 * if first comes before second : negative
5260 * if first comes after second : positive
5261 * if first and second are equivalent : zero
5262 */
5263 static INT WINAPI LISTVIEW_CallBackCompare(
5264 LPVOID first,
5265 LPVOID second,
5266 LPARAM lParam)
5267 {
5268 /* Forward the call to the client defined callback */
5269 HWND hwnd = (HWND)lParam;
5270 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
5271
5272 return (infoPtr->pfnCompare)(
5273 ((LISTVIEW_ITEM *)first)->lParam,
5274 ((LISTVIEW_ITEM *)second)->lParam,
5275 infoPtr->lParamSort);
5276 }
5277
5278 /***
5279 * DESCRIPTION:
5280 * Sorts the listview items.
5281 *
5282 * PARAMETER(S):
5283 * [I] HWND : window handle
5284 * [I] WPARAM : application-defined value
5285 * [I] LPARAM : pointer to comparision callback
5286 *
5287 * RETURN:
5288 * SUCCESS : TRUE
5289 * FAILURE : FALSE
5290 */
5291 static LRESULT LISTVIEW_SortItems(HWND hwnd, WPARAM wParam, LPARAM lParam)
5292 {
5293 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
5294 HDPA hdpaSubItems;
5295 LISTVIEW_ITEM *lpItem;
5296 int nCount, i;
5297 HDPA sortList;
5298
5299 if (!infoPtr || !infoPtr->hdpaItems)
5300 return FALSE;
5301
5302 nCount = GETITEMCOUNT(infoPtr);
5303 /* if there are 0 or 1 items, there is no need to sort */
5304 if (nCount > 1)
5305 {
5306 sortList = DPA_Create(nCount);
5307
5308 infoPtr->pfnCompare = (PFNLVCOMPARE)lParam;
5309 infoPtr->lParamSort = (LPARAM)wParam;
5310
5311 /* append pointers one by one to sortList */
5312 for (i = 0; i < nCount; i++)
5313 {
5314 if ((hdpaSubItems = (HDPA) DPA_GetPtr(infoPtr->hdpaItems, i)))
5315 if ((lpItem = (LISTVIEW_ITEM *) DPA_GetPtr(hdpaSubItems, 0)))
5316 DPA_InsertPtr(sortList, nCount + 1, lpItem);
5317 }
5318
5319 /* sort the sortList */
5320 DPA_Sort(sortList, LISTVIEW_CallBackCompare, hwnd);
5321
5322 /* copy the pointers back */
5323 for (i = 0; i < nCount; i++)
5324 {
5325 if ((hdpaSubItems = (HDPA) DPA_GetPtr(infoPtr->hdpaItems, i)) &&
5326 (lpItem = (LISTVIEW_ITEM *) DPA_GetPtr(sortList, i)))
5327 DPA_SetPtr(hdpaSubItems, 0, lpItem);
5328 }
5329
5330 DPA_Destroy(sortList);
5331 }
5332
5333 return TRUE;
5334 }
5335
5336 /* LISTVIEW_SubItemHitTest */
5337
5338 /***
5339 * DESCRIPTION:
5340 * Updates an items or rearranges the listview control.
5341 *
5342 * PARAMETER(S):
5343 * [I] HWND : window handle
5344 * [I] INT : item index
5345 *
5346 * RETURN:
5347 * SUCCESS : TRUE
5348 * FAILURE : FALSE
5349 */
5350 static LRESULT LISTVIEW_Update(HWND hwnd, INT nItem)
5351 {
5352 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
5353 LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
5354 BOOL bResult = FALSE;
5355 RECT rc;
5356
5357 if ((nItem >= 0) && (nItem < GETITEMCOUNT(infoPtr)))
5358 {
5359 bResult = TRUE;
5360
5361 /* rearrange with default alignment style */
5362 if ((lStyle & LVS_AUTOARRANGE) && (((lStyle & LVS_TYPEMASK) == LVS_ICON) ||
5363 ((lStyle & LVS_TYPEMASK) == LVS_SMALLICON)))
5364 {
5365 ListView_Arrange(hwnd, 0);
5366 }
5367 else
5368 {
5369 /* get item bounding rectangle */
5370 rc.left = LVIR_BOUNDS;
5371 ListView_GetItemRect(hwnd, nItem, &rc);
5372 InvalidateRect(hwnd, &rc, TRUE);
5373 }
5374 }
5375
5376 return bResult;
5377 }
5378
5379 /***
5380 * DESCRIPTION:
5381 * Creates the listview control.
5382 *
5383 * PARAMETER(S):
5384 * [I] HWND : window handle
5385 *
5386 * RETURN:
5387 * Zero
5388 */
5389 static LRESULT LISTVIEW_Create(HWND hwnd, WPARAM wParam, LPARAM lParam)
5390 {
5391 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
5392 LPCREATESTRUCTA lpcs = (LPCREATESTRUCTA)lParam;
5393 UINT uView = lpcs->style & LVS_TYPEMASK;
5394 LOGFONTA logFont;
5395
5396 /* initialize info pointer */
5397 ZeroMemory(infoPtr, sizeof(LISTVIEW_INFO));
5398
5399 /* determine the type of structures to use */
5400 infoPtr->notifyFormat = SendMessageA(GetParent(hwnd), WM_NOTIFYFORMAT,
5401 (WPARAM)hwnd, (LPARAM)NF_QUERY);
5402 if (infoPtr->notifyFormat != NFR_ANSI)
5403 {
5404 FIXME("ANSI notify format is NOT used\n");
5405 }
5406
5407 /* initialize color information */
5408 infoPtr->clrBk = GetSysColor(COLOR_WINDOW);
5409 infoPtr->clrText = GetSysColor(COLOR_WINDOWTEXT);
5410 infoPtr->clrTextBk = GetSysColor(COLOR_WINDOW);
5411
5412 /* set default values */
5413 infoPtr->uCallbackMask = 0;
5414 infoPtr->nFocusedItem = -1;
5415 infoPtr->nSelectionMark = -1;
5416 infoPtr->nHotItem = -1;
5417 infoPtr->iconSpacing.cx = GetSystemMetrics(SM_CXICONSPACING);
5418 infoPtr->iconSpacing.cy = GetSystemMetrics(SM_CYICONSPACING);
5419 ZeroMemory(&infoPtr->rcList, sizeof(RECT));
5420
5421 /* get default font (icon title) */
5422 SystemParametersInfoA(SPI_GETICONTITLELOGFONT, 0, &logFont, 0);
5423 infoPtr->hDefaultFont = CreateFontIndirectA(&logFont);
5424 infoPtr->hFont = infoPtr->hDefaultFont;
5425
5426 /* create header */
5427 infoPtr->hwndHeader = CreateWindowA(WC_HEADERA, (LPCSTR)NULL,
5428 WS_CHILD | HDS_HORZ | HDS_BUTTONS,
5429 0, 0, 0, 0, hwnd, (HMENU)0,
5430 lpcs->hInstance, NULL);
5431
5432 /* set header font */
5433 SendMessageA(infoPtr->hwndHeader, WM_SETFONT, (WPARAM)infoPtr->hFont,
5434 (LPARAM)TRUE);
5435
5436 if (uView == LVS_ICON)
5437 {
5438 infoPtr->iconSize.cx = GetSystemMetrics(SM_CXICON);
5439 infoPtr->iconSize.cy = GetSystemMetrics(SM_CYICON);
5440 }
5441 else if (uView == LVS_REPORT)
5442 {
5443 if (!(LVS_NOCOLUMNHEADER & lpcs->style))
5444 {
5445 ShowWindow(infoPtr->hwndHeader, SW_SHOWNORMAL);
5446 }
5447
5448 infoPtr->iconSize.cx = GetSystemMetrics(SM_CXSMICON);
5449 infoPtr->iconSize.cy = GetSystemMetrics(SM_CYSMICON);
5450 }
5451 else
5452 {
5453 infoPtr->iconSize.cx = GetSystemMetrics(SM_CXSMICON);
5454 infoPtr->iconSize.cy = GetSystemMetrics(SM_CYSMICON);
5455 }
5456
5457 /* display unsupported listview window styles */
5458 LISTVIEW_UnsupportedStyles(lpcs->style);
5459
5460 /* allocate memory for the data structure */
5461 infoPtr->hdpaItems = DPA_Create(10);
5462
5463 /* initialize size of items */
5464 infoPtr->nItemWidth = LISTVIEW_GetItemWidth(hwnd);
5465 infoPtr->nItemHeight = LISTVIEW_GetItemHeight(hwnd);
5466
5467 return 0;
5468 }
5469
5470 /***
5471 * DESCRIPTION:
5472 * Erases the background of the listview control.
5473 *
5474 * PARAMETER(S):
5475 * [I] HWND : window handle
5476 * [I] WPARAM : device context handle
5477 * [I] LPARAM : not used
5478 *
5479 * RETURN:
5480 * SUCCESS : TRUE
5481 * FAILURE : FALSE
5482 */
5483 static LRESULT LISTVIEW_EraseBackground(HWND hwnd, WPARAM wParam,
5484 LPARAM lParam)
5485 {
5486 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
5487 BOOL bResult;
5488
5489 if (infoPtr->clrBk == CLR_NONE)
5490 {
5491 bResult = SendMessageA(GetParent(hwnd), WM_ERASEBKGND, wParam, lParam);
5492 }
5493 else
5494 {
5495 RECT rc;
5496 HBRUSH hBrush = CreateSolidBrush(infoPtr->clrBk);
5497 GetClientRect(hwnd, &rc);
5498 FillRect((HDC)wParam, &rc, hBrush);
5499 DeleteObject(hBrush);
5500 bResult = TRUE;
5501 }
5502
5503 return bResult;
5504 }
5505
5506 /***
5507 * DESCRIPTION:
5508 * Retrieves the listview control font.
5509 *
5510 * PARAMETER(S):
5511 * [I] HWND : window handle
5512 *
5513 * RETURN:
5514 * Font handle.
5515 */
5516 static LRESULT LISTVIEW_GetFont(HWND hwnd)
5517 {
5518 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
5519
5520 return infoPtr->hFont;
5521 }
5522
5523 /***
5524 * DESCRIPTION:
5525 * Performs vertical scrolling.
5526 *
5527 * PARAMETER(S):
5528 * [I] HWND : window handle
5529 * [I] INT : scroll code
5530 * [I] SHORT : current scroll position if scroll code is SB_THIMBPOSITION
5531 * or SB_THUMBTRACK.
5532 * [I] HWND : scrollbar control window handle
5533 *
5534 * RETURN:
5535 * Zero
5536 */
5537 static LRESULT LISTVIEW_VScroll(HWND hwnd, INT nScrollCode, SHORT nCurrentPos,
5538 HWND hScrollWnd)
5539 {
5540 UINT uView = GetWindowLongA(hwnd, GWL_STYLE) & LVS_TYPEMASK;
5541 SCROLLINFO scrollInfo;
5542
5543 ZeroMemory(&scrollInfo, sizeof(SCROLLINFO));
5544 scrollInfo.cbSize = sizeof(SCROLLINFO);
5545 scrollInfo.fMask = /*SIF_PAGE |*/ SIF_POS | SIF_RANGE;
5546
5547 if (GetScrollInfo(hwnd, SB_VERT, &scrollInfo) != FALSE)
5548 {
5549 INT nOldScrollPos = scrollInfo.nPos;
5550 switch (nScrollCode)
5551 {
5552 case SB_LINEUP:
5553 if (scrollInfo.nPos > scrollInfo.nMin)
5554 {
5555 scrollInfo.nPos--;
5556 }
5557 break;
5558
5559 case SB_LINEDOWN:
5560 if (scrollInfo.nPos < scrollInfo.nMax)
5561 {
5562 scrollInfo.nPos++;
5563 }
5564 break;
5565
5566 case SB_PAGEUP:
5567 if (scrollInfo.nPos > scrollInfo.nMin)
5568 {
5569 INT nPage = 0;
5570
5571 if (uView == LVS_REPORT)
5572 {
5573 nPage = LISTVIEW_GetCountPerColumn(hwnd);
5574 }
5575 else if ((uView == LVS_ICON) || (uView == LVS_SMALLICON))
5576 {
5577 nPage = 10;
5578 }
5579
5580 if (scrollInfo.nPos >= nPage)
5581 {
5582 scrollInfo.nPos -= nPage;
5583 }
5584 else
5585 {
5586 scrollInfo.nPos = scrollInfo.nMin;
5587 }
5588 }
5589 break;
5590
5591 case SB_PAGEDOWN:
5592 if (scrollInfo.nPos < scrollInfo.nMax)
5593 {
5594 INT nPage = 0;
5595
5596 if (uView == LVS_REPORT)
5597 {
5598 nPage = LISTVIEW_GetCountPerColumn(hwnd);
5599 }
5600 else if ((uView == LVS_ICON) || (uView == LVS_SMALLICON))
5601 {
5602 nPage = 10;
5603 }
5604
5605 if (scrollInfo.nPos <= scrollInfo.nMax - nPage)
5606 {
5607 scrollInfo.nPos += nPage;
5608 }
5609 else
5610 {
5611 scrollInfo.nPos = scrollInfo.nMax;
5612 }
5613 }
5614 break;
5615
5616 case SB_THUMBPOSITION:
5617 break;
5618 }
5619
5620 if (nOldScrollPos != scrollInfo.nPos)
5621 {
5622 scrollInfo.fMask = SIF_POS;
5623 SetScrollInfo(hwnd, SB_VERT, &scrollInfo, TRUE);
5624 InvalidateRect(hwnd, NULL, TRUE);
5625 }
5626 }
5627
5628 return 0;
5629 }
5630
5631 /***
5632 * DESCRIPTION:
5633 * Performs horizontal scrolling.
5634 *
5635 * PARAMETER(S):
5636 * [I] HWND : window handle
5637 * [I] INT : scroll code
5638 * [I] SHORT : current scroll position if scroll code is SB_THIMBPOSITION
5639 * or SB_THUMBTRACK.
5640 * [I] HWND : scrollbar control window handle
5641 *
5642 * RETURN:
5643 * Zero
5644 */
5645 static LRESULT LISTVIEW_HScroll(HWND hwnd, INT nScrollCode, SHORT nCurrentPos,
5646 HWND hScrollWnd)
5647 {
5648 UINT uView = GetWindowLongA(hwnd, GWL_STYLE) & LVS_TYPEMASK;
5649 SCROLLINFO scrollInfo;
5650
5651 ZeroMemory(&scrollInfo, sizeof(SCROLLINFO));
5652 scrollInfo.cbSize = sizeof(SCROLLINFO);
5653 scrollInfo.fMask = /*SIF_PAGE |*/ SIF_POS | SIF_RANGE;
5654
5655 if (GetScrollInfo(hwnd, SB_HORZ, &scrollInfo) != FALSE)
5656 {
5657 INT nOldScrollPos = scrollInfo.nPos;
5658
5659 switch (nScrollCode)
5660 {
5661 case SB_LINELEFT:
5662 if (scrollInfo.nPos > scrollInfo.nMin)
5663 {
5664 scrollInfo.nPos--;
5665 }
5666 break;
5667
5668 case SB_LINERIGHT:
5669 if (scrollInfo.nPos < scrollInfo.nMax)
5670 {
5671 scrollInfo.nPos++;
5672 }
5673 break;
5674
5675 case SB_PAGELEFT:
5676 if (scrollInfo.nPos > scrollInfo.nMin)
5677 {
5678 INT nPage = 0;
5679
5680 if (uView == LVS_LIST)
5681 {
5682 nPage = LISTVIEW_GetCountPerRow(hwnd);
5683 }
5684 else if ((uView == LVS_ICON) || (uView == LVS_SMALLICON))
5685 {
5686 nPage = 10;
5687 }
5688
5689 if (scrollInfo.nPos >= nPage)
5690 {
5691 scrollInfo.nPos -= nPage;
5692 }
5693 else
5694 {
5695 scrollInfo.nPos = scrollInfo.nMin;
5696 }
5697 }
5698 break;
5699
5700 case SB_PAGERIGHT:
5701 if (scrollInfo.nPos < scrollInfo.nMax)
5702 {
5703 INT nPage = 0;
5704
5705 if (uView == LVS_LIST)
5706 {
5707 nPage = LISTVIEW_GetCountPerRow(hwnd);
5708 }
5709 else if ((uView == LVS_ICON) || (uView == LVS_SMALLICON))
5710 {
5711 nPage = 10;
5712 }
5713
5714 if (scrollInfo.nPos <= scrollInfo.nMax - nPage)
5715 {
5716 scrollInfo.nPos += nPage;
5717 }
5718 else
5719 {
5720 scrollInfo.nPos = scrollInfo.nMax;
5721 }
5722 }
5723 break;
5724
5725 case SB_THUMBPOSITION:
5726 break;
5727 }
5728
5729 if (nOldScrollPos != scrollInfo.nPos)
5730 {
5731 scrollInfo.fMask = SIF_POS;
5732 SetScrollInfo(hwnd, SB_HORZ, &scrollInfo, TRUE);
5733 InvalidateRect(hwnd, NULL, TRUE);
5734 }
5735 }
5736
5737 return 0;
5738 }
5739
5740 /***
5741 * DESCRIPTION:
5742 * ???
5743 *
5744 * PARAMETER(S):
5745 * [I] HWND : window handle
5746 * [I] INT : virtual key
5747 * [I] LONG : key data
5748 *
5749 * RETURN:
5750 * Zero
5751 */
5752 static LRESULT LISTVIEW_KeyDown(HWND hwnd, INT nVirtualKey, LONG lKeyData)
5753 {
5754 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
5755 INT nCtrlId = GetWindowLongA(hwnd, GWL_ID);
5756 HWND hwndParent = GetParent(hwnd);
5757 NMLVKEYDOWN nmKeyDown;
5758 NMHDR nmh;
5759 INT nItem = -1;
5760 BOOL bRedraw = FALSE;
5761
5762 /* send LVN_KEYDOWN notification */
5763 ZeroMemory(&nmKeyDown, sizeof(NMLVKEYDOWN));
5764 nmKeyDown.hdr.hwndFrom = hwnd;
5765 nmKeyDown.hdr.idFrom = nCtrlId;
5766 nmKeyDown.hdr.code = LVN_KEYDOWN;
5767 nmKeyDown.wVKey = nVirtualKey;
5768 nmKeyDown.flags = 0;
5769 SendMessageA(hwndParent, WM_NOTIFY, (WPARAM)nCtrlId, (LPARAM)&nmKeyDown);
5770
5771 /* initialize */
5772 nmh.hwndFrom = hwnd;
5773 nmh.idFrom = nCtrlId;
5774
5775 switch (nVirtualKey)
5776 {
5777 case VK_RETURN:
5778 if ((GETITEMCOUNT(infoPtr) > 0) && (infoPtr->nFocusedItem != -1))
5779 {
5780 /* send NM_RETURN notification */
5781 nmh.code = NM_RETURN;
5782 ListView_Notify(hwndParent, nCtrlId, &nmh);
5783
5784 /* send LVN_ITEMACTIVATE notification */
5785 nmh.code = LVN_ITEMACTIVATE;
5786 ListView_Notify(hwndParent, nCtrlId, &nmh);
5787 }
5788 break;
5789
5790 case VK_HOME:
5791 if (GETITEMCOUNT(infoPtr) > 0)
5792 {
5793 nItem = 0;
5794 }
5795 break;
5796
5797 case VK_END:
5798 if (GETITEMCOUNT(infoPtr) > 0)
5799 {
5800 nItem = GETITEMCOUNT(infoPtr) - 1;
5801 }
5802 break;
5803
5804 case VK_LEFT:
5805 nItem = ListView_GetNextItem(hwnd, infoPtr->nFocusedItem, LVNI_TOLEFT);
5806 break;
5807
5808 case VK_UP:
5809 nItem = ListView_GetNextItem(hwnd, infoPtr->nFocusedItem, LVNI_ABOVE);
5810 break;
5811
5812 case VK_RIGHT:
5813 nItem = ListView_GetNextItem(hwnd, infoPtr->nFocusedItem, LVNI_TORIGHT);
5814 break;
5815
5816 case VK_DOWN:
5817 nItem = ListView_GetNextItem(hwnd, infoPtr->nFocusedItem, LVNI_BELOW);
5818 break;
5819
5820 case VK_PRIOR:
5821 /* TO DO */
5822 break;
5823
5824 case VK_NEXT:
5825 /* TO DO */
5826 break;
5827 }
5828
5829 if ((nItem != -1) && (nItem != infoPtr->nFocusedItem))
5830 {
5831 bRedraw = LISTVIEW_KeySelection(hwnd, nItem);
5832 if (bRedraw != FALSE)
5833 {
5834 /* refresh client area */
5835 InvalidateRect(hwnd, NULL, TRUE);
5836 UpdateWindow(hwnd);
5837 }
5838 }
5839
5840 return 0;
5841 }
5842
5843 /***
5844 * DESCRIPTION:
5845 * Kills the focus.
5846 *
5847 * PARAMETER(S):
5848 * [I] HWND : window handle
5849 *
5850 * RETURN:
5851 * Zero
5852 */
5853 static LRESULT LISTVIEW_KillFocus(HWND hwnd)
5854 {
5855 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO*)GetWindowLongA(hwnd, 0);
5856 INT nCtrlId = GetWindowLongA(hwnd, GWL_ID);
5857 NMHDR nmh;
5858
5859 /* send NM_KILLFOCUS notification */
5860 nmh.hwndFrom = hwnd;
5861 nmh.idFrom = nCtrlId;
5862 nmh.code = NM_KILLFOCUS;
5863 ListView_Notify(GetParent(hwnd), nCtrlId, &nmh);
5864
5865 /* set window focus flag */
5866 infoPtr->bFocus = FALSE;
5867
5868 /* NEED drawing optimization ; redraw the selected items */
5869 InvalidateRect(hwnd, NULL, FALSE);
5870
5871 return 0;
5872 }
5873
5874 /***
5875 * DESCRIPTION:
5876 * Processes double click messages (left mouse button).
5877 *
5878 * PARAMETER(S):
5879 * [I] HWND : window handle
5880 * [I] WORD : key flag
5881 * [I] WORD : x coordinate
5882 * [I] WORD : y coordinate
5883 *
5884 * RETURN:
5885 * Zero
5886 */
5887 static LRESULT LISTVIEW_LButtonDblClk(HWND hwnd, WORD wKey, WORD wPosX,
5888 WORD wPosY)
5889 {
5890 LONG nCtrlId = GetWindowLongA(hwnd, GWL_ID);
5891 NMHDR nmh;
5892
5893 TRACE("(hwnd=%x,key=%hu,X=%hu,Y=%hu)\n", hwnd, wKey, wPosX, wPosY);
5894
5895 /* send NM_DBLCLK notification */
5896 nmh.hwndFrom = hwnd;
5897 nmh.idFrom = nCtrlId;
5898 nmh.code = NM_DBLCLK;
5899 ListView_Notify(GetParent(hwnd), nCtrlId, &nmh);
5900
5901 /* send LVN_ITEMACTIVATE notification */
5902 nmh.code = LVN_ITEMACTIVATE;
5903 ListView_Notify(GetParent(hwnd), nCtrlId, &nmh);
5904
5905 return 0;
5906 }
5907
5908 /***
5909 * DESCRIPTION:
5910 * Processes mouse down messages (left mouse button).
5911 *
5912 * PARAMETER(S):
5913 * [I] HWND : window handle
5914 * [I] WORD : key flag
5915 * [I] WORD : x coordinate
5916 * [I] WORD : y coordinate
5917 *
5918 * RETURN:
5919 * Zero
5920 */
5921 static LRESULT LISTVIEW_LButtonDown(HWND hwnd, WORD wKey, WORD wPosX,
5922 WORD wPosY)
5923 {
5924 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
5925 LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
5926 INT nCtrlId = GetWindowLongA(hwnd, GWL_ID);
5927 static BOOL bGroupSelect = TRUE;
5928 POINT ptPosition;
5929 NMHDR nmh;
5930 INT nItem;
5931
5932 TRACE("(hwnd=%x, key=%hu, X=%hu, Y=%hu)\n", hwnd, wKey, wPosX,
5933 wPosY);
5934
5935 /* send NM_RELEASEDCAPTURE notification */
5936 nmh.hwndFrom = hwnd;
5937 nmh.idFrom = nCtrlId;
5938 nmh.code = NM_RELEASEDCAPTURE;
5939 ListView_Notify(GetParent(hwnd), nCtrlId, &nmh);
5940
5941 if (infoPtr->bFocus == FALSE)
5942 {
5943 SetFocus(hwnd);
5944 }
5945
5946 /* set left button down flag */
5947 infoPtr->bLButtonDown = TRUE;
5948
5949 ptPosition.x = wPosX;
5950 ptPosition.y = wPosY;
5951 nItem = LISTVIEW_MouseSelection(hwnd, ptPosition);
5952 if ((nItem >= 0) && (nItem < GETITEMCOUNT(infoPtr)))
5953 {
5954 if (lStyle & LVS_SINGLESEL)
5955 {
5956 LISTVIEW_SetSelection(hwnd, nItem);
5957 }
5958 else
5959 {
5960 if ((wKey & MK_CONTROL) && (wKey & MK_SHIFT))
5961 {
5962 if (bGroupSelect != FALSE)
5963 {
5964 LISTVIEW_AddGroupSelection(hwnd, nItem);
5965 }
5966 else
5967 {
5968 LISTVIEW_AddSelection(hwnd, nItem);
5969 }
5970 }
5971 else if (wKey & MK_CONTROL)
5972 {
5973 bGroupSelect = LISTVIEW_ToggleSelection(hwnd, nItem);
5974 }
5975 else if (wKey & MK_SHIFT)
5976 {
5977 LISTVIEW_SetGroupSelection(hwnd, nItem);
5978 }
5979 else
5980 {
5981 LISTVIEW_SetSelection(hwnd, nItem);
5982 }
5983 }
5984 }
5985 else
5986 {
5987 /* remove all selections */
5988 LISTVIEW_RemoveSelections(hwnd, 0, GETITEMCOUNT(infoPtr));
5989 }
5990
5991 InvalidateRect(hwnd, NULL, TRUE);
5992
5993 return 0;
5994 }
5995
5996 /***
5997 * DESCRIPTION:
5998 * Processes mouse up messages (left mouse button).
5999 *
6000 * PARAMETER(S):
6001 * [I] HWND : window handle
6002 * [I] WORD : key flag
6003 * [I] WORD : x coordinate
6004 * [I] WORD : y coordinate
6005 *
6006 * RETURN:
6007 * Zero
6008 */
6009 static LRESULT LISTVIEW_LButtonUp(HWND hwnd, WORD wKey, WORD wPosX,
6010 WORD wPosY)
6011 {
6012 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
6013
6014 TRACE("(hwnd=%x,key=%hu,X=%hu,Y=%hu)\n", hwnd, wKey, wPosX, wPosY);
6015
6016 if (infoPtr->bLButtonDown != FALSE)
6017 {
6018 INT nCtrlId = GetWindowLongA(hwnd, GWL_ID);
6019 NMHDR nmh;
6020
6021 /* send NM_CLICK notification */
6022 nmh.hwndFrom = hwnd;
6023 nmh.idFrom = nCtrlId;
6024 nmh.code = NM_CLICK;
6025 ListView_Notify(GetParent(hwnd), nCtrlId, &nmh);
6026
6027 /* set left button flag */
6028 infoPtr->bLButtonDown = FALSE;
6029 }
6030
6031 return 0;
6032 }
6033
6034 /***
6035 * DESCRIPTION:
6036 * Creates the listview control (called before WM_CREATE).
6037 *
6038 * PARAMETER(S):
6039 * [I] HWND : window handle
6040 * [I] WPARAM : unhandled
6041 * [I] LPARAM : widow creation info
6042 *
6043 * RETURN:
6044 * Zero
6045 */
6046 static LRESULT LISTVIEW_NCCreate(HWND hwnd, WPARAM wParam, LPARAM lParam)
6047 {
6048 LISTVIEW_INFO *infoPtr;
6049
6050 TRACE("(hwnd=%x,wParam=%x,lParam=%lx)\n", hwnd, wParam, lParam);
6051
6052 /* allocate memory for info structure */
6053 infoPtr = (LISTVIEW_INFO *)COMCTL32_Alloc(sizeof(LISTVIEW_INFO));
6054 SetWindowLongA(hwnd, 0, (LONG)infoPtr);
6055 if (infoPtr == NULL)
6056 {
6057 ERR("could not allocate info memory!\n");
6058 return 0;
6059 }
6060
6061 if ((LISTVIEW_INFO *)GetWindowLongA(hwnd, 0) != infoPtr)
6062 {
6063 ERR("pointer assignment error!\n");
6064 return 0;
6065 }
6066
6067 return DefWindowProcA(hwnd, WM_NCCREATE, wParam, lParam);
6068 }
6069
6070 /***
6071 * DESCRIPTION:
6072 * Destroys the listview control (called after WM_DESTROY).
6073 *
6074 * PARAMETER(S):
6075 * [I] HWND : window handle
6076 *
6077 * RETURN:
6078 * Zero
6079 */
6080 static LRESULT LISTVIEW_NCDestroy(HWND hwnd)
6081 {
6082 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
6083
6084 TRACE("(hwnd=%x)\n", hwnd);
6085
6086 /* delete all items */
6087 LISTVIEW_DeleteAllItems(hwnd);
6088
6089 /* destroy data structure */
6090 DPA_Destroy(infoPtr->hdpaItems);
6091
6092 /* destroy font */
6093 infoPtr->hFont = (HFONT)0;
6094 if (infoPtr->hDefaultFont)
6095 {
6096 DeleteObject(infoPtr->hDefaultFont);
6097 }
6098
6099 /* free listview info pointer*/
6100 COMCTL32_Free(infoPtr);
6101
6102 return 0;
6103 }
6104
6105 /***
6106 * DESCRIPTION:
6107 * Handles notifications from children.
6108 *
6109 * PARAMETER(S):
6110 * [I] HWND : window handle
6111 * [I] INT : control identifier
6112 * [I] LPNMHDR : notification information
6113 *
6114 * RETURN:
6115 * Zero
6116 */
6117 static LRESULT LISTVIEW_Notify(HWND hwnd, INT nCtrlId, LPNMHDR lpnmh)
6118 {
6119 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
6120
6121 if (lpnmh->hwndFrom == infoPtr->hwndHeader)
6122 {
6123 /* handle notification from header control */
6124 if (lpnmh->code == HDN_ENDTRACKA)
6125 {
6126 infoPtr->nItemWidth = LISTVIEW_GetItemWidth(hwnd);
6127 InvalidateRect(hwnd, NULL, TRUE);
6128 }
6129 }
6130
6131 return 0;
6132 }
6133
6134 /***
6135 * DESCRIPTION:
6136 * Determines the type of structure to use.
6137 *
6138 * PARAMETER(S):
6139 * [I] HWND : window handle of the sender
6140 * [I] HWND : listview window handle
6141 * [I] INT : command specifying the nature of the WM_NOTIFYFORMAT
6142 *
6143 * RETURN:
6144 * Zero
6145 */
6146 static LRESULT LISTVIEW_NotifyFormat(HWND hwndFrom, HWND hwnd, INT nCommand)
6147 {
6148 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
6149
6150 if (nCommand == NF_REQUERY)
6151 {
6152 /* determine the type of structure to use */
6153 infoPtr->notifyFormat = SendMessageA(hwndFrom, WM_NOTIFYFORMAT,
6154 (WPARAM)hwnd, (LPARAM)NF_QUERY);
6155 if (infoPtr->notifyFormat == NFR_UNICODE)
6156 {
6157 FIXME("NO support for unicode structures");
6158 }
6159 }
6160
6161 return 0;
6162 }
6163
6164 /***
6165 * DESCRIPTION:
6166 * Paints/Repaints the listview control.
6167 *
6168 * PARAMETER(S):
6169 * [I] HWND : window handle
6170 * [I] HDC : device context handle
6171 *
6172 * RETURN:
6173 * Zero
6174 */
6175 static LRESULT LISTVIEW_Paint(HWND hwnd, HDC hdc)
6176 {
6177 PAINTSTRUCT ps;
6178
6179 TRACE("(hwnd=%x,hdc=%x)\n", hwnd, hdc);
6180
6181 if (hdc == 0)
6182 {
6183 hdc = BeginPaint(hwnd, &ps);
6184 LISTVIEW_Refresh(hwnd, hdc);
6185 EndPaint(hwnd, &ps);
6186 }
6187 else
6188 {
6189 LISTVIEW_Refresh(hwnd, hdc);
6190 }
6191
6192 return 0;
6193 }
6194
6195 /***
6196 * DESCRIPTION:
6197 * Processes double click messages (right mouse button).
6198 *
6199 * PARAMETER(S):
6200 * [I] HWND : window handle
6201 * [I] WORD : key flag
6202 * [I] WORD : x coordinate
6203 * [I] WORD : y coordinate
6204 *
6205 * RETURN:
6206 * Zero
6207 */
6208 static LRESULT LISTVIEW_RButtonDblClk(HWND hwnd, WORD wKey, WORD wPosX,
6209 WORD wPosY)
6210 {
6211 INT nCtrlId = GetWindowLongA(hwnd, GWL_ID);
6212 NMHDR nmh;
6213
6214 TRACE("(hwnd=%x,key=%hu,X=%hu,Y=%hu)\n", hwnd, wKey, wPosX, wPosY);
6215
6216 /* send NM_RELEASEDCAPTURE notification */
6217 nmh.hwndFrom = hwnd;
6218 nmh.idFrom = nCtrlId;
6219 nmh.code = NM_RELEASEDCAPTURE;
6220 ListView_Notify(GetParent(hwnd), nCtrlId, &nmh);
6221
6222 /* send NM_RDBLCLK notification */
6223 nmh.code = NM_RDBLCLK;
6224 ListView_Notify(GetParent(hwnd), nCtrlId, &nmh);
6225
6226 return 0;
6227 }
6228
6229 /***
6230 * DESCRIPTION:
6231 * Processes mouse down messages (right mouse button).
6232 *
6233 * PARAMETER(S):
6234 * [I] HWND : window handle
6235 * [I] WORD : key flag
6236 * [I] WORD : x coordinate
6237 * [I] WORD : y coordinate
6238 *
6239 * RETURN:
6240 * Zero
6241 */
6242 static LRESULT LISTVIEW_RButtonDown(HWND hwnd, WORD wKey, WORD wPosX,
6243 WORD wPosY)
6244 {
6245 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
6246 INT nCtrlId = GetWindowLongA(hwnd, GWL_ID);
6247 POINT ptPosition;
6248 NMHDR nmh;
6249 INT nItem;
6250
6251 TRACE("(hwnd=%x,key=%hu,X=%hu,Y=%hu)\n", hwnd, wKey, wPosX, wPosY);
6252
6253 /* send NM_RELEASEDCAPTURE notification */
6254 nmh.hwndFrom = hwnd;
6255 nmh.idFrom = nCtrlId;
6256 nmh.code = NM_RELEASEDCAPTURE;
6257 ListView_Notify(GetParent(hwnd), nCtrlId, &nmh);
6258
6259 /* make sure the listview control window has the focus */
6260 if (infoPtr->bFocus == FALSE)
6261 {
6262 SetFocus(hwnd);
6263 }
6264
6265 /* set right button down flag */
6266 infoPtr->bRButtonDown = TRUE;
6267
6268 /* determine the index of the selected item */
6269 ptPosition.x = wPosX;
6270 ptPosition.y = wPosY;
6271 nItem = LISTVIEW_MouseSelection(hwnd, ptPosition);
6272 if ((nItem >= 0) && (nItem < GETITEMCOUNT(infoPtr)))
6273 {
6274 if (!((wKey & MK_SHIFT) || (wKey & MK_CONTROL)))
6275 {
6276 LISTVIEW_SetSelection(hwnd, nItem);
6277 }
6278 }
6279 else
6280 {
6281 LISTVIEW_RemoveSelections(hwnd, 0, GETITEMCOUNT(infoPtr));
6282 }
6283
6284 return 0;
6285 }
6286
6287 /***
6288 * DESCRIPTION:
6289 * Processes mouse up messages (right mouse button).
6290 *
6291 * PARAMETER(S):
6292 * [I] HWND : window handle
6293 * [I] WORD : key flag
6294 * [I] WORD : x coordinate
6295 * [I] WORD : y coordinate
6296 *
6297 * RETURN:
6298 * Zero
6299 */
6300 static LRESULT LISTVIEW_RButtonUp(HWND hwnd, WORD wKey, WORD wPosX,
6301 WORD wPosY)
6302 {
6303 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
6304 INT nCtrlId = GetWindowLongA(hwnd, GWL_ID);
6305 NMHDR nmh;
6306
6307 TRACE("(hwnd=%x,key=%hu,X=%hu,Y=%hu)\n", hwnd, wKey, wPosX, wPosY);
6308
6309 if (infoPtr->bRButtonDown != FALSE)
6310 {
6311 /* send NM_RClICK notification */
6312 ZeroMemory(&nmh, sizeof(NMHDR));
6313 nmh.hwndFrom = hwnd;
6314 nmh.idFrom = nCtrlId;
6315 nmh.code = NM_RCLICK;
6316 ListView_Notify(GetParent(hwnd), nCtrlId, &nmh);
6317
6318 /* set button flag */
6319 infoPtr->bRButtonDown = FALSE;
6320 }
6321
6322 return 0;
6323 }
6324
6325 /***
6326 * DESCRIPTION:
6327 * Sets the focus.
6328 *
6329 * PARAMETER(S):
6330 * [I] HWND : window handle
6331 * [I] HWND : window handle of previously focused window
6332 *
6333 * RETURN:
6334 * Zero
6335 */
6336 static LRESULT LISTVIEW_SetFocus(HWND hwnd, HWND hwndLoseFocus)
6337 {
6338 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
6339 INT nCtrlId = GetWindowLongA(hwnd, GWL_ID);
6340 NMHDR nmh;
6341
6342 /* send NM_SETFOCUS notification */
6343 nmh.hwndFrom = hwnd;
6344 nmh.idFrom = nCtrlId;
6345 nmh.code = NM_SETFOCUS;
6346 ListView_Notify(GetParent(hwnd), nCtrlId, &nmh);
6347
6348 /* set window focus flag */
6349 infoPtr->bFocus = TRUE;
6350
6351 return 0;
6352 }
6353
6354 /***
6355 * DESCRIPTION:
6356 * Sets the font.
6357 *
6358 * PARAMETER(S):
6359 * [I] HWND : window handle
6360 * [I] HFONT : font handle
6361 * [I] WORD : redraw flag
6362 *
6363 * RETURN:
6364 * Zero
6365 */
6366 static LRESULT LISTVIEW_SetFont(HWND hwnd, HFONT hFont, WORD fRedraw)
6367 {
6368 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
6369 UINT uView = GetWindowLongA(hwnd, GWL_STYLE) & LVS_TYPEMASK;
6370
6371 TRACE("(hwnd=%x,hfont=%x,redraw=%hu)\n", hwnd, hFont, fRedraw);
6372
6373 if (hFont == 0)
6374 {
6375 infoPtr->hFont = infoPtr->hDefaultFont;
6376 }
6377 else
6378 {
6379 infoPtr->hFont = hFont;
6380 }
6381
6382 if (uView == LVS_REPORT)
6383 {
6384 /* set header font */
6385 SendMessageA(infoPtr->hwndHeader, WM_SETFONT, (WPARAM)hFont,
6386 MAKELPARAM(fRedraw, 0));
6387 }
6388
6389 /* invalidate listview control client area */
6390 InvalidateRect(hwnd, NULL, TRUE);
6391
6392 if (fRedraw != FALSE)
6393 {
6394 UpdateWindow(hwnd);
6395 }
6396
6397 return 0;
6398 }
6399
6400 /***
6401 * DESCRIPTION:
6402 * Resizes the listview control. This function processes WM_SIZE
6403 * messages. At this time, the width and height are not used.
6404 *
6405 * PARAMETER(S):
6406 * [I] HWND : window handle
6407 * [I] WORD : new width
6408 * [I] WORD : new height
6409 *
6410 * RETURN:
6411 * Zero
6412 */
6413 static LRESULT LISTVIEW_Size(HWND hwnd, int Width, int Height)
6414 {
6415 LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
6416 UINT uView = lStyle & LVS_TYPEMASK;
6417
6418 TRACE("(hwnd=%x, width=%d, height=%d)\n",hwnd, Width, Height);
6419
6420 LISTVIEW_UpdateSize(hwnd);
6421
6422 if ((uView == LVS_SMALLICON) || (uView == LVS_ICON))
6423 {
6424 if (lStyle & LVS_ALIGNLEFT)
6425 {
6426 LISTVIEW_AlignLeft(hwnd);
6427 }
6428 else
6429 {
6430 LISTVIEW_AlignTop(hwnd);
6431 }
6432 }
6433
6434 LISTVIEW_UpdateScroll(hwnd);
6435
6436 /* invalidate client area + erase background */
6437 InvalidateRect(hwnd, NULL, TRUE);
6438
6439 return 0;
6440 }
6441
6442 /***
6443 * DESCRIPTION:
6444 * Sets the size information.
6445 *
6446 * PARAMETER(S):
6447 * [I] HWND : window handle
6448 *
6449 * RETURN:
6450 * Zero
6451 */
6452 static VOID LISTVIEW_UpdateSize(HWND hwnd)
6453 {
6454 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
6455 LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
6456 UINT uView = lStyle & LVS_TYPEMASK;
6457 RECT rcList;
6458
6459 GetClientRect(hwnd, &rcList);
6460 infoPtr->rcList.left = 0;
6461 infoPtr->rcList.right = max(rcList.right - rcList.left, 1);
6462 infoPtr->rcList.top = 0;
6463 infoPtr->rcList.bottom = max(rcList.bottom - rcList.top, 1);
6464
6465 if (uView == LVS_LIST)
6466 {
6467 if ((lStyle & WS_HSCROLL) == 0)
6468 {
6469 INT nHScrollHeight = GetSystemMetrics(SM_CYHSCROLL);
6470 if (infoPtr->rcList.bottom > nHScrollHeight)
6471 {
6472 infoPtr->rcList.bottom -= nHScrollHeight;
6473 }
6474 }
6475 }
6476 else if (uView == LVS_REPORT)
6477 {
6478 HDLAYOUT hl;
6479 WINDOWPOS wp;
6480
6481 hl.prc = &rcList;
6482 hl.pwpos = &wp;
6483 Header_Layout(infoPtr->hwndHeader, &hl);
6484 if (!(LVS_NOCOLUMNHEADER & lStyle))
6485 {
6486 infoPtr->rcList.top = max(wp.cy, 0);
6487 }
6488 }
6489 }
6490
6491 /***
6492 * DESCRIPTION:
6493 * Processes WM_STYLECHANGED messages.
6494 *
6495 * PARAMETER(S):
6496 * [I] HWND : window handle
6497 * [I] WPARAM : window style type (normal or extended)
6498 * [I] LPSTYLESTRUCT : window style information
6499 *
6500 * RETURN:
6501 * Zero
6502 */
6503 static INT LISTVIEW_StyleChanged(HWND hwnd, WPARAM wStyleType,
6504 LPSTYLESTRUCT lpss)
6505 {
6506 LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
6507 UINT uNewView = lpss->styleNew & LVS_TYPEMASK;
6508 UINT uOldView = lpss->styleOld & LVS_TYPEMASK;
6509 RECT rcList = infoPtr->rcList;
6510
6511 TRACE("(hwnd=%x, styletype=%x, stylestruct=%p)\n",
6512 hwnd, wStyleType, lpss);
6513
6514 if (wStyleType == GWL_STYLE)
6515 {
6516 if (uOldView == LVS_REPORT)
6517 {
6518 ShowWindow(infoPtr->hwndHeader, SW_HIDE);
6519 }
6520
6521 if ((lpss->styleOld & WS_HSCROLL) != 0)
6522 {
6523 ShowScrollBar(hwnd, SB_HORZ, FALSE);
6524 }
6525
6526 if ((lpss->styleOld & WS_VSCROLL) != 0)
6527 {
6528 ShowScrollBar(hwnd, SB_VERT, FALSE);
6529 }
6530
6531 if (uNewView == LVS_ICON)
6532 {
6533 infoPtr->iconSize.cx = GetSystemMetrics(SM_CXICON);
6534 infoPtr->iconSize.cy = GetSystemMetrics(SM_CYICON);
6535 infoPtr->nItemWidth = LISTVIEW_GetItemWidth(hwnd);
6536 infoPtr->nItemHeight = LISTVIEW_GetItemHeight(hwnd);
6537 if (lpss->styleNew & LVS_ALIGNLEFT)
6538 {
6539 LISTVIEW_AlignLeft(hwnd);
6540 }
6541 else
6542 {
6543 LISTVIEW_AlignTop(hwnd);
6544 }
6545 }
6546 else if (uNewView == LVS_REPORT)
6547 {
6548 HDLAYOUT hl;
6549 WINDOWPOS wp;
6550
6551 hl.prc = &rcList;
6552 hl.pwpos = &wp;
6553 Header_Layout(infoPtr->hwndHeader, &hl);
6554 SetWindowPos(infoPtr->hwndHeader, hwnd, wp.x, wp.y, wp.cx, wp.cy,
6555 wp.flags);
6556 if (!(LVS_NOCOLUMNHEADER & lpss->styleNew))
6557 {
6558 ShowWindow(infoPtr->hwndHeader, SW_SHOWNORMAL);
6559 }
6560 infoPtr->iconSize.cx = GetSystemMetrics(SM_CXSMICON);
6561 infoPtr->iconSize.cy = GetSystemMetrics(SM_CYSMICON);
6562 infoPtr->nItemWidth = LISTVIEW_GetItemWidth(hwnd);
6563 infoPtr->nItemHeight = LISTVIEW_GetItemHeight(hwnd);
6564 }
6565 else if (uNewView == LVS_LIST)
6566 {
6567 infoPtr->iconSize.cx = GetSystemMetrics(SM_CXSMICON);
6568 infoPtr->iconSize.cy = GetSystemMetrics(SM_CYSMICON);
6569 infoPtr->nItemWidth = LISTVIEW_GetItemWidth(hwnd);
6570 infoPtr->nItemHeight = LISTVIEW_GetItemHeight(hwnd);
6571 }
6572 else
6573 {
6574 infoPtr->iconSize.cx = GetSystemMetrics(SM_CXSMICON);
6575 infoPtr->iconSize.cy = GetSystemMetrics(SM_CYSMICON);
6576 infoPtr->nItemWidth = LISTVIEW_GetItemWidth(hwnd);
6577 infoPtr->nItemHeight = LISTVIEW_GetItemHeight(hwnd);
6578 if (lpss->styleNew & LVS_ALIGNLEFT)
6579 {
6580 LISTVIEW_AlignLeft(hwnd);
6581 }
6582 else
6583 {
6584 LISTVIEW_AlignTop(hwnd);
6585 }
6586 }
6587
6588 /* update the size of the client area */
6589 LISTVIEW_UpdateSize(hwnd);
6590
6591 /* add scrollbars if needed */
6592 LISTVIEW_UpdateScroll(hwnd);
6593
6594 /* invalidate client area + erase background */
6595 InvalidateRect(hwnd, NULL, TRUE);
6596
6597 /* print the list of unsupported window styles */
6598 LISTVIEW_UnsupportedStyles(lpss->styleNew);
6599 }
6600
6601 return 0;
6602 }
6603
6604 /***
6605 * DESCRIPTION:
6606 * Window procedure of the listview control.
6607 *
6608 */
6609 LRESULT WINAPI LISTVIEW_WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam,
6610 LPARAM lParam)
6611 {
6612 switch (uMsg)
6613 {
6614 case LVM_APPROXIMATEVIEWRECT:
6615 return LISTVIEW_ApproximateViewRect(hwnd, (INT)wParam,
6616 LOWORD(lParam), HIWORD(lParam));
6617 case LVM_ARRANGE:
6618 return LISTVIEW_Arrange(hwnd, (INT)wParam);
6619
6620 /* case LVM_CREATEDRAGIMAGE: */
6621
6622 case LVM_DELETEALLITEMS:
6623 return LISTVIEW_DeleteAllItems(hwnd);
6624
6625 case LVM_DELETECOLUMN:
6626 return LISTVIEW_DeleteColumn(hwnd, (INT)wParam);
6627
6628 case LVM_DELETEITEM:
6629 return LISTVIEW_DeleteItem(hwnd, (INT)wParam);
6630
6631 /* case LVM_EDITLABEL: */
6632
6633 case LVM_ENSUREVISIBLE:
6634 return LISTVIEW_EnsureVisible(hwnd, (INT)wParam, (BOOL)lParam);
6635
6636 case LVM_FINDITEMA:
6637 return LISTVIEW_FindItem(hwnd, (INT)wParam, (LPLVFINDINFO)lParam);
6638
6639 case LVM_GETBKCOLOR:
6640 return LISTVIEW_GetBkColor(hwnd);
6641
6642 /* case LVM_GETBKIMAGE: */
6643
6644 case LVM_GETCALLBACKMASK:
6645 return LISTVIEW_GetCallbackMask(hwnd);
6646
6647 case LVM_GETCOLUMNA:
6648 return LISTVIEW_GetColumnA(hwnd, (INT)wParam, (LPLVCOLUMNA)lParam);
6649
6650 /* case LVM_GETCOLUMNW: */
6651
6652 case LVM_GETCOLUMNORDERARRAY:
6653 FIXME("Unimplemented msg LVM_GETCOLUMNORDERARRAY\n");
6654 return 0;
6655
6656 case LVM_GETCOLUMNWIDTH:
6657 return LISTVIEW_GetColumnWidth(hwnd, (INT)wParam);
6658
6659 case LVM_GETCOUNTPERPAGE:
6660 return LISTVIEW_GetCountPerPage(hwnd);
6661
6662 /* case LVM_GETEDITCONTROL: */
6663
6664 case LVM_GETEXTENDEDLISTVIEWSTYLE:
6665 return LISTVIEW_GetExtendedListViewStyle(hwnd);
6666
6667 case LVM_GETHEADER:
6668 return LISTVIEW_GetHeader(hwnd);
6669
6670 /* case LVM_GETHOTCURSOR: */
6671
6672 case LVM_GETHOTITEM:
6673 return LISTVIEW_GetHotItem(hwnd);
6674
6675 /* case LVM_GETHOVERTIME: */
6676
6677 case LVM_GETIMAGELIST:
6678 return LISTVIEW_GetImageList(hwnd, (INT)wParam);
6679
6680 /* case LVM_GETISEARCHSTRING: */
6681
6682 case LVM_GETITEMA:
6683 return LISTVIEW_GetItemA(hwnd, (LPLVITEMA)lParam);
6684
6685 /* case LVM_GETITEMW: */
6686
6687 case LVM_GETITEMCOUNT:
6688 return LISTVIEW_GetItemCount(hwnd);
6689
6690 case LVM_GETITEMPOSITION:
6691 return LISTVIEW_GetItemPosition(hwnd, (INT)wParam, (LPPOINT)lParam);
6692
6693 case LVM_GETITEMRECT:
6694 return LISTVIEW_GetItemRect(hwnd, (INT)wParam, (LPRECT)lParam);
6695
6696 case LVM_GETITEMSPACING:
6697 return LISTVIEW_GetItemSpacing(hwnd, (BOOL)wParam);
6698
6699 case LVM_GETITEMSTATE:
6700 return LISTVIEW_GetItemState(hwnd, (INT)wParam, (UINT)lParam);
6701
6702 case LVM_GETITEMTEXTA:
6703 LISTVIEW_GetItemTextA(hwnd, (INT)wParam, (LPLVITEMA)lParam);
6704 break;
6705
6706 /* case LVM_GETITEMTEXTW: */
6707
6708 case LVM_GETNEXTITEM:
6709 return LISTVIEW_GetNextItem(hwnd, (INT)wParam, LOWORD(lParam));
6710
6711 /* case LVM_GETNUMBEROFWORKAREAS: */
6712
6713 case LVM_GETORIGIN:
6714 return LISTVIEW_GetOrigin(hwnd, (LPPOINT)lParam);
6715
6716 case LVM_GETSELECTEDCOUNT:
6717 return LISTVIEW_GetSelectedCount(hwnd);
6718
6719 case LVM_GETSELECTIONMARK:
6720 return LISTVIEW_GetSelectionMark(hwnd);
6721
6722 case LVM_GETSTRINGWIDTHA:
6723 return LISTVIEW_GetStringWidthA (hwnd, (LPCSTR)lParam);
6724
6725 /* case LVM_GETSTRINGWIDTHW: */
6726 /* case LVM_GETSUBITEMRECT: */
6727
6728 case LVM_GETTEXTBKCOLOR:
6729 return LISTVIEW_GetTextBkColor(hwnd);
6730
6731 case LVM_GETTEXTCOLOR:
6732 return LISTVIEW_GetTextColor(hwnd);
6733
6734 /* case LVM_GETTOOLTIPS: */
6735
6736 case LVM_GETTOPINDEX:
6737 return LISTVIEW_GetTopIndex(hwnd);
6738
6739 /* case LVM_GETUNICODEFORMAT: */
6740
6741 case LVM_GETVIEWRECT:
6742 return LISTVIEW_GetViewRect(hwnd, (LPRECT)lParam);
6743
6744 /* case LVM_GETWORKAREAS: */
6745
6746 case LVM_HITTEST:
6747 return LISTVIEW_HitTest(hwnd, (LPLVHITTESTINFO)lParam);
6748
6749 case LVM_INSERTCOLUMNA:
6750 return LISTVIEW_InsertColumnA(hwnd, (INT)wParam,
6751 (LPLVCOLUMNA)lParam);
6752
6753 /* case LVM_INSERTCOLUMNW: */
6754
6755 case LVM_INSERTITEMA:
6756 return LISTVIEW_InsertItemA(hwnd, (LPLVITEMA)lParam);
6757
6758 /* case LVM_INSERTITEMW: */
6759
6760 case LVM_REDRAWITEMS:
6761 return LISTVIEW_RedrawItems(hwnd, (INT)wParam, (INT)lParam);
6762
6763 /* case LVM_SCROLL: */
6764 /* return LISTVIEW_Scroll(hwnd, (INT)wParam, (INT)lParam); */
6765
6766 case LVM_SETBKCOLOR:
6767 return LISTVIEW_SetBkColor(hwnd, (COLORREF)lParam);
6768
6769 /* case LVM_SETBKIMAGE: */
6770
6771 case LVM_SETCALLBACKMASK:
6772 return LISTVIEW_SetCallbackMask(hwnd, (UINT)wParam);
6773
6774 case LVM_SETCOLUMNA:
6775 return LISTVIEW_SetColumnA(hwnd, (INT)wParam, (LPLVCOLUMNA)lParam);
6776
6777 case LVM_SETCOLUMNW:
6778 FIXME("Unimplemented msg LVM_SETCOLUMNW\n");
6779 return 0;
6780
6781 case LVM_SETCOLUMNORDERARRAY:
6782 FIXME("Unimplemented msg LVM_SETCOLUMNORDERARRAY\n");
6783 return 0;
6784
6785 case LVM_SETCOLUMNWIDTH:
6786 return LISTVIEW_SetColumnWidth(hwnd, (INT)wParam, (INT)lParam);
6787
6788 case LVM_SETEXTENDEDLISTVIEWSTYLE:
6789 return LISTVIEW_SetExtendedListViewStyle(hwnd, (DWORD)wParam, (DWORD)lParam);
6790
6791 /* case LVM_SETHOTCURSOR: */
6792
6793 case LVM_SETHOTITEM:
6794 return LISTVIEW_SetHotItem(hwnd, (INT)wParam);
6795
6796 /* case LVM_SETHOVERTIME: */
6797 /* case LVM_SETICONSPACING: */
6798
6799 case LVM_SETIMAGELIST:
6800 return LISTVIEW_SetImageList(hwnd, (INT)wParam, (HIMAGELIST)lParam);
6801
6802 case LVM_SETITEMA:
6803 return LISTVIEW_SetItemA(hwnd, (LPLVITEMA)lParam);
6804
6805 /* case LVM_SETITEMW: */
6806
6807 case LVM_SETITEMCOUNT:
6808 return LISTVIEW_SetItemCount(hwnd, (INT)wParam, (DWORD)lParam);
6809
6810 case LVM_SETITEMPOSITION:
6811 return LISTVIEW_SetItemPosition(hwnd, (INT)wParam, (INT)LOWORD(lParam),
6812 (INT)HIWORD(lParam));
6813
6814 /* case LVM_SETITEMPOSITION32: */
6815
6816 case LVM_SETITEMSTATE:
6817 return LISTVIEW_SetItemState(hwnd, (INT)wParam, (LPLVITEMA)lParam);
6818
6819 case LVM_SETITEMTEXTA:
6820 return LISTVIEW_SetItemTextA(hwnd, (INT)wParam, (LPLVITEMA)lParam);
6821
6822 /* case LVM_SETITEMTEXTW: */
6823
6824 case LVM_SETSELECTIONMARK:
6825 return LISTVIEW_SetSelectionMark(hwnd, (INT)lParam);
6826
6827 case LVM_SETTEXTBKCOLOR:
6828 return LISTVIEW_SetTextBkColor(hwnd, (COLORREF)lParam);
6829
6830 case LVM_SETTEXTCOLOR:
6831 return LISTVIEW_SetTextColor(hwnd, (COLORREF)lParam);
6832
6833 /* case LVM_SETTOOLTIPS: */
6834 /* case LVM_SETUNICODEFORMAT: */
6835 /* case LVM_SETWORKAREAS: */
6836
6837 case LVM_SORTITEMS:
6838 return LISTVIEW_SortItems(hwnd, wParam, lParam);
6839
6840 /* case LVM_SUBITEMHITTEST: */
6841
6842 case LVM_UPDATE:
6843 return LISTVIEW_Update(hwnd, (INT)wParam);
6844
6845 /* case WM_CHAR: */
6846 /* case WM_COMMAND: */
6847
6848 case WM_CREATE:
6849 return LISTVIEW_Create(hwnd, wParam, lParam);
6850
6851 case WM_ERASEBKGND:
6852 return LISTVIEW_EraseBackground(hwnd, wParam, lParam);
6853
6854 case WM_GETDLGCODE:
6855 return DLGC_WANTTAB | DLGC_WANTARROWS;
6856
6857 case WM_GETFONT:
6858 return LISTVIEW_GetFont(hwnd);
6859
6860 case WM_HSCROLL:
6861 return LISTVIEW_HScroll(hwnd, (INT)LOWORD(wParam),
6862 (INT)HIWORD(wParam), (HWND)lParam);
6863
6864 case WM_KEYDOWN:
6865 return LISTVIEW_KeyDown(hwnd, (INT)wParam, (LONG)lParam);
6866
6867 case WM_KILLFOCUS:
6868 return LISTVIEW_KillFocus(hwnd);
6869
6870 case WM_LBUTTONDBLCLK:
6871 return LISTVIEW_LButtonDblClk(hwnd, (WORD)wParam, LOWORD(lParam),
6872 HIWORD(lParam));
6873
6874 case WM_LBUTTONDOWN:
6875 return LISTVIEW_LButtonDown(hwnd, (WORD)wParam, LOWORD(lParam),
6876 HIWORD(lParam));
6877 case WM_LBUTTONUP:
6878 return LISTVIEW_LButtonUp(hwnd, (WORD)wParam, LOWORD(lParam),
6879 HIWORD(lParam));
6880
6881 /* case WM_MOUSEMOVE: */
6882 /* return LISTVIEW_MouseMove (hwnd, wParam, lParam); */
6883
6884 case WM_NCCREATE:
6885 return LISTVIEW_NCCreate(hwnd, wParam, lParam);
6886
6887 case WM_NCDESTROY:
6888 return LISTVIEW_NCDestroy(hwnd);
6889
6890 case WM_NOTIFY:
6891 return LISTVIEW_Notify(hwnd, (INT)wParam, (LPNMHDR)lParam);
6892
6893 case WM_NOTIFYFORMAT:
6894 return LISTVIEW_NotifyFormat(hwnd, (HWND)wParam, (INT)lParam);
6895
6896 case WM_PAINT:
6897 return LISTVIEW_Paint(hwnd, (HDC)wParam);
6898
6899 case WM_RBUTTONDBLCLK:
6900 return LISTVIEW_RButtonDblClk(hwnd, (WORD)wParam, LOWORD(lParam),
6901 HIWORD(lParam));
6902
6903 case WM_RBUTTONDOWN:
6904 return LISTVIEW_RButtonDown(hwnd, (WORD)wParam, LOWORD(lParam),
6905 HIWORD(lParam));
6906
6907 case WM_RBUTTONUP:
6908 return LISTVIEW_RButtonUp(hwnd, (WORD)wParam, LOWORD(lParam),
6909 HIWORD(lParam));
6910
6911 case WM_SETFOCUS:
6912 return LISTVIEW_SetFocus(hwnd, (HWND)wParam);
6913
6914 case WM_SETFONT:
6915 return LISTVIEW_SetFont(hwnd, (HFONT)wParam, (WORD)lParam);
6916
6917 /* case WM_SETREDRAW: */
6918
6919 case WM_SIZE:
6920 return LISTVIEW_Size(hwnd, (int)SLOWORD(lParam), (int)SHIWORD(lParam));
6921
6922 case WM_STYLECHANGED:
6923 return LISTVIEW_StyleChanged(hwnd, wParam, (LPSTYLESTRUCT)lParam);
6924
6925 /* case WM_TIMER: */
6926
6927 case WM_VSCROLL:
6928 return LISTVIEW_VScroll(hwnd, (INT)LOWORD(wParam),
6929 (INT)HIWORD(wParam), (HWND)lParam);
6930
6931 /* case WM_WINDOWPOSCHANGED: */
6932 /* case WM_WININICHANGE: */
6933
6934 default:
6935 if (uMsg >= WM_USER)
6936 {
6937 ERR("unknown msg %04x wp=%08x lp=%08lx\n", uMsg, wParam,
6938 lParam);
6939 }
6940
6941 /* call default window procedure */
6942 return DefWindowProcA(hwnd, uMsg, wParam, lParam);
6943 }
6944
6945 return 0;
6946 }
6947
6948 /***
6949 * DESCRIPTION:
6950 * Registers the window class.
6951 *
6952 * PARAMETER(S):
6953 * None
6954 *
6955 * RETURN:
6956 * None
6957 */
6958 VOID LISTVIEW_Register(void)
6959 {
6960 WNDCLASSA wndClass;
6961
6962 if (!GlobalFindAtomA(WC_LISTVIEWA))
6963 {
6964 ZeroMemory(&wndClass, sizeof(WNDCLASSA));
6965 wndClass.style = CS_GLOBALCLASS | CS_DBLCLKS;
6966 wndClass.lpfnWndProc = (WNDPROC)LISTVIEW_WindowProc;
6967 wndClass.cbClsExtra = 0;
6968 wndClass.cbWndExtra = sizeof(LISTVIEW_INFO *);
6969 wndClass.hCursor = LoadCursorA(0, IDC_ARROWA);
6970 wndClass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
6971 wndClass.lpszClassName = WC_LISTVIEWA;
6972 RegisterClassA(&wndClass);
6973 }
6974 }
6975
6976 /***
6977 * DESCRIPTION:
6978 * Unregisters the window class.
6979 *
6980 * PARAMETER(S):
6981 * None
6982 *
6983 * RETURN:
6984 * None
6985 */
6986 VOID LISTVIEW_Unregister(void)
6987 {
6988 if (GlobalFindAtomA(WC_LISTVIEWA))
6989 {
6990 UnregisterClassA(WC_LISTVIEWA, (HINSTANCE)NULL);
6991 }
6992 }
6993
Maarten's multimedia branch