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