?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dbghelp: Remove DMT_ entries for .DBG and .PDB files.
[wine.git] / dlls / comctl32 / treeview.c
blobc531ad7537080f5f7203ea8dd25cf3468e21bd26
1 /* Treeview control
2 *
3 * Copyright 1998 Eric Kohl <ekohl@abo.rhein-zeitung.de>
4 * Copyright 1998,1999 Alex Priem <alexp@sci.kun.nl>
5 * Copyright 1999 Sylvain St-Germain
6 * Copyright 2002 CodeWeavers, Aric Stewart
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 *
22 * NOTES
23 *
24 * Note that TREEVIEW_INFO * and HTREEITEM are the same thing.
25 *
26 * Note2: If item's text == LPSTR_TEXTCALLBACKA we allocate buffer
27 * of size TEXT_CALLBACK_SIZE in DoSetItem.
28 * We use callbackMask to keep track of fields to be updated.
29 *
30 * TODO:
31 * missing notifications: TVN_GETINFOTIP, TVN_KEYDOWN,
32 * TVN_SETDISPINFO
33 *
34 * missing styles: TVS_INFOTIP, TVS_RTLREADING,
35 *
36 * missing item styles: TVIS_EXPANDPARTIAL, TVIS_EX_FLAT,
37 * TVIS_EX_DISABLED
38 *
39 * Make the insertion mark look right.
40 * Scroll (instead of repaint) as much as possible.
41 */
42
43 #include <assert.h>
44 #include <ctype.h>
45 #include <stdarg.h>
46 #include <string.h>
47 #include <limits.h>
48 #include <stdlib.h>
49
50 #include "windef.h"
51 #include "winbase.h"
52 #include "wingdi.h"
53 #include "winuser.h"
54 #include "winnls.h"
55 #include "commctrl.h"
56 #include "comctl32.h"
57 #include "uxtheme.h"
58 #include "vssym32.h"
59 #include "wine/debug.h"
60 #include "wine/exception.h"
61
62 WINE_DEFAULT_DEBUG_CHANNEL(treeview);
63
64 /* internal structures */
65 typedef struct tagTREEVIEW_INFO
66 {
67 HWND hwnd;
68 HWND hwndNotify; /* Owner window to send notifications to */
69 DWORD dwStyle;
70 HTREEITEM root;
71 UINT uInternalStatus;
72 INT Timer;
73 UINT uNumItems; /* number of valid TREEVIEW_ITEMs */
74 INT cdmode; /* last custom draw setting */
75 UINT uScrollTime; /* max. time for scrolling in milliseconds */
76 BOOL bRedraw; /* if FALSE we validate but don't redraw in TREEVIEW_Paint() */
77
78 UINT uItemHeight; /* item height */
79 BOOL bHeightSet;
80
81 LONG clientWidth; /* width of control window */
82 LONG clientHeight; /* height of control window */
83
84 LONG treeWidth; /* width of visible tree items */
85 LONG treeHeight; /* height of visible tree items */
86
87 UINT uIndent; /* indentation in pixels */
88 HTREEITEM selectedItem; /* handle to selected item or 0 if none */
89 HTREEITEM hotItem; /* handle currently under cursor, 0 if none */
90 HTREEITEM focusedItem; /* item that was under the cursor when WM_LBUTTONDOWN was received */
91 HTREEITEM editItem; /* item being edited with builtin edit box */
92
93 HTREEITEM firstVisible; /* handle to item whose top edge is at y = 0 */
94 LONG maxVisibleOrder;
95 HTREEITEM dropItem; /* handle to item selected by drag cursor */
96 HTREEITEM insertMarkItem; /* item after which insertion mark is placed */
97 BOOL insertBeforeorAfter; /* flag used by TVM_SETINSERTMARK */
98 HIMAGELIST dragList; /* Bitmap of dragged item */
99 LONG scrollX;
100 INT wheelRemainder;
101 COLORREF clrBk;
102 COLORREF clrText;
103 COLORREF clrLine;
104 COLORREF clrInsertMark;
105 HFONT hFont;
106 HFONT hDefaultFont;
107 HFONT hBoldFont;
108 HFONT hUnderlineFont;
109 HFONT hBoldUnderlineFont;
110 HCURSOR hcurHand;
111 HWND hwndToolTip;
112
113 HWND hwndEdit;
114 WNDPROC wpEditOrig; /* orig window proc for subclassing edit */
115 BOOL bIgnoreEditKillFocus;
116 BOOL bLabelChanged;
117
118 BOOL bNtfUnicode; /* TRUE if should send NOTIFY with W */
119 HIMAGELIST himlNormal;
120 int normalImageHeight;
121 int normalImageWidth;
122 HIMAGELIST himlState;
123 int stateImageHeight;
124 int stateImageWidth;
125 HDPA items;
126
127 DWORD lastKeyPressTimestamp;
128 WPARAM charCode;
129 INT nSearchParamLength;
130 WCHAR szSearchParam[ MAX_PATH ];
131 } TREEVIEW_INFO;
132
133 typedef struct _TREEITEM /* HTREEITEM is a _TREEINFO *. */
134 {
135 HTREEITEM parent; /* handle to parent or 0 if at root */
136 HTREEITEM nextSibling; /* handle to next item in list, 0 if last */
137 HTREEITEM firstChild; /* handle to first child or 0 if no child */
138
139 UINT callbackMask;
140 UINT state;
141 UINT stateMask;
142 LPWSTR pszText;
143 int cchTextMax;
144 int iImage;
145 int iSelectedImage;
146 int iExpandedImage;
147 int cChildren;
148 LPARAM lParam;
149 int iIntegral; /* item height multiplier (1 is normal) */
150 int iLevel; /* indentation level:0=root level */
151 HTREEITEM lastChild;
152 HTREEITEM prevSibling; /* handle to prev item in list, 0 if first */
153 RECT rect;
154 LONG linesOffset;
155 LONG stateOffset;
156 LONG imageOffset;
157 LONG textOffset;
158 LONG textWidth; /* horizontal text extent for pszText */
159 LONG visibleOrder; /* Depth-first numbering of the items whose ancestors are all expanded,
160 corresponding to a top-to-bottom ordering in the tree view.
161 Each item takes up "item.iIntegral" spots in the visible order.
162 0 is the root's first child. */
163 const TREEVIEW_INFO *infoPtr; /* tree data this item belongs to */
164 } TREEVIEW_ITEM;
165
166 /******** Defines that TREEVIEW_ProcessLetterKeys uses ****************/
167 #define KEY_DELAY 450
168
169 /* bitflags for infoPtr->uInternalStatus */
170
171 #define TV_HSCROLL 0x01 /* treeview too large to fit in window */
172 #define TV_VSCROLL 0x02 /* (horizontal/vertical) */
173 #define TV_LDRAG 0x04 /* Lbutton pushed to start drag */
174 #define TV_LDRAGGING 0x08 /* Lbutton pushed, mouse moved. */
175 #define TV_RDRAG 0x10 /* ditto Rbutton */
176 #define TV_RDRAGGING 0x20
177
178 /* bitflags for infoPtr->timer */
179
180 #define TV_EDIT_TIMER 2
181 #define TV_EDIT_TIMER_SET 2
182
183 #define TEXT_CALLBACK_SIZE 260
184
185 #define TREEVIEW_LEFT_MARGIN 8
186
187 #define MINIMUM_INDENT 19
188
189 #define CALLBACK_MASK_ALL (TVIF_TEXT|TVIF_CHILDREN|TVIF_IMAGE|TVIF_SELECTEDIMAGE)
190
191 #define STATEIMAGEINDEX(x) (((x) >> 12) & 0x0f)
192 #define OVERLAYIMAGEINDEX(x) (((x) >> 8) & 0x0f)
193 #define ISVISIBLE(x) ((x)->visibleOrder >= 0)
194
195 #define GETLINECOLOR(x) ((x) == CLR_DEFAULT ? comctl32_color.clrGrayText : (x))
196 #define GETBKCOLOR(x) ((x) == CLR_NONE ? comctl32_color.clrWindow : (x))
197 #define GETTXTCOLOR(x) ((x) == CLR_NONE ? comctl32_color.clrWindowText : (x))
198 #define GETINSCOLOR(x) ((x) == CLR_DEFAULT ? comctl32_color.clrBtnText : (x))
199
200 static const WCHAR themeClass[] = L"Treeview";
201
202
203 typedef VOID (*TREEVIEW_ItemEnumFunc)(TREEVIEW_INFO *, TREEVIEW_ITEM *,LPVOID);
204
205
206 static VOID TREEVIEW_Invalidate(const TREEVIEW_INFO *, const TREEVIEW_ITEM *);
207
208 static LRESULT TREEVIEW_DoSelectItem(TREEVIEW_INFO *, INT, HTREEITEM, INT);
209 static VOID TREEVIEW_SetFirstVisible(TREEVIEW_INFO *, TREEVIEW_ITEM *, BOOL);
210 static LRESULT TREEVIEW_EnsureVisible(TREEVIEW_INFO *, HTREEITEM, BOOL);
211 static LRESULT TREEVIEW_EndEditLabelNow(TREEVIEW_INFO *infoPtr, BOOL bCancel);
212 static VOID TREEVIEW_UpdateScrollBars(TREEVIEW_INFO *infoPtr);
213 static LRESULT TREEVIEW_HScroll(TREEVIEW_INFO *, WPARAM);
214
215 /* Random Utilities *****************************************************/
216 static void TREEVIEW_VerifyTree(TREEVIEW_INFO *infoPtr);
217
218 /* Returns the treeview private data if hwnd is a treeview.
219 * Otherwise returns an undefined value. */
220 static inline TREEVIEW_INFO *
221 TREEVIEW_GetInfoPtr(HWND hwnd)
222 {
223 return (TREEVIEW_INFO *)GetWindowLongPtrW(hwnd, 0);
224 }
225
226 /* Don't call this. Nothing wants an item index. */
227 static inline int
228 TREEVIEW_GetItemIndex(const TREEVIEW_INFO *infoPtr, HTREEITEM handle)
229 {
230 return DPA_GetPtrIndex(infoPtr->items, handle);
231 }
232
233 /* Checks if item has changed and needs to be redrawn */
234 static inline BOOL item_changed (const TREEVIEW_ITEM *tiOld, const TREEVIEW_ITEM *tiNew,
235 const TVITEMEXW *tvChange)
236 {
237 /* Number of children has changed */
238 if ((tvChange->mask & TVIF_CHILDREN) && (tiOld->cChildren != tiNew->cChildren))
239 return TRUE;
240
241 /* Image has changed and it's not a callback */
242 if ((tvChange->mask & TVIF_IMAGE) && (tiOld->iImage != tiNew->iImage) &&
243 tiNew->iImage != I_IMAGECALLBACK)
244 return TRUE;
245
246 /* Selected image has changed and it's not a callback */
247 if ((tvChange->mask & TVIF_SELECTEDIMAGE) && (tiOld->iSelectedImage != tiNew->iSelectedImage) &&
248 tiNew->iSelectedImage != I_IMAGECALLBACK)
249 return TRUE;
250
251 if ((tvChange->mask & TVIF_EXPANDEDIMAGE) && (tiOld->iExpandedImage != tiNew->iExpandedImage) &&
252 tiNew->iExpandedImage != I_IMAGECALLBACK)
253 return TRUE;
254
255 /* Text has changed and it's not a callback */
256 if ((tvChange->mask & TVIF_TEXT) && (tiOld->pszText != tiNew->pszText) &&
257 tiNew->pszText != LPSTR_TEXTCALLBACKW)
258 return TRUE;
259
260 /* Indent has changed */
261 if ((tvChange->mask & TVIF_INTEGRAL) && (tiOld->iIntegral != tiNew->iIntegral))
262 return TRUE;
263
264 /* Item state has changed */
265 if ((tvChange->mask & TVIF_STATE) && ((tiOld->state ^ tiNew->state) & tvChange->stateMask ))
266 return TRUE;
267
268 return FALSE;
269 }
270
271 /***************************************************************************
272 * This method checks that handle is an item for this tree.
273 */
274 static BOOL
275 TREEVIEW_ValidItem(const TREEVIEW_INFO *infoPtr, HTREEITEM handle)
276 {
277 if (TREEVIEW_GetItemIndex(infoPtr, handle) == -1)
278 {
279 TRACE("invalid item %p\n", handle);
280 return FALSE;
281 }
282 else
283 return TRUE;
284 }
285
286 static HFONT
287 TREEVIEW_CreateBoldFont(HFONT hOrigFont)
288 {
289 LOGFONTW font;
290
291 GetObjectW(hOrigFont, sizeof(font), &font);
292 font.lfWeight = FW_BOLD;
293 return CreateFontIndirectW(&font);
294 }
295
296 static HFONT
297 TREEVIEW_CreateUnderlineFont(HFONT hOrigFont)
298 {
299 LOGFONTW font;
300
301 GetObjectW(hOrigFont, sizeof(font), &font);
302 font.lfUnderline = TRUE;
303 return CreateFontIndirectW(&font);
304 }
305
306 static HFONT
307 TREEVIEW_CreateBoldUnderlineFont(HFONT hfont)
308 {
309 LOGFONTW font;
310
311 GetObjectW(hfont, sizeof(font), &font);
312 font.lfWeight = FW_BOLD;
313 font.lfUnderline = TRUE;
314 return CreateFontIndirectW(&font);
315 }
316
317 static inline HFONT
318 TREEVIEW_FontForItem(const TREEVIEW_INFO *infoPtr, const TREEVIEW_ITEM *item)
319 {
320 if ((infoPtr->dwStyle & TVS_TRACKSELECT) && (item == infoPtr->hotItem))
321 return item->state & TVIS_BOLD ? infoPtr->hBoldUnderlineFont : infoPtr->hUnderlineFont;
322 if (item->state & TVIS_BOLD)
323 return infoPtr->hBoldFont;
324 return infoPtr->hFont;
325 }
326
327 /* for trace/debugging purposes only */
328 static const char *
329 TREEVIEW_ItemName(const TREEVIEW_ITEM *item)
330 {
331 if (item == NULL) return "<null item>";
332 if (item->pszText == LPSTR_TEXTCALLBACKW) return "<callback>";
333 if (item->pszText == NULL) return "<null>";
334 return debugstr_w(item->pszText);
335 }
336
337 /* An item is not a child of itself. */
338 static BOOL
339 TREEVIEW_IsChildOf(const TREEVIEW_ITEM *parent, const TREEVIEW_ITEM *child)
340 {
341 do
342 {
343 child = child->parent;
344 if (child == parent) return TRUE;
345 } while (child != NULL);
346
347 return FALSE;
348 }
349
350 static BOOL
351 TREEVIEW_IsFullRowSelect(const TREEVIEW_INFO *infoPtr)
352 {
353 return !(infoPtr->dwStyle & TVS_HASLINES) && (infoPtr->dwStyle & TVS_FULLROWSELECT);
354 }
355
356 static BOOL
357 TREEVIEW_IsItemHit(const TREEVIEW_INFO *infoPtr, const TVHITTESTINFO *ht)
358 {
359 if (TREEVIEW_IsFullRowSelect(infoPtr))
360 return ht->flags & (TVHT_ONITEMINDENT | TVHT_ONITEMBUTTON | TVHT_ONITEM | TVHT_ONITEMRIGHT);
361 else
362 return ht->flags & TVHT_ONITEM;
363 }
364
365 /* Tree Traversal *******************************************************/
366
367 /***************************************************************************
368 * This method returns the last expanded sibling or child child item
369 * of a tree node
370 */
371 static TREEVIEW_ITEM *
372 TREEVIEW_GetLastListItem(const TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *item)
373 {
374 if (!item) return NULL;
375
376 while (item->lastChild)
377 {
378 if (item->state & TVIS_EXPANDED)
379 item = item->lastChild;
380 else
381 break;
382 }
383
384 if (item == infoPtr->root)
385 return NULL;
386
387 return item;
388 }
389
390 /***************************************************************************
391 * This method returns the previous non-hidden item in the list not
392 * considering the tree hierarchy.
393 */
394 static TREEVIEW_ITEM *
395 TREEVIEW_GetPrevListItem(const TREEVIEW_INFO *infoPtr, const TREEVIEW_ITEM *tvItem)
396 {
397 if (tvItem->prevSibling)
398 {
399 /* This item has a prevSibling, get the last item in the sibling's tree. */
400 TREEVIEW_ITEM *upItem = tvItem->prevSibling;
401
402 if ((upItem->state & TVIS_EXPANDED) && upItem->lastChild != NULL)
403 return TREEVIEW_GetLastListItem(infoPtr, upItem->lastChild);
404 else
405 return upItem;
406 }
407 else
408 {
409 /* this item does not have a prevSibling, get the parent */
410 return (tvItem->parent != infoPtr->root) ? tvItem->parent : NULL;
411 }
412 }
413
414
415 /***************************************************************************
416 * This method returns the next physical item in the treeview not
417 * considering the tree hierarchy.
418 */
419 static TREEVIEW_ITEM *
420 TREEVIEW_GetNextListItem(const TREEVIEW_INFO *infoPtr, const TREEVIEW_ITEM *tvItem)
421 {
422 /*
423 * If this item has children and is expanded, return the first child
424 */
425 if ((tvItem->state & TVIS_EXPANDED) && tvItem->firstChild != NULL)
426 {
427 return tvItem->firstChild;
428 }
429
430
431 /*
432 * try to get the sibling
433 */
434 if (tvItem->nextSibling)
435 return tvItem->nextSibling;
436
437 /*
438 * Otherwise, get the parent's sibling.
439 */
440 while (tvItem->parent)
441 {
442 tvItem = tvItem->parent;
443
444 if (tvItem->nextSibling)
445 return tvItem->nextSibling;
446 }
447
448 return NULL;
449 }
450
451 /***************************************************************************
452 * This method returns the nth item starting at the given item. It returns
453 * the last item (or first) we we run out of items.
454 *
455 * Will scroll backward if count is <0.
456 * forward if count is >0.
457 */
458 static TREEVIEW_ITEM *
459 TREEVIEW_GetListItem(const TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *item,
460 LONG count)
461 {
462 TREEVIEW_ITEM *(*next_item)(const TREEVIEW_INFO *, const TREEVIEW_ITEM *);
463 TREEVIEW_ITEM *previousItem;
464
465 assert(item != NULL);
466
467 if (count > 0)
468 {
469 next_item = TREEVIEW_GetNextListItem;
470 }
471 else if (count < 0)
472 {
473 count = -count;
474 next_item = TREEVIEW_GetPrevListItem;
475 }
476 else
477 return item;
478
479 do
480 {
481 previousItem = item;
482 item = next_item(infoPtr, item);
483
484 } while (--count && item != NULL);
485
486
487 return item ? item : previousItem;
488 }
489
490 /* Notifications ************************************************************/
491
492 static INT get_notifycode(const TREEVIEW_INFO *infoPtr, INT code)
493 {
494 if (!infoPtr->bNtfUnicode) {
495 switch (code) {
496 case TVN_SELCHANGINGW: return TVN_SELCHANGINGA;
497 case TVN_SELCHANGEDW: return TVN_SELCHANGEDA;
498 case TVN_GETDISPINFOW: return TVN_GETDISPINFOA;
499 case TVN_SETDISPINFOW: return TVN_SETDISPINFOA;
500 case TVN_ITEMEXPANDINGW: return TVN_ITEMEXPANDINGA;
501 case TVN_ITEMEXPANDEDW: return TVN_ITEMEXPANDEDA;
502 case TVN_BEGINDRAGW: return TVN_BEGINDRAGA;
503 case TVN_BEGINRDRAGW: return TVN_BEGINRDRAGA;
504 case TVN_DELETEITEMW: return TVN_DELETEITEMA;
505 case TVN_BEGINLABELEDITW: return TVN_BEGINLABELEDITA;
506 case TVN_ENDLABELEDITW: return TVN_ENDLABELEDITA;
507 case TVN_GETINFOTIPW: return TVN_GETINFOTIPA;
508 }
509 }
510 return code;
511 }
512
513 static inline BOOL
514 TREEVIEW_SendRealNotify(const TREEVIEW_INFO *infoPtr, UINT code, NMHDR *hdr)
515 {
516 TRACE("code=%d, hdr=%p\n", code, hdr);
517
518 hdr->hwndFrom = infoPtr->hwnd;
519 hdr->idFrom = GetWindowLongPtrW(infoPtr->hwnd, GWLP_ID);
520 hdr->code = get_notifycode(infoPtr, code);
521
522 return SendMessageW(infoPtr->hwndNotify, WM_NOTIFY, hdr->idFrom, (LPARAM)hdr);
523 }
524
525 static BOOL
526 TREEVIEW_SendSimpleNotify(const TREEVIEW_INFO *infoPtr, UINT code)
527 {
528 NMHDR hdr;
529 return TREEVIEW_SendRealNotify(infoPtr, code, &hdr);
530 }
531
532 static VOID
533 TREEVIEW_TVItemFromItem(const TREEVIEW_INFO *infoPtr, UINT mask, TVITEMW *tvItem, TREEVIEW_ITEM *item)
534 {
535 tvItem->mask = mask;
536 tvItem->hItem = item;
537 tvItem->state = item->state;
538 tvItem->stateMask = 0;
539 tvItem->iImage = item->iImage;
540 tvItem->iSelectedImage = item->iSelectedImage;
541 tvItem->cChildren = item->cChildren;
542 tvItem->lParam = item->lParam;
543
544 if(mask & TVIF_TEXT)
545 {
546 if (!infoPtr->bNtfUnicode)
547 {
548 tvItem->cchTextMax = WideCharToMultiByte( CP_ACP, 0, item->pszText, -1, NULL, 0, NULL, NULL );
549 tvItem->pszText = Alloc (tvItem->cchTextMax);
550 WideCharToMultiByte( CP_ACP, 0, item->pszText, -1, (LPSTR)tvItem->pszText, tvItem->cchTextMax, 0, 0 );
551 }
552 else
553 {
554 tvItem->cchTextMax = item->cchTextMax;
555 tvItem->pszText = item->pszText;
556 }
557 }
558 else
559 {
560 tvItem->cchTextMax = 0;
561 tvItem->pszText = NULL;
562 }
563 }
564
565 static BOOL
566 TREEVIEW_SendTreeviewNotify(const TREEVIEW_INFO *infoPtr, UINT code, UINT action,
567 UINT mask, HTREEITEM oldItem, HTREEITEM newItem)
568 {
569 NMTREEVIEWW nmhdr;
570 BOOL ret;
571
572 TRACE("code:%d action:0x%x olditem:%p newitem:%p\n",
573 code, action, oldItem, newItem);
574
575 memset(&nmhdr, 0, sizeof(NMTREEVIEWW));
576 nmhdr.action = action;
577
578 if (oldItem)
579 TREEVIEW_TVItemFromItem(infoPtr, mask, &nmhdr.itemOld, oldItem);
580
581 if (newItem)
582 TREEVIEW_TVItemFromItem(infoPtr, mask, &nmhdr.itemNew, newItem);
583
584 nmhdr.ptDrag.x = 0;
585 nmhdr.ptDrag.y = 0;
586
587 ret = TREEVIEW_SendRealNotify(infoPtr, code, &nmhdr.hdr);
588 if (!infoPtr->bNtfUnicode)
589 {
590 Free(nmhdr.itemOld.pszText);
591 Free(nmhdr.itemNew.pszText);
592 }
593 return ret;
594 }
595
596 static BOOL
597 TREEVIEW_SendTreeviewDnDNotify(const TREEVIEW_INFO *infoPtr, UINT code,
598 HTREEITEM dragItem, POINT pt)
599 {
600 NMTREEVIEWW nmhdr;
601
602 TRACE("code:%d dragitem:%p\n", code, dragItem);
603
604 nmhdr.action = 0;
605 nmhdr.itemNew.mask = TVIF_STATE | TVIF_PARAM | TVIF_HANDLE;
606 nmhdr.itemNew.hItem = dragItem;
607 nmhdr.itemNew.state = dragItem->state;
608 nmhdr.itemNew.lParam = dragItem->lParam;
609
610 nmhdr.ptDrag.x = pt.x;
611 nmhdr.ptDrag.y = pt.y;
612
613 return TREEVIEW_SendRealNotify(infoPtr, code, &nmhdr.hdr);
614 }
615
616
617 static BOOL
618 TREEVIEW_SendCustomDrawNotify(const TREEVIEW_INFO *infoPtr, DWORD dwDrawStage,
619 HDC hdc, RECT rc)
620 {
621 NMTVCUSTOMDRAW nmcdhdr;
622 NMCUSTOMDRAW *nmcd;
623
624 TRACE("drawstage %#lx, hdc %p\n", dwDrawStage, hdc);
625
626 nmcd = &nmcdhdr.nmcd;
627 nmcd->dwDrawStage = dwDrawStage;
628 nmcd->hdc = hdc;
629 nmcd->rc = rc;
630 nmcd->dwItemSpec = 0;
631 nmcd->uItemState = 0;
632 nmcd->lItemlParam = 0;
633 nmcdhdr.clrText = infoPtr->clrText;
634 nmcdhdr.clrTextBk = infoPtr->clrBk;
635 nmcdhdr.iLevel = 0;
636
637 return TREEVIEW_SendRealNotify(infoPtr, NM_CUSTOMDRAW, &nmcdhdr.nmcd.hdr);
638 }
639
640 /* FIXME: need to find out when the flags in uItemState need to be set */
641
642 static BOOL
643 TREEVIEW_SendCustomDrawItemNotify(const TREEVIEW_INFO *infoPtr, HDC hdc,
644 TREEVIEW_ITEM *item, UINT uItemDrawState,
645 NMTVCUSTOMDRAW *nmcdhdr)
646 {
647 NMCUSTOMDRAW *nmcd;
648 DWORD dwDrawStage;
649 DWORD_PTR dwItemSpec;
650 UINT uItemState;
651
652 dwDrawStage = CDDS_ITEM | uItemDrawState;
653 dwItemSpec = (DWORD_PTR)item;
654 uItemState = 0;
655 if (item->state & TVIS_SELECTED)
656 uItemState |= CDIS_SELECTED;
657 if (item == infoPtr->selectedItem)
658 uItemState |= CDIS_FOCUS;
659 if (item == infoPtr->hotItem)
660 uItemState |= CDIS_HOT;
661
662 nmcd = &nmcdhdr->nmcd;
663 nmcd->dwDrawStage = dwDrawStage;
664 nmcd->hdc = hdc;
665 nmcd->rc = item->rect;
666 nmcd->dwItemSpec = dwItemSpec;
667 nmcd->uItemState = uItemState;
668 nmcd->lItemlParam = item->lParam;
669 nmcdhdr->iLevel = item->iLevel;
670
671 TRACE("drawstage %#lx hdc:%p item:%Ix, itemstate:0x%x, lItemlParam:%Ix\n",
672 nmcd->dwDrawStage, nmcd->hdc, nmcd->dwItemSpec,
673 nmcd->uItemState, nmcd->lItemlParam);
674
675 return TREEVIEW_SendRealNotify(infoPtr, NM_CUSTOMDRAW, &nmcdhdr->nmcd.hdr);
676 }
677
678 static BOOL
679 TREEVIEW_BeginLabelEditNotify(const TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *editItem)
680 {
681 NMTVDISPINFOW tvdi;
682 BOOL ret;
683
684 TREEVIEW_TVItemFromItem(infoPtr, TVIF_HANDLE | TVIF_STATE | TVIF_PARAM | TVIF_TEXT,
685 &tvdi.item, editItem);
686
687 ret = TREEVIEW_SendRealNotify(infoPtr, TVN_BEGINLABELEDITW, &tvdi.hdr);
688
689 if (!infoPtr->bNtfUnicode)
690 Free(tvdi.item.pszText);
691
692 return ret;
693 }
694
695 static void
696 TREEVIEW_UpdateDispInfo(const TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *item,
697 UINT mask)
698 {
699 NMTVDISPINFOEXW callback;
700
701 TRACE("mask=0x%x, callbackmask=0x%x\n", mask, item->callbackMask);
702 mask &= item->callbackMask;
703
704 if (mask == 0) return;
705
706 /* 'state' always contains valid value, as well as 'lParam'.
707 * All other parameters are uninitialized.
708 */
709 callback.item.pszText = item->pszText;
710 callback.item.cchTextMax = item->cchTextMax;
711 callback.item.mask = mask;
712 callback.item.hItem = item;
713 callback.item.state = item->state;
714 callback.item.lParam = item->lParam;
715
716 /* If text is changed we need to recalculate textWidth */
717 if (mask & TVIF_TEXT)
718 item->textWidth = 0;
719
720 TREEVIEW_SendRealNotify(infoPtr, TVN_GETDISPINFOW, &callback.hdr);
721 TRACE("resulting code 0x%08x\n", callback.hdr.code);
722
723 /* It may have changed due to a call to SetItem. */
724 mask &= item->callbackMask;
725
726 if ((mask & TVIF_TEXT) && callback.item.pszText != item->pszText)
727 {
728 /* Instead of copying text into our buffer user specified his own */
729 if (!infoPtr->bNtfUnicode && (callback.hdr.code == TVN_GETDISPINFOA)) {
730 LPWSTR newText;
731 int buflen;
732 int len = MultiByteToWideChar( CP_ACP, 0,
733 (LPSTR)callback.item.pszText, -1,
734 NULL, 0);
735 buflen = max((len)*sizeof(WCHAR), TEXT_CALLBACK_SIZE);
736 newText = ReAlloc(item->pszText, buflen);
737
738 TRACE("returned str %s, len=%d, buflen=%d\n",
739 debugstr_a((LPSTR)callback.item.pszText), len, buflen);
740
741 if (newText)
742 {
743 item->pszText = newText;
744 MultiByteToWideChar( CP_ACP, 0,
745 (LPSTR)callback.item.pszText, -1,
746 item->pszText, buflen/sizeof(WCHAR));
747 item->cchTextMax = buflen/sizeof(WCHAR);
748 }
749 /* If realloc fails we have nothing to do, but keep original text */
750 }
751 else {
752 int len = max(lstrlenW(callback.item.pszText) + 1,
753 TEXT_CALLBACK_SIZE);
754 LPWSTR newText = ReAlloc(item->pszText, len*sizeof(WCHAR));
755
756 TRACE("returned wstr %s, len=%d\n",
757 debugstr_w(callback.item.pszText), len);
758
759 if (newText)
760 {
761 item->pszText = newText;
762 lstrcpyW(item->pszText, callback.item.pszText);
763 item->cchTextMax = len;
764 }
765 /* If realloc fails we have nothing to do, but keep original text */
766 }
767 }
768 else if (mask & TVIF_TEXT) {
769 /* User put text into our buffer, that is ok unless A string */
770 if (!infoPtr->bNtfUnicode && (callback.hdr.code == TVN_GETDISPINFOA)) {
771 LPWSTR newText;
772 int buflen;
773 int len = MultiByteToWideChar( CP_ACP, 0,
774 (LPSTR)callback.item.pszText, -1,
775 NULL, 0);
776 buflen = max((len)*sizeof(WCHAR), TEXT_CALLBACK_SIZE);
777 newText = Alloc(buflen);
778
779 TRACE("same buffer str %s, len=%d, buflen=%d\n",
780 debugstr_a((LPSTR)callback.item.pszText), len, buflen);
781
782 if (newText)
783 {
784 LPWSTR oldText = item->pszText;
785 item->pszText = newText;
786 MultiByteToWideChar( CP_ACP, 0,
787 (LPSTR)callback.item.pszText, -1,
788 item->pszText, buflen/sizeof(WCHAR));
789 item->cchTextMax = buflen/sizeof(WCHAR);
790 Free(oldText);
791 }
792 }
793 }
794
795 if (mask & TVIF_IMAGE)
796 item->iImage = callback.item.iImage;
797
798 if (mask & TVIF_SELECTEDIMAGE)
799 item->iSelectedImage = callback.item.iSelectedImage;
800
801 if (mask & TVIF_EXPANDEDIMAGE)
802 item->iExpandedImage = callback.item.iExpandedImage;
803
804 if (mask & TVIF_CHILDREN)
805 item->cChildren = callback.item.cChildren;
806
807 if (callback.item.mask & TVIF_STATE)
808 {
809 item->state &= ~callback.item.stateMask;
810 item->state |= (callback.item.state & callback.item.stateMask);
811 }
812
813 /* These members are now permanently set. */
814 if (callback.item.mask & TVIF_DI_SETITEM)
815 item->callbackMask &= ~callback.item.mask;
816 }
817
818 /***************************************************************************
819 * This function uses cChildren field to decide whether the item has
820 * children or not.
821 * Note: if this returns TRUE, the child items may not actually exist,
822 * they could be virtual.
823 *
824 * Just use item->firstChild to check for physical children.
825 */
826 static BOOL
827 TREEVIEW_HasChildren(const TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *item)
828 {
829 TREEVIEW_UpdateDispInfo(infoPtr, item, TVIF_CHILDREN);
830 /* Protect for a case when callback field is not changed by a host,
831 otherwise negative values trigger normal notifications. */
832 return item->cChildren != 0 && item->cChildren != I_CHILDRENCALLBACK;
833 }
834
835 static INT TREEVIEW_NotifyFormat (TREEVIEW_INFO *infoPtr, HWND hwndFrom, UINT nCommand)
836 {
837 INT format;
838
839 TRACE("(hwndFrom=%p, nCommand=%d)\n", hwndFrom, nCommand);
840
841 if (nCommand != NF_REQUERY) return 0;
842
843 format = SendMessageW(hwndFrom, WM_NOTIFYFORMAT, (WPARAM)infoPtr->hwnd, NF_QUERY);
844 TRACE("format=%d\n", format);
845
846 /* Invalid format returned by NF_QUERY defaults to ANSI*/
847 if (format != NFR_ANSI && format != NFR_UNICODE)
848 format = NFR_ANSI;
849
850 infoPtr->bNtfUnicode = (format == NFR_UNICODE);
851
852 return format;
853 }
854
855 /* Item Position ********************************************************/
856
857 /* Compute linesOffset, stateOffset, imageOffset, textOffset of an item. */
858 static VOID
859 TREEVIEW_ComputeItemInternalMetrics(const TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *item)
860 {
861 /* has TVS_LINESATROOT and (TVS_HASLINES|TVS_HASBUTTONS) */
862 BOOL lar = ((infoPtr->dwStyle & (TVS_LINESATROOT|TVS_HASLINES|TVS_HASBUTTONS))
863 > TVS_LINESATROOT);
864
865 item->linesOffset = infoPtr->uIndent * (lar ? item->iLevel : item->iLevel - 1)
866 - infoPtr->scrollX;
867 item->stateOffset = item->linesOffset + infoPtr->uIndent;
868 item->imageOffset = item->stateOffset
869 + (STATEIMAGEINDEX(item->state) ? infoPtr->stateImageWidth : 0);
870 item->textOffset = item->imageOffset + infoPtr->normalImageWidth;
871 }
872
873 static VOID
874 TREEVIEW_ComputeTextWidth(const TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *item, HDC hDC)
875 {
876 HDC hdc;
877 HFONT hOldFont=0;
878 SIZE sz;
879
880 /* DRAW's OM docker creates items like this */
881 if (item->pszText == NULL)
882 {
883 item->textWidth = 0;
884 return;
885 }
886
887 if (hDC != 0)
888 {
889 hdc = hDC;
890 }
891 else
892 {
893 hdc = GetDC(infoPtr->hwnd);
894 hOldFont = SelectObject(hdc, TREEVIEW_FontForItem(infoPtr, item));
895 }
896
897 GetTextExtentPoint32W(hdc, item->pszText, lstrlenW(item->pszText), &sz);
898 item->textWidth = sz.cx;
899
900 if (hDC == 0)
901 {
902 SelectObject(hdc, hOldFont);
903 ReleaseDC(0, hdc);
904 }
905 }
906
907 static VOID
908 TREEVIEW_ComputeItemRect(const TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *item)
909 {
910 item->rect.top = infoPtr->uItemHeight *
911 (item->visibleOrder - infoPtr->firstVisible->visibleOrder);
912
913 item->rect.bottom = item->rect.top
914 + infoPtr->uItemHeight * item->iIntegral - 1;
915
916 item->rect.left = 0;
917 item->rect.right = infoPtr->clientWidth;
918 }
919
920 /* We know that only items after start need their order updated. */
921 static void
922 TREEVIEW_RecalculateVisibleOrder(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *start)
923 {
924 TREEVIEW_ITEM *item;
925 int order;
926
927 if (!start)
928 {
929 start = infoPtr->root->firstChild;
930 order = 0;
931 }
932 else
933 order = start->visibleOrder;
934
935 for (item = start; item != NULL;
936 item = TREEVIEW_GetNextListItem(infoPtr, item))
937 {
938 if (!ISVISIBLE(item) && order > 0)
939 TREEVIEW_ComputeItemInternalMetrics(infoPtr, item);
940 item->visibleOrder = order;
941 order += item->iIntegral;
942 }
943
944 infoPtr->maxVisibleOrder = order;
945
946 for (item = infoPtr->root->firstChild; item != NULL;
947 item = TREEVIEW_GetNextListItem(infoPtr, item))
948 {
949 TREEVIEW_ComputeItemRect(infoPtr, item);
950 }
951 }
952
953
954 /* Update metrics of all items in selected subtree.
955 * root must be expanded
956 */
957 static VOID
958 TREEVIEW_UpdateSubTree(const TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *root)
959 {
960 TREEVIEW_ITEM *sibling;
961 HDC hdc;
962 HFONT hOldFont;
963
964 if (!root->firstChild || !(root->state & TVIS_EXPANDED))
965 return;
966
967 root->state &= ~TVIS_EXPANDED;
968 sibling = TREEVIEW_GetNextListItem(infoPtr, root);
969 root->state |= TVIS_EXPANDED;
970
971 hdc = GetDC(infoPtr->hwnd);
972 hOldFont = SelectObject(hdc, infoPtr->hFont);
973
974 for (; root != sibling;
975 root = TREEVIEW_GetNextListItem(infoPtr, root))
976 {
977 TREEVIEW_ComputeItemInternalMetrics(infoPtr, root);
978
979 if (root->callbackMask & TVIF_TEXT)
980 TREEVIEW_UpdateDispInfo(infoPtr, root, TVIF_TEXT);
981
982 if (root->textWidth == 0)
983 {
984 SelectObject(hdc, TREEVIEW_FontForItem(infoPtr, root));
985 TREEVIEW_ComputeTextWidth(infoPtr, root, hdc);
986 }
987 }
988
989 SelectObject(hdc, hOldFont);
990 ReleaseDC(infoPtr->hwnd, hdc);
991 }
992
993 /* Item Allocation **********************************************************/
994
995 static TREEVIEW_ITEM *
996 TREEVIEW_AllocateItem(const TREEVIEW_INFO *infoPtr)
997 {
998 TREEVIEW_ITEM *newItem = Alloc(sizeof(*newItem));
999
1000 if (!newItem)
1001 return NULL;
1002
1003 /* I_IMAGENONE would make more sense but this is neither what is
1004 * documented (MSDN doesn't specify) nor what Windows actually does
1005 * (it sets it to zero)... and I can so imagine an application using
1006 * inc/dec to toggle the images. */
1007 newItem->iImage = 0;
1008 newItem->iSelectedImage = 0;
1009 newItem->iExpandedImage = (WORD)I_IMAGENONE;
1010 newItem->infoPtr = infoPtr;
1011
1012 if (DPA_InsertPtr(infoPtr->items, INT_MAX, newItem) == -1)
1013 {
1014 Free(newItem);
1015 return NULL;
1016 }
1017
1018 return newItem;
1019 }
1020
1021 /* Exact opposite of TREEVIEW_AllocateItem. In particular, it does not
1022 * free item->pszText. */
1023 static void
1024 TREEVIEW_FreeItem(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *item)
1025 {
1026 DPA_DeletePtr(infoPtr->items, DPA_GetPtrIndex(infoPtr->items, item));
1027 if (infoPtr->selectedItem == item)
1028 infoPtr->selectedItem = NULL;
1029 if (infoPtr->hotItem == item)
1030 infoPtr->hotItem = NULL;
1031 if (infoPtr->focusedItem == item)
1032 infoPtr->focusedItem = NULL;
1033 if (infoPtr->firstVisible == item)
1034 infoPtr->firstVisible = NULL;
1035 if (infoPtr->dropItem == item)
1036 infoPtr->dropItem = NULL;
1037 if (infoPtr->insertMarkItem == item)
1038 infoPtr->insertMarkItem = NULL;
1039 Free(item);
1040 }
1041
1042
1043 /* Item Insertion *******************************************************/
1044
1045 /***************************************************************************
1046 * This method inserts newItem before sibling as a child of parent.
1047 * sibling can be NULL, but only if parent has no children.
1048 */
1049 static void
1050 TREEVIEW_InsertBefore(TREEVIEW_ITEM *newItem, TREEVIEW_ITEM *sibling,
1051 TREEVIEW_ITEM *parent)
1052 {
1053 assert(parent != NULL);
1054
1055 if (sibling != NULL)
1056 {
1057 assert(sibling->parent == parent);
1058
1059 if (sibling->prevSibling != NULL)
1060 sibling->prevSibling->nextSibling = newItem;
1061
1062 newItem->prevSibling = sibling->prevSibling;
1063 sibling->prevSibling = newItem;
1064 }
1065 else
1066 newItem->prevSibling = NULL;
1067
1068 newItem->nextSibling = sibling;
1069
1070 if (parent->firstChild == sibling)
1071 parent->firstChild = newItem;
1072
1073 if (parent->lastChild == NULL)
1074 parent->lastChild = newItem;
1075 }
1076
1077 /***************************************************************************
1078 * This method inserts newItem after sibling as a child of parent.
1079 * sibling can be NULL, but only if parent has no children.
1080 */
1081 static void
1082 TREEVIEW_InsertAfter(TREEVIEW_ITEM *newItem, TREEVIEW_ITEM *sibling,
1083 TREEVIEW_ITEM *parent)
1084 {
1085 assert(parent != NULL);
1086
1087 if (sibling != NULL)
1088 {
1089 assert(sibling->parent == parent);
1090
1091 if (sibling->nextSibling != NULL)
1092 sibling->nextSibling->prevSibling = newItem;
1093
1094 newItem->nextSibling = sibling->nextSibling;
1095 sibling->nextSibling = newItem;
1096 }
1097 else
1098 newItem->nextSibling = NULL;
1099
1100 newItem->prevSibling = sibling;
1101
1102 if (parent->lastChild == sibling)
1103 parent->lastChild = newItem;
1104
1105 if (parent->firstChild == NULL)
1106 parent->firstChild = newItem;
1107 }
1108
1109 static BOOL
1110 TREEVIEW_DoSetItemT(const TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *item,
1111 const TVITEMEXW *tvItem, BOOL isW)
1112 {
1113 UINT callbackClear = 0;
1114 UINT callbackSet = 0;
1115
1116 TRACE("item %p\n", item);
1117 /* Do this first in case it fails. */
1118 if (tvItem->mask & TVIF_TEXT)
1119 {
1120 item->textWidth = 0; /* force width recalculation */
1121
1122 /* Covers != TEXTCALLBACKA too, and undocumented: pszText of NULL also means TEXTCALLBACK */
1123 if (tvItem->pszText != LPSTR_TEXTCALLBACKW && tvItem->pszText != NULL)
1124 {
1125 int len;
1126 LPWSTR newText;
1127 if (isW)
1128 len = lstrlenW(tvItem->pszText) + 1;
1129 else
1130 len = MultiByteToWideChar(CP_ACP, 0, (LPSTR)tvItem->pszText, -1, NULL, 0);
1131
1132 /* Allocate new block to make pointer comparison in item_changed() work. */
1133 newText = Alloc(len * sizeof(WCHAR));
1134
1135 if (newText == NULL) return FALSE;
1136
1137 callbackClear |= TVIF_TEXT;
1138
1139 Free(item->pszText);
1140 item->pszText = newText;
1141 item->cchTextMax = len;
1142 if (isW)
1143 lstrcpynW(item->pszText, tvItem->pszText, len);
1144 else
1145 MultiByteToWideChar(CP_ACP, 0, (LPSTR)tvItem->pszText, -1,
1146 item->pszText, len);
1147
1148 TRACE("setting text %s, item %p\n", debugstr_w(item->pszText), item);
1149 }
1150 else
1151 {
1152 callbackSet |= TVIF_TEXT;
1153 item->pszText = ReAlloc(item->pszText, TEXT_CALLBACK_SIZE * sizeof(WCHAR));
1154 item->cchTextMax = TEXT_CALLBACK_SIZE;
1155 TRACE("setting callback, item %p\n", item);
1156 }
1157 }
1158
1159 if (tvItem->mask & TVIF_CHILDREN)
1160 {
1161 item->cChildren = tvItem->cChildren;
1162
1163 if (item->cChildren == I_CHILDRENCALLBACK)
1164 callbackSet |= TVIF_CHILDREN;
1165 else
1166 callbackClear |= TVIF_CHILDREN;
1167 }
1168
1169 if (tvItem->mask & TVIF_IMAGE)
1170 {
1171 item->iImage = tvItem->iImage;
1172
1173 if (item->iImage == I_IMAGECALLBACK)
1174 callbackSet |= TVIF_IMAGE;
1175 else
1176 callbackClear |= TVIF_IMAGE;
1177 }
1178
1179 if (tvItem->mask & TVIF_SELECTEDIMAGE)
1180 {
1181 item->iSelectedImage = tvItem->iSelectedImage;
1182
1183 if (item->iSelectedImage == I_IMAGECALLBACK)
1184 callbackSet |= TVIF_SELECTEDIMAGE;
1185 else
1186 callbackClear |= TVIF_SELECTEDIMAGE;
1187 }
1188
1189 if (tvItem->mask & TVIF_EXPANDEDIMAGE)
1190 {
1191 item->iExpandedImage = tvItem->iExpandedImage;
1192
1193 if (item->iExpandedImage == I_IMAGECALLBACK)
1194 callbackSet |= TVIF_EXPANDEDIMAGE;
1195 else
1196 callbackClear |= TVIF_EXPANDEDIMAGE;
1197 }
1198
1199 if (tvItem->mask & TVIF_PARAM)
1200 item->lParam = tvItem->lParam;
1201
1202 /* If the application sets TVIF_INTEGRAL without
1203 * supplying a TVITEMEX structure, it's toast. */
1204 if (tvItem->mask & TVIF_INTEGRAL)
1205 item->iIntegral = tvItem->iIntegral;
1206
1207 if (tvItem->mask & TVIF_STATE)
1208 {
1209 TRACE("prevstate 0x%x, state 0x%x, mask 0x%x\n", item->state, tvItem->state,
1210 tvItem->stateMask);
1211 item->state &= ~tvItem->stateMask;
1212 item->state |= (tvItem->state & tvItem->stateMask);
1213 }
1214
1215 if (tvItem->mask & TVIF_STATEEX)
1216 {
1217 FIXME("New extended state: 0x%x\n", tvItem->uStateEx);
1218 }
1219
1220 item->callbackMask |= callbackSet;
1221 item->callbackMask &= ~callbackClear;
1222
1223 return TRUE;
1224 }
1225
1226 /* Note that the new item is pre-zeroed. */
1227 static LRESULT
1228 TREEVIEW_InsertItemT(TREEVIEW_INFO *infoPtr, const TVINSERTSTRUCTW *ptdi, BOOL isW)
1229 {
1230 const TVITEMEXW *tvItem = &ptdi->itemex;
1231 HTREEITEM insertAfter;
1232 TREEVIEW_ITEM *newItem, *parentItem;
1233 BOOL bTextUpdated = FALSE;
1234
1235 if (ptdi->hParent == TVI_ROOT || ptdi->hParent == 0)
1236 {
1237 parentItem = infoPtr->root;
1238 }
1239 else
1240 {
1241 parentItem = ptdi->hParent;
1242
1243 if (!TREEVIEW_ValidItem(infoPtr, parentItem))
1244 {
1245 WARN("invalid parent %p\n", parentItem);
1246 return 0;
1247 }
1248 }
1249
1250 insertAfter = ptdi->hInsertAfter;
1251
1252 /* Validate this now for convenience. */
1253 switch ((DWORD_PTR)insertAfter)
1254 {
1255 case (DWORD_PTR)TVI_FIRST:
1256 case (DWORD_PTR)TVI_LAST:
1257 case (DWORD_PTR)TVI_SORT:
1258 break;
1259
1260 default:
1261 if (!TREEVIEW_ValidItem(infoPtr, insertAfter) ||
1262 insertAfter->parent != parentItem)
1263 {
1264 WARN("invalid insert after %p\n", insertAfter);
1265 insertAfter = TVI_LAST;
1266 }
1267 }
1268
1269 TRACE("parent %p position %p: %s\n", parentItem, insertAfter,
1270 (tvItem->mask & TVIF_TEXT)
1271 ? ((tvItem->pszText == LPSTR_TEXTCALLBACKW) ? "<callback>"
1272 : (isW ? debugstr_w(tvItem->pszText) : debugstr_a((LPSTR)tvItem->pszText)))
1273 : "<no label>");
1274
1275 newItem = TREEVIEW_AllocateItem(infoPtr);
1276 if (newItem == NULL)
1277 return 0;
1278
1279 newItem->parent = parentItem;
1280 newItem->iIntegral = 1;
1281 newItem->visibleOrder = -1;
1282
1283 if (!TREEVIEW_DoSetItemT(infoPtr, newItem, tvItem, isW))
1284 return 0;
1285
1286 /* After this point, nothing can fail. (Except for TVI_SORT.) */
1287
1288 infoPtr->uNumItems++;
1289
1290 switch ((DWORD_PTR)insertAfter)
1291 {
1292 case (DWORD_PTR)TVI_FIRST:
1293 {
1294 TREEVIEW_ITEM *originalFirst = parentItem->firstChild;
1295 TREEVIEW_InsertBefore(newItem, parentItem->firstChild, parentItem);
1296 if (infoPtr->firstVisible == originalFirst)
1297 TREEVIEW_SetFirstVisible(infoPtr, newItem, TRUE);
1298 }
1299 break;
1300
1301 case (DWORD_PTR)TVI_LAST:
1302 TREEVIEW_InsertAfter(newItem, parentItem->lastChild, parentItem);
1303 break;
1304
1305 /* hInsertAfter names a specific item we want to insert after */
1306 default:
1307 TREEVIEW_InsertAfter(newItem, insertAfter, insertAfter->parent);
1308 break;
1309
1310 case (DWORD_PTR)TVI_SORT:
1311 {
1312 TREEVIEW_ITEM *aChild;
1313 TREEVIEW_ITEM *previousChild = NULL;
1314 TREEVIEW_ITEM *originalFirst = parentItem->firstChild;
1315 BOOL bItemInserted = FALSE;
1316
1317 aChild = parentItem->firstChild;
1318
1319 bTextUpdated = TRUE;
1320 TREEVIEW_UpdateDispInfo(infoPtr, newItem, TVIF_TEXT);
1321
1322 /* Iterate the parent children to see where we fit in */
1323 while (aChild != NULL)
1324 {
1325 INT comp;
1326
1327 TREEVIEW_UpdateDispInfo(infoPtr, aChild, TVIF_TEXT);
1328 comp = lstrcmpW(newItem->pszText, aChild->pszText);
1329
1330 if (comp < 0) /* we are smaller than the current one */
1331 {
1332 TREEVIEW_InsertBefore(newItem, aChild, parentItem);
1333 if (infoPtr->firstVisible == originalFirst &&
1334 aChild == originalFirst)
1335 TREEVIEW_SetFirstVisible(infoPtr, newItem, TRUE);
1336 bItemInserted = TRUE;
1337 break;
1338 }
1339 else if (comp > 0) /* we are bigger than the current one */
1340 {
1341 previousChild = aChild;
1342
1343 /* This will help us to exit if there is no more sibling */
1344 aChild = (aChild->nextSibling == 0)
1345 ? NULL
1346 : aChild->nextSibling;
1347
1348 /* Look at the next item */
1349 continue;
1350 }
1351 else if (comp == 0)
1352 {
1353 /*
1354 * An item with this name is already existing, therefore,
1355 * we add after the one we found
1356 */
1357 TREEVIEW_InsertAfter(newItem, aChild, parentItem);
1358 bItemInserted = TRUE;
1359 break;
1360 }
1361 }
1362
1363 /*
1364 * we reach the end of the child list and the item has not
1365 * yet been inserted, therefore, insert it after the last child.
1366 */
1367 if ((!bItemInserted) && (aChild == NULL))
1368 TREEVIEW_InsertAfter(newItem, previousChild, parentItem);
1369
1370 break;
1371 }
1372 }
1373
1374
1375 TRACE("new item %p; parent %p, mask 0x%x\n", newItem,
1376 newItem->parent, tvItem->mask);
1377
1378 newItem->iLevel = newItem->parent->iLevel + 1;
1379
1380 if (newItem->parent->cChildren == 0)
1381 newItem->parent->cChildren = 1;
1382
1383 if (infoPtr->dwStyle & TVS_CHECKBOXES)
1384 {
1385 if (STATEIMAGEINDEX(newItem->state) == 0)
1386 newItem->state |= INDEXTOSTATEIMAGEMASK(1);
1387 }
1388
1389 if (infoPtr->firstVisible == NULL)
1390 infoPtr->firstVisible = newItem;
1391
1392 TREEVIEW_VerifyTree(infoPtr);
1393
1394 if (!infoPtr->bRedraw) return (LRESULT)newItem;
1395
1396 if (parentItem == infoPtr->root ||
1397 (ISVISIBLE(parentItem) && parentItem->state & TVIS_EXPANDED))
1398 {
1399 TREEVIEW_ITEM *item;
1400 TREEVIEW_ITEM *prev = TREEVIEW_GetPrevListItem(infoPtr, newItem);
1401
1402 TREEVIEW_RecalculateVisibleOrder(infoPtr, prev);
1403 TREEVIEW_ComputeItemInternalMetrics(infoPtr, newItem);
1404
1405 if (!bTextUpdated)
1406 TREEVIEW_UpdateDispInfo(infoPtr, newItem, TVIF_TEXT);
1407
1408 TREEVIEW_ComputeTextWidth(infoPtr, newItem, 0);
1409 TREEVIEW_UpdateScrollBars(infoPtr);
1410 /*
1411 * if the item was inserted in a visible part of the tree,
1412 * invalidate it, as well as those after it
1413 */
1414 for (item = newItem;
1415 item != NULL;
1416 item = TREEVIEW_GetNextListItem(infoPtr, item))
1417 TREEVIEW_Invalidate(infoPtr, item);
1418 }
1419 else
1420 {
1421 /* refresh treeview if newItem is the first item inserted under parentItem */
1422 if (ISVISIBLE(parentItem) && newItem->prevSibling == newItem->nextSibling)
1423 {
1424 /* parent got '+' - update it */
1425 TREEVIEW_Invalidate(infoPtr, parentItem);
1426 }
1427 }
1428
1429 return (LRESULT)newItem;
1430 }
1431
1432 /* Item Deletion ************************************************************/
1433 static void
1434 TREEVIEW_RemoveItem(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *item);
1435
1436 static void
1437 TREEVIEW_RemoveAllChildren(TREEVIEW_INFO *infoPtr, const TREEVIEW_ITEM *parentItem)
1438 {
1439 TREEVIEW_ITEM *kill = parentItem->firstChild;
1440
1441 while (kill != NULL)
1442 {
1443 TREEVIEW_ITEM *next = kill->nextSibling;
1444
1445 TREEVIEW_RemoveItem(infoPtr, kill);
1446
1447 kill = next;
1448 }
1449
1450 assert(parentItem->cChildren <= 0); /* I_CHILDRENCALLBACK or 0 */
1451 assert(parentItem->firstChild == NULL);
1452 assert(parentItem->lastChild == NULL);
1453 }
1454
1455 static void
1456 TREEVIEW_UnlinkItem(const TREEVIEW_ITEM *item)
1457 {
1458 TREEVIEW_ITEM *parentItem;
1459
1460 assert(item != NULL);
1461 assert(item->parent != NULL); /* i.e. it must not be the root */
1462
1463 parentItem = item->parent;
1464
1465 if (parentItem->firstChild == item)
1466 parentItem->firstChild = item->nextSibling;
1467
1468 if (parentItem->lastChild == item)
1469 parentItem->lastChild = item->prevSibling;
1470
1471 if (parentItem->firstChild == NULL && parentItem->lastChild == NULL
1472 && parentItem->cChildren > 0)
1473 parentItem->cChildren = 0;
1474
1475 if (item->prevSibling)
1476 item->prevSibling->nextSibling = item->nextSibling;
1477
1478 if (item->nextSibling)
1479 item->nextSibling->prevSibling = item->prevSibling;
1480 }
1481
1482 static void
1483 TREEVIEW_RemoveItem(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *item)
1484 {
1485 TRACE("%p, (%s)\n", item, TREEVIEW_ItemName(item));
1486
1487 if (item->firstChild)
1488 TREEVIEW_RemoveAllChildren(infoPtr, item);
1489
1490 TREEVIEW_SendTreeviewNotify(infoPtr, TVN_DELETEITEMW, TVC_UNKNOWN,
1491 TVIF_HANDLE | TVIF_PARAM, item, 0);
1492
1493 TREEVIEW_UnlinkItem(item);
1494
1495 infoPtr->uNumItems--;
1496
1497 if (item->pszText != LPSTR_TEXTCALLBACKW)
1498 Free(item->pszText);
1499
1500 TREEVIEW_FreeItem(infoPtr, item);
1501 }
1502
1503
1504 /* Empty out the tree. */
1505 static void
1506 TREEVIEW_RemoveTree(TREEVIEW_INFO *infoPtr)
1507 {
1508 TREEVIEW_RemoveAllChildren(infoPtr, infoPtr->root);
1509
1510 assert(infoPtr->uNumItems == 0); /* root isn't counted in uNumItems */
1511 }
1512
1513 static LRESULT
1514 TREEVIEW_DeleteItem(TREEVIEW_INFO *infoPtr, HTREEITEM item)
1515 {
1516 TREEVIEW_ITEM *newSelection = NULL;
1517 TREEVIEW_ITEM *newFirstVisible = NULL;
1518 TREEVIEW_ITEM *parent, *prev = NULL;
1519 BOOL visible = FALSE;
1520
1521 if (item == TVI_ROOT || !item)
1522 {
1523 TRACE("TVI_ROOT\n");
1524 parent = infoPtr->root;
1525 newSelection = NULL;
1526 visible = TRUE;
1527 TREEVIEW_RemoveTree(infoPtr);
1528 }
1529 else
1530 {
1531 if (!TREEVIEW_ValidItem(infoPtr, item))
1532 return FALSE;
1533
1534 TRACE("%p (%s)\n", item, TREEVIEW_ItemName(item));
1535 parent = item->parent;
1536
1537 if (ISVISIBLE(item))
1538 {
1539 prev = TREEVIEW_GetPrevListItem(infoPtr, item);
1540 visible = TRUE;
1541 }
1542
1543 if (infoPtr->selectedItem != NULL
1544 && (item == infoPtr->selectedItem
1545 || TREEVIEW_IsChildOf(item, infoPtr->selectedItem)))
1546 {
1547 if (item->nextSibling)
1548 newSelection = item->nextSibling;
1549 else if (item->parent != infoPtr->root)
1550 newSelection = item->parent;
1551 else
1552 newSelection = item->prevSibling;
1553 TRACE("newSelection = %p\n", newSelection);
1554 }
1555
1556 if (infoPtr->firstVisible == item)
1557 {
1558 visible = TRUE;
1559 if (item->nextSibling)
1560 newFirstVisible = item->nextSibling;
1561 else if (item->prevSibling)
1562 newFirstVisible = item->prevSibling;
1563 else if (item->parent != infoPtr->root)
1564 newFirstVisible = item->parent;
1565 TREEVIEW_SetFirstVisible(infoPtr, NULL, TRUE);
1566 }
1567 else
1568 newFirstVisible = infoPtr->firstVisible;
1569
1570 TREEVIEW_RemoveItem(infoPtr, item);
1571 }
1572
1573 /* Don't change if somebody else already has (infoPtr->selectedItem is cleared by FreeItem). */
1574 if (!infoPtr->selectedItem && newSelection)
1575 {
1576 if (TREEVIEW_ValidItem(infoPtr, newSelection))
1577 TREEVIEW_DoSelectItem(infoPtr, TVGN_CARET, newSelection, TVC_UNKNOWN);
1578 }
1579
1580 /* Validate insertMark dropItem.
1581 * hotItem ??? - used for comparison only.
1582 */
1583 if (!TREEVIEW_ValidItem(infoPtr, infoPtr->insertMarkItem))
1584 infoPtr->insertMarkItem = 0;
1585
1586 if (!TREEVIEW_ValidItem(infoPtr, infoPtr->dropItem))
1587 infoPtr->dropItem = 0;
1588
1589 if (!TREEVIEW_ValidItem(infoPtr, newFirstVisible))
1590 newFirstVisible = infoPtr->root->firstChild;
1591
1592 TREEVIEW_VerifyTree(infoPtr);
1593
1594 if (visible)
1595 TREEVIEW_SetFirstVisible(infoPtr, newFirstVisible, TRUE);
1596
1597 if (!infoPtr->bRedraw) return TRUE;
1598
1599 if (visible)
1600 {
1601 TREEVIEW_RecalculateVisibleOrder(infoPtr, prev);
1602 TREEVIEW_UpdateScrollBars(infoPtr);
1603 TREEVIEW_Invalidate(infoPtr, NULL);
1604 }
1605 else if (ISVISIBLE(parent) && !TREEVIEW_HasChildren(infoPtr, parent))
1606 {
1607 /* parent lost '+/-' - update it */
1608 TREEVIEW_Invalidate(infoPtr, parent);
1609 }
1610
1611 return TRUE;
1612 }
1613
1614
1615 /* Get/Set Messages *********************************************************/
1616 static LRESULT
1617 TREEVIEW_SetRedraw(TREEVIEW_INFO* infoPtr, WPARAM wParam)
1618 {
1619 infoPtr->bRedraw = wParam != 0;
1620
1621 if (infoPtr->bRedraw)
1622 {
1623 TREEVIEW_UpdateSubTree(infoPtr, infoPtr->root);
1624 TREEVIEW_RecalculateVisibleOrder(infoPtr, NULL);
1625 TREEVIEW_UpdateScrollBars(infoPtr);
1626 TREEVIEW_Invalidate(infoPtr, NULL);
1627 }
1628 return 0;
1629 }
1630
1631 static LRESULT
1632 TREEVIEW_GetIndent(const TREEVIEW_INFO *infoPtr)
1633 {
1634 TRACE("\n");
1635 return infoPtr->uIndent;
1636 }
1637
1638 static LRESULT
1639 TREEVIEW_SetIndent(TREEVIEW_INFO *infoPtr, UINT newIndent)
1640 {
1641 TRACE("\n");
1642
1643 if (newIndent < MINIMUM_INDENT)
1644 newIndent = MINIMUM_INDENT;
1645
1646 if (infoPtr->uIndent != newIndent)
1647 {
1648 infoPtr->uIndent = newIndent;
1649 TREEVIEW_UpdateSubTree(infoPtr, infoPtr->root);
1650 TREEVIEW_UpdateScrollBars(infoPtr);
1651 TREEVIEW_Invalidate(infoPtr, NULL);
1652 }
1653
1654 return 0;
1655 }
1656
1657
1658 static LRESULT
1659 TREEVIEW_GetToolTips(const TREEVIEW_INFO *infoPtr)
1660 {
1661 TRACE("\n");
1662 return (LRESULT)infoPtr->hwndToolTip;
1663 }
1664
1665 static LRESULT
1666 TREEVIEW_SetToolTips(TREEVIEW_INFO *infoPtr, HWND hwndTT)
1667 {
1668 HWND prevToolTip;
1669
1670 TRACE("\n");
1671 prevToolTip = infoPtr->hwndToolTip;
1672 infoPtr->hwndToolTip = hwndTT;
1673
1674 return (LRESULT)prevToolTip;
1675 }
1676
1677 static LRESULT
1678 TREEVIEW_SetUnicodeFormat(TREEVIEW_INFO *infoPtr, BOOL fUnicode)
1679 {
1680 BOOL rc = infoPtr->bNtfUnicode;
1681 infoPtr->bNtfUnicode = fUnicode;
1682 return rc;
1683 }
1684
1685 static LRESULT
1686 TREEVIEW_GetUnicodeFormat(const TREEVIEW_INFO *infoPtr)
1687 {
1688 return infoPtr->bNtfUnicode;
1689 }
1690
1691 static LRESULT
1692 TREEVIEW_GetScrollTime(const TREEVIEW_INFO *infoPtr)
1693 {
1694 return infoPtr->uScrollTime;
1695 }
1696
1697 static LRESULT
1698 TREEVIEW_SetScrollTime(TREEVIEW_INFO *infoPtr, UINT uScrollTime)
1699 {
1700 UINT uOldScrollTime = infoPtr->uScrollTime;
1701
1702 infoPtr->uScrollTime = min(uScrollTime, 100);
1703
1704 return uOldScrollTime;
1705 }
1706
1707
1708 static LRESULT
1709 TREEVIEW_GetImageList(const TREEVIEW_INFO *infoPtr, WPARAM wParam)
1710 {
1711 TRACE("\n");
1712
1713 switch (wParam)
1714 {
1715 case TVSIL_NORMAL:
1716 return (LRESULT)infoPtr->himlNormal;
1717
1718 case TVSIL_STATE:
1719 return (LRESULT)infoPtr->himlState;
1720
1721 default:
1722 return 0;
1723 }
1724 }
1725
1726 #define TVHEIGHT_MIN 16
1727 #define TVHEIGHT_FONT_ADJUST 3 /* 2 for focus border + 1 for margin some apps assume */
1728
1729 /* Compute the natural height for items. */
1730 static UINT
1731 TREEVIEW_NaturalHeight(const TREEVIEW_INFO *infoPtr)
1732 {
1733 TEXTMETRICW tm;
1734 HDC hdc = GetDC(0);
1735 HFONT hOldFont = SelectObject(hdc, infoPtr->hFont);
1736 UINT height;
1737
1738 /* Height is the maximum of:
1739 * 16 (a hack because our fonts are tiny), and
1740 * The text height + border & margin, and
1741 * The size of the normal image list
1742 */
1743 GetTextMetricsW(hdc, &tm);
1744 SelectObject(hdc, hOldFont);
1745 ReleaseDC(0, hdc);
1746
1747 height = TVHEIGHT_MIN;
1748 if (height < tm.tmHeight + tm.tmExternalLeading + TVHEIGHT_FONT_ADJUST)
1749 height = tm.tmHeight + tm.tmExternalLeading + TVHEIGHT_FONT_ADJUST;
1750 if (height < infoPtr->normalImageHeight)
1751 height = infoPtr->normalImageHeight;
1752
1753 /* Round down, unless we support odd ("non even") heights. */
1754 if (!(infoPtr->dwStyle & TVS_NONEVENHEIGHT))
1755 height &= ~1;
1756
1757 return height;
1758 }
1759
1760 static LRESULT
1761 TREEVIEW_SetImageList(TREEVIEW_INFO *infoPtr, UINT type, HIMAGELIST himlNew)
1762 {
1763 HIMAGELIST himlOld = 0;
1764 int oldWidth = infoPtr->normalImageWidth;
1765 int oldHeight = infoPtr->normalImageHeight;
1766
1767 TRACE("%u,%p\n", type, himlNew);
1768
1769 switch (type)
1770 {
1771 case TVSIL_NORMAL:
1772 himlOld = infoPtr->himlNormal;
1773 infoPtr->himlNormal = himlNew;
1774
1775 if (himlNew)
1776 ImageList_GetIconSize(himlNew, &infoPtr->normalImageWidth,
1777 &infoPtr->normalImageHeight);
1778 else
1779 {
1780 infoPtr->normalImageWidth = 0;
1781 infoPtr->normalImageHeight = 0;
1782 }
1783
1784 break;
1785
1786 case TVSIL_STATE:
1787 himlOld = infoPtr->himlState;
1788 infoPtr->himlState = himlNew;
1789
1790 if (himlNew)
1791 ImageList_GetIconSize(himlNew, &infoPtr->stateImageWidth,
1792 &infoPtr->stateImageHeight);
1793 else
1794 {
1795 infoPtr->stateImageWidth = 0;
1796 infoPtr->stateImageHeight = 0;
1797 }
1798
1799 break;
1800
1801 default:
1802 ERR("unknown imagelist type %u\n", type);
1803 }
1804
1805 if (oldWidth != infoPtr->normalImageWidth ||
1806 oldHeight != infoPtr->normalImageHeight)
1807 {
1808 BOOL bRecalcVisible = FALSE;
1809
1810 if (oldHeight != infoPtr->normalImageHeight &&
1811 !infoPtr->bHeightSet)
1812 {
1813 infoPtr->uItemHeight = TREEVIEW_NaturalHeight(infoPtr);
1814 bRecalcVisible = TRUE;
1815 }
1816
1817 if (infoPtr->normalImageWidth > MINIMUM_INDENT &&
1818 infoPtr->normalImageWidth != infoPtr->uIndent)
1819 {
1820 infoPtr->uIndent = infoPtr->normalImageWidth;
1821 bRecalcVisible = TRUE;
1822 }
1823
1824 if (bRecalcVisible)
1825 TREEVIEW_RecalculateVisibleOrder(infoPtr, NULL);
1826
1827 TREEVIEW_UpdateSubTree(infoPtr, infoPtr->root);
1828 TREEVIEW_UpdateScrollBars(infoPtr);
1829 }
1830
1831 TREEVIEW_Invalidate(infoPtr, NULL);
1832
1833 return (LRESULT)himlOld;
1834 }
1835
1836 static LRESULT
1837 TREEVIEW_SetItemHeight(TREEVIEW_INFO *infoPtr, INT newHeight)
1838 {
1839 INT prevHeight = infoPtr->uItemHeight;
1840
1841 TRACE("new=%d, old=%d\n", newHeight, prevHeight);
1842 if (newHeight == -1)
1843 {
1844 infoPtr->uItemHeight = TREEVIEW_NaturalHeight(infoPtr);
1845 infoPtr->bHeightSet = FALSE;
1846 }
1847 else
1848 {
1849 if (newHeight == 0) newHeight = 1;
1850 infoPtr->uItemHeight = newHeight;
1851 infoPtr->bHeightSet = TRUE;
1852 }
1853
1854 /* Round down, unless we support odd ("non even") heights. */
1855 if (!(infoPtr->dwStyle & TVS_NONEVENHEIGHT) && infoPtr->uItemHeight != 1)
1856 {
1857 infoPtr->uItemHeight &= ~1;
1858 TRACE("after rounding=%d\n", infoPtr->uItemHeight);
1859 }
1860
1861 if (infoPtr->uItemHeight != prevHeight)
1862 {
1863 TREEVIEW_RecalculateVisibleOrder(infoPtr, NULL);
1864 TREEVIEW_UpdateScrollBars(infoPtr);
1865 TREEVIEW_Invalidate(infoPtr, NULL);
1866 }
1867
1868 return prevHeight;
1869 }
1870
1871 static LRESULT
1872 TREEVIEW_GetItemHeight(const TREEVIEW_INFO *infoPtr)
1873 {
1874 TRACE("\n");
1875 return infoPtr->uItemHeight;
1876 }
1877
1878
1879 static LRESULT
1880 TREEVIEW_GetFont(const TREEVIEW_INFO *infoPtr)
1881 {
1882 TRACE("%p\n", infoPtr->hFont);
1883 return (LRESULT)infoPtr->hFont;
1884 }
1885
1886
1887 static INT CALLBACK
1888 TREEVIEW_ResetTextWidth(LPVOID pItem, LPVOID unused)
1889 {
1890 (void)unused;
1891
1892 ((TREEVIEW_ITEM *)pItem)->textWidth = 0;
1893
1894 return 1;
1895 }
1896
1897 static LRESULT
1898 TREEVIEW_SetFont(TREEVIEW_INFO *infoPtr, HFONT hFont, BOOL bRedraw)
1899 {
1900 UINT uHeight = infoPtr->uItemHeight;
1901
1902 TRACE("%p %i\n", hFont, bRedraw);
1903
1904 infoPtr->hFont = hFont ? hFont : infoPtr->hDefaultFont;
1905
1906 DeleteObject(infoPtr->hBoldFont);
1907 DeleteObject(infoPtr->hUnderlineFont);
1908 DeleteObject(infoPtr->hBoldUnderlineFont);
1909 infoPtr->hBoldFont = TREEVIEW_CreateBoldFont(infoPtr->hFont);
1910 infoPtr->hUnderlineFont = TREEVIEW_CreateUnderlineFont(infoPtr->hFont);
1911 infoPtr->hBoldUnderlineFont = TREEVIEW_CreateBoldUnderlineFont(infoPtr->hFont);
1912
1913 if (!infoPtr->bHeightSet)
1914 infoPtr->uItemHeight = TREEVIEW_NaturalHeight(infoPtr);
1915
1916 if (uHeight != infoPtr->uItemHeight)
1917 TREEVIEW_RecalculateVisibleOrder(infoPtr, NULL);
1918
1919 DPA_EnumCallback(infoPtr->items, TREEVIEW_ResetTextWidth, 0);
1920
1921 TREEVIEW_UpdateSubTree(infoPtr, infoPtr->root);
1922 TREEVIEW_UpdateScrollBars(infoPtr);
1923
1924 if (bRedraw)
1925 TREEVIEW_Invalidate(infoPtr, NULL);
1926
1927 return 0;
1928 }
1929
1930
1931 static LRESULT
1932 TREEVIEW_GetLineColor(const TREEVIEW_INFO *infoPtr)
1933 {
1934 TRACE("\n");
1935 return (LRESULT)infoPtr->clrLine;
1936 }
1937
1938 static LRESULT
1939 TREEVIEW_SetLineColor(TREEVIEW_INFO *infoPtr, COLORREF color)
1940 {
1941 COLORREF prevColor = infoPtr->clrLine;
1942
1943 TRACE("\n");
1944 infoPtr->clrLine = color;
1945 return (LRESULT)prevColor;
1946 }
1947
1948
1949 static LRESULT
1950 TREEVIEW_GetTextColor(const TREEVIEW_INFO *infoPtr)
1951 {
1952 TRACE("\n");
1953 return (LRESULT)infoPtr->clrText;
1954 }
1955
1956 static LRESULT
1957 TREEVIEW_SetTextColor(TREEVIEW_INFO *infoPtr, COLORREF color)
1958 {
1959 COLORREF prevColor = infoPtr->clrText;
1960
1961 TRACE("\n");
1962 infoPtr->clrText = color;
1963
1964 if (infoPtr->clrText != prevColor)
1965 TREEVIEW_Invalidate(infoPtr, NULL);
1966
1967 return (LRESULT)prevColor;
1968 }
1969
1970
1971 static LRESULT
1972 TREEVIEW_GetBkColor(const TREEVIEW_INFO *infoPtr)
1973 {
1974 TRACE("\n");
1975 return (LRESULT)infoPtr->clrBk;
1976 }
1977
1978 static LRESULT
1979 TREEVIEW_SetBkColor(TREEVIEW_INFO *infoPtr, COLORREF newColor)
1980 {
1981 COLORREF prevColor = infoPtr->clrBk;
1982
1983 TRACE("\n");
1984 infoPtr->clrBk = newColor;
1985
1986 if (newColor != prevColor)
1987 TREEVIEW_Invalidate(infoPtr, NULL);
1988
1989 return (LRESULT)prevColor;
1990 }
1991
1992
1993 static LRESULT
1994 TREEVIEW_GetInsertMarkColor(const TREEVIEW_INFO *infoPtr)
1995 {
1996 TRACE("\n");
1997 return (LRESULT)infoPtr->clrInsertMark;
1998 }
1999
2000 static LRESULT
2001 TREEVIEW_SetInsertMarkColor(TREEVIEW_INFO *infoPtr, COLORREF color)
2002 {
2003 COLORREF prevColor = infoPtr->clrInsertMark;
2004
2005 TRACE("%#lx\n", color);
2006 infoPtr->clrInsertMark = color;
2007
2008 return (LRESULT)prevColor;
2009 }
2010
2011
2012 static LRESULT
2013 TREEVIEW_SetInsertMark(TREEVIEW_INFO *infoPtr, BOOL wParam, HTREEITEM item)
2014 {
2015 TRACE("%d %p\n", wParam, item);
2016
2017 if (!TREEVIEW_ValidItem(infoPtr, item))
2018 return 0;
2019
2020 infoPtr->insertBeforeorAfter = wParam;
2021 infoPtr->insertMarkItem = item;
2022
2023 TREEVIEW_Invalidate(infoPtr, NULL);
2024
2025 return 1;
2026 }
2027
2028
2029 /************************************************************************
2030 * Some serious braindamage here. lParam is a pointer to both the
2031 * input HTREEITEM and the output RECT.
2032 */
2033 static LRESULT
2034 TREEVIEW_GetItemRect(const TREEVIEW_INFO *infoPtr, BOOL fTextRect, LPRECT lpRect)
2035 {
2036 TREEVIEW_ITEM *item;
2037 const HTREEITEM *pItem = (HTREEITEM *)lpRect;
2038
2039 TRACE("\n");
2040
2041 if (pItem == NULL)
2042 return FALSE;
2043
2044 item = *pItem;
2045 if (!TREEVIEW_ValidItem(infoPtr, item) || !ISVISIBLE(item))
2046 return FALSE;
2047
2048 /*
2049 * If wParam is TRUE return the text size otherwise return
2050 * the whole item size
2051 */
2052 if (fTextRect)
2053 {
2054 /* Windows does not send TVN_GETDISPINFO here. */
2055
2056 lpRect->top = item->rect.top;
2057 lpRect->bottom = item->rect.bottom;
2058
2059 lpRect->left = item->textOffset;
2060 if (!item->textWidth)
2061 TREEVIEW_ComputeTextWidth(infoPtr, item, 0);
2062
2063 lpRect->right = item->textOffset + item->textWidth + 4;
2064 }
2065 else
2066 {
2067 *lpRect = item->rect;
2068 }
2069
2070 TRACE("%s [%s]\n", fTextRect ? "text" : "item", wine_dbgstr_rect(lpRect));
2071
2072 return TRUE;
2073 }
2074
2075 static inline LRESULT
2076 TREEVIEW_GetVisibleCount(const TREEVIEW_INFO *infoPtr)
2077 {
2078 /* Surprise! This does not take integral height into account. */
2079 TRACE("client=%ld, item=%d\n", infoPtr->clientHeight, infoPtr->uItemHeight);
2080 return infoPtr->clientHeight / infoPtr->uItemHeight;
2081 }
2082
2083
2084 static LRESULT
2085 TREEVIEW_GetItemT(const TREEVIEW_INFO *infoPtr, LPTVITEMEXW tvItem, BOOL isW)
2086 {
2087 TREEVIEW_ITEM *item = tvItem->hItem;
2088
2089 if (!TREEVIEW_ValidItem(infoPtr, item))
2090 {
2091 BOOL valid_item = FALSE;
2092 if (!item) return FALSE;
2093
2094 __TRY
2095 {
2096 infoPtr = item->infoPtr;
2097 TRACE("got item from different tree %p, called from %p\n", item->infoPtr, infoPtr);
2098 valid_item = TREEVIEW_ValidItem(infoPtr, item);
2099 }
2100 __EXCEPT_PAGE_FAULT
2101 {
2102 }
2103 __ENDTRY
2104 if (!valid_item) return FALSE;
2105 }
2106
2107 TREEVIEW_UpdateDispInfo(infoPtr, item, tvItem->mask);
2108
2109 if (tvItem->mask & TVIF_CHILDREN)
2110 {
2111 if (item->cChildren==I_CHILDRENCALLBACK)
2112 FIXME("I_CHILDRENCALLBACK not supported\n");
2113 tvItem->cChildren = item->cChildren;
2114 }
2115
2116 if (tvItem->mask & TVIF_HANDLE)
2117 tvItem->hItem = item;
2118
2119 if (tvItem->mask & TVIF_IMAGE)
2120 tvItem->iImage = item->iImage;
2121
2122 if (tvItem->mask & TVIF_INTEGRAL)
2123 tvItem->iIntegral = item->iIntegral;
2124
2125 /* undocumented: (mask & TVIF_PARAM) ignored and lParam is always set */
2126 tvItem->lParam = item->lParam;
2127
2128 if (tvItem->mask & TVIF_SELECTEDIMAGE)
2129 tvItem->iSelectedImage = item->iSelectedImage;
2130
2131 if (tvItem->mask & TVIF_EXPANDEDIMAGE)
2132 tvItem->iExpandedImage = item->iExpandedImage;
2133
2134 /* undocumented: stateMask and (state & TVIF_STATE) ignored, so state is always set */
2135 tvItem->state = item->state;
2136
2137 if (tvItem->mask & TVIF_TEXT)
2138 {
2139 if (item->pszText == NULL)
2140 {
2141 if (tvItem->cchTextMax > 0)
2142 tvItem->pszText[0] = '\0';
2143 }
2144 else if (isW)
2145 {
2146 if (item->pszText == LPSTR_TEXTCALLBACKW)
2147 {
2148 tvItem->pszText = LPSTR_TEXTCALLBACKW;
2149 FIXME(" GetItem called with LPSTR_TEXTCALLBACK\n");
2150 }
2151 else
2152 {
2153 lstrcpynW(tvItem->pszText, item->pszText, tvItem->cchTextMax);
2154 }
2155 }
2156 else
2157 {
2158 if (item->pszText == LPSTR_TEXTCALLBACKW)
2159 {
2160 tvItem->pszText = (LPWSTR)LPSTR_TEXTCALLBACKA;
2161 FIXME(" GetItem called with LPSTR_TEXTCALLBACK\n");
2162 }
2163 else
2164 {
2165 WideCharToMultiByte(CP_ACP, 0, item->pszText, -1,
2166 (LPSTR)tvItem->pszText, tvItem->cchTextMax, NULL, NULL);
2167 }
2168 }
2169 }
2170
2171 if (tvItem->mask & TVIF_STATEEX)
2172 {
2173 FIXME("Extended item state not supported, returning 0.\n");
2174 tvItem->uStateEx = 0;
2175 }
2176
2177 TRACE("item <%p>, txt %p, img %d, mask 0x%x\n",
2178 item, tvItem->pszText, tvItem->iImage, tvItem->mask);
2179
2180 return TRUE;
2181 }
2182
2183 /* Beware MSDN Library Visual Studio 6.0. It says -1 on failure, 0 on success,
2184 * which is wrong. */
2185 static LRESULT
2186 TREEVIEW_SetItemT(TREEVIEW_INFO *infoPtr, const TVITEMEXW *tvItem, BOOL isW)
2187 {
2188 TREEVIEW_ITEM *item;
2189 TREEVIEW_ITEM originalItem;
2190
2191 item = tvItem->hItem;
2192
2193 TRACE("item %d, mask 0x%x\n", TREEVIEW_GetItemIndex(infoPtr, item),
2194 tvItem->mask);
2195
2196 if (!TREEVIEW_ValidItem(infoPtr, item))
2197 return FALSE;
2198
2199 /* Store the original item values. Text buffer will be freed in TREEVIEW_DoSetItemT() below. */
2200 originalItem = *item;
2201
2202 if (!TREEVIEW_DoSetItemT(infoPtr, item, tvItem, isW))
2203 return FALSE;
2204
2205 /* If the text or TVIS_BOLD was changed, and it is visible, recalculate. */
2206 if ((tvItem->mask & TVIF_TEXT
2207 || (tvItem->mask & TVIF_STATE && tvItem->stateMask & TVIS_BOLD))
2208 && ISVISIBLE(item))
2209 {
2210 TREEVIEW_UpdateDispInfo(infoPtr, item, TVIF_TEXT);
2211 TREEVIEW_ComputeTextWidth(infoPtr, item, 0);
2212 }
2213
2214 if (tvItem->mask != 0 && ISVISIBLE(item))
2215 {
2216 /* The refresh updates everything, but we can't wait until then. */
2217 TREEVIEW_ComputeItemInternalMetrics(infoPtr, item);
2218
2219 /* if any of the item's values changed and it's not a callback, redraw the item */
2220 if (item_changed(&originalItem, item, tvItem))
2221 {
2222 if (tvItem->mask & TVIF_INTEGRAL)
2223 {
2224 TREEVIEW_RecalculateVisibleOrder(infoPtr, item);
2225 TREEVIEW_UpdateScrollBars(infoPtr);
2226
2227 TREEVIEW_Invalidate(infoPtr, NULL);
2228 }
2229 else
2230 {
2231 TREEVIEW_UpdateScrollBars(infoPtr);
2232 TREEVIEW_Invalidate(infoPtr, item);
2233 }
2234 }
2235 }
2236
2237 return TRUE;
2238 }
2239
2240 static LRESULT
2241 TREEVIEW_GetItemState(const TREEVIEW_INFO *infoPtr, HTREEITEM item, UINT mask)
2242 {
2243 TRACE("\n");
2244
2245 if (!item || !TREEVIEW_ValidItem(infoPtr, item))
2246 return 0;
2247
2248 return (item->state & mask);
2249 }
2250
2251 static LRESULT
2252 TREEVIEW_GetNextItem(const TREEVIEW_INFO *infoPtr, UINT which, HTREEITEM item)
2253 {
2254 TREEVIEW_ITEM *retval;
2255
2256 retval = 0;
2257
2258 /* handle all the global data here */
2259 switch (which)
2260 {
2261 case TVGN_CHILD: /* Special case: child of 0 is root */
2262 if (item)
2263 break;
2264 /* fall through */
2265 case TVGN_ROOT:
2266 retval = infoPtr->root->firstChild;
2267 break;
2268
2269 case TVGN_CARET:
2270 retval = infoPtr->selectedItem;
2271 break;
2272
2273 case TVGN_FIRSTVISIBLE:
2274 retval = infoPtr->firstVisible;
2275 break;
2276
2277 case TVGN_DROPHILITE:
2278 retval = infoPtr->dropItem;
2279 break;
2280
2281 case TVGN_LASTVISIBLE:
2282 retval = TREEVIEW_GetLastListItem(infoPtr, infoPtr->root);
2283 break;
2284 }
2285
2286 if (retval)
2287 {
2288 TRACE("flags:0x%x, returns %p\n", which, retval);
2289 return (LRESULT)retval;
2290 }
2291
2292 if (item == TVI_ROOT) item = infoPtr->root;
2293
2294 if (!TREEVIEW_ValidItem(infoPtr, item))
2295 return FALSE;
2296
2297 switch (which)
2298 {
2299 case TVGN_NEXT:
2300 retval = item->nextSibling;
2301 break;
2302 case TVGN_PREVIOUS:
2303 retval = item->prevSibling;
2304 break;
2305 case TVGN_PARENT:
2306 retval = (item->parent != infoPtr->root) ? item->parent : NULL;
2307 break;
2308 case TVGN_CHILD:
2309 retval = item->firstChild;
2310 break;
2311 case TVGN_NEXTVISIBLE:
2312 retval = TREEVIEW_GetNextListItem(infoPtr, item);
2313 break;
2314 case TVGN_PREVIOUSVISIBLE:
2315 retval = TREEVIEW_GetPrevListItem(infoPtr, item);
2316 break;
2317 default:
2318 TRACE("Unknown msg 0x%x, item %p\n", which, item);
2319 break;
2320 }
2321
2322 TRACE("flags: 0x%x, item %p;returns %p\n", which, item, retval);
2323 return (LRESULT)retval;
2324 }
2325
2326
2327 static LRESULT
2328 TREEVIEW_GetCount(const TREEVIEW_INFO *infoPtr)
2329 {
2330 TRACE(" %d\n", infoPtr->uNumItems);
2331 return (LRESULT)infoPtr->uNumItems;
2332 }
2333
2334 static VOID
2335 TREEVIEW_ToggleItemState(const TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *item)
2336 {
2337 if (infoPtr->dwStyle & TVS_CHECKBOXES)
2338 {
2339 static const unsigned int state_table[] = { 0, 2, 1 };
2340
2341 unsigned int state;
2342
2343 state = STATEIMAGEINDEX(item->state);
2344 TRACE("state: 0x%x\n", state);
2345 item->state &= ~TVIS_STATEIMAGEMASK;
2346
2347 if (state < 3)
2348 state = state_table[state];
2349
2350 item->state |= INDEXTOSTATEIMAGEMASK(state);
2351
2352 TRACE("state: 0x%x\n", state);
2353 TREEVIEW_Invalidate(infoPtr, item);
2354 }
2355 }
2356
2357
2358 /* Painting *************************************************************/
2359
2360 /* Draw the lines and expand button for an item. Also draws one section
2361 * of the line from item's parent to item's parent's next sibling. */
2362 static void
2363 TREEVIEW_DrawItemLines(const TREEVIEW_INFO *infoPtr, HDC hdc, const TREEVIEW_ITEM *item)
2364 {
2365 LONG centerx, centery;
2366 BOOL lar = ((infoPtr->dwStyle
2367 & (TVS_LINESATROOT|TVS_HASLINES|TVS_HASBUTTONS))
2368 > TVS_LINESATROOT);
2369 HBRUSH hbr, hbrOld;
2370 COLORREF clrBk = GETBKCOLOR(infoPtr->clrBk);
2371
2372 if (!lar && item->iLevel == 0)
2373 return;
2374
2375 hbr = CreateSolidBrush(clrBk);
2376 hbrOld = SelectObject(hdc, hbr);
2377
2378 centerx = (item->linesOffset + item->stateOffset) / 2;
2379 centery = (item->rect.top + item->rect.bottom) / 2;
2380
2381 if (infoPtr->dwStyle & TVS_HASLINES)
2382 {
2383 HPEN hOldPen, hNewPen;
2384 HTREEITEM parent;
2385 LOGBRUSH lb;
2386
2387 /* Get a dotted grey pen */
2388 lb.lbStyle = BS_SOLID;
2389 lb.lbColor = GETLINECOLOR(infoPtr->clrLine);
2390 hNewPen = ExtCreatePen(PS_COSMETIC|PS_ALTERNATE, 1, &lb, 0, NULL);
2391 hOldPen = SelectObject(hdc, hNewPen);
2392
2393 /* Make sure the center is on a dot (using +2 instead
2394 * of +1 gives us pixel-by-pixel compat with native) */
2395 centery = (centery + 2) & ~1;
2396
2397 MoveToEx(hdc, item->stateOffset, centery, NULL);
2398 LineTo(hdc, centerx - 1, centery);
2399
2400 if (item->prevSibling || item->parent != infoPtr->root)
2401 {
2402 MoveToEx(hdc, centerx, item->rect.top, NULL);
2403 LineTo(hdc, centerx, centery);
2404 }
2405
2406 if (item->nextSibling)
2407 {
2408 MoveToEx(hdc, centerx, centery, NULL);
2409 LineTo(hdc, centerx, item->rect.bottom + 1);
2410 }
2411
2412 /* Draw the line from our parent to its next sibling. */
2413 parent = item->parent;
2414 while (parent != infoPtr->root)
2415 {
2416 int pcenterx = (parent->linesOffset + parent->stateOffset) / 2;
2417
2418 if (parent->nextSibling
2419 /* skip top-levels unless TVS_LINESATROOT */
2420 && parent->stateOffset > parent->linesOffset)
2421 {
2422 MoveToEx(hdc, pcenterx, item->rect.top, NULL);
2423 LineTo(hdc, pcenterx, item->rect.bottom + 1);
2424 }
2425
2426 parent = parent->parent;
2427 }
2428
2429 SelectObject(hdc, hOldPen);
2430 DeleteObject(hNewPen);
2431 }
2432
2433 /*
2434 * Display the (+/-) signs
2435 */
2436
2437 if (infoPtr->dwStyle & TVS_HASBUTTONS)
2438 {
2439 if (item->cChildren)
2440 {
2441 HTHEME theme = GetWindowTheme(infoPtr->hwnd);
2442 if (theme)
2443 {
2444 RECT glyphRect = item->rect;
2445 glyphRect.left = item->linesOffset;
2446 glyphRect.right = item->stateOffset;
2447 DrawThemeBackground (theme, hdc, TVP_GLYPH,
2448 (item->state & TVIS_EXPANDED) ? GLPS_OPENED : GLPS_CLOSED,
2449 &glyphRect, NULL);
2450 }
2451 else
2452 {
2453 LONG height = item->rect.bottom - item->rect.top;
2454 LONG width = item->stateOffset - item->linesOffset;
2455 LONG rectsize = min(height, width) / 4;
2456 /* plussize = ceil(rectsize * 3/4) */
2457 LONG plussize = (rectsize + 1) * 3 / 4;
2458
2459 HPEN new_pen = CreatePen(PS_SOLID, 0, GETLINECOLOR(infoPtr->clrLine));
2460 HPEN old_pen = SelectObject(hdc, new_pen);
2461
2462 Rectangle(hdc, centerx - rectsize - 1, centery - rectsize - 1,
2463 centerx + rectsize + 2, centery + rectsize + 2);
2464
2465 SelectObject(hdc, old_pen);
2466 DeleteObject(new_pen);
2467
2468 /* draw +/- signs with current text color */
2469 new_pen = CreatePen(PS_SOLID, 0, GETTXTCOLOR(infoPtr->clrText));
2470 old_pen = SelectObject(hdc, new_pen);
2471
2472 if (height < 18 || width < 18)
2473 {
2474 MoveToEx(hdc, centerx - plussize + 1, centery, NULL);
2475 LineTo(hdc, centerx + plussize, centery);
2476
2477 if (!(item->state & TVIS_EXPANDED) ||
2478 (item->state & TVIS_EXPANDPARTIAL))
2479 {
2480 MoveToEx(hdc, centerx, centery - plussize + 1, NULL);
2481 LineTo(hdc, centerx, centery + plussize);
2482 }
2483 }
2484 else
2485 {
2486 Rectangle(hdc, centerx - plussize + 1, centery - 1,
2487 centerx + plussize, centery + 2);
2488
2489 if (!(item->state & TVIS_EXPANDED) ||
2490 (item->state & TVIS_EXPANDPARTIAL))
2491 {
2492 Rectangle(hdc, centerx - 1, centery - plussize + 1,
2493 centerx + 2, centery + plussize);
2494 SetPixel(hdc, centerx - 1, centery, clrBk);
2495 SetPixel(hdc, centerx + 1, centery, clrBk);
2496 }
2497 }
2498
2499 SelectObject(hdc, old_pen);
2500 DeleteObject(new_pen);
2501 }
2502 }
2503 }
2504 SelectObject(hdc, hbrOld);
2505 DeleteObject(hbr);
2506 }
2507
2508 static void
2509 TREEVIEW_DrawItem(const TREEVIEW_INFO *infoPtr, HDC hdc, TREEVIEW_ITEM *item)
2510 {
2511 INT cditem;
2512 HFONT hOldFont;
2513 COLORREF oldTextColor, oldTextBkColor;
2514 int centery;
2515 BOOL inFocus = (GetFocus() == infoPtr->hwnd);
2516 NMTVCUSTOMDRAW nmcdhdr;
2517
2518 TREEVIEW_UpdateDispInfo(infoPtr, item, CALLBACK_MASK_ALL);
2519
2520 /* - If item is drop target or it is selected and window is in focus -
2521 * use blue background (COLOR_HIGHLIGHT).
2522 * - If item is selected, window is not in focus, but it has style
2523 * TVS_SHOWSELALWAYS - use grey background (COLOR_BTNFACE)
2524 * - Otherwise - use background color
2525 */
2526 if ((item->state & TVIS_DROPHILITED) || ((item == infoPtr->focusedItem) && !(item->state & TVIS_SELECTED)) ||
2527 ((item->state & TVIS_SELECTED) && (!infoPtr->focusedItem || item == infoPtr->focusedItem) &&
2528 (inFocus || (infoPtr->dwStyle & TVS_SHOWSELALWAYS))))
2529 {
2530 if ((item->state & TVIS_DROPHILITED) || inFocus)
2531 {
2532 nmcdhdr.clrTextBk = comctl32_color.clrHighlight;
2533 nmcdhdr.clrText = comctl32_color.clrHighlightText;
2534 }
2535 else
2536 {
2537 nmcdhdr.clrTextBk = comctl32_color.clrBtnFace;
2538 nmcdhdr.clrText = GETTXTCOLOR(infoPtr->clrText);
2539 }
2540 }
2541 else
2542 {
2543 nmcdhdr.clrTextBk = GETBKCOLOR(infoPtr->clrBk);
2544 if ((infoPtr->dwStyle & TVS_TRACKSELECT) && (item == infoPtr->hotItem))
2545 nmcdhdr.clrText = comctl32_color.clrHighlight;
2546 else
2547 nmcdhdr.clrText = GETTXTCOLOR(infoPtr->clrText);
2548 }
2549
2550 hOldFont = SelectObject(hdc, TREEVIEW_FontForItem(infoPtr, item));
2551 oldTextColor = SetTextColor(hdc, nmcdhdr.clrText);
2552 oldTextBkColor = SetBkColor(hdc, nmcdhdr.clrTextBk);
2553
2554 /* The custom draw handler can query the text rectangle,
2555 * so get ready. */
2556 /* should already be known, set to 0 when changed */
2557 if (!item->textWidth)
2558 TREEVIEW_ComputeTextWidth(infoPtr, item, hdc);
2559
2560 cditem = 0;
2561
2562 if (infoPtr->cdmode & CDRF_NOTIFYITEMDRAW)
2563 {
2564 cditem = TREEVIEW_SendCustomDrawItemNotify
2565 (infoPtr, hdc, item, CDDS_ITEMPREPAINT, &nmcdhdr);
2566 TRACE("prepaint:cditem-app returns 0x%x\n", cditem);
2567
2568 if (cditem & CDRF_SKIPDEFAULT)
2569 {
2570 SelectObject(hdc, hOldFont);
2571 return;
2572 }
2573 }
2574
2575 if (cditem & CDRF_NEWFONT)
2576 TREEVIEW_ComputeTextWidth(infoPtr, item, hdc);
2577
2578 if (TREEVIEW_IsFullRowSelect(infoPtr))
2579 {
2580 HBRUSH brush = CreateSolidBrush(nmcdhdr.clrTextBk);
2581 FillRect(hdc, &item->rect, brush);
2582 DeleteObject(brush);
2583 }
2584
2585 TREEVIEW_DrawItemLines(infoPtr, hdc, item);
2586
2587 /* reset colors. Custom draw handler can change them */
2588 SetTextColor(hdc, nmcdhdr.clrText);
2589 SetBkColor(hdc, nmcdhdr.clrTextBk);
2590
2591 centery = (item->rect.top + item->rect.bottom) / 2;
2592
2593 /*
2594 * Display the images associated with this item
2595 */
2596 {
2597 INT imageIndex;
2598
2599 /* State images are displayed to the left of the Normal image
2600 * image number is in state; zero should be `display no image'.
2601 */
2602 imageIndex = STATEIMAGEINDEX(item->state);
2603
2604 if (infoPtr->himlState && imageIndex)
2605 {
2606 ImageList_Draw(infoPtr->himlState, imageIndex, hdc,
2607 item->stateOffset,
2608 centery - infoPtr->stateImageHeight / 2,
2609 ILD_NORMAL);
2610 }
2611
2612 /* Now, draw the normal image; can be either selected,
2613 * non-selected or expanded image.
2614 */
2615
2616 if ((item->state & TVIS_SELECTED) && (item->iSelectedImage >= 0))
2617 {
2618 /* The item is currently selected */
2619 imageIndex = item->iSelectedImage;
2620 }
2621 else if ((item->state & TVIS_EXPANDED) && (item->iExpandedImage != (WORD)I_IMAGENONE))
2622 {
2623 /* The item is currently not selected but expanded */
2624 imageIndex = item->iExpandedImage;
2625 }
2626 else
2627 {
2628 /* The item is not selected and not expanded */
2629 imageIndex = item->iImage;
2630 }
2631
2632 if (infoPtr->himlNormal)
2633 {
2634 UINT style = item->state & TVIS_CUT ? ILD_SELECTED : ILD_NORMAL;
2635
2636 style |= item->state & TVIS_OVERLAYMASK;
2637
2638 ImageList_DrawEx(infoPtr->himlNormal, imageIndex, hdc,
2639 item->imageOffset, centery - infoPtr->normalImageHeight / 2,
2640 0, 0,
2641 TREEVIEW_IsFullRowSelect(infoPtr) ? nmcdhdr.clrTextBk : infoPtr->clrBk,
2642 item->state & TVIS_CUT ? GETBKCOLOR(infoPtr->clrBk) : CLR_DEFAULT,
2643 style);
2644 }
2645 }
2646
2647
2648 /*
2649 * Display the text associated with this item
2650 */
2651
2652 /* Don't paint item's text if it's being edited */
2653 if (!infoPtr->hwndEdit || (infoPtr->selectedItem != item))
2654 {
2655 if (item->pszText)
2656 {
2657 RECT rcText;
2658 UINT align;
2659 SIZE sz;
2660
2661 rcText.top = item->rect.top;
2662 rcText.bottom = item->rect.bottom;
2663 rcText.left = item->textOffset;
2664 rcText.right = rcText.left + item->textWidth + 4;
2665
2666 TRACE("drawing text %s at (%s)\n",
2667 debugstr_w(item->pszText), wine_dbgstr_rect(&rcText));
2668
2669 /* Draw it */
2670 GetTextExtentPoint32W(hdc, item->pszText, lstrlenW(item->pszText), &sz);
2671
2672 align = SetTextAlign(hdc, TA_LEFT | TA_TOP);
2673 ExtTextOutW(hdc, rcText.left + 2, (rcText.top + rcText.bottom - sz.cy) / 2,
2674 ETO_CLIPPED | ETO_OPAQUE,
2675 &rcText,
2676 item->pszText,
2677 lstrlenW(item->pszText),
2678 NULL);
2679 SetTextAlign(hdc, align);
2680
2681 /* Draw focus box around the selected item */
2682 if ((item == infoPtr->selectedItem) && inFocus)
2683 {
2684 DrawFocusRect(hdc,&rcText);
2685 }
2686 }
2687 }
2688
2689 /* Draw insertion mark if necessary */
2690
2691 if (infoPtr->insertMarkItem)
2692 TRACE("item:%d,mark:%p\n",
2693 TREEVIEW_GetItemIndex(infoPtr, item),
2694 infoPtr->insertMarkItem);
2695
2696 if (item == infoPtr->insertMarkItem)
2697 {
2698 HPEN hNewPen, hOldPen;
2699 int offset;
2700 int left, right;
2701
2702 hNewPen = CreatePen(PS_SOLID, 2, GETINSCOLOR(infoPtr->clrInsertMark));
2703 hOldPen = SelectObject(hdc, hNewPen);
2704
2705 if (infoPtr->insertBeforeorAfter)
2706 offset = item->rect.bottom - 1;
2707 else
2708 offset = item->rect.top + 1;
2709
2710 left = item->textOffset - 2;
2711 right = item->textOffset + item->textWidth + 2;
2712
2713 MoveToEx(hdc, left, offset - 3, NULL);
2714 LineTo(hdc, left, offset + 4);
2715
2716 MoveToEx(hdc, left, offset, NULL);
2717 LineTo(hdc, right + 1, offset);
2718
2719 MoveToEx(hdc, right, offset + 3, NULL);
2720 LineTo(hdc, right, offset - 4);
2721
2722 SelectObject(hdc, hOldPen);
2723 DeleteObject(hNewPen);
2724 }
2725
2726 /* Restore the hdc state */
2727 SetTextColor(hdc, oldTextColor);
2728 SetBkColor(hdc, oldTextBkColor);
2729 SelectObject(hdc, hOldFont);
2730
2731 if (cditem & CDRF_NOTIFYPOSTPAINT)
2732 {
2733 cditem = TREEVIEW_SendCustomDrawItemNotify
2734 (infoPtr, hdc, item, CDDS_ITEMPOSTPAINT, &nmcdhdr);
2735 TRACE("postpaint:cditem-app returns 0x%x\n", cditem);
2736 }
2737 }
2738
2739 /* Computes treeHeight and treeWidth and updates the scroll bars.
2740 */
2741 static void
2742 TREEVIEW_UpdateScrollBars(TREEVIEW_INFO *infoPtr)
2743 {
2744 TREEVIEW_ITEM *item;
2745 HWND hwnd = infoPtr->hwnd;
2746 BOOL vert = FALSE;
2747 BOOL horz = FALSE;
2748 SCROLLINFO si;
2749 LONG scrollX = infoPtr->scrollX;
2750
2751 infoPtr->treeWidth = 0;
2752 infoPtr->treeHeight = 0;
2753
2754 /* We iterate through all visible items in order to get the tree height
2755 * and width */
2756 item = infoPtr->root->firstChild;
2757
2758 while (item != NULL)
2759 {
2760 if (ISVISIBLE(item))
2761 {
2762 /* actually we draw text at textOffset + 2 */
2763 if (2+item->textOffset+item->textWidth > infoPtr->treeWidth)
2764 infoPtr->treeWidth = item->textOffset+item->textWidth+2;
2765
2766 /* This is scroll-adjusted, but we fix this below. */
2767 infoPtr->treeHeight = item->rect.bottom;
2768 }
2769
2770 item = TREEVIEW_GetNextListItem(infoPtr, item);
2771 }
2772
2773 /* Fix the scroll adjusted treeHeight and treeWidth. */
2774 if (infoPtr->root->firstChild)
2775 infoPtr->treeHeight -= infoPtr->root->firstChild->rect.top;
2776
2777 infoPtr->treeWidth += infoPtr->scrollX;
2778
2779 if (infoPtr->dwStyle & TVS_NOSCROLL) return;
2780
2781 /* Adding one scroll bar may take up enough space that it forces us
2782 * to add the other as well. */
2783 if (infoPtr->treeHeight > infoPtr->clientHeight)
2784 {
2785 vert = TRUE;
2786
2787 if (infoPtr->treeWidth
2788 > infoPtr->clientWidth - GetSystemMetrics(SM_CXVSCROLL))
2789 horz = TRUE;
2790 }
2791 else if (infoPtr->treeWidth > infoPtr->clientWidth || infoPtr->scrollX > 0)
2792 horz = TRUE;
2793
2794 if (!vert && horz && infoPtr->treeHeight
2795 > infoPtr->clientHeight - GetSystemMetrics(SM_CYVSCROLL))
2796 vert = TRUE;
2797
2798 if (horz && (infoPtr->dwStyle & TVS_NOHSCROLL)) horz = FALSE;
2799
2800 si.cbSize = sizeof(SCROLLINFO);
2801 si.fMask = SIF_POS|SIF_RANGE|SIF_PAGE;
2802 si.nMin = 0;
2803
2804 if (vert)
2805 {
2806 si.nPage = TREEVIEW_GetVisibleCount(infoPtr);
2807 if ( si.nPage && NULL != infoPtr->firstVisible)
2808 {
2809 si.nPos = infoPtr->firstVisible->visibleOrder;
2810 si.nMax = infoPtr->maxVisibleOrder - 1;
2811
2812 SetScrollInfo(hwnd, SB_VERT, &si, TRUE);
2813
2814 if (!(infoPtr->uInternalStatus & TV_VSCROLL))
2815 ShowScrollBar(hwnd, SB_VERT, TRUE);
2816 infoPtr->uInternalStatus |= TV_VSCROLL;
2817 }
2818 else
2819 {
2820 if (infoPtr->uInternalStatus & TV_VSCROLL)
2821 ShowScrollBar(hwnd, SB_VERT, FALSE);
2822 infoPtr->uInternalStatus &= ~TV_VSCROLL;
2823 }
2824 }
2825 else
2826 {
2827 if (infoPtr->uInternalStatus & TV_VSCROLL)
2828 ShowScrollBar(hwnd, SB_VERT, FALSE);
2829 infoPtr->uInternalStatus &= ~TV_VSCROLL;
2830 }
2831
2832 if (horz)
2833 {
2834 si.nPage = infoPtr->clientWidth;
2835 si.nPos = infoPtr->scrollX;
2836 si.nMax = infoPtr->treeWidth - 1;
2837
2838 if (si.nPos > si.nMax - max( si.nPage-1, 0 ))
2839 {
2840 si.nPos = si.nMax - max( si.nPage-1, 0 );
2841 scrollX = si.nPos;
2842 }
2843
2844 if (!(infoPtr->uInternalStatus & TV_HSCROLL))
2845 ShowScrollBar(hwnd, SB_HORZ, TRUE);
2846 infoPtr->uInternalStatus |= TV_HSCROLL;
2847
2848 SetScrollInfo(hwnd, SB_HORZ, &si, TRUE);
2849 TREEVIEW_HScroll(infoPtr,
2850 MAKEWPARAM(SB_THUMBPOSITION, scrollX));
2851 }
2852 else
2853 {
2854 if (infoPtr->uInternalStatus & TV_HSCROLL)
2855 ShowScrollBar(hwnd, SB_HORZ, FALSE);
2856 infoPtr->uInternalStatus &= ~TV_HSCROLL;
2857
2858 scrollX = 0;
2859 if (infoPtr->scrollX != 0)
2860 {
2861 TREEVIEW_HScroll(infoPtr,
2862 MAKEWPARAM(SB_THUMBPOSITION, scrollX));
2863 }
2864 }
2865
2866 if (!horz)
2867 infoPtr->uInternalStatus &= ~TV_HSCROLL;
2868 }
2869
2870 static void
2871 TREEVIEW_FillBkgnd(const TREEVIEW_INFO *infoPtr, HDC hdc, const RECT *rc)
2872 {
2873 HBRUSH hBrush;
2874 COLORREF clrBk = GETBKCOLOR(infoPtr->clrBk);
2875
2876 hBrush = CreateSolidBrush(clrBk);
2877 FillRect(hdc, rc, hBrush);
2878 DeleteObject(hBrush);
2879 }
2880
2881 /* CtrlSpy doesn't mention this, but CorelDRAW's object manager needs it. */
2882 static LRESULT
2883 TREEVIEW_EraseBackground(const TREEVIEW_INFO *infoPtr, HDC hdc)
2884 {
2885 RECT rect;
2886
2887 TRACE("%p\n", infoPtr);
2888
2889 GetClientRect(infoPtr->hwnd, &rect);
2890 TREEVIEW_FillBkgnd(infoPtr, hdc, &rect);
2891
2892 return 1;
2893 }
2894
2895 static void
2896 TREEVIEW_Refresh(TREEVIEW_INFO *infoPtr, HDC hdc, const RECT *rc)
2897 {
2898 HWND hwnd = infoPtr->hwnd;
2899 RECT rect = *rc;
2900 TREEVIEW_ITEM *item;
2901 HTHEME theme;
2902
2903 if (infoPtr->clientHeight == 0 || infoPtr->clientWidth == 0)
2904 {
2905 TRACE("empty window\n");
2906 return;
2907 }
2908
2909 infoPtr->cdmode = TREEVIEW_SendCustomDrawNotify(infoPtr, CDDS_PREPAINT,
2910 hdc, rect);
2911
2912 if (infoPtr->cdmode == CDRF_SKIPDEFAULT)
2913 {
2914 ReleaseDC(hwnd, hdc);
2915 return;
2916 }
2917
2918 if (infoPtr->dwStyle & TVS_HASBUTTONS && (theme = GetWindowTheme(infoPtr->hwnd)))
2919 {
2920 if (IsThemeBackgroundPartiallyTransparent(theme, TVP_GLYPH, 0))
2921 DrawThemeParentBackground(infoPtr->hwnd, hdc, NULL);
2922 }
2923
2924 for (item = infoPtr->root->firstChild;
2925 item != NULL;
2926 item = TREEVIEW_GetNextListItem(infoPtr, item))
2927 {
2928 if (ISVISIBLE(item))
2929 {
2930 /* Avoid unneeded calculations */
2931 if (item->rect.top > rect.bottom)
2932 break;
2933 if (item->rect.bottom < rect.top)
2934 continue;
2935
2936 TREEVIEW_DrawItem(infoPtr, hdc, item);
2937 }
2938 }
2939
2940 TREEVIEW_UpdateScrollBars(infoPtr);
2941
2942 if (infoPtr->cdmode & CDRF_NOTIFYPOSTPAINT)
2943 infoPtr->cdmode =
2944 TREEVIEW_SendCustomDrawNotify(infoPtr, CDDS_POSTPAINT, hdc, rect);
2945 }
2946
2947 static inline void
2948 TREEVIEW_InvalidateItem(const TREEVIEW_INFO *infoPtr, const TREEVIEW_ITEM *item)
2949 {
2950 if (item) InvalidateRect(infoPtr->hwnd, &item->rect, TRUE);
2951 }
2952
2953 static void
2954 TREEVIEW_Invalidate(const TREEVIEW_INFO *infoPtr, const TREEVIEW_ITEM *item)
2955 {
2956 if (item)
2957 InvalidateRect(infoPtr->hwnd, &item->rect, TRUE);
2958 else
2959 InvalidateRect(infoPtr->hwnd, NULL, TRUE);
2960 }
2961
2962 static BOOL TREEVIEW_InitThemedCheckboxes(TREEVIEW_INFO *info)
2963 {
2964 HBITMAP bitmap, old_bitmap;
2965 HDC hdc, hdc_screen;
2966 HTHEME theme;
2967 RECT rect;
2968 SIZE size;
2969
2970 if (!GetWindowTheme(info->hwnd))
2971 return FALSE;
2972
2973 theme = OpenThemeDataForDpi(NULL, L"Button", GetDpiForWindow(info->hwnd));
2974 if (!theme)
2975 return FALSE;
2976
2977 hdc_screen = GetDC(0);
2978 hdc = CreateCompatibleDC(hdc_screen);
2979 GetThemePartSize(theme, hdc, BP_CHECKBOX, 0, NULL, TS_DRAW, &size);
2980 bitmap = CreateCompatibleBitmap(hdc_screen, size.cx * 3, size.cy);
2981 old_bitmap = SelectObject(hdc, bitmap);
2982
2983 SetRect(&rect, 0, 0, size.cx * 3, size.cy);
2984 FillRect(hdc, &rect, (HBRUSH)(COLOR_WINDOW + 1));
2985
2986 rect.left = size.cx;
2987 rect.right = rect.left + size.cx;
2988 DrawThemeBackground(theme, hdc, BP_CHECKBOX, CBS_UNCHECKEDNORMAL, &rect, NULL);
2989
2990 rect.left = size.cx * 2;
2991 rect.right = rect.left + size.cx;
2992 DrawThemeBackground(theme, hdc, BP_CHECKBOX, CBS_CHECKEDNORMAL, &rect, NULL);
2993
2994 SelectObject(hdc, old_bitmap);
2995 info->himlState = ImageList_Create(size.cx, size.cy, ILC_COLOR32, 3, 0);
2996 ImageList_Add(info->himlState, bitmap, NULL);
2997
2998 DeleteObject(bitmap);
2999 DeleteDC(hdc);
3000 ReleaseDC(0, hdc_screen);
3001 CloseThemeData(theme);
3002
3003 info->stateImageWidth = size.cx;
3004 info->stateImageHeight = size.cy;
3005 return TRUE;
3006 }
3007
3008 static void
3009 TREEVIEW_InitCheckboxes(TREEVIEW_INFO *infoPtr)
3010 {
3011 int nIndex, width, height;
3012 RECT rc;
3013 HBITMAP hbm, hbmOld;
3014 HDC hdc, hdcScreen;
3015
3016 if (TREEVIEW_InitThemedCheckboxes(infoPtr))
3017 return;
3018
3019 width = 12 * GetDpiForWindow(infoPtr->hwnd) / 96 + 1;
3020 height = width;
3021 infoPtr->himlState = ImageList_Create(width, height, ILC_COLOR | ILC_MASK, 3, 0);
3022
3023 hdcScreen = GetDC(0);
3024
3025 hdc = CreateCompatibleDC(hdcScreen);
3026 hbm = CreateCompatibleBitmap(hdcScreen, width * 3, height);
3027 hbmOld = SelectObject(hdc, hbm);
3028
3029 SetRect(&rc, 0, 0, width * 3, height);
3030 FillRect(hdc, &rc, (HBRUSH)(COLOR_WINDOW+1));
3031
3032 rc.left = width;
3033 rc.right = rc.left + width;
3034 DrawFrameControl(hdc, &rc, DFC_BUTTON, DFCS_BUTTONCHECK | DFCS_MONO);
3035
3036 rc.left = width * 2;
3037 rc.right = rc.left + width;
3038 DrawFrameControl(hdc, &rc, DFC_BUTTON, DFCS_BUTTONCHECK | DFCS_MONO | DFCS_CHECKED);
3039
3040 SelectObject(hdc, hbmOld);
3041 nIndex = ImageList_AddMasked(infoPtr->himlState, hbm,
3042 comctl32_color.clrWindow);
3043 TRACE("checkbox index %d\n", nIndex);
3044
3045 DeleteObject(hbm);
3046 DeleteDC(hdc);
3047 ReleaseDC(0, hdcScreen);
3048
3049 infoPtr->stateImageWidth = width;
3050 infoPtr->stateImageHeight = height;
3051 }
3052
3053 static void
3054 TREEVIEW_ResetImageStateIndex(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *item)
3055 {
3056 TREEVIEW_ITEM *child = item->firstChild;
3057
3058 item->state &= ~TVIS_STATEIMAGEMASK;
3059 item->state |= INDEXTOSTATEIMAGEMASK(1);
3060
3061 while (child)
3062 {
3063 TREEVIEW_ITEM *next = child->nextSibling;
3064 TREEVIEW_ResetImageStateIndex(infoPtr, child);
3065 child = next;
3066 }
3067 }
3068
3069 static LRESULT
3070 TREEVIEW_Paint(TREEVIEW_INFO *infoPtr, HDC hdc_ref)
3071 {
3072 HDC hdc;
3073 PAINTSTRUCT ps;
3074 RECT rc;
3075
3076 TRACE("(%p %p)\n", infoPtr, hdc_ref);
3077
3078 if ((infoPtr->dwStyle & TVS_CHECKBOXES) && !infoPtr->himlState)
3079 {
3080 TREEVIEW_InitCheckboxes(infoPtr);
3081 TREEVIEW_ResetImageStateIndex(infoPtr, infoPtr->root);
3082
3083 TREEVIEW_EndEditLabelNow(infoPtr, TRUE);
3084 TREEVIEW_UpdateSubTree(infoPtr, infoPtr->root);
3085 TREEVIEW_UpdateScrollBars(infoPtr);
3086 TREEVIEW_Invalidate(infoPtr, NULL);
3087 }
3088
3089 if (hdc_ref)
3090 {
3091 hdc = hdc_ref;
3092 GetClientRect(infoPtr->hwnd, &rc);
3093 TREEVIEW_FillBkgnd(infoPtr, hdc, &rc);
3094 }
3095 else
3096 {
3097 hdc = BeginPaint(infoPtr->hwnd, &ps);
3098 rc = ps.rcPaint;
3099 if(ps.fErase)
3100 TREEVIEW_FillBkgnd(infoPtr, hdc, &rc);
3101 }
3102
3103 if(infoPtr->bRedraw) /* WM_SETREDRAW sets bRedraw */
3104 TREEVIEW_Refresh(infoPtr, hdc, &rc);
3105
3106 if (!hdc_ref)
3107 EndPaint(infoPtr->hwnd, &ps);
3108
3109 return 0;
3110 }
3111
3112 static LRESULT
3113 TREEVIEW_PrintClient(TREEVIEW_INFO *infoPtr, HDC hdc, DWORD options)
3114 {
3115 RECT rc;
3116
3117 FIXME("Partial Stub: (hdc=%p options=%#lx)\n", hdc, options);
3118
3119 TREEVIEW_EraseBackground(infoPtr, hdc);
3120 GetClientRect(infoPtr->hwnd, &rc);
3121 TREEVIEW_Refresh(infoPtr, hdc, &rc);
3122
3123 return 0;
3124 }
3125
3126 /* Sorting **************************************************************/
3127
3128 /***************************************************************************
3129 * Forward the DPA local callback to the treeview owner callback
3130 */
3131 static INT WINAPI
3132 TREEVIEW_CallBackCompare(const TREEVIEW_ITEM *first, const TREEVIEW_ITEM *second,
3133 const TVSORTCB *pCallBackSort)
3134 {
3135 /* Forward the call to the client-defined callback */
3136 return pCallBackSort->lpfnCompare(first->lParam,
3137 second->lParam,
3138 pCallBackSort->lParam);
3139 }
3140
3141 /***************************************************************************
3142 * Treeview native sort routine: sort on item text.
3143 */
3144 static INT WINAPI
3145 TREEVIEW_SortOnName(TREEVIEW_ITEM *first, TREEVIEW_ITEM *second,
3146 const TREEVIEW_INFO *infoPtr)
3147 {
3148 TREEVIEW_UpdateDispInfo(infoPtr, first, TVIF_TEXT);
3149 TREEVIEW_UpdateDispInfo(infoPtr, second, TVIF_TEXT);
3150
3151 if(first->pszText && second->pszText)
3152 return lstrcmpiW(first->pszText, second->pszText);
3153 else if(first->pszText)
3154 return -1;
3155 else if(second->pszText)
3156 return 1;
3157 else
3158 return 0;
3159 }
3160
3161 /* Returns the number of physical children belonging to item. */
3162 static INT
3163 TREEVIEW_CountChildren(const TREEVIEW_ITEM *item)
3164 {
3165 INT cChildren = 0;
3166 HTREEITEM hti;
3167
3168 for (hti = item->firstChild; hti != NULL; hti = hti->nextSibling)
3169 cChildren++;
3170
3171 return cChildren;
3172 }
3173
3174 /* Returns a DPA containing a pointer to each physical child of item in
3175 * sibling order. If item has no children, an empty DPA is returned. */
3176 static HDPA
3177 TREEVIEW_BuildChildDPA(const TREEVIEW_ITEM *item)
3178 {
3179 HTREEITEM child;
3180
3181 HDPA list = DPA_Create(8);
3182 if (list == 0) return NULL;
3183
3184 for (child = item->firstChild; child != NULL; child = child->nextSibling)
3185 {
3186 if (DPA_InsertPtr(list, INT_MAX, child) == -1)
3187 {
3188 DPA_Destroy(list);
3189 return NULL;
3190 }
3191 }
3192
3193 return list;
3194 }
3195
3196 /***************************************************************************
3197 * Setup the treeview structure with regards of the sort method
3198 * and sort the children of the TV item specified in lParam
3199 * fRecurse: currently unused. Should be zero.
3200 * parent: if pSort!=NULL, should equal pSort->hParent.
3201 * otherwise, item which child items are to be sorted.
3202 * pSort: sort method info. if NULL, sort on item text.
3203 * if non-NULL, sort on item's lParam content, and let the
3204 * application decide what that means. See also TVM_SORTCHILDRENCB.
3205 */
3206
3207 static LRESULT
3208 TREEVIEW_Sort(TREEVIEW_INFO *infoPtr, HTREEITEM parent,
3209 LPTVSORTCB pSort)
3210 {
3211 INT cChildren;
3212 PFNDPACOMPARE pfnCompare;
3213 LPARAM lpCompare;
3214
3215 /* undocumented feature: TVI_ROOT or NULL means `sort the whole tree' */
3216 if (parent == TVI_ROOT || parent == NULL)
3217 parent = infoPtr->root;
3218
3219 /* Check for a valid handle to the parent item */
3220 if (!TREEVIEW_ValidItem(infoPtr, parent))
3221 {
3222 ERR("invalid item hParent=%p\n", parent);
3223 return FALSE;
3224 }
3225
3226 if (pSort)
3227 {
3228 pfnCompare = (PFNDPACOMPARE)TREEVIEW_CallBackCompare;
3229 lpCompare = (LPARAM)pSort;
3230 }
3231 else
3232 {
3233 pfnCompare = (PFNDPACOMPARE)TREEVIEW_SortOnName;
3234 lpCompare = (LPARAM)infoPtr;
3235 }
3236
3237 cChildren = TREEVIEW_CountChildren(parent);
3238
3239 /* Make sure there is something to sort */
3240 if (cChildren > 1)
3241 {
3242 /* TREEVIEW_ITEM rechaining */
3243 INT count = 0;
3244 HTREEITEM item = 0;
3245 HTREEITEM nextItem = 0;
3246 HTREEITEM prevItem = 0;
3247
3248 HDPA sortList = TREEVIEW_BuildChildDPA(parent);
3249
3250 if (sortList == NULL)
3251 return FALSE;
3252
3253 /* let DPA sort the list */
3254 DPA_Sort(sortList, pfnCompare, lpCompare);
3255
3256 /* The order of DPA entries has been changed, so fixup the
3257 * nextSibling and prevSibling pointers. */
3258
3259 item = DPA_GetPtr(sortList, count++);
3260 while ((nextItem = DPA_GetPtr(sortList, count++)) != NULL)
3261 {
3262 /* link the two current item together */
3263 item->nextSibling = nextItem;
3264 nextItem->prevSibling = item;
3265
3266 if (prevItem == NULL)
3267 {
3268 /* this is the first item, update the parent */
3269 parent->firstChild = item;
3270 item->prevSibling = NULL;
3271 }
3272 else
3273 {
3274 /* fix the back chaining */
3275 item->prevSibling = prevItem;
3276 }
3277
3278 /* get ready for the next one */
3279 prevItem = item;
3280 item = nextItem;
3281 }
3282
3283 /* the last item is pointed to by item and never has a sibling */
3284 item->nextSibling = NULL;
3285 parent->lastChild = item;
3286
3287 DPA_Destroy(sortList);
3288
3289 TREEVIEW_VerifyTree(infoPtr);
3290
3291 if (parent->state & TVIS_EXPANDED)
3292 {
3293 int visOrder = infoPtr->firstVisible->visibleOrder;
3294
3295 if (parent == infoPtr->root)
3296 TREEVIEW_RecalculateVisibleOrder(infoPtr, NULL);
3297 else
3298 TREEVIEW_RecalculateVisibleOrder(infoPtr, parent);
3299
3300 if (TREEVIEW_IsChildOf(parent, infoPtr->firstVisible))
3301 {
3302 TREEVIEW_ITEM *item;
3303
3304 for (item = infoPtr->root->firstChild; item != NULL;
3305 item = TREEVIEW_GetNextListItem(infoPtr, item))
3306 {
3307 if (item->visibleOrder == visOrder)
3308 break;
3309 }
3310
3311 if (!item) item = parent->firstChild;
3312 TREEVIEW_SetFirstVisible(infoPtr, item, FALSE);
3313 }
3314
3315 TREEVIEW_Invalidate(infoPtr, NULL);
3316 }
3317
3318 return TRUE;
3319 }
3320 return FALSE;
3321 }
3322
3323
3324 /***************************************************************************
3325 * Setup the treeview structure with regards of the sort method
3326 * and sort the children of the TV item specified in lParam
3327 */
3328 static LRESULT
3329 TREEVIEW_SortChildrenCB(TREEVIEW_INFO *infoPtr, LPTVSORTCB pSort)
3330 {
3331 return TREEVIEW_Sort(infoPtr, pSort->hParent, pSort);
3332 }
3333
3334
3335 /***************************************************************************
3336 * Sort the children of the TV item specified in lParam.
3337 */
3338 static LRESULT
3339 TREEVIEW_SortChildren(TREEVIEW_INFO *infoPtr, LPARAM lParam)
3340 {
3341 return TREEVIEW_Sort(infoPtr, (HTREEITEM)lParam, NULL);
3342 }
3343
3344
3345 /* Expansion/Collapse ***************************************************/
3346
3347 static BOOL
3348 TREEVIEW_SendExpanding(const TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *item,
3349 UINT action)
3350 {
3351 return !TREEVIEW_SendTreeviewNotify(infoPtr, TVN_ITEMEXPANDINGW, action,
3352 TVIF_HANDLE | TVIF_STATE | TVIF_PARAM
3353 | TVIF_IMAGE | TVIF_SELECTEDIMAGE,
3354 0, item);
3355 }
3356
3357 static VOID
3358 TREEVIEW_SendExpanded(const TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *item,
3359 UINT action)
3360 {
3361 TREEVIEW_SendTreeviewNotify(infoPtr, TVN_ITEMEXPANDEDW, action,
3362 TVIF_HANDLE | TVIF_STATE | TVIF_PARAM
3363 | TVIF_IMAGE | TVIF_SELECTEDIMAGE,
3364 0, item);
3365 }
3366
3367
3368 /* This corresponds to TVM_EXPAND with TVE_COLLAPSE.
3369 * bRemoveChildren corresponds to TVE_COLLAPSERESET. */
3370 static BOOL
3371 TREEVIEW_Collapse(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *item,
3372 BOOL bRemoveChildren, BOOL bUser)
3373 {
3374 UINT action = TVE_COLLAPSE | (bRemoveChildren ? TVE_COLLAPSERESET : 0);
3375 BOOL bSetSelection, bSetFirstVisible;
3376 RECT scrollRect;
3377 LONG scrollDist = 0;
3378 TREEVIEW_ITEM *nextItem = NULL, *tmpItem;
3379 BOOL wasExpanded;
3380
3381 TRACE("TVE_COLLAPSE %p %s\n", item, TREEVIEW_ItemName(item));
3382
3383 if (!TREEVIEW_HasChildren(infoPtr, item))
3384 return FALSE;
3385
3386 if (bUser)
3387 TREEVIEW_SendExpanding(infoPtr, item, action);
3388
3389 if (item->firstChild == NULL)
3390 return FALSE;
3391
3392 wasExpanded = (item->state & TVIS_EXPANDED) != 0;
3393 item->state &= ~TVIS_EXPANDED;
3394
3395 if (wasExpanded && bUser)
3396 TREEVIEW_SendExpanded(infoPtr, item, action);
3397
3398 bSetSelection = (infoPtr->selectedItem != NULL
3399 && TREEVIEW_IsChildOf(item, infoPtr->selectedItem));
3400
3401 bSetFirstVisible = (infoPtr->firstVisible != NULL
3402 && TREEVIEW_IsChildOf(item, infoPtr->firstVisible));
3403
3404 tmpItem = item;
3405 while (tmpItem)
3406 {
3407 if (tmpItem->nextSibling)
3408 {
3409 nextItem = tmpItem->nextSibling;
3410 break;
3411 }
3412 tmpItem = tmpItem->parent;
3413 }
3414
3415 if (nextItem)
3416 scrollDist = nextItem->rect.top;
3417
3418 if (bRemoveChildren)
3419 {
3420 INT old_cChildren = item->cChildren;
3421 TRACE("TVE_COLLAPSERESET\n");
3422 item->state &= ~TVIS_EXPANDEDONCE;
3423 TREEVIEW_RemoveAllChildren(infoPtr, item);
3424 item->cChildren = old_cChildren;
3425 }
3426 if (!wasExpanded)
3427 return FALSE;
3428
3429 if (item->firstChild)
3430 {
3431 TREEVIEW_ITEM *i, *sibling;
3432
3433 sibling = TREEVIEW_GetNextListItem(infoPtr, item);
3434
3435 for (i = item->firstChild; i != sibling;
3436 i = TREEVIEW_GetNextListItem(infoPtr, i))
3437 {
3438 i->visibleOrder = -1;
3439 }
3440 }
3441
3442 TREEVIEW_RecalculateVisibleOrder(infoPtr, item);
3443
3444 if (nextItem)
3445 scrollDist = -(scrollDist - nextItem->rect.top);
3446
3447 if (bSetSelection)
3448 {
3449 /* Don't call DoSelectItem, it sends notifications. */
3450 if (TREEVIEW_ValidItem(infoPtr, infoPtr->selectedItem))
3451 infoPtr->selectedItem->state &= ~TVIS_SELECTED;
3452 item->state |= TVIS_SELECTED;
3453 infoPtr->selectedItem = item;
3454 }
3455
3456 TREEVIEW_UpdateScrollBars(infoPtr);
3457
3458 scrollRect.left = 0;
3459 scrollRect.right = infoPtr->clientWidth;
3460 scrollRect.bottom = infoPtr->clientHeight;
3461
3462 if (nextItem)
3463 {
3464 scrollRect.top = nextItem->rect.top;
3465
3466 ScrollWindowEx (infoPtr->hwnd, 0, scrollDist, &scrollRect, &scrollRect,
3467 NULL, NULL, SW_ERASE | SW_INVALIDATE);
3468 TREEVIEW_Invalidate(infoPtr, item);
3469 } else {
3470 scrollRect.top = item->rect.top;
3471 InvalidateRect(infoPtr->hwnd, &scrollRect, TRUE);
3472 }
3473
3474 TREEVIEW_SetFirstVisible(infoPtr,
3475 bSetFirstVisible ? item : infoPtr->firstVisible,
3476 TRUE);
3477
3478 return wasExpanded;
3479 }
3480
3481 static BOOL
3482 TREEVIEW_Expand(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *item,
3483 BOOL partial, BOOL user)
3484 {
3485 LONG scrollDist;
3486 LONG orgNextTop = 0;
3487 RECT scrollRect;
3488 TREEVIEW_ITEM *nextItem, *tmpItem;
3489 BOOL sendsNotifications;
3490
3491 TRACE("(%p, %p, partial=%d, %d)\n", infoPtr, item, partial, user);
3492
3493 if (!TREEVIEW_HasChildren(infoPtr, item))
3494 return FALSE;
3495
3496 tmpItem = item; nextItem = NULL;
3497 while (tmpItem)
3498 {
3499 if (tmpItem->nextSibling)
3500 {
3501 nextItem = tmpItem->nextSibling;
3502 break;
3503 }
3504 tmpItem = tmpItem->parent;
3505 }
3506
3507 if (nextItem)
3508 orgNextTop = nextItem->rect.top;
3509
3510 TRACE("TVE_EXPAND %p %s\n", item, TREEVIEW_ItemName(item));
3511
3512 sendsNotifications = user || ((item->cChildren != 0) &&
3513 !(item->state & TVIS_EXPANDEDONCE));
3514 if (sendsNotifications)
3515 {
3516 if (!TREEVIEW_SendExpanding(infoPtr, item, TVE_EXPAND))
3517 {
3518 TRACE(" TVN_ITEMEXPANDING returned TRUE, exiting...\n");
3519 return FALSE;
3520 }
3521 }
3522 if (!item->firstChild)
3523 return FALSE;
3524
3525 item->state |= TVIS_EXPANDED;
3526
3527 if (partial)
3528 FIXME("TVE_EXPANDPARTIAL not implemented\n");
3529
3530 if (ISVISIBLE(item))
3531 {
3532 TREEVIEW_RecalculateVisibleOrder(infoPtr, item);
3533 TREEVIEW_UpdateSubTree(infoPtr, item);
3534 TREEVIEW_UpdateScrollBars(infoPtr);
3535
3536 scrollRect.left = 0;
3537 scrollRect.bottom = infoPtr->treeHeight;
3538 scrollRect.right = infoPtr->clientWidth;
3539 if (nextItem)
3540 {
3541 scrollDist = nextItem->rect.top - orgNextTop;
3542 scrollRect.top = orgNextTop;
3543
3544 ScrollWindowEx (infoPtr->hwnd, 0, scrollDist, &scrollRect, NULL,
3545 NULL, NULL, SW_ERASE | SW_INVALIDATE);
3546 TREEVIEW_Invalidate (infoPtr, item);
3547 } else {
3548 scrollRect.top = item->rect.top;
3549 InvalidateRect(infoPtr->hwnd, &scrollRect, FALSE);
3550 }
3551
3552 /* Scroll up so that as many children as possible are visible.
3553 * This fails when expanding causes an HScroll bar to appear, but we
3554 * don't know that yet, so the last item is obscured. */
3555 if (item->firstChild != NULL)
3556 {
3557 int nChildren = item->lastChild->visibleOrder
3558 - item->firstChild->visibleOrder + 1;
3559
3560 int visible_pos = item->visibleOrder
3561 - infoPtr->firstVisible->visibleOrder;
3562
3563 int rows_below = TREEVIEW_GetVisibleCount(infoPtr) - visible_pos - 1;
3564
3565 if (visible_pos > 0 && nChildren > rows_below)
3566 {
3567 int scroll = nChildren - rows_below;
3568
3569 if (scroll > visible_pos)
3570 scroll = visible_pos;
3571
3572 if (scroll > 0)
3573 {
3574 TREEVIEW_ITEM *newFirstVisible
3575 = TREEVIEW_GetListItem(infoPtr, infoPtr->firstVisible,
3576 scroll);
3577
3578
3579 TREEVIEW_SetFirstVisible(infoPtr, newFirstVisible, TRUE);
3580 }
3581 }
3582 }
3583 }
3584
3585 if (sendsNotifications) {
3586 TREEVIEW_SendExpanded(infoPtr, item, TVE_EXPAND);
3587 item->state |= TVIS_EXPANDEDONCE;
3588 }
3589
3590 return TRUE;
3591 }
3592
3593 /* Handler for TVS_SINGLEEXPAND behaviour. Used on response
3594 to mouse messages and TVM_SELECTITEM.
3595
3596 selection - previously selected item, used to collapse a part of a tree
3597 item - new selected item
3598 */
3599 static void TREEVIEW_SingleExpand(TREEVIEW_INFO *infoPtr,
3600 HTREEITEM selection, HTREEITEM item)
3601 {
3602 TREEVIEW_ITEM *prev, *curr;
3603
3604 if ((infoPtr->dwStyle & TVS_SINGLEEXPAND) == 0 || infoPtr->hwndEdit || !item) return;
3605
3606 TREEVIEW_SendTreeviewNotify(infoPtr, TVN_SINGLEEXPAND, TVC_UNKNOWN, TVIF_HANDLE | TVIF_PARAM, item, 0);
3607
3608 /*
3609 * Close the previous item and its ancestors as long as they are not
3610 * ancestors of the current item
3611 */
3612 for (prev = selection; prev && TREEVIEW_ValidItem(infoPtr, prev); prev = prev->parent)
3613 {
3614 for (curr = item; curr && TREEVIEW_ValidItem(infoPtr, curr); curr = curr->parent)
3615 {
3616 if (curr == prev)
3617 goto finish;
3618 }
3619 TREEVIEW_Collapse(infoPtr, prev, FALSE, TRUE);
3620 }
3621
3622 finish:
3623 /*
3624 * Expand the current item
3625 */
3626 TREEVIEW_Expand(infoPtr, item, FALSE, TRUE);
3627 }
3628
3629 static BOOL
3630 TREEVIEW_Toggle(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *item, BOOL user)
3631 {
3632 TRACE("item=%p, user=%d\n", item, user);
3633
3634 if (item->state & TVIS_EXPANDED)
3635 return TREEVIEW_Collapse(infoPtr, item, FALSE, user);
3636 else
3637 return TREEVIEW_Expand(infoPtr, item, FALSE, user);
3638 }
3639
3640 static VOID
3641 TREEVIEW_ExpandAll(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *item)
3642 {
3643 TREEVIEW_Expand(infoPtr, item, FALSE, TRUE);
3644
3645 for (item = item->firstChild; item != NULL; item = item->nextSibling)
3646 {
3647 if (TREEVIEW_HasChildren(infoPtr, item))
3648 TREEVIEW_ExpandAll(infoPtr, item);
3649 }
3650 }
3651
3652 /* Note:If the specified item is the child of a collapsed parent item,
3653 the parent's list of child items is (recursively) expanded to reveal the
3654 specified item. This is mentioned for TREEVIEW_SelectItem; don't
3655 know if it also applies here.
3656 */
3657
3658 static LRESULT
3659 TREEVIEW_ExpandMsg(TREEVIEW_INFO *infoPtr, UINT flag, HTREEITEM item)
3660 {
3661 if (!TREEVIEW_ValidItem(infoPtr, item))
3662 return 0;
3663
3664 TRACE("For (%s) item:%d, flags 0x%x, state:%d\n",
3665 TREEVIEW_ItemName(item), TREEVIEW_GetItemIndex(infoPtr, item),
3666 flag, item->state);
3667
3668 switch (flag & TVE_TOGGLE)
3669 {
3670 case TVE_COLLAPSE:
3671 return TREEVIEW_Collapse(infoPtr, item, flag & TVE_COLLAPSERESET,
3672 FALSE);
3673
3674 case TVE_EXPAND:
3675 return TREEVIEW_Expand(infoPtr, item, flag & TVE_EXPANDPARTIAL,
3676 FALSE);
3677
3678 case TVE_TOGGLE:
3679 return TREEVIEW_Toggle(infoPtr, item, FALSE);
3680
3681 default:
3682 return 0;
3683 }
3684 }
3685
3686 /* Hit-Testing **********************************************************/
3687
3688 static TREEVIEW_ITEM *
3689 TREEVIEW_HitTestPoint(const TREEVIEW_INFO *infoPtr, POINT pt)
3690 {
3691 TREEVIEW_ITEM *item;
3692 LONG row;
3693
3694 if (!infoPtr->firstVisible)
3695 return NULL;
3696
3697 row = pt.y / infoPtr->uItemHeight + infoPtr->firstVisible->visibleOrder;
3698
3699 for (item = infoPtr->firstVisible; item != NULL;
3700 item = TREEVIEW_GetNextListItem(infoPtr, item))
3701 {
3702 if (row >= item->visibleOrder
3703 && row < item->visibleOrder + item->iIntegral)
3704 break;
3705 }
3706
3707 return item;
3708 }
3709
3710 static TREEVIEW_ITEM *
3711 TREEVIEW_HitTest(const TREEVIEW_INFO *infoPtr, LPTVHITTESTINFO lpht)
3712 {
3713 TREEVIEW_ITEM *item;
3714 RECT rect;
3715 UINT status;
3716 LONG x, y;
3717
3718 lpht->hItem = 0;
3719 GetClientRect(infoPtr->hwnd, &rect);
3720 status = 0;
3721 x = lpht->pt.x;
3722 y = lpht->pt.y;
3723
3724 if (x < rect.left)
3725 {
3726 status |= TVHT_TOLEFT;
3727 }
3728 else if (x > rect.right)
3729 {
3730 status |= TVHT_TORIGHT;
3731 }
3732
3733 if (y < rect.top)
3734 {
3735 status |= TVHT_ABOVE;
3736 }
3737 else if (y > rect.bottom)
3738 {
3739 status |= TVHT_BELOW;
3740 }
3741
3742 if (status)
3743 {
3744 lpht->flags = status;
3745 return NULL;
3746 }
3747
3748 item = TREEVIEW_HitTestPoint(infoPtr, lpht->pt);
3749 if (!item)
3750 {
3751 lpht->flags = TVHT_NOWHERE;
3752 return NULL;
3753 }
3754
3755 if (!item->textWidth)
3756 TREEVIEW_ComputeTextWidth(infoPtr, item, 0);
3757
3758 if (x >= item->textOffset + item->textWidth)
3759 {
3760 lpht->flags = TVHT_ONITEMRIGHT;
3761 }
3762 else if (x >= item->textOffset)
3763 {
3764 lpht->flags = TVHT_ONITEMLABEL;
3765 }
3766 else if (x >= item->imageOffset)
3767 {
3768 lpht->flags = TVHT_ONITEMICON;
3769 }
3770 else if (x >= item->stateOffset)
3771 {
3772 lpht->flags = TVHT_ONITEMSTATEICON;
3773 }
3774 else if (x >= item->linesOffset && infoPtr->dwStyle & TVS_HASBUTTONS)
3775 {
3776 lpht->flags = TVHT_ONITEMBUTTON;
3777 }
3778 else
3779 {
3780 lpht->flags = TVHT_ONITEMINDENT;
3781 }
3782
3783 lpht->hItem = item;
3784 TRACE("(%ld, %ld) : result 0x%x\n", lpht->pt.x, lpht->pt.y, lpht->flags);
3785
3786 return item;
3787 }
3788
3789 /* Item Label Editing ***************************************************/
3790
3791 static LRESULT
3792 TREEVIEW_GetEditControl(const TREEVIEW_INFO *infoPtr)
3793 {
3794 return (LRESULT)infoPtr->hwndEdit;
3795 }
3796
3797 static LRESULT CALLBACK
3798 TREEVIEW_Edit_SubclassProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
3799 {
3800 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(GetParent(hwnd));
3801 BOOL bCancel = FALSE;
3802 LRESULT rc;
3803
3804 switch (uMsg)
3805 {
3806 case WM_PAINT:
3807 TRACE("WM_PAINT start\n");
3808 rc = CallWindowProcW(infoPtr->wpEditOrig, hwnd, uMsg, wParam,
3809 lParam);
3810 TRACE("WM_PAINT done\n");
3811 return rc;
3812
3813 case WM_KILLFOCUS:
3814 if (infoPtr->bIgnoreEditKillFocus)
3815 return TRUE;
3816 break;
3817
3818 case WM_DESTROY:
3819 {
3820 WNDPROC editProc = infoPtr->wpEditOrig;
3821 infoPtr->wpEditOrig = 0;
3822 SetWindowLongPtrW(hwnd, GWLP_WNDPROC, (DWORD_PTR)editProc);
3823 return CallWindowProcW(editProc, hwnd, uMsg, wParam, lParam);
3824 }
3825
3826 case WM_GETDLGCODE:
3827 return DLGC_WANTARROWS | DLGC_WANTALLKEYS;
3828
3829 case WM_KEYDOWN:
3830 if (wParam == VK_ESCAPE)
3831 {
3832 bCancel = TRUE;
3833 break;
3834 }
3835 else if (wParam == VK_RETURN)
3836 {
3837 break;
3838 }
3839
3840 /* fall through */
3841 default:
3842 return CallWindowProcW(infoPtr->wpEditOrig, hwnd, uMsg, wParam, lParam);
3843 }
3844
3845 /* Processing TVN_ENDLABELEDIT message could kill the focus */
3846 /* eg. Using a messagebox */
3847
3848 infoPtr->bIgnoreEditKillFocus = TRUE;
3849 TREEVIEW_EndEditLabelNow(infoPtr, bCancel || !infoPtr->bLabelChanged);
3850 infoPtr->bIgnoreEditKillFocus = FALSE;
3851
3852 return 0;
3853 }
3854
3855
3856 /* should handle edit control messages here */
3857
3858 static LRESULT
3859 TREEVIEW_Command(TREEVIEW_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
3860 {
3861 TRACE("code 0x%x, id=0x%x, handle %Ix\n", HIWORD(wParam), LOWORD(wParam), lParam);
3862
3863 switch (HIWORD(wParam))
3864 {
3865 case EN_UPDATE:
3866 {
3867 /*
3868 * Adjust the edit window size
3869 */
3870 WCHAR buffer[1024];
3871 TREEVIEW_ITEM *editItem = infoPtr->editItem;
3872 HDC hdc = GetDC(infoPtr->hwndEdit);
3873 SIZE sz;
3874 HFONT hFont, hOldFont = 0;
3875
3876 TRACE("edit=%p\n", infoPtr->hwndEdit);
3877
3878 if (!IsWindow(infoPtr->hwndEdit) || !hdc) return FALSE;
3879
3880 infoPtr->bLabelChanged = TRUE;
3881
3882 GetWindowTextW(infoPtr->hwndEdit, buffer, ARRAY_SIZE(buffer));
3883
3884 /* Select font to get the right dimension of the string */
3885 hFont = (HFONT)SendMessageW(infoPtr->hwndEdit, WM_GETFONT, 0, 0);
3886
3887 if (hFont != 0)
3888 {
3889 hOldFont = SelectObject(hdc, hFont);
3890 }
3891
3892 if (GetTextExtentPoint32W(hdc, buffer, lstrlenW(buffer), &sz))
3893 {
3894 TEXTMETRICW textMetric;
3895
3896 /* Add Extra spacing for the next character */
3897 GetTextMetricsW(hdc, &textMetric);
3898 sz.cx += (textMetric.tmMaxCharWidth * 2);
3899
3900 sz.cx = max(sz.cx, textMetric.tmMaxCharWidth * 3);
3901 sz.cx = min(sz.cx,
3902 infoPtr->clientWidth - editItem->textOffset + 2);
3903
3904 SetWindowPos(infoPtr->hwndEdit,
3905 HWND_TOP,
3906 0,
3907 0,
3908 sz.cx,
3909 editItem->rect.bottom - editItem->rect.top + 3,
3910 SWP_NOMOVE | SWP_DRAWFRAME);
3911 }
3912
3913 if (hFont != 0)
3914 {
3915 SelectObject(hdc, hOldFont);
3916 }
3917
3918 ReleaseDC(infoPtr->hwnd, hdc);
3919 break;
3920 }
3921 case EN_KILLFOCUS:
3922 /* apparently we should respect passed handle value */
3923 if (infoPtr->hwndEdit != (HWND)lParam) return FALSE;
3924
3925 TREEVIEW_EndEditLabelNow(infoPtr, FALSE);
3926 break;
3927
3928 default:
3929 return SendMessageW(infoPtr->hwndNotify, WM_COMMAND, wParam, lParam);
3930 }
3931
3932 return 0;
3933 }
3934
3935 static HWND
3936 TREEVIEW_EditLabel(TREEVIEW_INFO *infoPtr, HTREEITEM hItem)
3937 {
3938 HWND hwnd = infoPtr->hwnd;
3939 HWND hwndEdit;
3940 SIZE sz;
3941 HINSTANCE hinst = (HINSTANCE)GetWindowLongPtrW(hwnd, GWLP_HINSTANCE);
3942 HDC hdc;
3943 HFONT hOldFont=0;
3944 TEXTMETRICW textMetric;
3945
3946 TRACE("%p %p\n", hwnd, hItem);
3947 if (!(infoPtr->dwStyle & TVS_EDITLABELS))
3948 return NULL;
3949
3950 if (!TREEVIEW_ValidItem(infoPtr, hItem))
3951 return NULL;
3952
3953 if (infoPtr->hwndEdit)
3954 return infoPtr->hwndEdit;
3955
3956 infoPtr->bLabelChanged = FALSE;
3957
3958 /* make edit item visible */
3959 TREEVIEW_EnsureVisible(infoPtr, hItem, TRUE);
3960
3961 TREEVIEW_UpdateDispInfo(infoPtr, hItem, TVIF_TEXT);
3962
3963 hdc = GetDC(hwnd);
3964 /* Select the font to get appropriate metric dimensions */
3965 if (infoPtr->hFont != 0)
3966 {
3967 hOldFont = SelectObject(hdc, infoPtr->hFont);
3968 }
3969
3970 /* Get string length in pixels */
3971 if (hItem->pszText)
3972 GetTextExtentPoint32W(hdc, hItem->pszText, lstrlenW(hItem->pszText),
3973 &sz);
3974 else
3975 GetTextExtentPoint32A(hdc, "", 0, &sz);
3976
3977 /* Add Extra spacing for the next character */
3978 GetTextMetricsW(hdc, &textMetric);
3979 sz.cx += (textMetric.tmMaxCharWidth * 2);
3980
3981 sz.cx = max(sz.cx, textMetric.tmMaxCharWidth * 3);
3982 sz.cx = min(sz.cx, infoPtr->clientWidth - hItem->textOffset + 2);
3983
3984 if (infoPtr->hFont != 0)
3985 {
3986 SelectObject(hdc, hOldFont);
3987 }
3988
3989 ReleaseDC(hwnd, hdc);
3990
3991 infoPtr->editItem = hItem;
3992
3993 hwndEdit = CreateWindowExW(WS_EX_LEFT,
3994 WC_EDITW,
3995 0,
3996 WS_CHILD | WS_BORDER | ES_AUTOHSCROLL |
3997 WS_CLIPSIBLINGS | ES_WANTRETURN |
3998 ES_LEFT, hItem->textOffset - 2,
3999 hItem->rect.top - 1, sz.cx + 3,
4000 hItem->rect.bottom -
4001 hItem->rect.top + 3, hwnd, 0, hinst, 0);
4002 /* FIXME: (HMENU)IDTVEDIT,pcs->hInstance,0); */
4003
4004 infoPtr->hwndEdit = hwndEdit;
4005
4006 /* Get a 2D border. */
4007 SetWindowLongW(hwndEdit, GWL_EXSTYLE,
4008 GetWindowLongW(hwndEdit, GWL_EXSTYLE) & ~WS_EX_CLIENTEDGE);
4009 SetWindowLongW(hwndEdit, GWL_STYLE,
4010 GetWindowLongW(hwndEdit, GWL_STYLE) | WS_BORDER);
4011
4012 SendMessageW(hwndEdit, WM_SETFONT,
4013 (WPARAM)TREEVIEW_FontForItem(infoPtr, hItem), FALSE);
4014
4015 infoPtr->wpEditOrig = (WNDPROC)SetWindowLongPtrW(hwndEdit, GWLP_WNDPROC,
4016 (DWORD_PTR)
4017 TREEVIEW_Edit_SubclassProc);
4018 SendMessageW(hwndEdit, EM_SETLIMITTEXT, MAX_PATH - 1, 0);
4019 if (hItem->pszText)
4020 SetWindowTextW(hwndEdit, hItem->pszText);
4021
4022 if (TREEVIEW_BeginLabelEditNotify(infoPtr, hItem))
4023 {
4024 DestroyWindow(hwndEdit);
4025 infoPtr->hwndEdit = 0;
4026 infoPtr->editItem = NULL;
4027 return NULL;
4028 }
4029
4030 SetFocus(hwndEdit);
4031 SendMessageW(hwndEdit, EM_SETSEL, 0, -1);
4032 ShowWindow(hwndEdit, SW_SHOW);
4033
4034 return hwndEdit;
4035 }
4036
4037
4038 static LRESULT
4039 TREEVIEW_EndEditLabelNow(TREEVIEW_INFO *infoPtr, BOOL bCancel)
4040 {
4041 TREEVIEW_ITEM *editedItem = infoPtr->editItem;
4042 NMTVDISPINFOW tvdi;
4043 BOOL bCommit;
4044 WCHAR tmpText[MAX_PATH] = { '\0' };
4045 WCHAR *newText;
4046 int iLength = 0;
4047
4048 if (!IsWindow(infoPtr->hwndEdit)) return FALSE;
4049
4050 tvdi.item.mask = 0;
4051 tvdi.item.hItem = editedItem;
4052 tvdi.item.state = editedItem->state;
4053 tvdi.item.lParam = editedItem->lParam;
4054
4055 if (!bCancel)
4056 {
4057 if (!infoPtr->bNtfUnicode)
4058 iLength = GetWindowTextA(infoPtr->hwndEdit, (LPSTR)tmpText, ARRAY_SIZE(tmpText));
4059 else
4060 iLength = GetWindowTextW(infoPtr->hwndEdit, tmpText, ARRAY_SIZE(tmpText));
4061
4062 tvdi.item.mask = TVIF_TEXT;
4063 tvdi.item.pszText = tmpText;
4064 tvdi.item.cchTextMax = ARRAY_SIZE(tmpText);
4065 }
4066 else
4067 {
4068 tvdi.item.pszText = NULL;
4069 tvdi.item.cchTextMax = 0;
4070 }
4071
4072 bCommit = TREEVIEW_SendRealNotify(infoPtr, TVN_ENDLABELEDITW, &tvdi.hdr);
4073
4074 if (!bCancel && bCommit) /* Apply the changes */
4075 {
4076 if (!infoPtr->bNtfUnicode)
4077 {
4078 DWORD len = MultiByteToWideChar( CP_ACP, 0, (LPSTR)tvdi.item.pszText, -1, NULL, 0 );
4079 newText = Alloc(len * sizeof(WCHAR));
4080 MultiByteToWideChar( CP_ACP, 0, (LPSTR)tvdi.item.pszText, -1, newText, len );
4081 iLength = len - 1;
4082 }
4083 else
4084 newText = tvdi.item.pszText;
4085
4086 if (lstrcmpW(newText, editedItem->pszText) != 0)
4087 {
4088 WCHAR *ptr = ReAlloc(editedItem->pszText, sizeof(WCHAR)*(iLength + 1));
4089 if (ptr == NULL)
4090 {
4091 ERR("OutOfMemory, cannot allocate space for label\n");
4092 if (newText != tmpText) Free(newText);
4093 DestroyWindow(infoPtr->hwndEdit);
4094 infoPtr->hwndEdit = 0;
4095 infoPtr->editItem = NULL;
4096 return FALSE;
4097 }
4098 else
4099 {
4100 editedItem->pszText = ptr;
4101 editedItem->cchTextMax = iLength + 1;
4102 lstrcpyW(editedItem->pszText, newText);
4103 TREEVIEW_ComputeTextWidth(infoPtr, editedItem, 0);
4104 }
4105 }
4106 if (newText != tmpText) Free(newText);
4107 }
4108
4109 ShowWindow(infoPtr->hwndEdit, SW_HIDE);
4110 DestroyWindow(infoPtr->hwndEdit);
4111 infoPtr->hwndEdit = 0;
4112 infoPtr->editItem = NULL;
4113 return TRUE;
4114 }
4115
4116 static LRESULT
4117 TREEVIEW_HandleTimer(TREEVIEW_INFO *infoPtr, WPARAM wParam)
4118 {
4119 if (wParam != TV_EDIT_TIMER)
4120 {
4121 ERR("got unknown timer\n");
4122 return 1;
4123 }
4124
4125 KillTimer(infoPtr->hwnd, TV_EDIT_TIMER);
4126 infoPtr->Timer &= ~TV_EDIT_TIMER_SET;
4127
4128 TREEVIEW_EditLabel(infoPtr, infoPtr->selectedItem);
4129
4130 return 0;
4131 }
4132
4133
4134 /* Mouse Tracking/Drag **************************************************/
4135
4136 /***************************************************************************
4137 * This is quite unusual piece of code, but that's how it's implemented in
4138 * Windows.
4139 */
4140 static LRESULT
4141 TREEVIEW_TrackMouse(const TREEVIEW_INFO *infoPtr, POINT pt)
4142 {
4143 INT cxDrag = GetSystemMetrics(SM_CXDRAG);
4144 INT cyDrag = GetSystemMetrics(SM_CYDRAG);
4145 RECT r;
4146 MSG msg;
4147
4148 r.top = pt.y - cyDrag;
4149 r.left = pt.x - cxDrag;
4150 r.bottom = pt.y + cyDrag;
4151 r.right = pt.x + cxDrag;
4152
4153 SetCapture(infoPtr->hwnd);
4154
4155 while (1)
4156 {
4157 if (PeekMessageW(&msg, 0, 0, 0, PM_REMOVE | PM_NOYIELD))
4158 {
4159 if (msg.message == WM_MOUSEMOVE)
4160 {
4161 pt.x = (short)LOWORD(msg.lParam);
4162 pt.y = (short)HIWORD(msg.lParam);
4163 if (PtInRect(&r, pt))
4164 continue;
4165 else
4166 {
4167 ReleaseCapture();
4168 return 1;
4169 }
4170 }
4171 else if (msg.message >= WM_LBUTTONDOWN &&
4172 msg.message <= WM_RBUTTONDBLCLK)
4173 {
4174 break;
4175 }
4176
4177 DispatchMessageW(&msg);
4178 }
4179
4180 if (GetCapture() != infoPtr->hwnd)
4181 return 0;
4182 }
4183
4184 ReleaseCapture();
4185 return 0;
4186 }
4187
4188
4189 static LRESULT
4190 TREEVIEW_LButtonDoubleClick(TREEVIEW_INFO *infoPtr, LPARAM lParam)
4191 {
4192 TREEVIEW_ITEM *item;
4193 TVHITTESTINFO hit;
4194
4195 TRACE("\n");
4196 SetFocus(infoPtr->hwnd);
4197
4198 if (infoPtr->Timer & TV_EDIT_TIMER_SET)
4199 {
4200 /* If there is pending 'edit label' event - kill it now */
4201 KillTimer(infoPtr->hwnd, TV_EDIT_TIMER);
4202 }
4203
4204 hit.pt.x = (short)LOWORD(lParam);
4205 hit.pt.y = (short)HIWORD(lParam);
4206
4207 item = TREEVIEW_HitTest(infoPtr, &hit);
4208 if (!item)
4209 return 0;
4210 TRACE("item %d\n", TREEVIEW_GetItemIndex(infoPtr, item));
4211
4212 if (TREEVIEW_SendSimpleNotify(infoPtr, NM_DBLCLK) == FALSE)
4213 { /* FIXME! */
4214 switch (hit.flags)
4215 {
4216 case TVHT_ONITEMRIGHT:
4217 /* FIXME: we should not have sent NM_DBLCLK in this case. */
4218 break;
4219
4220 case TVHT_ONITEMINDENT:
4221 if (!(infoPtr->dwStyle & TVS_HASLINES))
4222 {
4223 break;
4224 }
4225 else
4226 {
4227 int level = hit.pt.x / infoPtr->uIndent;
4228 if (!(infoPtr->dwStyle & TVS_LINESATROOT)) level++;
4229
4230 while (item->iLevel > level)
4231 {
4232 item = item->parent;
4233 }
4234
4235 /* fall through */
4236 }
4237
4238 case TVHT_ONITEMLABEL:
4239 case TVHT_ONITEMICON:
4240 case TVHT_ONITEMBUTTON:
4241 TREEVIEW_Toggle(infoPtr, item, TRUE);
4242 break;
4243
4244 case TVHT_ONITEMSTATEICON:
4245 if (infoPtr->dwStyle & TVS_CHECKBOXES)
4246 TREEVIEW_ToggleItemState(infoPtr, item);
4247 else
4248 TREEVIEW_Toggle(infoPtr, item, TRUE);
4249 break;
4250 }
4251 }
4252 return TRUE;
4253 }
4254
4255
4256 static LRESULT
4257 TREEVIEW_LButtonDown(TREEVIEW_INFO *infoPtr, LPARAM lParam)
4258 {
4259 BOOL do_track, do_select, bDoLabelEdit;
4260 HWND hwnd = infoPtr->hwnd;
4261 TVHITTESTINFO ht;
4262
4263 /* If Edit control is active - kill it and return.
4264 * The best way to do it is to set focus to itself.
4265 * Edit control subclassed procedure will automatically call
4266 * EndEditLabelNow.
4267 */
4268 if (infoPtr->hwndEdit)
4269 {
4270 SetFocus(hwnd);
4271 return 0;
4272 }
4273
4274 ht.pt.x = (short)LOWORD(lParam);
4275 ht.pt.y = (short)HIWORD(lParam);
4276
4277 TREEVIEW_HitTest(infoPtr, &ht);
4278 TRACE("item %d\n", TREEVIEW_GetItemIndex(infoPtr, ht.hItem));
4279
4280 /* update focusedItem and redraw both items */
4281 if (ht.hItem)
4282 {
4283 BOOL do_focus;
4284
4285 if (TREEVIEW_IsFullRowSelect(infoPtr))
4286 do_focus = ht.flags & (TVHT_ONITEMINDENT | TVHT_ONITEM | TVHT_ONITEMRIGHT);
4287 else
4288 do_focus = ht.flags & TVHT_ONITEM;
4289
4290 if (do_focus)
4291 {
4292 infoPtr->focusedItem = ht.hItem;
4293 TREEVIEW_InvalidateItem(infoPtr, infoPtr->focusedItem);
4294 TREEVIEW_InvalidateItem(infoPtr, infoPtr->selectedItem);
4295 }
4296 }
4297
4298 if (!(infoPtr->dwStyle & TVS_DISABLEDRAGDROP))
4299 {
4300 if (TREEVIEW_IsFullRowSelect(infoPtr))
4301 do_track = ht.flags & (TVHT_ONITEMINDENT | TVHT_ONITEM | TVHT_ONITEMRIGHT);
4302 else
4303 do_track = ht.flags & TVHT_ONITEM;
4304 }
4305 else
4306 do_track = FALSE;
4307
4308 /*
4309 * If the style allows editing and the node is already selected
4310 * and the click occurred on the item label...
4311 */
4312 bDoLabelEdit = (infoPtr->dwStyle & TVS_EDITLABELS) &&
4313 (ht.flags & TVHT_ONITEMLABEL) && (infoPtr->selectedItem == ht.hItem);
4314
4315 /* Send NM_CLICK right away */
4316 if (!do_track && TREEVIEW_SendSimpleNotify(infoPtr, NM_CLICK))
4317 goto setfocus;
4318
4319 if (ht.flags & TVHT_ONITEMBUTTON)
4320 {
4321 TREEVIEW_Toggle(infoPtr, ht.hItem, TRUE);
4322 goto setfocus;
4323 }
4324 else if (do_track)
4325 { /* if TREEVIEW_TrackMouse == 1 dragging occurred and the cursor left the dragged item's rectangle */
4326 if (TREEVIEW_TrackMouse(infoPtr, ht.pt))
4327 {
4328 TREEVIEW_SendTreeviewDnDNotify(infoPtr, TVN_BEGINDRAGW, ht.hItem, ht.pt);
4329 infoPtr->dropItem = ht.hItem;
4330
4331 /* clean up focusedItem as we dragged and won't select this item */
4332 if(infoPtr->focusedItem)
4333 {
4334 /* refresh the item that was focused */
4335 TREEVIEW_InvalidateItem(infoPtr, infoPtr->focusedItem);
4336 infoPtr->focusedItem = NULL;
4337
4338 /* refresh the selected item to return the filled background */
4339 TREEVIEW_InvalidateItem(infoPtr, infoPtr->selectedItem);
4340 }
4341
4342 return 0;
4343 }
4344 }
4345
4346 if (do_track && TREEVIEW_SendSimpleNotify(infoPtr, NM_CLICK))
4347 goto setfocus;
4348
4349 if (TREEVIEW_IsFullRowSelect(infoPtr))
4350 do_select = ht.flags & (TVHT_ONITEMINDENT | TVHT_ONITEMICON | TVHT_ONITEMLABEL | TVHT_ONITEMRIGHT);
4351 else
4352 do_select = ht.flags & (TVHT_ONITEMICON | TVHT_ONITEMLABEL);
4353
4354 if (bDoLabelEdit)
4355 {
4356 if (infoPtr->Timer & TV_EDIT_TIMER_SET)
4357 KillTimer(hwnd, TV_EDIT_TIMER);
4358
4359 SetTimer(hwnd, TV_EDIT_TIMER, GetDoubleClickTime(), 0);
4360 infoPtr->Timer |= TV_EDIT_TIMER_SET;
4361 }
4362 else if (do_select)
4363 {
4364 TREEVIEW_ITEM *selection = infoPtr->selectedItem;
4365
4366 /* Select the current item */
4367 TREEVIEW_DoSelectItem(infoPtr, TVGN_CARET, ht.hItem, TVC_BYMOUSE);
4368 TREEVIEW_SingleExpand(infoPtr, selection, ht.hItem);
4369 }
4370 else if (ht.flags & TVHT_ONITEMSTATEICON)
4371 {
4372 /* TVS_CHECKBOXES requires us to toggle the current state */
4373 if (infoPtr->dwStyle & TVS_CHECKBOXES)
4374 TREEVIEW_ToggleItemState(infoPtr, ht.hItem);
4375 }
4376
4377 setfocus:
4378 SetFocus(hwnd);
4379 return 0;
4380 }
4381
4382
4383 static LRESULT
4384 TREEVIEW_RButtonDown(TREEVIEW_INFO *infoPtr, LPARAM lParam)
4385 {
4386 TVHITTESTINFO ht;
4387
4388 if (infoPtr->hwndEdit)
4389 {
4390 SetFocus(infoPtr->hwnd);
4391 return 0;
4392 }
4393
4394 ht.pt.x = (short)LOWORD(lParam);
4395 ht.pt.y = (short)HIWORD(lParam);
4396
4397 if (TREEVIEW_HitTest(infoPtr, &ht))
4398 {
4399 infoPtr->focusedItem = ht.hItem;
4400 TREEVIEW_InvalidateItem(infoPtr, infoPtr->focusedItem);
4401 TREEVIEW_InvalidateItem(infoPtr, infoPtr->selectedItem);
4402 }
4403
4404 if (TREEVIEW_TrackMouse(infoPtr, ht.pt))
4405 {
4406 if (ht.hItem)
4407 {
4408 TREEVIEW_SendTreeviewDnDNotify(infoPtr, TVN_BEGINRDRAGW, ht.hItem, ht.pt);
4409 infoPtr->dropItem = ht.hItem;
4410 }
4411 }
4412 else
4413 {
4414 SetFocus(infoPtr->hwnd);
4415 if(!TREEVIEW_SendSimpleNotify(infoPtr, NM_RCLICK))
4416 {
4417 /* Send a WM_CONTEXTMENU message in response to the RBUTTONUP */
4418 SendMessageW(infoPtr->hwndNotify, WM_CONTEXTMENU,
4419 (WPARAM)infoPtr->hwnd, (LPARAM)GetMessagePos());
4420 }
4421 }
4422
4423 if (ht.hItem)
4424 {
4425 TREEVIEW_InvalidateItem(infoPtr, infoPtr->focusedItem);
4426 infoPtr->focusedItem = infoPtr->selectedItem;
4427 TREEVIEW_InvalidateItem(infoPtr, infoPtr->focusedItem);
4428 }
4429
4430 return 0;
4431 }
4432
4433 static LRESULT
4434 TREEVIEW_CreateDragImage(TREEVIEW_INFO *infoPtr, LPARAM lParam)
4435 {
4436 TREEVIEW_ITEM *dragItem = (HTREEITEM)lParam;
4437 INT cx, cy;
4438 HDC hdc, htopdc;
4439 HWND hwtop;
4440 HBITMAP hbmp, hOldbmp;
4441 SIZE size;
4442 RECT rc;
4443 HFONT hOldFont;
4444
4445 TRACE("\n");
4446
4447 if (!(infoPtr->himlNormal))
4448 return 0;
4449
4450 if (!dragItem || !TREEVIEW_ValidItem(infoPtr, dragItem))
4451 return 0;
4452
4453 TREEVIEW_UpdateDispInfo(infoPtr, dragItem, TVIF_TEXT);
4454
4455 hwtop = GetDesktopWindow();
4456 htopdc = GetDC(hwtop);
4457 hdc = CreateCompatibleDC(htopdc);
4458
4459 hOldFont = SelectObject(hdc, infoPtr->hFont);
4460
4461 if (dragItem->pszText)
4462 GetTextExtentPoint32W(hdc, dragItem->pszText, lstrlenW(dragItem->pszText),
4463 &size);
4464 else
4465 GetTextExtentPoint32A(hdc, "", 0, &size);
4466
4467 TRACE("%ld, %ld, %s\n", size.cx, size.cy, debugstr_w(dragItem->pszText));
4468 hbmp = CreateCompatibleBitmap(htopdc, size.cx, size.cy);
4469 hOldbmp = SelectObject(hdc, hbmp);
4470
4471 ImageList_GetIconSize(infoPtr->himlNormal, &cx, &cy);
4472 size.cx += cx;
4473 if (cy > size.cy)
4474 size.cy = cy;
4475
4476 infoPtr->dragList = ImageList_Create(size.cx, size.cy, ILC_COLOR, 10, 10);
4477 ImageList_Draw(infoPtr->himlNormal, dragItem->iImage, hdc, 0, 0,
4478 ILD_NORMAL);
4479
4480 /*
4481 ImageList_GetImageInfo (infoPtr->himlNormal, dragItem->hItem, &iminfo);
4482 ImageList_AddMasked (infoPtr->dragList, iminfo.hbmImage, CLR_DEFAULT);
4483 */
4484
4485 /* draw item text */
4486
4487 SetRect(&rc, cx, 0, size.cx, size.cy);
4488
4489 if (dragItem->pszText)
4490 DrawTextW(hdc, dragItem->pszText, lstrlenW(dragItem->pszText), &rc,
4491 DT_LEFT);
4492
4493 SelectObject(hdc, hOldFont);
4494 SelectObject(hdc, hOldbmp);
4495
4496 ImageList_Add(infoPtr->dragList, hbmp, 0);
4497
4498 DeleteDC(hdc);
4499 DeleteObject(hbmp);
4500 ReleaseDC(hwtop, htopdc);
4501
4502 return (LRESULT)infoPtr->dragList;
4503 }
4504
4505 /* Selection ************************************************************/
4506
4507 static LRESULT
4508 TREEVIEW_DoSelectItem(TREEVIEW_INFO *infoPtr, INT action, HTREEITEM newSelect,
4509 INT cause)
4510 {
4511 TREEVIEW_ITEM *prevSelect;
4512
4513 assert(newSelect == NULL || TREEVIEW_ValidItem(infoPtr, newSelect));
4514
4515 TRACE("Entering item %p (%s), flag 0x%x, cause 0x%x, state 0x%x\n",
4516 newSelect, TREEVIEW_ItemName(newSelect), action, cause,
4517 newSelect ? newSelect->state : 0);
4518
4519 /* reset and redraw focusedItem if focusedItem was set so we don't */
4520 /* have to worry about the previously focused item when we set a new one */
4521 TREEVIEW_InvalidateItem(infoPtr, infoPtr->focusedItem);
4522 infoPtr->focusedItem = NULL;
4523
4524 switch (action)
4525 {
4526 case TVGN_CARET|TVSI_NOSINGLEEXPAND:
4527 FIXME("TVSI_NOSINGLEEXPAND specified.\n");
4528 /* Fall through */
4529 case TVGN_CARET:
4530 prevSelect = infoPtr->selectedItem;
4531
4532 if (prevSelect == newSelect) {
4533 TREEVIEW_EnsureVisible(infoPtr, infoPtr->selectedItem, FALSE);
4534 break;
4535 }
4536
4537 if (TREEVIEW_SendTreeviewNotify(infoPtr,
4538 TVN_SELCHANGINGW,
4539 cause,
4540 TVIF_TEXT | TVIF_HANDLE | TVIF_STATE | TVIF_PARAM,
4541 prevSelect,
4542 newSelect))
4543 return FALSE;
4544
4545 if (prevSelect)
4546 prevSelect->state &= ~TVIS_SELECTED;
4547 if (newSelect)
4548 newSelect->state |= TVIS_SELECTED;
4549
4550 infoPtr->selectedItem = newSelect;
4551
4552 TREEVIEW_EnsureVisible(infoPtr, infoPtr->selectedItem, FALSE);
4553
4554 TREEVIEW_InvalidateItem(infoPtr, prevSelect);
4555 TREEVIEW_InvalidateItem(infoPtr, newSelect);
4556
4557 TREEVIEW_SendTreeviewNotify(infoPtr,
4558 TVN_SELCHANGEDW,
4559 cause,
4560 TVIF_TEXT | TVIF_HANDLE | TVIF_STATE | TVIF_PARAM,
4561 prevSelect,
4562 newSelect);
4563 break;
4564
4565 case TVGN_DROPHILITE:
4566 prevSelect = infoPtr->dropItem;
4567
4568 if (prevSelect)
4569 prevSelect->state &= ~TVIS_DROPHILITED;
4570
4571 infoPtr->dropItem = newSelect;
4572
4573 if (newSelect)
4574 newSelect->state |= TVIS_DROPHILITED;
4575
4576 TREEVIEW_Invalidate(infoPtr, prevSelect);
4577 TREEVIEW_Invalidate(infoPtr, newSelect);
4578 break;
4579
4580 case TVGN_FIRSTVISIBLE:
4581 if (newSelect != NULL)
4582 {
4583 TREEVIEW_EnsureVisible(infoPtr, newSelect, FALSE);
4584 TREEVIEW_SetFirstVisible(infoPtr, newSelect, TRUE);
4585 TREEVIEW_Invalidate(infoPtr, NULL);
4586 }
4587 break;
4588 }
4589
4590 TRACE("Leaving state 0x%x\n", newSelect ? newSelect->state : 0);
4591 return TRUE;
4592 }
4593
4594 /* FIXME: handle NM_KILLFOCUS etc */
4595 static LRESULT
4596 TREEVIEW_SelectItem(TREEVIEW_INFO *infoPtr, INT wParam, HTREEITEM item)
4597 {
4598 TREEVIEW_ITEM *selection = infoPtr->selectedItem;
4599
4600 if (item && !TREEVIEW_ValidItem(infoPtr, item))
4601 return FALSE;
4602
4603 if (item == infoPtr->selectedItem)
4604 return TRUE;
4605
4606 TRACE("%p (%s) %d\n", item, TREEVIEW_ItemName(item), wParam);
4607
4608 if (!TREEVIEW_DoSelectItem(infoPtr, wParam, item, TVC_UNKNOWN))
4609 return FALSE;
4610
4611 TREEVIEW_SingleExpand(infoPtr, selection, item);
4612
4613 return TRUE;
4614 }
4615
4616 /*************************************************************************
4617 * TREEVIEW_ProcessLetterKeys
4618 *
4619 * Processes keyboard messages generated by pressing the letter keys
4620 * on the keyboard.
4621 * What this does is perform a case insensitive search from the
4622 * current position with the following quirks:
4623 * - If two chars or more are pressed in quick succession we search
4624 * for the corresponding string (e.g. 'abc').
4625 * - If there is a delay we wipe away the current search string and
4626 * restart with just that char.
4627 * - If the user keeps pressing the same character, whether slowly or
4628 * fast, so that the search string is entirely composed of this
4629 * character ('aaaaa' for instance), then we search for first item
4630 * that starting with that character.
4631 * - If the user types the above character in quick succession, then
4632 * we must also search for the corresponding string ('aaaaa'), and
4633 * go to that string if there is a match.
4634 *
4635 * RETURNS
4636 *
4637 * Zero.
4638 *
4639 * BUGS
4640 *
4641 * - The current implementation has a list of characters it will
4642 * accept and it ignores everything else. In particular it will
4643 * ignore accentuated characters which seems to match what
4644 * Windows does. But I'm not sure it makes sense to follow
4645 * Windows there.
4646 * - We don't sound a beep when the search fails.
4647 * - The search should start from the focused item, not from the selected
4648 * item. One reason for this is to allow for multiple selections in trees.
4649 * But currently infoPtr->focusedItem does not seem very usable.
4650 *
4651 * SEE ALSO
4652 *
4653 * TREEVIEW_ProcessLetterKeys
4654 */
4655 static INT TREEVIEW_ProcessLetterKeys(TREEVIEW_INFO *infoPtr, WPARAM charCode, LPARAM keyData)
4656 {
4657 HTREEITEM nItem;
4658 HTREEITEM endidx,idx;
4659 TVITEMEXW item;
4660 WCHAR buffer[MAX_PATH];
4661 DWORD timestamp,elapsed;
4662
4663 /* simple parameter checking */
4664 if (!charCode || !keyData) return 0;
4665
4666 /* only allow the valid WM_CHARs through */
4667 if (!iswalnum(charCode) &&
4668 charCode != '.' && charCode != '`' && charCode != '!' &&
4669 charCode != '@' && charCode != '#' && charCode != '$' &&
4670 charCode != '%' && charCode != '^' && charCode != '&' &&
4671 charCode != '*' && charCode != '(' && charCode != ')' &&
4672 charCode != '-' && charCode != '_' && charCode != '+' &&
4673 charCode != '=' && charCode != '\\'&& charCode != ']' &&
4674 charCode != '}' && charCode != '[' && charCode != '{' &&
4675 charCode != '/' && charCode != '?' && charCode != '>' &&
4676 charCode != '<' && charCode != ',' && charCode != '~')
4677 return 0;
4678
4679 /* compute how much time elapsed since last keypress */
4680 timestamp = GetTickCount();
4681 if (timestamp > infoPtr->lastKeyPressTimestamp) {
4682 elapsed=timestamp-infoPtr->lastKeyPressTimestamp;
4683 } else {
4684 elapsed=infoPtr->lastKeyPressTimestamp-timestamp;
4685 }
4686
4687 /* update the search parameters */
4688 infoPtr->lastKeyPressTimestamp=timestamp;
4689 if (elapsed < KEY_DELAY) {
4690 if (infoPtr->nSearchParamLength < ARRAY_SIZE(infoPtr->szSearchParam)) {
4691 infoPtr->szSearchParam[infoPtr->nSearchParamLength++]=charCode;
4692 }
4693 if (infoPtr->charCode != charCode) {
4694 infoPtr->charCode=charCode=0;
4695 }
4696 } else {
4697 infoPtr->charCode=charCode;
4698 infoPtr->szSearchParam[0]=charCode;
4699 infoPtr->nSearchParamLength=1;
4700 /* Redundant with the 1 char string */
4701 charCode=0;
4702 }
4703
4704 /* and search from the current position */
4705 nItem=NULL;
4706 if (infoPtr->selectedItem != NULL) {
4707 endidx=infoPtr->selectedItem;
4708 /* if looking for single character match,
4709 * then we must always move forward
4710 */
4711 if (infoPtr->nSearchParamLength == 1)
4712 idx=TREEVIEW_GetNextListItem(infoPtr,endidx);
4713 else
4714 idx=endidx;
4715 } else {
4716 endidx=NULL;
4717 idx=infoPtr->root->firstChild;
4718 }
4719 do {
4720 /* At the end point, sort out wrapping */
4721 if (idx == NULL) {
4722
4723 /* If endidx is null, stop at the last item (ie top to bottom) */
4724 if (endidx == NULL)
4725 break;
4726
4727 /* Otherwise, start again at the very beginning */
4728 idx=infoPtr->root->firstChild;
4729
4730 /* But if we are stopping on the first child, end now! */
4731 if (idx == endidx) break;
4732 }
4733
4734 /* get item */
4735 ZeroMemory(&item, sizeof(item));
4736 item.mask = TVIF_TEXT;
4737 item.hItem = idx;
4738 item.pszText = buffer;
4739 item.cchTextMax = ARRAY_SIZE(buffer);
4740 TREEVIEW_GetItemT( infoPtr, &item, TRUE );
4741
4742 /* check for a match */
4743 if (wcsnicmp(item.pszText,infoPtr->szSearchParam,infoPtr->nSearchParamLength) == 0) {
4744 nItem=idx;
4745 break;
4746 } else if ( (charCode != 0) && (nItem == NULL) &&
4747 (nItem != infoPtr->selectedItem) &&
4748 (wcsnicmp(item.pszText,infoPtr->szSearchParam,1) == 0) ) {
4749 /* This would work but we must keep looking for a longer match */
4750 nItem=idx;
4751 }
4752 idx=TREEVIEW_GetNextListItem(infoPtr,idx);
4753 } while (idx != endidx);
4754
4755 if (nItem != NULL) {
4756 if (TREEVIEW_DoSelectItem(infoPtr, TVGN_CARET, nItem, TVC_BYKEYBOARD)) {
4757 TREEVIEW_EnsureVisible(infoPtr, nItem, FALSE);
4758 }
4759 }
4760
4761 return 0;
4762 }
4763
4764 /* Scrolling ************************************************************/
4765
4766 static LRESULT
4767 TREEVIEW_EnsureVisible(TREEVIEW_INFO *infoPtr, HTREEITEM item, BOOL bHScroll)
4768 {
4769 int viscount;
4770 BOOL hasFirstVisible = infoPtr->firstVisible != NULL;
4771 HTREEITEM newFirstVisible = NULL;
4772 int visible_pos = -1;
4773
4774 if (!TREEVIEW_ValidItem(infoPtr, item))
4775 return FALSE;
4776
4777 if (!ISVISIBLE(item))
4778 {
4779 /* Expand parents as necessary. */
4780 HTREEITEM parent;
4781
4782 /* see if we are trying to ensure that root is visible */
4783 if((item != infoPtr->root) && TREEVIEW_ValidItem(infoPtr, item))
4784 parent = item->parent;
4785 else
4786 parent = item; /* this item is the topmost item */
4787
4788 while (parent != infoPtr->root)
4789 {
4790 if (!(parent->state & TVIS_EXPANDED))
4791 TREEVIEW_Expand(infoPtr, parent, FALSE, TRUE);
4792
4793 parent = parent->parent;
4794 }
4795 }
4796
4797 viscount = TREEVIEW_GetVisibleCount(infoPtr);
4798
4799 TRACE("%p (%s) %ld - %ld viscount(%d)\n", item, TREEVIEW_ItemName(item), item->visibleOrder,
4800 hasFirstVisible ? infoPtr->firstVisible->visibleOrder : -1, viscount);
4801
4802 if (hasFirstVisible)
4803 visible_pos = item->visibleOrder - infoPtr->firstVisible->visibleOrder;
4804
4805 if (visible_pos < 0)
4806 {
4807 /* item is before the start of the list: put it at the top. */
4808 newFirstVisible = item;
4809 }
4810 else if (visible_pos >= viscount
4811 /* Sometimes, before we are displayed, GVC is 0, causing us to
4812 * spuriously scroll up. */
4813 && visible_pos > 0 && !(infoPtr->dwStyle & TVS_NOSCROLL) )
4814 {
4815 /* item is past the end of the list. */
4816 int scroll = visible_pos - viscount;
4817
4818 newFirstVisible = TREEVIEW_GetListItem(infoPtr, infoPtr->firstVisible,
4819 scroll + 1);
4820 }
4821
4822 if (bHScroll)
4823 {
4824 /* Scroll window so item's text is visible as much as possible */
4825 /* Calculation of amount of extra space is taken from EditLabel code */
4826 INT pos, x;
4827 TEXTMETRICW textMetric;
4828 HDC hdc = GetWindowDC(infoPtr->hwnd);
4829
4830 x = item->textWidth;
4831
4832 GetTextMetricsW(hdc, &textMetric);
4833 ReleaseDC(infoPtr->hwnd, hdc);
4834
4835 x += (textMetric.tmMaxCharWidth * 2);
4836 x = max(x, textMetric.tmMaxCharWidth * 3);
4837
4838 if (item->textOffset < 0)
4839 pos = item->textOffset;
4840 else if (item->textOffset + x > infoPtr->clientWidth)
4841 {
4842 if (x > infoPtr->clientWidth)
4843 pos = item->textOffset;
4844 else
4845 pos = item->textOffset + x - infoPtr->clientWidth;
4846 }
4847 else
4848 pos = 0;
4849
4850 TREEVIEW_HScroll(infoPtr, MAKEWPARAM(SB_THUMBPOSITION, infoPtr->scrollX + pos));
4851 }
4852
4853 if (newFirstVisible != NULL && newFirstVisible != infoPtr->firstVisible)
4854 {
4855 TREEVIEW_SetFirstVisible(infoPtr, newFirstVisible, TRUE);
4856
4857 return TRUE;
4858 }
4859
4860 return FALSE;
4861 }
4862
4863 static VOID
4864 TREEVIEW_SetFirstVisible(TREEVIEW_INFO *infoPtr,
4865 TREEVIEW_ITEM *newFirstVisible,
4866 BOOL bUpdateScrollPos)
4867 {
4868 int gap_size;
4869
4870 TRACE("%p: %s\n", newFirstVisible, TREEVIEW_ItemName(newFirstVisible));
4871
4872 if (newFirstVisible != NULL)
4873 {
4874 /* Prevent an empty gap from appearing at the bottom... */
4875 gap_size = TREEVIEW_GetVisibleCount(infoPtr)
4876 - infoPtr->maxVisibleOrder + newFirstVisible->visibleOrder;
4877
4878 if (gap_size > 0)
4879 {
4880 newFirstVisible = TREEVIEW_GetListItem(infoPtr, newFirstVisible,
4881 -gap_size);
4882
4883 /* ... unless we just don't have enough items. */
4884 if (newFirstVisible == NULL)
4885 newFirstVisible = infoPtr->root->firstChild;
4886 }
4887 }
4888
4889 if (infoPtr->firstVisible != newFirstVisible)
4890 {
4891 if (infoPtr->firstVisible == NULL || newFirstVisible == NULL)
4892 {
4893 infoPtr->firstVisible = newFirstVisible;
4894 TREEVIEW_Invalidate(infoPtr, NULL);
4895 }
4896 else
4897 {
4898 TREEVIEW_ITEM *item;
4899 int scroll = infoPtr->uItemHeight *
4900 (infoPtr->firstVisible->visibleOrder
4901 - newFirstVisible->visibleOrder);
4902
4903 infoPtr->firstVisible = newFirstVisible;
4904
4905 for (item = infoPtr->root->firstChild; item != NULL;
4906 item = TREEVIEW_GetNextListItem(infoPtr, item))
4907 {
4908 item->rect.top += scroll;
4909 item->rect.bottom += scroll;
4910 }
4911
4912 if (bUpdateScrollPos)
4913 SetScrollPos(infoPtr->hwnd, SB_VERT,
4914 newFirstVisible->visibleOrder, TRUE);
4915
4916 ScrollWindowEx(infoPtr->hwnd, 0, scroll, NULL, NULL, NULL, NULL, SW_ERASE | SW_INVALIDATE);
4917 }
4918 }
4919 }
4920
4921 /************************************************************************
4922 * VScroll is always in units of visible items. i.e. we always have a
4923 * visible item aligned to the top of the control. (Unless we have no
4924 * items at all.)
4925 */
4926 static LRESULT
4927 TREEVIEW_VScroll(TREEVIEW_INFO *infoPtr, WPARAM wParam)
4928 {
4929 TREEVIEW_ITEM *oldFirstVisible = infoPtr->firstVisible;
4930 TREEVIEW_ITEM *newFirstVisible = NULL;
4931
4932 int nScrollCode = LOWORD(wParam);
4933
4934 TRACE("wp %Ix\n", wParam);
4935
4936 if (!(infoPtr->uInternalStatus & TV_VSCROLL))
4937 return 0;
4938
4939 if (!oldFirstVisible)
4940 {
4941 assert(infoPtr->root->firstChild == NULL);
4942 return 0;
4943 }
4944
4945 switch (nScrollCode)
4946 {
4947 case SB_TOP:
4948 newFirstVisible = infoPtr->root->firstChild;
4949 break;
4950
4951 case SB_BOTTOM:
4952 newFirstVisible = TREEVIEW_GetLastListItem(infoPtr, infoPtr->root);
4953 break;
4954
4955 case SB_LINEUP:
4956 newFirstVisible = TREEVIEW_GetPrevListItem(infoPtr, oldFirstVisible);
4957 break;
4958
4959 case SB_LINEDOWN:
4960 newFirstVisible = TREEVIEW_GetNextListItem(infoPtr, oldFirstVisible);
4961 break;
4962
4963 case SB_PAGEUP:
4964 newFirstVisible = TREEVIEW_GetListItem(infoPtr, oldFirstVisible,
4965 -max(1, TREEVIEW_GetVisibleCount(infoPtr)));
4966 break;
4967
4968 case SB_PAGEDOWN:
4969 newFirstVisible = TREEVIEW_GetListItem(infoPtr, oldFirstVisible,
4970 max(1, TREEVIEW_GetVisibleCount(infoPtr)));
4971 break;
4972
4973 case SB_THUMBTRACK:
4974 case SB_THUMBPOSITION:
4975 newFirstVisible = TREEVIEW_GetListItem(infoPtr,
4976 infoPtr->root->firstChild,
4977 (LONG)(SHORT)HIWORD(wParam));
4978 break;
4979
4980 case SB_ENDSCROLL:
4981 return 0;
4982 }
4983
4984 if (newFirstVisible != NULL)
4985 {
4986 if (newFirstVisible != oldFirstVisible)
4987 TREEVIEW_SetFirstVisible(infoPtr, newFirstVisible,
4988 nScrollCode != SB_THUMBTRACK);
4989 else if (nScrollCode == SB_THUMBPOSITION)
4990 SetScrollPos(infoPtr->hwnd, SB_VERT,
4991 newFirstVisible->visibleOrder, TRUE);
4992 }
4993
4994 return 0;
4995 }
4996
4997 static LRESULT
4998 TREEVIEW_HScroll(TREEVIEW_INFO *infoPtr, WPARAM wParam)
4999 {
5000 int maxWidth;
5001 int scrollX = infoPtr->scrollX;
5002 int nScrollCode = LOWORD(wParam);
5003
5004 TRACE("wp %Ix\n", wParam);
5005
5006 if (!(infoPtr->uInternalStatus & TV_HSCROLL))
5007 return FALSE;
5008
5009 maxWidth = infoPtr->treeWidth - infoPtr->clientWidth;
5010 /* shall never occur */
5011 if (maxWidth <= 0)
5012 {
5013 scrollX = 0;
5014 goto scroll;
5015 }
5016
5017 switch (nScrollCode)
5018 {
5019 case SB_LINELEFT:
5020 scrollX -= infoPtr->uItemHeight;
5021 break;
5022 case SB_LINERIGHT:
5023 scrollX += infoPtr->uItemHeight;
5024 break;
5025 case SB_PAGELEFT:
5026 scrollX -= infoPtr->clientWidth;
5027 break;
5028 case SB_PAGERIGHT:
5029 scrollX += infoPtr->clientWidth;
5030 break;
5031
5032 case SB_THUMBTRACK:
5033 case SB_THUMBPOSITION:
5034 scrollX = (int)(SHORT)HIWORD(wParam);
5035 break;
5036
5037 case SB_ENDSCROLL:
5038 return 0;
5039 }
5040
5041 if (scrollX > maxWidth)
5042 scrollX = maxWidth;
5043 else if (scrollX < 0)
5044 scrollX = 0;
5045
5046 scroll:
5047 if (scrollX != infoPtr->scrollX)
5048 {
5049 TREEVIEW_ITEM *item;
5050 LONG scroll_pixels = infoPtr->scrollX - scrollX;
5051
5052 for (item = infoPtr->root->firstChild; item != NULL;
5053 item = TREEVIEW_GetNextListItem(infoPtr, item))
5054 {
5055 item->linesOffset += scroll_pixels;
5056 item->stateOffset += scroll_pixels;
5057 item->imageOffset += scroll_pixels;
5058 item->textOffset += scroll_pixels;
5059 }
5060
5061 ScrollWindow(infoPtr->hwnd, scroll_pixels, 0, NULL, NULL);
5062 infoPtr->scrollX = scrollX;
5063 UpdateWindow(infoPtr->hwnd);
5064 }
5065
5066 if (nScrollCode != SB_THUMBTRACK)
5067 SetScrollPos(infoPtr->hwnd, SB_HORZ, scrollX, TRUE);
5068
5069 return 0;
5070 }
5071
5072 static LRESULT
5073 TREEVIEW_MouseWheel(TREEVIEW_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
5074 {
5075 short wheelDelta;
5076 INT pulScrollLines = 3;
5077
5078 if (wParam & (MK_SHIFT | MK_CONTROL))
5079 return DefWindowProcW(infoPtr->hwnd, WM_MOUSEWHEEL, wParam, lParam);
5080
5081 if (infoPtr->firstVisible == NULL)
5082 return TRUE;
5083
5084 SystemParametersInfoW(SPI_GETWHEELSCROLLLINES, 0, &pulScrollLines, 0);
5085
5086 wheelDelta = GET_WHEEL_DELTA_WPARAM(wParam);
5087 /* if scrolling changes direction, ignore left overs */
5088 if ((wheelDelta < 0 && infoPtr->wheelRemainder < 0) ||
5089 (wheelDelta > 0 && infoPtr->wheelRemainder > 0))
5090 infoPtr->wheelRemainder += wheelDelta;
5091 else
5092 infoPtr->wheelRemainder = wheelDelta;
5093
5094 if (infoPtr->wheelRemainder && pulScrollLines)
5095 {
5096 int newDy;
5097 int maxDy;
5098 int lineScroll;
5099
5100 lineScroll = pulScrollLines * infoPtr->wheelRemainder / WHEEL_DELTA;
5101 infoPtr->wheelRemainder -= WHEEL_DELTA * lineScroll / pulScrollLines;
5102
5103 newDy = infoPtr->firstVisible->visibleOrder - lineScroll;
5104 maxDy = infoPtr->maxVisibleOrder;
5105
5106 if (newDy > maxDy)
5107 newDy = maxDy;
5108
5109 if (newDy < 0)
5110 newDy = 0;
5111
5112 TREEVIEW_VScroll(infoPtr, MAKEWPARAM(SB_THUMBPOSITION, newDy));
5113 }
5114 return TRUE;
5115 }
5116
5117 /* Create/Destroy *******************************************************/
5118
5119 static LRESULT
5120 TREEVIEW_Create(HWND hwnd, const CREATESTRUCTW *lpcs)
5121 {
5122 RECT rcClient;
5123 TREEVIEW_INFO *infoPtr;
5124 LOGFONTW lf;
5125
5126 TRACE("wnd %p, style %#lx\n", hwnd, GetWindowLongW(hwnd, GWL_STYLE));
5127
5128 if (!(infoPtr = Alloc(sizeof(*infoPtr))))
5129 {
5130 ERR("could not allocate info memory!\n");
5131 return 0;
5132 }
5133
5134 SetWindowLongPtrW(hwnd, 0, (DWORD_PTR)infoPtr);
5135
5136 infoPtr->hwnd = hwnd;
5137 infoPtr->dwStyle = GetWindowLongW(hwnd, GWL_STYLE);
5138 infoPtr->Timer = 0;
5139 infoPtr->uNumItems = 0;
5140 infoPtr->cdmode = 0;
5141 infoPtr->uScrollTime = 300; /* milliseconds */
5142 infoPtr->bRedraw = TRUE;
5143
5144 GetClientRect(hwnd, &rcClient);
5145
5146 /* No scroll bars yet. */
5147 infoPtr->clientWidth = rcClient.right;
5148 infoPtr->clientHeight = rcClient.bottom;
5149 infoPtr->uInternalStatus = 0;
5150
5151 infoPtr->treeWidth = 0;
5152 infoPtr->treeHeight = 0;
5153
5154 infoPtr->uIndent = MINIMUM_INDENT;
5155 infoPtr->selectedItem = NULL;
5156 infoPtr->focusedItem = NULL;
5157 infoPtr->hotItem = NULL;
5158 infoPtr->editItem = NULL;
5159 infoPtr->firstVisible = NULL;
5160 infoPtr->maxVisibleOrder = 0;
5161 infoPtr->dropItem = NULL;
5162 infoPtr->insertMarkItem = NULL;
5163 infoPtr->insertBeforeorAfter = 0;
5164 /* dragList */
5165
5166 infoPtr->scrollX = 0;
5167 infoPtr->wheelRemainder = 0;
5168
5169 infoPtr->clrBk = CLR_NONE; /* use system color */
5170 infoPtr->clrText = CLR_NONE; /* use system color */
5171 infoPtr->clrLine = CLR_DEFAULT;
5172 infoPtr->clrInsertMark = CLR_DEFAULT;
5173
5174 /* hwndToolTip */
5175
5176 infoPtr->hwndEdit = NULL;
5177 infoPtr->wpEditOrig = NULL;
5178 infoPtr->bIgnoreEditKillFocus = FALSE;
5179 infoPtr->bLabelChanged = FALSE;
5180
5181 infoPtr->himlNormal = NULL;
5182 infoPtr->himlState = NULL;
5183 infoPtr->normalImageWidth = 0;
5184 infoPtr->normalImageHeight = 0;
5185 infoPtr->stateImageWidth = 0;
5186 infoPtr->stateImageHeight = 0;
5187
5188 infoPtr->items = DPA_Create(16);
5189
5190 SystemParametersInfoW(SPI_GETICONTITLELOGFONT, sizeof(lf), &lf, 0);
5191 infoPtr->hFont = infoPtr->hDefaultFont = CreateFontIndirectW(&lf);
5192 infoPtr->hBoldFont = TREEVIEW_CreateBoldFont(infoPtr->hFont);
5193 infoPtr->hUnderlineFont = TREEVIEW_CreateUnderlineFont(infoPtr->hFont);
5194 infoPtr->hBoldUnderlineFont = TREEVIEW_CreateBoldUnderlineFont(infoPtr->hFont);
5195 infoPtr->hcurHand = LoadCursorW(NULL, (LPWSTR)IDC_HAND);
5196
5197 infoPtr->uItemHeight = TREEVIEW_NaturalHeight(infoPtr);
5198
5199 infoPtr->root = TREEVIEW_AllocateItem(infoPtr);
5200 infoPtr->root->state = TVIS_EXPANDED;
5201 infoPtr->root->iLevel = -1;
5202 infoPtr->root->visibleOrder = -1;
5203
5204 infoPtr->hwndNotify = lpcs->hwndParent;
5205 infoPtr->hwndToolTip = 0;
5206
5207 /* Determine what type of notify should be issued (sets infoPtr->bNtfUnicode) */
5208 TREEVIEW_NotifyFormat(infoPtr, infoPtr->hwndNotify, NF_REQUERY);
5209
5210 if (!(infoPtr->dwStyle & TVS_NOTOOLTIPS))
5211 infoPtr->hwndToolTip = CreateWindowExW(0, TOOLTIPS_CLASSW, NULL, WS_POPUP,
5212 CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
5213 hwnd, 0, 0, 0);
5214
5215 /* Make sure actual scrollbar state is consistent with uInternalStatus */
5216 ShowScrollBar(hwnd, SB_VERT, FALSE);
5217 ShowScrollBar(hwnd, SB_HORZ, FALSE);
5218
5219 OpenThemeData (hwnd, themeClass);
5220
5221 return 0;
5222 }
5223
5224
5225 static LRESULT
5226 TREEVIEW_Destroy(TREEVIEW_INFO *infoPtr)
5227 {
5228 TRACE("\n");
5229
5230 /* free item data */
5231 TREEVIEW_RemoveTree(infoPtr);
5232 /* root isn't freed with other items */
5233 TREEVIEW_FreeItem(infoPtr, infoPtr->root);
5234 DPA_Destroy(infoPtr->items);
5235
5236 /* Restore original wndproc */
5237 if (infoPtr->hwndEdit)
5238 SetWindowLongPtrW(infoPtr->hwndEdit, GWLP_WNDPROC,
5239 (DWORD_PTR)infoPtr->wpEditOrig);
5240
5241 CloseThemeData (GetWindowTheme (infoPtr->hwnd));
5242
5243 /* Deassociate treeview from the window before doing anything drastic. */
5244 SetWindowLongPtrW(infoPtr->hwnd, 0, 0);
5245
5246 DeleteObject(infoPtr->hDefaultFont);
5247 DeleteObject(infoPtr->hBoldFont);
5248 DeleteObject(infoPtr->hUnderlineFont);
5249 DeleteObject(infoPtr->hBoldUnderlineFont);
5250 DestroyWindow(infoPtr->hwndToolTip);
5251 Free(infoPtr);
5252
5253 return 0;
5254 }
5255
5256 /* Miscellaneous Messages ***********************************************/
5257
5258 static LRESULT
5259 TREEVIEW_ScrollKeyDown(TREEVIEW_INFO *infoPtr, WPARAM key)
5260 {
5261 static const struct
5262 {
5263 unsigned char code;
5264 }
5265 scroll[] =
5266 {
5267 #define SCROLL_ENTRY(dir, code) { ((dir) << 7) | (code) }
5268 SCROLL_ENTRY(SB_VERT, SB_PAGEUP), /* VK_PRIOR */
5269 SCROLL_ENTRY(SB_VERT, SB_PAGEDOWN), /* VK_NEXT */
5270 SCROLL_ENTRY(SB_VERT, SB_BOTTOM), /* VK_END */
5271 SCROLL_ENTRY(SB_VERT, SB_TOP), /* VK_HOME */
5272 SCROLL_ENTRY(SB_HORZ, SB_LINEUP), /* VK_LEFT */
5273 SCROLL_ENTRY(SB_VERT, SB_LINEUP), /* VK_UP */
5274 SCROLL_ENTRY(SB_HORZ, SB_LINEDOWN), /* VK_RIGHT */
5275 SCROLL_ENTRY(SB_VERT, SB_LINEDOWN) /* VK_DOWN */
5276 #undef SCROLL_ENTRY
5277 };
5278
5279 if (key >= VK_PRIOR && key <= VK_DOWN)
5280 {
5281 unsigned char code = scroll[key - VK_PRIOR].code;
5282
5283 (((code & (1 << 7)) == (SB_HORZ << 7))
5284 ? TREEVIEW_HScroll
5285 : TREEVIEW_VScroll)(infoPtr, code & 0x7F);
5286 }
5287
5288 return 0;
5289 }
5290
5291 /************************************************************************
5292 * TREEVIEW_KeyDown
5293 *
5294 * VK_UP Move selection to the previous non-hidden item.
5295 * VK_DOWN Move selection to the next non-hidden item.
5296 * VK_HOME Move selection to the first item.
5297 * VK_END Move selection to the last item.
5298 * VK_LEFT If expanded then collapse, otherwise move to parent.
5299 * VK_RIGHT If collapsed then expand, otherwise move to first child.
5300 * VK_ADD Expand.
5301 * VK_SUBTRACT Collapse.
5302 * VK_MULTIPLY Expand all.
5303 * VK_PRIOR Move up GetVisibleCount items.
5304 * VK_NEXT Move down GetVisibleCount items.
5305 * VK_BACK Move to parent.
5306 * CTRL-Left,Right,Up,Down,PgUp,PgDown,Home,End: Scroll without changing selection
5307 */
5308 static LRESULT
5309 TREEVIEW_KeyDown(TREEVIEW_INFO *infoPtr, WPARAM wParam)
5310 {
5311 /* If it is non-NULL and different, it will be selected and visible. */
5312 TREEVIEW_ITEM *newSelection = NULL;
5313 TREEVIEW_ITEM *prevItem = infoPtr->selectedItem;
5314 NMTVKEYDOWN nmkeydown;
5315
5316 TRACE("%Ix\n", wParam);
5317
5318 nmkeydown.wVKey = wParam;
5319 nmkeydown.flags = 0;
5320 TREEVIEW_SendRealNotify(infoPtr, TVN_KEYDOWN, &nmkeydown.hdr);
5321
5322 if (prevItem == NULL)
5323 return FALSE;
5324
5325 if (GetAsyncKeyState(VK_CONTROL) & 0x8000)
5326 return TREEVIEW_ScrollKeyDown(infoPtr, wParam);
5327
5328 switch (wParam)
5329 {
5330 case VK_UP:
5331 newSelection = TREEVIEW_GetPrevListItem(infoPtr, prevItem);
5332 if (!newSelection)
5333 newSelection = infoPtr->root->firstChild;
5334 break;
5335
5336 case VK_DOWN:
5337 newSelection = TREEVIEW_GetNextListItem(infoPtr, prevItem);
5338 break;
5339
5340 case VK_RETURN:
5341 TREEVIEW_SendSimpleNotify(infoPtr, NM_RETURN);
5342 break;
5343
5344 case VK_HOME:
5345 newSelection = infoPtr->root->firstChild;
5346 break;
5347
5348 case VK_END:
5349 newSelection = TREEVIEW_GetLastListItem(infoPtr, infoPtr->root);
5350 break;
5351
5352 case VK_LEFT:
5353 if (prevItem->state & TVIS_EXPANDED)
5354 {
5355 TREEVIEW_Collapse(infoPtr, prevItem, FALSE, TRUE);
5356 }
5357 else if (prevItem->parent != infoPtr->root)
5358 {
5359 newSelection = prevItem->parent;
5360 }
5361 break;
5362
5363 case VK_RIGHT:
5364 if (TREEVIEW_HasChildren(infoPtr, prevItem))
5365 {
5366 if (!(prevItem->state & TVIS_EXPANDED))
5367 TREEVIEW_Expand(infoPtr, prevItem, FALSE, TRUE);
5368 else
5369 {
5370 newSelection = prevItem->firstChild;
5371 }
5372 }
5373
5374 break;
5375
5376 case VK_MULTIPLY:
5377 TREEVIEW_ExpandAll(infoPtr, prevItem);
5378 break;
5379
5380 case VK_ADD:
5381 TREEVIEW_Expand(infoPtr, prevItem, FALSE, TRUE);
5382 break;
5383
5384 case VK_SUBTRACT:
5385 TREEVIEW_Collapse(infoPtr, prevItem, FALSE, TRUE);
5386 break;
5387
5388 case VK_PRIOR:
5389 newSelection
5390 = TREEVIEW_GetListItem(infoPtr, prevItem,
5391 -TREEVIEW_GetVisibleCount(infoPtr));
5392 break;
5393
5394 case VK_NEXT:
5395 newSelection
5396 = TREEVIEW_GetListItem(infoPtr, prevItem,
5397 TREEVIEW_GetVisibleCount(infoPtr));
5398 break;
5399
5400 case VK_BACK:
5401 newSelection = prevItem->parent;
5402 if (newSelection == infoPtr->root)
5403 newSelection = NULL;
5404 break;
5405
5406 case VK_SPACE:
5407 if (infoPtr->dwStyle & TVS_CHECKBOXES)
5408 TREEVIEW_ToggleItemState(infoPtr, prevItem);
5409 break;
5410 }
5411
5412 if (newSelection && newSelection != prevItem)
5413 {
5414 if (TREEVIEW_DoSelectItem(infoPtr, TVGN_CARET, newSelection,
5415 TVC_BYKEYBOARD))
5416 {
5417 TREEVIEW_EnsureVisible(infoPtr, newSelection, FALSE);
5418 }
5419 }
5420
5421 return FALSE;
5422 }
5423
5424 static LRESULT
5425 TREEVIEW_MouseLeave (TREEVIEW_INFO * infoPtr)
5426 {
5427 /* remove hot effect from item */
5428 TREEVIEW_InvalidateItem(infoPtr, infoPtr->hotItem);
5429 infoPtr->hotItem = NULL;
5430
5431 return 0;
5432 }
5433
5434 static LRESULT
5435 TREEVIEW_MouseMove (TREEVIEW_INFO * infoPtr, LPARAM lParam)
5436 {
5437 TRACKMOUSEEVENT trackinfo;
5438 TREEVIEW_ITEM * item;
5439 TVHITTESTINFO ht;
5440 BOOL item_hit;
5441
5442 if (!(infoPtr->dwStyle & TVS_TRACKSELECT)) return 0;
5443
5444 /* fill in the TRACKMOUSEEVENT struct */
5445 trackinfo.cbSize = sizeof(TRACKMOUSEEVENT);
5446 trackinfo.dwFlags = TME_QUERY;
5447 trackinfo.hwndTrack = infoPtr->hwnd;
5448
5449 /* call _TrackMouseEvent to see if we are currently tracking for this hwnd */
5450 _TrackMouseEvent(&trackinfo);
5451
5452 /* Make sure tracking is enabled so we receive a WM_MOUSELEAVE message */
5453 if(!(trackinfo.dwFlags & TME_LEAVE))
5454 {
5455 trackinfo.dwFlags = TME_LEAVE; /* notify upon leaving */
5456 trackinfo.hwndTrack = infoPtr->hwnd;
5457 /* do it as fast as possible, minimal systimer latency will be used */
5458 trackinfo.dwHoverTime = 1;
5459
5460 /* call TRACKMOUSEEVENT so we receive a WM_MOUSELEAVE message */
5461 /* and can properly deactivate the hot item */
5462 _TrackMouseEvent(&trackinfo);
5463 }
5464
5465 ht.pt.x = (short)LOWORD(lParam);
5466 ht.pt.y = (short)HIWORD(lParam);
5467
5468 item = TREEVIEW_HitTest(infoPtr, &ht);
5469 item_hit = TREEVIEW_IsItemHit(infoPtr, &ht);
5470 if ((item != infoPtr->hotItem) || !item_hit)
5471 {
5472 /* redraw old hot item */
5473 TREEVIEW_InvalidateItem(infoPtr, infoPtr->hotItem);
5474 infoPtr->hotItem = NULL;
5475 if (item && item_hit)
5476 {
5477 infoPtr->hotItem = item;
5478 /* redraw new hot item */
5479 TREEVIEW_InvalidateItem(infoPtr, infoPtr->hotItem);
5480 }
5481 }
5482
5483 return 0;
5484 }
5485
5486 /* Draw themed border */
5487 static BOOL TREEVIEW_NCPaint (const TREEVIEW_INFO *infoPtr, HRGN region, LPARAM lParam)
5488 {
5489 int cxEdge, cyEdge;
5490 LONG ex_style;
5491 HTHEME theme;
5492 HDC dc;
5493 RECT r;
5494 HRGN cliprgn;
5495
5496 ex_style = GetWindowLongW(infoPtr->hwnd, GWL_EXSTYLE);
5497 if (!(ex_style & WS_EX_CLIENTEDGE))
5498 return DefWindowProcW(infoPtr->hwnd, WM_NCPAINT, (WPARAM)region, lParam);
5499
5500 theme = GetWindowTheme(infoPtr->hwnd);
5501 if (!theme)
5502 return DefWindowProcW (infoPtr->hwnd, WM_NCPAINT, (WPARAM)region, lParam);
5503
5504 GetWindowRect(infoPtr->hwnd, &r);
5505
5506 cxEdge = GetSystemMetrics(SM_CXEDGE);
5507 cyEdge = GetSystemMetrics(SM_CYEDGE);
5508 cliprgn = CreateRectRgn (r.left + cxEdge, r.top + cyEdge,
5509 r.right - cxEdge, r.bottom - cyEdge);
5510 if (region != (HRGN)1)
5511 CombineRgn (cliprgn, cliprgn, region, RGN_AND);
5512 OffsetRect(&r, -r.left, -r.top);
5513
5514 dc = GetDCEx(infoPtr->hwnd, region, DCX_WINDOW|DCX_INTERSECTRGN);
5515
5516 if (IsThemeBackgroundPartiallyTransparent (theme, 0, 0))
5517 DrawThemeParentBackground(infoPtr->hwnd, dc, &r);
5518 DrawThemeBackground (theme, dc, 0, 0, &r, 0);
5519 ReleaseDC(infoPtr->hwnd, dc);
5520
5521 /* Call default proc to get the scrollbars etc. painted */
5522 DefWindowProcW (infoPtr->hwnd, WM_NCPAINT, (WPARAM)cliprgn, 0);
5523 DeleteObject(cliprgn);
5524
5525 return TRUE;
5526 }
5527
5528 static LRESULT
5529 TREEVIEW_Notify(const TREEVIEW_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
5530 {
5531 LPNMHDR lpnmh = (LPNMHDR)lParam;
5532
5533 if (lpnmh->code == PGN_CALCSIZE) {
5534 LPNMPGCALCSIZE lppgc = (LPNMPGCALCSIZE)lParam;
5535
5536 if (lppgc->dwFlag == PGF_CALCWIDTH) {
5537 lppgc->iWidth = infoPtr->treeWidth;
5538 TRACE("got PGN_CALCSIZE, returning horz size = %ld, client= %ld\n",
5539 infoPtr->treeWidth, infoPtr->clientWidth);
5540 }
5541 else {
5542 lppgc->iHeight = infoPtr->treeHeight;
5543 TRACE("got PGN_CALCSIZE, returning vert size = %ld, client = %ld\n", infoPtr->treeHeight,
5544 infoPtr->clientHeight);
5545 }
5546 return 0;
5547 }
5548 return DefWindowProcW(infoPtr->hwnd, WM_NOTIFY, wParam, lParam);
5549 }
5550
5551 static LRESULT
5552 TREEVIEW_Size(TREEVIEW_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
5553 {
5554 if (wParam == SIZE_RESTORED)
5555 {
5556 infoPtr->clientWidth = (short)LOWORD(lParam);
5557 infoPtr->clientHeight = (short)HIWORD(lParam);
5558
5559 TREEVIEW_RecalculateVisibleOrder(infoPtr, NULL);
5560 TREEVIEW_SetFirstVisible(infoPtr, infoPtr->firstVisible, TRUE);
5561 TREEVIEW_UpdateScrollBars(infoPtr);
5562 }
5563 else
5564 {
5565 FIXME("WM_SIZE flag %Ix %Ix not handled\n", wParam, lParam);
5566 }
5567
5568 TREEVIEW_Invalidate(infoPtr, NULL);
5569 return 0;
5570 }
5571
5572 static LRESULT
5573 TREEVIEW_StyleChanged(TREEVIEW_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
5574 {
5575 TRACE("%Ix, %Ix.\n", wParam, lParam);
5576
5577 if (wParam == GWL_STYLE)
5578 {
5579 DWORD dwNewStyle = ((LPSTYLESTRUCT)lParam)->styleNew;
5580
5581 if ((infoPtr->dwStyle ^ dwNewStyle) & TVS_CHECKBOXES)
5582 {
5583 if (dwNewStyle & TVS_CHECKBOXES)
5584 {
5585 TREEVIEW_InitCheckboxes(infoPtr);
5586 TRACE("checkboxes enabled\n");
5587
5588 /* set all items to state image index 1 */
5589 TREEVIEW_ResetImageStateIndex(infoPtr, infoPtr->root);
5590 }
5591 else
5592 {
5593 FIXME("tried to disable checkboxes\n");
5594 }
5595 }
5596
5597 if ((infoPtr->dwStyle ^ dwNewStyle) & TVS_NOTOOLTIPS)
5598 {
5599 if (infoPtr->dwStyle & TVS_NOTOOLTIPS)
5600 {
5601 infoPtr->hwndToolTip = COMCTL32_CreateToolTip(infoPtr->hwnd);
5602 TRACE("tooltips enabled\n");
5603 }
5604 else
5605 {
5606 DestroyWindow(infoPtr->hwndToolTip);
5607 infoPtr->hwndToolTip = 0;
5608 TRACE("tooltips disabled\n");
5609 }
5610 }
5611
5612 infoPtr->dwStyle = dwNewStyle;
5613 }
5614
5615 TREEVIEW_EndEditLabelNow(infoPtr, TRUE);
5616 TREEVIEW_UpdateSubTree(infoPtr, infoPtr->root);
5617 TREEVIEW_UpdateScrollBars(infoPtr);
5618
5619 return 0;
5620 }
5621
5622 static LRESULT
5623 TREEVIEW_SetCursor(const TREEVIEW_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
5624 {
5625 TREEVIEW_ITEM * item;
5626 TVHITTESTINFO ht;
5627 NMMOUSE nmmouse;
5628
5629 GetCursorPos(&ht.pt);
5630 ScreenToClient(infoPtr->hwnd, &ht.pt);
5631
5632 item = TREEVIEW_HitTest(infoPtr, &ht);
5633
5634 memset(&nmmouse, 0, sizeof(nmmouse));
5635 if (item)
5636 {
5637 nmmouse.dwItemSpec = (DWORD_PTR)item;
5638 nmmouse.dwItemData = item->lParam;
5639 }
5640 nmmouse.pt.x = 0;
5641 nmmouse.pt.y = 0;
5642 nmmouse.dwHitInfo = lParam;
5643 if (TREEVIEW_SendRealNotify(infoPtr, NM_SETCURSOR, &nmmouse.hdr))
5644 return 0;
5645
5646 if (item && (infoPtr->dwStyle & TVS_TRACKSELECT) && TREEVIEW_IsItemHit(infoPtr, &ht))
5647 {
5648 SetCursor(infoPtr->hcurHand);
5649 return 0;
5650 }
5651 else
5652 return DefWindowProcW(infoPtr->hwnd, WM_SETCURSOR, wParam, lParam);
5653 }
5654
5655 static LRESULT
5656 TREEVIEW_SetFocus(TREEVIEW_INFO *infoPtr)
5657 {
5658 TRACE("\n");
5659
5660 if (!infoPtr->selectedItem)
5661 {
5662 TREEVIEW_DoSelectItem(infoPtr, TVGN_CARET, infoPtr->firstVisible,
5663 TVC_UNKNOWN);
5664 }
5665
5666 TREEVIEW_Invalidate(infoPtr, infoPtr->selectedItem);
5667 TREEVIEW_SendSimpleNotify(infoPtr, NM_SETFOCUS);
5668 return 0;
5669 }
5670
5671 static LRESULT
5672 TREEVIEW_KillFocus(const TREEVIEW_INFO *infoPtr)
5673 {
5674 TRACE("\n");
5675
5676 TREEVIEW_Invalidate(infoPtr, infoPtr->selectedItem);
5677 UpdateWindow(infoPtr->hwnd);
5678 TREEVIEW_SendSimpleNotify(infoPtr, NM_KILLFOCUS);
5679 return 0;
5680 }
5681
5682 /* update theme after a WM_THEMECHANGED message */
5683 static LRESULT TREEVIEW_ThemeChanged(const TREEVIEW_INFO *infoPtr)
5684 {
5685 HTHEME theme = GetWindowTheme (infoPtr->hwnd);
5686 CloseThemeData (theme);
5687 OpenThemeData (infoPtr->hwnd, themeClass);
5688 InvalidateRect (infoPtr->hwnd, NULL, TRUE);
5689 return 0;
5690 }
5691
5692
5693 static LRESULT WINAPI
5694 TREEVIEW_WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
5695 {
5696 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
5697
5698 TRACE("hwnd %p, msg %04x, wp %Ix, lp %Ix\n", hwnd, uMsg, wParam, lParam);
5699
5700 if (infoPtr) TREEVIEW_VerifyTree(infoPtr);
5701 else
5702 {
5703 if (uMsg == WM_CREATE)
5704 TREEVIEW_Create(hwnd, (LPCREATESTRUCTW)lParam);
5705 else
5706 goto def;
5707 }
5708
5709 switch (uMsg)
5710 {
5711 case TVM_CREATEDRAGIMAGE:
5712 return TREEVIEW_CreateDragImage(infoPtr, lParam);
5713
5714 case TVM_DELETEITEM:
5715 return TREEVIEW_DeleteItem(infoPtr, (HTREEITEM)lParam);
5716
5717 case TVM_EDITLABELA:
5718 case TVM_EDITLABELW:
5719 return (LRESULT)TREEVIEW_EditLabel(infoPtr, (HTREEITEM)lParam);
5720
5721 case TVM_ENDEDITLABELNOW:
5722 return TREEVIEW_EndEditLabelNow(infoPtr, (BOOL)wParam);
5723
5724 case TVM_ENSUREVISIBLE:
5725 return TREEVIEW_EnsureVisible(infoPtr, (HTREEITEM)lParam, TRUE);
5726
5727 case TVM_EXPAND:
5728 return TREEVIEW_ExpandMsg(infoPtr, (UINT)wParam, (HTREEITEM)lParam);
5729
5730 case TVM_GETBKCOLOR:
5731 return TREEVIEW_GetBkColor(infoPtr);
5732
5733 case TVM_GETCOUNT:
5734 return TREEVIEW_GetCount(infoPtr);
5735
5736 case TVM_GETEDITCONTROL:
5737 return TREEVIEW_GetEditControl(infoPtr);
5738
5739 case TVM_GETIMAGELIST:
5740 return TREEVIEW_GetImageList(infoPtr, wParam);
5741
5742 case TVM_GETINDENT:
5743 return TREEVIEW_GetIndent(infoPtr);
5744
5745 case TVM_GETINSERTMARKCOLOR:
5746 return TREEVIEW_GetInsertMarkColor(infoPtr);
5747
5748 case TVM_GETISEARCHSTRINGA:
5749 FIXME("Unimplemented msg TVM_GETISEARCHSTRINGA\n");
5750 return 0;
5751
5752 case TVM_GETISEARCHSTRINGW:
5753 FIXME("Unimplemented msg TVM_GETISEARCHSTRINGW\n");
5754 return 0;
5755
5756 case TVM_GETITEMA:
5757 case TVM_GETITEMW:
5758 return TREEVIEW_GetItemT(infoPtr, (LPTVITEMEXW)lParam,
5759 uMsg == TVM_GETITEMW);
5760 case TVM_GETITEMHEIGHT:
5761 return TREEVIEW_GetItemHeight(infoPtr);
5762
5763 case TVM_GETITEMRECT:
5764 return TREEVIEW_GetItemRect(infoPtr, (BOOL)wParam, (LPRECT)lParam);
5765
5766 case TVM_GETITEMSTATE:
5767 return TREEVIEW_GetItemState(infoPtr, (HTREEITEM)wParam, (UINT)lParam);
5768
5769 case TVM_GETLINECOLOR:
5770 return TREEVIEW_GetLineColor(infoPtr);
5771
5772 case TVM_GETNEXTITEM:
5773 return TREEVIEW_GetNextItem(infoPtr, (UINT)wParam, (HTREEITEM)lParam);
5774
5775 case TVM_GETSCROLLTIME:
5776 return TREEVIEW_GetScrollTime(infoPtr);
5777
5778 case TVM_GETTEXTCOLOR:
5779 return TREEVIEW_GetTextColor(infoPtr);
5780
5781 case TVM_GETTOOLTIPS:
5782 return TREEVIEW_GetToolTips(infoPtr);
5783
5784 case TVM_GETUNICODEFORMAT:
5785 return TREEVIEW_GetUnicodeFormat(infoPtr);
5786
5787 case TVM_GETVISIBLECOUNT:
5788 return TREEVIEW_GetVisibleCount(infoPtr);
5789
5790 case TVM_HITTEST:
5791 return (LRESULT)TREEVIEW_HitTest(infoPtr, (TVHITTESTINFO*)lParam);
5792
5793 case TVM_INSERTITEMA:
5794 case TVM_INSERTITEMW:
5795 return TREEVIEW_InsertItemT(infoPtr, (LPTVINSERTSTRUCTW)lParam,
5796 uMsg == TVM_INSERTITEMW);
5797 case TVM_SELECTITEM:
5798 return TREEVIEW_SelectItem(infoPtr, (INT)wParam, (HTREEITEM)lParam);
5799
5800 case TVM_SETBKCOLOR:
5801 return TREEVIEW_SetBkColor(infoPtr, (COLORREF)lParam);
5802
5803 case TVM_SETIMAGELIST:
5804 return TREEVIEW_SetImageList(infoPtr, wParam, (HIMAGELIST)lParam);
5805
5806 case TVM_SETINDENT:
5807 return TREEVIEW_SetIndent(infoPtr, (UINT)wParam);
5808
5809 case TVM_SETINSERTMARK:
5810 return TREEVIEW_SetInsertMark(infoPtr, (BOOL)wParam, (HTREEITEM)lParam);
5811
5812 case TVM_SETINSERTMARKCOLOR:
5813 return TREEVIEW_SetInsertMarkColor(infoPtr, (COLORREF)lParam);
5814
5815 case TVM_SETITEMA:
5816 case TVM_SETITEMW:
5817 return TREEVIEW_SetItemT(infoPtr, (LPTVITEMEXW)lParam,
5818 uMsg == TVM_SETITEMW);
5819 case TVM_SETLINECOLOR:
5820 return TREEVIEW_SetLineColor(infoPtr, (COLORREF)lParam);
5821
5822 case TVM_SETITEMHEIGHT:
5823 return TREEVIEW_SetItemHeight(infoPtr, (INT)(SHORT)wParam);
5824
5825 case TVM_SETSCROLLTIME:
5826 return TREEVIEW_SetScrollTime(infoPtr, (UINT)wParam);
5827
5828 case TVM_SETTEXTCOLOR:
5829 return TREEVIEW_SetTextColor(infoPtr, (COLORREF)lParam);
5830
5831 case TVM_SETTOOLTIPS:
5832 return TREEVIEW_SetToolTips(infoPtr, (HWND)wParam);
5833
5834 case TVM_SETUNICODEFORMAT:
5835 return TREEVIEW_SetUnicodeFormat(infoPtr, (BOOL)wParam);
5836
5837 case TVM_SORTCHILDREN:
5838 return TREEVIEW_SortChildren(infoPtr, lParam);
5839
5840 case TVM_SORTCHILDRENCB:
5841 return TREEVIEW_SortChildrenCB(infoPtr, (LPTVSORTCB)lParam);
5842
5843 case WM_CHAR:
5844 return TREEVIEW_ProcessLetterKeys(infoPtr, wParam, lParam);
5845
5846 case WM_COMMAND:
5847 return TREEVIEW_Command(infoPtr, wParam, lParam);
5848
5849 case WM_DESTROY:
5850 return TREEVIEW_Destroy(infoPtr);
5851
5852 /* WM_ENABLE */
5853
5854 case WM_ERASEBKGND:
5855 return TREEVIEW_EraseBackground(infoPtr, (HDC)wParam);
5856
5857 case WM_GETDLGCODE:
5858 return DLGC_WANTARROWS | DLGC_WANTCHARS;
5859
5860 case WM_GETFONT:
5861 return TREEVIEW_GetFont(infoPtr);
5862
5863 case WM_HSCROLL:
5864 return TREEVIEW_HScroll(infoPtr, wParam);
5865
5866 case WM_KEYDOWN:
5867 case WM_SYSKEYDOWN:
5868 return TREEVIEW_KeyDown(infoPtr, wParam);
5869
5870 case WM_KILLFOCUS:
5871 return TREEVIEW_KillFocus(infoPtr);
5872
5873 case WM_LBUTTONDBLCLK:
5874 return TREEVIEW_LButtonDoubleClick(infoPtr, lParam);
5875
5876 case WM_LBUTTONDOWN:
5877 return TREEVIEW_LButtonDown(infoPtr, lParam);
5878
5879 /* WM_MBUTTONDOWN */
5880
5881 case WM_MOUSELEAVE:
5882 return TREEVIEW_MouseLeave(infoPtr);
5883
5884 case WM_MOUSEMOVE:
5885 return TREEVIEW_MouseMove(infoPtr, lParam);
5886
5887 case WM_NCLBUTTONDOWN:
5888 if (infoPtr->hwndEdit)
5889 SetFocus(infoPtr->hwnd);
5890 goto def;
5891
5892 case WM_NCPAINT:
5893 return TREEVIEW_NCPaint (infoPtr, (HRGN)wParam, lParam);
5894
5895 case WM_NOTIFY:
5896 return TREEVIEW_Notify(infoPtr, wParam, lParam);
5897
5898 case WM_NOTIFYFORMAT:
5899 return TREEVIEW_NotifyFormat(infoPtr, (HWND)wParam, (UINT)lParam);
5900
5901 case WM_PRINTCLIENT:
5902 return TREEVIEW_PrintClient(infoPtr, (HDC)wParam, lParam);
5903
5904 case WM_PAINT:
5905 return TREEVIEW_Paint(infoPtr, (HDC)wParam);
5906
5907 case WM_RBUTTONDOWN:
5908 return TREEVIEW_RButtonDown(infoPtr, lParam);
5909
5910 case WM_SETCURSOR:
5911 return TREEVIEW_SetCursor(infoPtr, wParam, lParam);
5912
5913 case WM_SETFOCUS:
5914 return TREEVIEW_SetFocus(infoPtr);
5915
5916 case WM_SETFONT:
5917 return TREEVIEW_SetFont(infoPtr, (HFONT)wParam, (BOOL)lParam);
5918
5919 case WM_SETREDRAW:
5920 return TREEVIEW_SetRedraw(infoPtr, wParam);
5921
5922 case WM_SIZE:
5923 return TREEVIEW_Size(infoPtr, wParam, lParam);
5924
5925 case WM_STYLECHANGED:
5926 return TREEVIEW_StyleChanged(infoPtr, wParam, lParam);
5927
5928 case WM_SYSCOLORCHANGE:
5929 COMCTL32_RefreshSysColors();
5930 return 0;
5931
5932 case WM_TIMER:
5933 return TREEVIEW_HandleTimer(infoPtr, wParam);
5934
5935 case WM_THEMECHANGED:
5936 return TREEVIEW_ThemeChanged (infoPtr);
5937
5938 case WM_VSCROLL:
5939 return TREEVIEW_VScroll(infoPtr, wParam);
5940
5941 /* WM_WININICHANGE */
5942
5943 case WM_MOUSEWHEEL:
5944 return TREEVIEW_MouseWheel(infoPtr, wParam, lParam);
5945
5946 case WM_DRAWITEM:
5947 TRACE("drawItem\n");
5948 goto def;
5949
5950 default:
5951 /* This mostly catches MFC and Delphi messages. :( */
5952 if ((uMsg >= WM_USER) && (uMsg < WM_APP) && !COMCTL32_IsReflectedMessage(uMsg))
5953 TRACE("Unknown msg %04x wp %Ix lp %Ix\n", uMsg, wParam, lParam);
5954 def:
5955 return DefWindowProcW(hwnd, uMsg, wParam, lParam);
5956 }
5957 }
5958
5959
5960 /* Class Registration ***************************************************/
5961
5962 VOID
5963 TREEVIEW_Register(void)
5964 {
5965 WNDCLASSW wndClass;
5966
5967 TRACE("\n");
5968
5969 ZeroMemory(&wndClass, sizeof(WNDCLASSW));
5970 wndClass.style = CS_GLOBALCLASS | CS_DBLCLKS;
5971 wndClass.lpfnWndProc = TREEVIEW_WindowProc;
5972 wndClass.cbClsExtra = 0;
5973 wndClass.cbWndExtra = sizeof(TREEVIEW_INFO *);
5974
5975 wndClass.hCursor = LoadCursorW(0, (LPWSTR)IDC_ARROW);
5976 wndClass.hbrBackground = 0;
5977 wndClass.lpszClassName = WC_TREEVIEWW;
5978
5979 RegisterClassW(&wndClass);
5980 }
5981
5982
5983 VOID
5984 TREEVIEW_Unregister(void)
5985 {
5986 UnregisterClassW(WC_TREEVIEWW, NULL);
5987 }
5988
5989
5990 /* Tree Verification ****************************************************/
5991
5992 static inline void
5993 TREEVIEW_VerifyChildren(TREEVIEW_INFO *infoPtr, const TREEVIEW_ITEM *item);
5994
5995 static inline void TREEVIEW_VerifyItemCommon(TREEVIEW_INFO *infoPtr,
5996 const TREEVIEW_ITEM *item)
5997 {
5998 assert(infoPtr != NULL);
5999 assert(item != NULL);
6000
6001 /* both NULL, or both non-null */
6002 assert((item->firstChild == NULL) == (item->lastChild == NULL));
6003
6004 assert(item->firstChild != item);
6005 assert(item->lastChild != item);
6006
6007 if (item->firstChild)
6008 {
6009 assert(item->firstChild->parent == item);
6010 assert(item->firstChild->prevSibling == NULL);
6011 }
6012
6013 if (item->lastChild)
6014 {
6015 assert(item->lastChild->parent == item);
6016 assert(item->lastChild->nextSibling == NULL);
6017 }
6018
6019 assert(item->nextSibling != item);
6020 if (item->nextSibling)
6021 {
6022 assert(item->nextSibling->parent == item->parent);
6023 assert(item->nextSibling->prevSibling == item);
6024 }
6025
6026 assert(item->prevSibling != item);
6027 if (item->prevSibling)
6028 {
6029 assert(item->prevSibling->parent == item->parent);
6030 assert(item->prevSibling->nextSibling == item);
6031 }
6032 }
6033
6034 static inline void
6035 TREEVIEW_VerifyItem(TREEVIEW_INFO *infoPtr, const TREEVIEW_ITEM *item)
6036 {
6037 assert(item != NULL);
6038
6039 assert(item->parent != NULL);
6040 assert(item->parent != item);
6041 assert(item->iLevel == item->parent->iLevel + 1);
6042
6043 assert(DPA_GetPtrIndex(infoPtr->items, item) != -1);
6044
6045 TREEVIEW_VerifyItemCommon(infoPtr, item);
6046
6047 TREEVIEW_VerifyChildren(infoPtr, item);
6048 }
6049
6050 static inline void
6051 TREEVIEW_VerifyChildren(TREEVIEW_INFO *infoPtr, const TREEVIEW_ITEM *item)
6052 {
6053 const TREEVIEW_ITEM *child;
6054 assert(item != NULL);
6055
6056 for (child = item->firstChild; child != NULL; child = child->nextSibling)
6057 TREEVIEW_VerifyItem(infoPtr, child);
6058 }
6059
6060 static inline void
6061 TREEVIEW_VerifyRoot(TREEVIEW_INFO *infoPtr)
6062 {
6063 TREEVIEW_ITEM *root = infoPtr->root;
6064
6065 assert(root != NULL);
6066 assert(root->iLevel == -1);
6067 assert(root->parent == NULL);
6068 assert(root->prevSibling == NULL);
6069
6070 TREEVIEW_VerifyItemCommon(infoPtr, root);
6071
6072 TREEVIEW_VerifyChildren(infoPtr, root);
6073 }
6074
6075 static void
6076 TREEVIEW_VerifyTree(TREEVIEW_INFO *infoPtr)
6077 {
6078 if (!TRACE_ON(treeview)) return;
6079
6080 assert(infoPtr != NULL);
6081 TREEVIEW_VerifyRoot(infoPtr);
6082 }
Windows API implementation