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
7 * Note that TREEVIEW_INFO * and HTREEITEM are the same thing.
9 * Note2: All items always! have valid (allocated) pszText field.
10 * If item's text == LPSTR_TEXTCALLBACKA we allocate buffer
11 * of size TEXT_CALLBACK_SIZE in DoSetItem.
12 * We use callbackMask to keep track of fields to be updated.
15 * missing notifications: NM_SETCURSOR, TVN_GETINFOTIP, TVN_KEYDOWN,
16 * TVN_SETDISPINFO, TVN_SINGLEEXPAND
18 * missing styles: TVS_FULLROWSELECT, TVS_INFOTIP, TVS_NOSCROLL,
19 * TVS_RTLREADING, TVS_TRACKSELECT
21 * missing item styles: TVIS_CUT, TVIS_EXPANDPARTIAL
23 * Make the insertion mark look right.
24 * Scroll (instead of repaint) as much as possible.
32 #include "wine/winestring.h"
35 #include "debugtools.h"
37 /* internal structures */
39 typedef struct _TREEITEM /* HTREEITEM is a _TREEINFO *. */
50 int iIntegral; /* item height multiplier (1 is normal) */
51 int iLevel; /* indentation level:0=root level */
52 HTREEITEM parent; /* handle to parent or 0 if at root*/
53 HTREEITEM firstChild; /* handle to first child or 0 if no child*/
55 HTREEITEM prevSibling; /* handle to prev item in list, 0 if first */
56 HTREEITEM nextSibling; /* handle to next item in list, 0 if last */
62 LONG textWidth; /* horizontal text extent for pszText */
63 LONG visibleOrder; /* visible ordering, 0 is first visible item */
67 typedef struct tagTREEVIEW_INFO
70 HWND hwndNotify; /* Owner window to send notifications to */
75 UINT uNumItems; /* number of valid TREEVIEW_ITEMs */
76 INT cdmode; /* last custom draw setting */
77 UINT uScrollTime; /* max. time for scrolling in milliseconds */
78 BOOL bRedraw; /* if FALSE we validate but don't redraw in TREEVIEW_Paint() */
80 UINT uItemHeight; /* item height */
83 LONG clientWidth; /* width of control window */
84 LONG clientHeight; /* height of control window */
86 LONG treeWidth; /* width of visible tree items */
87 LONG treeHeight; /* height of visible tree items */
89 UINT uIndent; /* indentation in pixels */
90 HTREEITEM selectedItem; /* handle to selected item or 0 if none */
91 HTREEITEM hotItem; /* handle currently under cursor, 0 if none */
92 HTREEITEM focusedItem; /* item that was under the cursor when WM_LBUTTONDOWN was received */
94 HTREEITEM firstVisible; /* handle to first visible item */
96 HTREEITEM dropItem; /* handle to item selected by drag cursor */
97 HTREEITEM insertMarkItem; /* item after which insertion mark is placed */
98 BOOL insertBeforeorAfter; /* flag used by TVM_SETINSERTMARK */
99 HIMAGELIST dragList; /* Bitmap of dragged item */
104 COLORREF clrInsertMark;
110 WNDPROC wpEditOrig; /* orig window proc for subclassing edit */
111 BOOL bIgnoreEditKillFocus;
114 HIMAGELIST himlNormal;
115 int normalImageHeight;
116 int normalImageWidth;
117 HIMAGELIST himlState;
118 int stateImageHeight;
125 /* bitflags for infoPtr->uInternalStatus */
127 #define TV_HSCROLL 0x01 /* treeview too large to fit in window */
128 #define TV_VSCROLL 0x02 /* (horizontal/vertical) */
129 #define TV_LDRAG 0x04 /* Lbutton pushed to start drag */
130 #define TV_LDRAGGING 0x08 /* Lbutton pushed, mouse moved. */
131 #define TV_RDRAG 0x10 /* dito Rbutton */
132 #define TV_RDRAGGING 0x20
134 /* bitflags for infoPtr->timer */
136 #define TV_EDIT_TIMER 2
137 #define TV_EDIT_TIMER_SET 2
140 VOID TREEVIEW_Register (VOID);
141 VOID TREEVIEW_Unregister (VOID);
144 DEFAULT_DEBUG_CHANNEL(treeview);
147 #define TEXT_CALLBACK_SIZE 260
149 #define TREEVIEW_LEFT_MARGIN 8
151 #define MINIMUM_INDENT 19
153 #define CALLBACK_MASK_ALL (TVIF_TEXT|TVIF_CHILDREN|TVIF_IMAGE|TVIF_SELECTEDIMAGE)
155 #define STATEIMAGEINDEX(x) (((x) >> 12) & 0x0f)
156 #define OVERLAYIMAGEINDEX(x) (((x) >> 8) & 0x0f)
157 #define ISVISIBLE(x) ((x)->visibleOrder >= 0)
160 typedef VOID (*TREEVIEW_ItemEnumFunc)(TREEVIEW_INFO *, TREEVIEW_ITEM *,LPVOID);
163 static VOID TREEVIEW_QueueRefresh(TREEVIEW_INFO *);
164 static VOID TREEVIEW_QueueItemRefresh(TREEVIEW_INFO *, TREEVIEW_ITEM *);
166 static LRESULT TREEVIEW_DoSelectItem(TREEVIEW_INFO *, INT, HTREEITEM, INT);
167 static VOID TREEVIEW_SetFirstVisible(TREEVIEW_INFO *, TREEVIEW_ITEM *, BOOL);
168 static LRESULT TREEVIEW_EnsureVisible(TREEVIEW_INFO *, HTREEITEM, BOOL);
169 static LRESULT TREEVIEW_RButtonUp(TREEVIEW_INFO *, LPPOINT);
170 static LRESULT TREEVIEW_EndEditLabelNow(TREEVIEW_INFO *infoPtr, BOOL bCancel);
171 static VOID TREEVIEW_UpdateScrollBars(TREEVIEW_INFO *infoPtr);
172 static LRESULT TREEVIEW_HScroll(TREEVIEW_INFO *, WPARAM);
175 /* Random Utilities *****************************************************/
179 TREEVIEW_VerifyTree(TREEVIEW_INFO *infoPtr)
184 /* The definition is at the end of the file. */
185 static void TREEVIEW_VerifyTree(TREEVIEW_INFO *infoPtr);
188 /* Returns the treeview private data if hwnd is a treeview.
189 * Otherwise returns an undefined value. */
190 static TREEVIEW_INFO *
191 TREEVIEW_GetInfoPtr(HWND hwnd)
193 return (TREEVIEW_INFO *)GetWindowLongA(hwnd, 0);
196 /* Don't call this. Nothing wants an item index. */
198 TREEVIEW_GetItemIndex(TREEVIEW_INFO *infoPtr, HTREEITEM handle)
200 assert(infoPtr != NULL);
202 return DPA_GetPtrIndex(infoPtr->items, handle);
205 /***************************************************************************
206 * This method checks that handle is an item for this tree.
209 TREEVIEW_ValidItem(TREEVIEW_INFO *infoPtr, HTREEITEM handle)
211 if (TREEVIEW_GetItemIndex(infoPtr, handle) == -1)
213 TRACE("invalid item %p\n", handle);
221 TREEVIEW_CreateBoldFont(HFONT hOrigFont)
225 GetObjectA(hOrigFont, sizeof(font), &font);
226 font.lfWeight = FW_BOLD;
227 return CreateFontIndirectA(&font);
231 TREEVIEW_FontForItem(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *item)
233 return (item->state & TVIS_BOLD) ? infoPtr->hBoldFont : infoPtr->hFont;
236 /* for trace/debugging purposes only */
238 TREEVIEW_ItemName(TREEVIEW_ITEM *item)
240 if (item == NULL) return "<null item>";
241 if (item->pszText == LPSTR_TEXTCALLBACKA) return "<callback>";
242 if (item->pszText == NULL) return "<null>";
243 return item->pszText;
246 /* An item is not a child of itself. */
248 TREEVIEW_IsChildOf(TREEVIEW_ITEM *parent, TREEVIEW_ITEM *child)
252 child = child->parent;
253 if (child == parent) return TRUE;
254 } while (child != NULL);
260 /* Tree Traversal *******************************************************/
262 /***************************************************************************
263 * This method returns the last expanded sibling or child child item
266 static TREEVIEW_ITEM *
267 TREEVIEW_GetLastListItem(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *wineItem)
272 while (wineItem->lastChild)
274 if (wineItem->state & TVIS_EXPANDED)
275 wineItem = wineItem->lastChild;
280 if (wineItem == infoPtr->root)
286 /***************************************************************************
287 * This method returns the previous non-hidden item in the list not
288 * considering the tree hierarchy.
290 static TREEVIEW_ITEM *
291 TREEVIEW_GetPrevListItem(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *tvItem)
293 if (tvItem->prevSibling)
295 /* This item has a prevSibling, get the last item in the sibling's tree. */
296 TREEVIEW_ITEM *upItem = tvItem->prevSibling;
298 if ((upItem->state & TVIS_EXPANDED) && upItem->lastChild != NULL)
299 return TREEVIEW_GetLastListItem(infoPtr, upItem->lastChild);
305 /* this item does not have a prevSibling, get the parent */
306 return (tvItem->parent != infoPtr->root) ? tvItem->parent : NULL;
311 /***************************************************************************
312 * This method returns the next physical item in the treeview not
313 * considering the tree hierarchy.
315 static TREEVIEW_ITEM *
316 TREEVIEW_GetNextListItem(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *tvItem)
318 assert(tvItem != NULL);
321 * If this item has children and is expanded, return the first child
323 if ((tvItem->state & TVIS_EXPANDED) && tvItem->firstChild != NULL)
325 return tvItem->firstChild;
330 * try to get the sibling
332 if (tvItem->nextSibling)
333 return tvItem->nextSibling;
336 * Otherwise, get the parent's sibling.
338 while (tvItem->parent)
340 tvItem = tvItem->parent;
342 if (tvItem->nextSibling)
343 return tvItem->nextSibling;
349 /***************************************************************************
350 * This method returns the nth item starting at the given item. It returns
351 * the last item (or first) we we run out of items.
353 * Will scroll backward if count is <0.
354 * forward if count is >0.
356 static TREEVIEW_ITEM *
357 TREEVIEW_GetListItem(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *wineItem,
360 TREEVIEW_ITEM *(*next_item)(TREEVIEW_INFO *, TREEVIEW_ITEM *);
361 TREEVIEW_ITEM *previousItem;
363 assert(wineItem != NULL);
367 next_item = TREEVIEW_GetNextListItem;
372 next_item = TREEVIEW_GetPrevListItem;
379 previousItem = wineItem;
380 wineItem = next_item(infoPtr, wineItem);
382 } while (--count && wineItem != NULL);
385 return wineItem ? wineItem : previousItem;
388 /* Notifications ************************************************************/
391 TREEVIEW_SendSimpleNotify(TREEVIEW_INFO *infoPtr, UINT code)
394 HWND hwnd = infoPtr->hwnd;
397 nmhdr.hwndFrom = hwnd;
398 nmhdr.idFrom = GetWindowLongA(hwnd, GWL_ID);
401 return (BOOL)SendMessageA(infoPtr->hwndNotify, WM_NOTIFY,
402 (WPARAM)nmhdr.idFrom, (LPARAM)&nmhdr);
406 TREEVIEW_TVItemFromItem(UINT mask, TVITEMA *tvItem, TREEVIEW_ITEM *item)
409 tvItem->hItem = item;
410 tvItem->state = item->state;
411 tvItem->stateMask = 0;
412 tvItem->iImage = item->iImage;
413 tvItem->pszText = item->pszText;
414 tvItem->cchTextMax = item->cchTextMax;
415 tvItem->iImage = item->iImage;
416 tvItem->iSelectedImage = item->iSelectedImage;
417 tvItem->cChildren = item->cChildren;
418 tvItem->lParam = item->lParam;
422 TREEVIEW_SendTreeviewNotify(TREEVIEW_INFO *infoPtr, UINT code, UINT action,
423 UINT mask, HTREEITEM oldItem, HTREEITEM newItem)
425 HWND hwnd = infoPtr->hwnd;
428 TRACE("code:%x action:%x olditem:%p newitem:%p\n",
429 code, action, oldItem, newItem);
431 ZeroMemory(&nmhdr, sizeof(NMTREEVIEWA));
433 nmhdr.hdr.hwndFrom = hwnd;
434 nmhdr.hdr.idFrom = GetWindowLongA(hwnd, GWL_ID);
435 nmhdr.hdr.code = code;
436 nmhdr.action = action;
439 TREEVIEW_TVItemFromItem(mask, &nmhdr.itemOld, oldItem);
442 TREEVIEW_TVItemFromItem(mask, &nmhdr.itemNew, newItem);
447 return (BOOL)SendMessageA(infoPtr->hwndNotify, WM_NOTIFY,
448 (WPARAM)GetWindowLongA(hwnd, GWL_ID),
453 TREEVIEW_SendTreeviewDnDNotify(TREEVIEW_INFO *infoPtr, UINT code,
454 HTREEITEM dragItem, POINT pt)
456 HWND hwnd = infoPtr->hwnd;
459 TRACE("code:%x dragitem:%p\n", code, dragItem);
461 nmhdr.hdr.hwndFrom = hwnd;
462 nmhdr.hdr.idFrom = GetWindowLongA(hwnd, GWL_ID);
463 nmhdr.hdr.code = code;
465 nmhdr.itemNew.mask = TVIF_STATE | TVIF_PARAM | TVIF_HANDLE;
466 nmhdr.itemNew.hItem = dragItem;
467 nmhdr.itemNew.state = dragItem->state;
468 nmhdr.itemNew.lParam = dragItem->lParam;
470 nmhdr.ptDrag.x = pt.x;
471 nmhdr.ptDrag.y = pt.y;
473 return (BOOL)SendMessageA(infoPtr->hwndNotify, WM_NOTIFY,
474 (WPARAM)GetWindowLongA(hwnd, GWL_ID),
480 TREEVIEW_SendCustomDrawNotify(TREEVIEW_INFO *infoPtr, DWORD dwDrawStage,
483 HWND hwnd = infoPtr->hwnd;
484 NMTVCUSTOMDRAW nmcdhdr;
487 TRACE("drawstage:%lx hdc:%x\n", dwDrawStage, hdc);
489 nmcd = &nmcdhdr.nmcd;
490 nmcd->hdr.hwndFrom = hwnd;
491 nmcd->hdr.idFrom = GetWindowLongA(hwnd, GWL_ID);
492 nmcd->hdr.code = NM_CUSTOMDRAW;
493 nmcd->dwDrawStage = dwDrawStage;
496 nmcd->dwItemSpec = 0;
497 nmcd->uItemState = 0;
498 nmcd->lItemlParam = 0;
499 nmcdhdr.clrText = infoPtr->clrText;
500 nmcdhdr.clrTextBk = infoPtr->clrBk;
503 return (BOOL)SendMessageA(infoPtr->hwndNotify, WM_NOTIFY,
504 (WPARAM)GetWindowLongA(hwnd, GWL_ID),
510 /* FIXME: need to find out when the flags in uItemState need to be set */
513 TREEVIEW_SendCustomDrawItemNotify(TREEVIEW_INFO *infoPtr, HDC hdc,
514 TREEVIEW_ITEM *wineItem, UINT uItemDrawState)
516 HWND hwnd = infoPtr->hwnd;
517 NMTVCUSTOMDRAW nmcdhdr;
519 DWORD dwDrawStage, dwItemSpec;
523 dwDrawStage = CDDS_ITEM | uItemDrawState;
524 dwItemSpec = (DWORD)wineItem;
526 if (wineItem->state & TVIS_SELECTED)
527 uItemState |= CDIS_SELECTED;
528 if (wineItem == infoPtr->selectedItem)
529 uItemState |= CDIS_FOCUS;
530 if (wineItem == infoPtr->hotItem)
531 uItemState |= CDIS_HOT;
533 nmcd = &nmcdhdr.nmcd;
534 nmcd->hdr.hwndFrom = hwnd;
535 nmcd->hdr.idFrom = GetWindowLongA(hwnd, GWL_ID);
536 nmcd->hdr.code = NM_CUSTOMDRAW;
537 nmcd->dwDrawStage = dwDrawStage;
539 nmcd->rc = wineItem->rect;
540 nmcd->dwItemSpec = dwItemSpec;
541 nmcd->uItemState = uItemState;
542 nmcd->lItemlParam = wineItem->lParam;
543 nmcdhdr.clrText = infoPtr->clrText;
544 nmcdhdr.clrTextBk = infoPtr->clrBk;
545 nmcdhdr.iLevel = wineItem->iLevel;
547 TRACE("drawstage:%lx hdc:%x item:%lx, itemstate:%x, lItemlParam:%lx\n",
548 nmcd->dwDrawStage, nmcd->hdc, nmcd->dwItemSpec,
549 nmcd->uItemState, nmcd->lItemlParam);
551 retval = SendMessageA(infoPtr->hwndNotify, WM_NOTIFY,
552 (WPARAM)GetWindowLongA(hwnd, GWL_ID),
555 infoPtr->clrText = nmcdhdr.clrText;
556 infoPtr->clrBk = nmcdhdr.clrTextBk;
561 TREEVIEW_BeginLabelEditNotify(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *editItem)
563 HWND hwnd = infoPtr->hwnd;
566 tvdi.hdr.hwndFrom = hwnd;
567 tvdi.hdr.idFrom = GetWindowLongA(hwnd, GWL_ID);
568 tvdi.hdr.code = TVN_BEGINLABELEDITA;
570 tvdi.item.mask = TVIF_HANDLE | TVIF_STATE | TVIF_PARAM | TVIF_TEXT;
571 tvdi.item.hItem = editItem;
572 tvdi.item.state = editItem->state;
573 tvdi.item.lParam = editItem->lParam;
574 tvdi.item.pszText = editItem->pszText;
575 tvdi.item.cchTextMax = editItem->cchTextMax;
577 return SendMessageA(infoPtr->hwndNotify, WM_NOTIFY, tvdi.hdr.idFrom,
582 TREEVIEW_UpdateDispInfo(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *wineItem,
585 NMTVDISPINFOA callback;
586 HWND hwnd = infoPtr->hwnd;
588 mask &= wineItem->callbackMask;
590 if (mask == 0) return;
592 callback.hdr.hwndFrom = hwnd;
593 callback.hdr.idFrom = GetWindowLongA(hwnd, GWL_ID);
594 callback.hdr.code = TVN_GETDISPINFOA;
596 /* 'state' always contains valid value, as well as 'lParam'.
597 * All other parameters are uninitialized.
599 callback.item.pszText = wineItem->pszText;
600 callback.item.cchTextMax = wineItem->cchTextMax;
601 callback.item.mask = mask;
602 callback.item.hItem = wineItem;
603 callback.item.state = wineItem->state;
604 callback.item.lParam = wineItem->lParam;
606 /* If text is changed we need to recalculate textWidth */
607 if (mask & TVIF_TEXT)
608 wineItem->textWidth = 0;
610 SendMessageA(infoPtr->hwndNotify, WM_NOTIFY, callback.hdr.idFrom, (LPARAM)&callback);
612 /* It may have changed due to a call to SetItem. */
613 mask &= wineItem->callbackMask;
615 if ((mask & TVIF_TEXT) && callback.item.pszText != wineItem->pszText)
617 /* Instead of copying text into our buffer user specified its own */
618 int len = max(lstrlenA(callback.item.pszText) + 1, TEXT_CALLBACK_SIZE);
619 LPSTR newText = COMCTL32_ReAlloc(wineItem->pszText, len);
623 wineItem->pszText = newText;
624 strcpy(wineItem->pszText, callback.item.pszText);
625 wineItem->cchTextMax = len;
627 /* If ReAlloc fails we have nothing to do, but keep original text */
630 if (mask & TVIF_IMAGE)
631 wineItem->iImage = callback.item.iImage;
633 if (mask & TVIF_SELECTEDIMAGE)
634 wineItem->iSelectedImage = callback.item.iSelectedImage;
636 if (mask & TVIF_CHILDREN)
637 wineItem->cChildren = callback.item.cChildren;
639 /* These members are now permanently set. */
640 if (callback.item.mask & TVIF_DI_SETITEM)
641 wineItem->callbackMask &= ~callback.item.mask;
644 /***************************************************************************
645 * This function uses cChildren field to decide whether the item has
647 * Note: if this returns TRUE, the child items may not actually exist,
648 * they could be virtual.
650 * Just use wineItem->firstChild to check for physical children.
653 TREEVIEW_HasChildren(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *wineItem)
655 TREEVIEW_UpdateDispInfo(infoPtr, wineItem, TVIF_CHILDREN);
657 return wineItem->cChildren > 0;
661 /* Item Position ********************************************************/
663 /* Compute linesOffset, stateOffset, imageOffset, textOffset of an item. */
665 TREEVIEW_ComputeItemInternalMetrics(TREEVIEW_INFO *infoPtr,
668 /* Same effect, different optimisation. */
670 BOOL lar = ((infoPtr->dwStyle & TVS_LINESATROOT)
671 && (infoPtr->dwStyle & (TVS_HASLINES|TVS_HASBUTTONS)));
673 BOOL lar = ((infoPtr->dwStyle
674 & (TVS_LINESATROOT|TVS_HASLINES|TVS_HASBUTTONS))
678 item->linesOffset = infoPtr->uIndent * (item->iLevel + lar - 1)
680 item->stateOffset = item->linesOffset + infoPtr->uIndent;
681 item->imageOffset = item->stateOffset
682 + (STATEIMAGEINDEX(item->state) ? infoPtr->stateImageWidth : 0);
683 item->textOffset = item->imageOffset + infoPtr->normalImageWidth;
687 TREEVIEW_ComputeTextWidth(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *item, HDC hDC)
693 /* DRAW's OM docker creates items like this */
694 if (item->pszText == NULL)
700 if (item->textWidth != 0 && !(item->callbackMask & TVIF_TEXT))
709 hdc = GetDC(infoPtr->hwnd);
710 hOldFont = SelectObject(hdc, TREEVIEW_FontForItem(infoPtr, item));
713 GetTextExtentPoint32A(hdc, item->pszText, strlen(item->pszText), &sz);
714 item->textWidth = sz.cx;
718 SelectObject(hdc, hOldFont);
724 TREEVIEW_ComputeItemRect(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *item)
726 item->rect.top = infoPtr->uItemHeight *
727 (item->visibleOrder - infoPtr->firstVisible->visibleOrder);
729 item->rect.bottom = item->rect.top
730 + infoPtr->uItemHeight * item->iIntegral - 1;
733 item->rect.right = infoPtr->clientWidth;
736 /* We know that only items after start need their order updated. */
738 TREEVIEW_RecalculateVisibleOrder(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *start)
745 start = infoPtr->root->firstChild;
749 order = start->visibleOrder;
751 for (item = start; item != NULL;
752 item = TREEVIEW_GetNextListItem(infoPtr, item))
754 item->visibleOrder = order;
755 order += item->iIntegral;
758 infoPtr->maxVisibleOrder = order;
760 for (item = start; item != NULL;
761 item = TREEVIEW_GetNextListItem(infoPtr, item))
763 TREEVIEW_ComputeItemRect(infoPtr, item);
768 /* Update metrics of all items in selected subtree.
769 * root must be expanded
772 TREEVIEW_UpdateSubTree(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *root)
774 TREEVIEW_ITEM *sibling;
778 if (!root->firstChild || !(root->state & TVIS_EXPANDED))
781 root->state &= ~TVIS_EXPANDED;
782 sibling = TREEVIEW_GetNextListItem(infoPtr, root);
783 root->state |= TVIS_EXPANDED;
785 hdc = GetDC(infoPtr->hwnd);
786 hOldFont = SelectObject(hdc, infoPtr->hFont);
788 for (; root != sibling;
789 root = TREEVIEW_GetNextListItem(infoPtr, root))
791 TREEVIEW_ComputeItemInternalMetrics(infoPtr, root);
793 if (root->callbackMask & TVIF_TEXT)
794 TREEVIEW_UpdateDispInfo(infoPtr, root, TVIF_TEXT);
796 if (root->textWidth == 0)
798 SelectObject(hdc, TREEVIEW_FontForItem(infoPtr, root));
799 TREEVIEW_ComputeTextWidth(infoPtr, root, hdc);
803 SelectObject(hdc, hOldFont);
804 ReleaseDC(infoPtr->hwnd, hdc);
807 /* Item Allocation **********************************************************/
809 static TREEVIEW_ITEM *
810 TREEVIEW_AllocateItem(TREEVIEW_INFO *infoPtr)
812 TREEVIEW_ITEM *newItem = COMCTL32_Alloc(sizeof(TREEVIEW_ITEM));
817 if (DPA_InsertPtr(infoPtr->items, INT_MAX, newItem) == -1)
819 COMCTL32_Free(newItem);
826 /* Exact opposite of TREEVIEW_AllocateItem. In particular, it does not
827 * free item->pszText. */
829 TREEVIEW_FreeItem(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *item)
831 DPA_DeletePtr(infoPtr->items, DPA_GetPtrIndex(infoPtr->items, item));
836 /* Item Insertion *******************************************************/
838 /***************************************************************************
839 * This method inserts newItem before sibling as a child of parent.
840 * sibling can be NULL, but only if parent has no children.
843 TREEVIEW_InsertBefore(TREEVIEW_ITEM *newItem, TREEVIEW_ITEM *sibling,
844 TREEVIEW_ITEM *parent)
846 assert(newItem != NULL);
847 assert(parent != NULL);
851 assert(sibling->parent == parent);
853 if (sibling->prevSibling != NULL)
854 sibling->prevSibling->nextSibling = newItem;
856 newItem->prevSibling = sibling->prevSibling;
857 sibling->prevSibling = newItem;
860 newItem->prevSibling = NULL;
862 newItem->nextSibling = sibling;
864 if (parent->firstChild == sibling)
865 parent->firstChild = newItem;
867 if (parent->lastChild == NULL)
868 parent->lastChild = newItem;
871 /***************************************************************************
872 * This method inserts newItem after sibling as a child of parent.
873 * sibling can be NULL, but only if parent has no children.
876 TREEVIEW_InsertAfter(TREEVIEW_ITEM *newItem, TREEVIEW_ITEM *sibling,
877 TREEVIEW_ITEM *parent)
879 assert(newItem != NULL);
880 assert(parent != NULL);
884 assert(sibling->parent == parent);
886 if (sibling->nextSibling != NULL)
887 sibling->nextSibling->prevSibling = newItem;
889 newItem->nextSibling = sibling->nextSibling;
890 sibling->nextSibling = newItem;
893 newItem->nextSibling = NULL;
895 newItem->prevSibling = sibling;
897 if (parent->lastChild == sibling)
898 parent->lastChild = newItem;
900 if (parent->firstChild == NULL)
901 parent->firstChild = newItem;
905 TREEVIEW_DoSetItem(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *wineItem,
906 const TVITEMEXA *tvItem)
908 UINT callbackClear = 0;
909 UINT callbackSet = 0;
911 /* Do this first in case it fails. */
912 if (tvItem->mask & TVIF_TEXT)
914 if (tvItem->pszText != LPSTR_TEXTCALLBACKA)
916 int len = lstrlenA(tvItem->pszText) + 1;
917 LPSTR newText = COMCTL32_ReAlloc(wineItem->pszText, len);
919 if (newText == NULL) return FALSE;
921 callbackClear |= TVIF_TEXT;
923 wineItem->pszText = newText;
924 wineItem->cchTextMax = len;
925 lstrcpynA(wineItem->pszText, tvItem->pszText, len);
929 callbackSet |= TVIF_TEXT;
931 wineItem->pszText = COMCTL32_ReAlloc(wineItem->pszText,
933 wineItem->cchTextMax = TEXT_CALLBACK_SIZE;
937 if (tvItem->mask & TVIF_CHILDREN)
939 wineItem->cChildren = tvItem->cChildren;
941 if (wineItem->cChildren == I_CHILDRENCALLBACK)
942 callbackSet |= TVIF_CHILDREN;
944 callbackClear |= TVIF_CHILDREN;
947 if (tvItem->mask & TVIF_IMAGE)
949 wineItem->iImage = tvItem->iImage;
951 if (wineItem->iImage == I_IMAGECALLBACK)
952 callbackSet |= TVIF_IMAGE;
954 callbackClear |= TVIF_IMAGE;
957 if (tvItem->mask & TVIF_SELECTEDIMAGE)
959 wineItem->iSelectedImage = tvItem->iSelectedImage;
961 if (wineItem->iSelectedImage == I_IMAGECALLBACK)
962 callbackSet |= TVIF_SELECTEDIMAGE;
964 callbackClear |= TVIF_SELECTEDIMAGE;
967 if (tvItem->mask & TVIF_PARAM)
968 wineItem->lParam = tvItem->lParam;
970 /* If the application sets TVIF_INTEGRAL without
971 * supplying a TVITEMEX structure, it's toast. */
972 if (tvItem->mask & TVIF_INTEGRAL)
973 wineItem->iIntegral = tvItem->iIntegral;
975 if (tvItem->mask & TVIF_STATE)
977 TRACE("prevstate,state,mask:%x,%x,%x\n", wineItem->state, tvItem->state,
979 wineItem->state &= ~tvItem->stateMask;
980 wineItem->state |= (tvItem->state & tvItem->stateMask);
983 wineItem->callbackMask |= callbackSet;
984 wineItem->callbackMask &= ~callbackClear;
989 /* Note that the new item is pre-zeroed. */
991 TREEVIEW_InsertItemA(TREEVIEW_INFO *infoPtr, LPARAM lParam)
993 const TVINSERTSTRUCTA *ptdi = (LPTVINSERTSTRUCTA) lParam;
994 const TVITEMEXA *tvItem = &ptdi->DUMMYUNIONNAME.itemex;
995 HTREEITEM insertAfter;
996 TREEVIEW_ITEM *newItem, *parentItem;
997 BOOL bTextUpdated = FALSE;
999 if (ptdi->hParent == TVI_ROOT || ptdi->hParent == 0)
1001 parentItem = infoPtr->root;
1005 parentItem = ptdi->hParent;
1007 if (!TREEVIEW_ValidItem(infoPtr, parentItem))
1009 WARN("invalid parent %p\n", parentItem);
1010 return (LRESULT)(HTREEITEM)NULL;
1014 insertAfter = ptdi->hInsertAfter;
1016 /* Validate this now for convenience. */
1017 switch ((DWORD)insertAfter)
1019 case (DWORD)TVI_FIRST:
1020 case (DWORD)TVI_LAST:
1021 case (DWORD)TVI_SORT:
1025 if (!TREEVIEW_ValidItem(infoPtr, insertAfter) ||
1026 insertAfter->parent != parentItem)
1028 WARN("invalid insert after %p\n", insertAfter);
1029 insertAfter = TVI_LAST;
1033 TRACE("parent %p position %p: '%s'\n", parentItem, insertAfter,
1034 (tvItem->mask & TVIF_TEXT)
1035 ? ((tvItem->pszText == LPSTR_TEXTCALLBACKA) ? "<callback>"
1039 newItem = TREEVIEW_AllocateItem(infoPtr);
1040 if (newItem == NULL)
1041 return (LRESULT)(HTREEITEM)NULL;
1043 newItem->parent = parentItem;
1044 newItem->iIntegral = 1;
1046 if (!TREEVIEW_DoSetItem(infoPtr, newItem, tvItem))
1047 return (LRESULT)(HTREEITEM)NULL;
1049 /* After this point, nothing can fail. (Except for TVI_SORT.) */
1051 infoPtr->uNumItems++;
1053 switch ((DWORD)insertAfter)
1055 case (DWORD)TVI_FIRST:
1056 if (infoPtr->firstVisible == parentItem->firstChild)
1057 TREEVIEW_SetFirstVisible(infoPtr, newItem, TRUE);
1058 TREEVIEW_InsertBefore(newItem, parentItem->firstChild, parentItem);
1061 case (DWORD)TVI_LAST:
1062 TREEVIEW_InsertAfter(newItem, parentItem->lastChild, parentItem);
1065 /* hInsertAfter names a specific item we want to insert after */
1067 TREEVIEW_InsertAfter(newItem, insertAfter, insertAfter->parent);
1070 case (DWORD)TVI_SORT:
1072 TREEVIEW_ITEM *aChild;
1073 TREEVIEW_ITEM *previousChild = NULL;
1074 BOOL bItemInserted = FALSE;
1076 aChild = parentItem->firstChild;
1078 bTextUpdated = TRUE;
1079 TREEVIEW_UpdateDispInfo(infoPtr, newItem, TVIF_TEXT);
1081 /* Iterate the parent children to see where we fit in */
1082 while (aChild != NULL)
1086 TREEVIEW_UpdateDispInfo(infoPtr, aChild, TVIF_TEXT);
1087 comp = lstrcmpA(newItem->pszText, aChild->pszText);
1089 if (comp < 0) /* we are smaller than the current one */
1091 TREEVIEW_InsertBefore(newItem, aChild, parentItem);
1092 bItemInserted = TRUE;
1095 else if (comp > 0) /* we are bigger than the current one */
1097 previousChild = aChild;
1099 /* This will help us to exit if there is no more sibling */
1100 aChild = (aChild->nextSibling == 0)
1102 : aChild->nextSibling;
1104 /* Look at the next item */
1110 * An item with this name is already existing, therefore,
1111 * we add after the one we found
1113 TREEVIEW_InsertAfter(newItem, aChild, parentItem);
1114 bItemInserted = TRUE;
1120 * we reach the end of the child list and the item has not
1121 * yet been inserted, therefore, insert it after the last child.
1123 if ((!bItemInserted) && (aChild == NULL))
1124 TREEVIEW_InsertAfter(newItem, previousChild, parentItem);
1131 TRACE("new item %p; parent %p, mask %x\n", newItem,
1132 newItem->parent, tvItem->mask);
1134 newItem->iLevel = newItem->parent->iLevel + 1;
1136 if (newItem->parent->cChildren == 0)
1137 newItem->parent->cChildren = 1;
1139 if (infoPtr->dwStyle & TVS_CHECKBOXES)
1141 if (STATEIMAGEINDEX(newItem->state) == 0)
1142 newItem->state |= INDEXTOSTATEIMAGEMASK(1);
1145 if (infoPtr->firstVisible == NULL)
1146 infoPtr->firstVisible = newItem;
1148 TREEVIEW_VerifyTree(infoPtr);
1150 if (parentItem == infoPtr->root ||
1151 (ISVISIBLE(parentItem) && parentItem->state & TVIS_EXPANDED))
1153 TREEVIEW_ITEM *prev = TREEVIEW_GetPrevListItem(infoPtr, newItem);
1155 TREEVIEW_RecalculateVisibleOrder(infoPtr, prev);
1156 TREEVIEW_ComputeItemInternalMetrics(infoPtr, newItem);
1159 TREEVIEW_UpdateDispInfo(infoPtr, newItem, TVIF_TEXT);
1161 TREEVIEW_ComputeTextWidth(infoPtr, newItem, 0);
1162 TREEVIEW_UpdateScrollBars(infoPtr);
1163 TREEVIEW_QueueRefresh(infoPtr);
1167 newItem->visibleOrder = -1;
1169 /* refresh treeview if newItem is the first item inserted under parentItem */
1170 if (ISVISIBLE(parentItem) && newItem->prevSibling == newItem->nextSibling)
1172 /* parent got '+' - update it */
1173 TREEVIEW_QueueItemRefresh(infoPtr, parentItem);
1177 return (LRESULT)newItem;
1182 TREEVIEW_InsertItemW(TREEVIEW_INFO *infoPtr, LPARAM lParam)
1184 TVINSERTSTRUCTW *tvisW;
1185 TVINSERTSTRUCTA tvisA;
1188 tvisW = (LPTVINSERTSTRUCTW) lParam;
1190 tvisA.hParent = tvisW->hParent;
1191 tvisA.hInsertAfter = tvisW->hInsertAfter;
1193 tvisA.DUMMYUNIONNAME.item.mask = tvisW->DUMMYUNIONNAME.item.mask;
1194 tvisA.DUMMYUNIONNAME.item.hItem = tvisW->DUMMYUNIONNAME.item.hItem;
1195 tvisA.DUMMYUNIONNAME.item.state = tvisW->DUMMYUNIONNAME.item.state;
1196 tvisA.DUMMYUNIONNAME.item.stateMask = tvisW->DUMMYUNIONNAME.item.stateMask;
1197 tvisA.DUMMYUNIONNAME.item.cchTextMax =
1198 tvisW->DUMMYUNIONNAME.item.cchTextMax;
1200 if (tvisW->DUMMYUNIONNAME.item.pszText)
1202 if (tvisW->DUMMYUNIONNAME.item.pszText != LPSTR_TEXTCALLBACKW)
1204 int len = lstrlenW(tvisW->DUMMYUNIONNAME.item.pszText) + 1;
1206 tvisA.DUMMYUNIONNAME.item.pszText = COMCTL32_Alloc(len);
1207 lstrcpyWtoA(tvisA.DUMMYUNIONNAME.item.pszText,
1208 tvisW->DUMMYUNIONNAME.item.pszText);
1212 tvisA.DUMMYUNIONNAME.item.pszText = LPSTR_TEXTCALLBACKA;
1213 tvisA.DUMMYUNIONNAME.item.cchTextMax = 0;
1217 tvisA.DUMMYUNIONNAME.item.iImage = tvisW->DUMMYUNIONNAME.item.iImage;
1218 tvisA.DUMMYUNIONNAME.item.iSelectedImage =
1219 tvisW->DUMMYUNIONNAME.item.iSelectedImage;
1220 tvisA.DUMMYUNIONNAME.item.cChildren = tvisW->DUMMYUNIONNAME.item.cChildren;
1221 tvisA.DUMMYUNIONNAME.item.lParam = tvisW->DUMMYUNIONNAME.item.lParam;
1223 lRes = TREEVIEW_InsertItemA(infoPtr, (LPARAM)&tvisA);
1225 if (tvisA.DUMMYUNIONNAME.item.pszText != LPSTR_TEXTCALLBACKA)
1227 COMCTL32_Free(tvisA.DUMMYUNIONNAME.item.pszText);
1235 /* Item Deletion ************************************************************/
1237 TREEVIEW_RemoveItem(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *wineItem);
1240 TREEVIEW_RemoveAllChildren(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *parentItem)
1242 TREEVIEW_ITEM *kill = parentItem->firstChild;
1244 while (kill != NULL)
1246 TREEVIEW_ITEM *next = kill->nextSibling;
1248 TREEVIEW_RemoveItem(infoPtr, kill);
1253 assert(parentItem->cChildren <= 0); /* I_CHILDRENCALLBACK or 0 */
1254 assert(parentItem->firstChild == NULL);
1255 assert(parentItem->lastChild == NULL);
1259 TREEVIEW_UnlinkItem(TREEVIEW_ITEM *item)
1261 TREEVIEW_ITEM *parentItem = item->parent;
1263 assert(item != NULL);
1264 assert(item->parent != NULL); /* i.e. it must not be the root */
1266 if (parentItem->firstChild == item)
1267 parentItem->firstChild = item->nextSibling;
1269 if (parentItem->lastChild == item)
1270 parentItem->lastChild = item->prevSibling;
1272 if (parentItem->firstChild == NULL && parentItem->lastChild == NULL
1273 && parentItem->cChildren > 0)
1274 parentItem->cChildren = 0;
1276 if (item->prevSibling)
1277 item->prevSibling->nextSibling = item->nextSibling;
1279 if (item->nextSibling)
1280 item->nextSibling->prevSibling = item->prevSibling;
1284 TREEVIEW_RemoveItem(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *wineItem)
1286 TRACE("%p, (%s)\n", wineItem, TREEVIEW_ItemName(wineItem));
1288 TREEVIEW_SendTreeviewNotify(infoPtr, TVN_DELETEITEMA,
1289 TVIF_HANDLE | TVIF_PARAM, 0, wineItem, 0);
1291 if (wineItem->firstChild)
1292 TREEVIEW_RemoveAllChildren(infoPtr, wineItem);
1294 TREEVIEW_UnlinkItem(wineItem);
1296 infoPtr->uNumItems--;
1298 if (wineItem->pszText != LPSTR_TEXTCALLBACKA)
1299 COMCTL32_Free(wineItem->pszText);
1301 TREEVIEW_FreeItem(infoPtr, wineItem);
1305 /* Empty out the tree. */
1307 TREEVIEW_RemoveTree(TREEVIEW_INFO *infoPtr)
1309 TREEVIEW_RemoveAllChildren(infoPtr, infoPtr->root);
1311 assert(infoPtr->uNumItems == 0); /* root isn't counted in uNumItems */
1315 TREEVIEW_DeleteItem(TREEVIEW_INFO *infoPtr, HTREEITEM wineItem)
1317 TREEVIEW_ITEM *oldSelection = infoPtr->selectedItem;
1318 TREEVIEW_ITEM *newSelection = oldSelection;
1319 TREEVIEW_ITEM *newFirstVisible = NULL;
1320 TREEVIEW_ITEM *parent, *prev = NULL;
1321 BOOL visible = FALSE;
1323 if (wineItem == TVI_ROOT)
1325 TRACE("TVI_ROOT\n");
1326 parent = infoPtr->root;
1327 newSelection = NULL;
1329 TREEVIEW_RemoveTree(infoPtr);
1333 if (!TREEVIEW_ValidItem(infoPtr, wineItem))
1336 TRACE("%p (%s)\n", wineItem, TREEVIEW_ItemName(wineItem));
1337 parent = wineItem->parent;
1339 if (ISVISIBLE(wineItem))
1341 prev = TREEVIEW_GetPrevListItem(infoPtr, wineItem);
1345 if (infoPtr->selectedItem != NULL
1346 && (wineItem == infoPtr->selectedItem
1347 || TREEVIEW_IsChildOf(wineItem, infoPtr->selectedItem)))
1349 if (wineItem->nextSibling)
1350 newSelection = wineItem->nextSibling;
1351 else if (wineItem->parent != infoPtr->root)
1352 newSelection = wineItem->parent;
1355 if (infoPtr->firstVisible == wineItem)
1357 if (wineItem->nextSibling)
1358 newFirstVisible = wineItem->nextSibling;
1359 else if (wineItem->prevSibling)
1360 newFirstVisible = wineItem->prevSibling;
1361 else if (wineItem->parent != infoPtr->root)
1362 newFirstVisible = wineItem->parent;
1365 newFirstVisible = infoPtr->firstVisible;
1367 TREEVIEW_RemoveItem(infoPtr, wineItem);
1370 /* Don't change if somebody else already has. */
1371 if (oldSelection == infoPtr->selectedItem)
1373 if (TREEVIEW_ValidItem(infoPtr, newSelection))
1374 TREEVIEW_DoSelectItem(infoPtr, TVGN_CARET, newSelection, TVC_UNKNOWN);
1376 infoPtr->selectedItem = 0;
1379 /* Validate insertMark dropItem.
1380 * hotItem ??? - used for comparison only.
1382 if (!TREEVIEW_ValidItem(infoPtr, infoPtr->insertMarkItem))
1383 infoPtr->insertMarkItem = 0;
1385 if (!TREEVIEW_ValidItem(infoPtr, infoPtr->dropItem))
1386 infoPtr->dropItem = 0;
1388 if (!TREEVIEW_ValidItem(infoPtr, newFirstVisible))
1389 newFirstVisible = infoPtr->root->firstChild;
1391 TREEVIEW_VerifyTree(infoPtr);
1396 TREEVIEW_RecalculateVisibleOrder(infoPtr, prev);
1397 TREEVIEW_SetFirstVisible(infoPtr, newFirstVisible, TRUE);
1398 TREEVIEW_UpdateScrollBars(infoPtr);
1399 TREEVIEW_QueueRefresh(infoPtr);
1401 else if (ISVISIBLE(parent) && !TREEVIEW_HasChildren(infoPtr, parent))
1403 /* parent lost '+/-' - update it */
1404 TREEVIEW_QueueItemRefresh(infoPtr, parent);
1411 /* Get/Set Messages *********************************************************/
1413 TREEVIEW_SetRedraw(TREEVIEW_INFO* infoPtr, WPARAM wParam, LPARAM lParam)
1416 infoPtr->bRedraw = TRUE;
1418 infoPtr->bRedraw = FALSE;
1424 TREEVIEW_GetIndent(TREEVIEW_INFO *infoPtr)
1427 return infoPtr->uIndent;
1431 TREEVIEW_SetIndent(TREEVIEW_INFO *infoPtr, UINT newIndent)
1435 if (newIndent < MINIMUM_INDENT)
1436 newIndent = MINIMUM_INDENT;
1438 if (infoPtr->uIndent != newIndent)
1440 infoPtr->uIndent = newIndent;
1441 TREEVIEW_UpdateSubTree(infoPtr, infoPtr->root);
1442 TREEVIEW_UpdateScrollBars(infoPtr);
1443 TREEVIEW_QueueRefresh(infoPtr);
1451 TREEVIEW_GetToolTips(TREEVIEW_INFO *infoPtr)
1454 return infoPtr->hwndToolTip;
1458 TREEVIEW_SetToolTips(TREEVIEW_INFO *infoPtr, HWND hwndTT)
1463 prevToolTip = infoPtr->hwndToolTip;
1464 infoPtr->hwndToolTip = hwndTT;
1471 TREEVIEW_GetScrollTime(TREEVIEW_INFO *infoPtr)
1473 return infoPtr->uScrollTime;
1477 TREEVIEW_SetScrollTime(TREEVIEW_INFO *infoPtr, UINT uScrollTime)
1479 UINT uOldScrollTime = infoPtr->uScrollTime;
1481 infoPtr->uScrollTime = min(uScrollTime, 100);
1483 return uOldScrollTime;
1488 TREEVIEW_GetImageList(TREEVIEW_INFO *infoPtr, WPARAM wParam)
1494 case (WPARAM)TVSIL_NORMAL:
1495 return (LRESULT)infoPtr->himlNormal;
1497 case (WPARAM)TVSIL_STATE:
1498 return (LRESULT)infoPtr->himlState;
1506 TREEVIEW_SetImageList(TREEVIEW_INFO *infoPtr, WPARAM wParam, HIMAGELIST himlNew)
1508 HIMAGELIST himlOld = 0;
1509 int oldWidth = infoPtr->normalImageWidth;
1510 int oldHeight = infoPtr->normalImageHeight;
1513 TRACE("%x,%p\n", wParam, himlNew);
1517 case (WPARAM)TVSIL_NORMAL:
1518 himlOld = infoPtr->himlNormal;
1519 infoPtr->himlNormal = himlNew;
1521 if (himlNew != NULL)
1522 ImageList_GetIconSize(himlNew, &infoPtr->normalImageWidth,
1523 &infoPtr->normalImageHeight);
1526 infoPtr->normalImageWidth = 0;
1527 infoPtr->normalImageHeight = 0;
1532 case (WPARAM)TVSIL_STATE:
1533 himlOld = infoPtr->himlState;
1534 infoPtr->himlState = himlNew;
1536 if (himlNew != NULL)
1537 ImageList_GetIconSize(himlNew, &infoPtr->stateImageWidth,
1538 &infoPtr->stateImageHeight);
1541 infoPtr->stateImageWidth = 0;
1542 infoPtr->stateImageHeight = 0;
1548 if (oldWidth != infoPtr->normalImageWidth ||
1549 oldHeight != infoPtr->normalImageHeight)
1551 TREEVIEW_UpdateSubTree(infoPtr, infoPtr->root);
1552 TREEVIEW_UpdateScrollBars(infoPtr);
1555 TREEVIEW_QueueRefresh(infoPtr);
1557 return (LRESULT)himlOld;
1560 /* Compute the natural height (based on the font size) for items. */
1562 TREEVIEW_NaturalHeight(TREEVIEW_INFO *infoPtr)
1566 HFONT hOldFont = SelectObject(hdc, infoPtr->hFont);
1568 GetTextMetricsA(hdc, &tm);
1570 SelectObject(hdc, hOldFont);
1573 /* The 16 is a hack because our fonts are tiny. */
1574 /* add 2 for the focus border and 1 more for margin some apps assume */
1575 return max(16, tm.tmHeight + tm.tmExternalLeading + 3);
1579 TREEVIEW_SetItemHeight(TREEVIEW_INFO *infoPtr, INT newHeight)
1581 INT prevHeight = infoPtr->uItemHeight;
1583 TRACE("%d \n", newHeight);
1584 if (newHeight == -1)
1586 infoPtr->uItemHeight = TREEVIEW_NaturalHeight(infoPtr);
1587 infoPtr->bHeightSet = FALSE;
1591 infoPtr->uItemHeight = newHeight;
1592 infoPtr->bHeightSet = TRUE;
1595 /* Round down, unless we support odd ("non even") heights. */
1596 if (!(infoPtr->dwStyle) & TVS_NONEVENHEIGHT)
1597 infoPtr->uItemHeight &= ~1;
1599 if (infoPtr->uItemHeight != prevHeight)
1601 TREEVIEW_RecalculateVisibleOrder(infoPtr, NULL);
1602 TREEVIEW_UpdateScrollBars(infoPtr);
1603 TREEVIEW_QueueRefresh(infoPtr);
1610 TREEVIEW_GetItemHeight(TREEVIEW_INFO *infoPtr)
1613 return infoPtr->uItemHeight;
1618 TREEVIEW_GetFont(TREEVIEW_INFO *infoPtr)
1620 TRACE("%x\n", infoPtr->hFont);
1621 return infoPtr->hFont;
1626 TREEVIEW_ResetTextWidth(LPVOID pItem, DWORD unused)
1630 ((TREEVIEW_ITEM *)pItem)->textWidth = 0;
1636 TREEVIEW_SetFont(TREEVIEW_INFO *infoPtr, HFONT hFont, BOOL bRedraw)
1638 UINT uHeight = infoPtr->uItemHeight;
1640 TRACE("%x %i\n", hFont, bRedraw);
1642 infoPtr->hFont = hFont ? hFont : GetStockObject(SYSTEM_FONT);
1644 DeleteObject(infoPtr->hBoldFont);
1645 infoPtr->hBoldFont = TREEVIEW_CreateBoldFont(infoPtr->hFont);
1647 if (!infoPtr->bHeightSet)
1648 infoPtr->uItemHeight = TREEVIEW_NaturalHeight(infoPtr);
1650 if (uHeight != infoPtr->uItemHeight)
1651 TREEVIEW_RecalculateVisibleOrder(infoPtr, NULL);
1653 DPA_EnumCallback(infoPtr->items, TREEVIEW_ResetTextWidth, 0);
1655 TREEVIEW_UpdateSubTree(infoPtr, infoPtr->root);
1656 TREEVIEW_UpdateScrollBars(infoPtr);
1659 TREEVIEW_QueueRefresh(infoPtr);
1666 TREEVIEW_GetLineColor(TREEVIEW_INFO *infoPtr)
1669 return (LRESULT)infoPtr->clrLine;
1673 TREEVIEW_SetLineColor(TREEVIEW_INFO *infoPtr, COLORREF color)
1675 COLORREF prevColor = infoPtr->clrLine;
1678 infoPtr->clrLine = color;
1679 return (LRESULT)prevColor;
1684 TREEVIEW_GetTextColor(TREEVIEW_INFO *infoPtr)
1687 return (LRESULT)infoPtr->clrText;
1691 TREEVIEW_SetTextColor(TREEVIEW_INFO *infoPtr, COLORREF color)
1693 COLORREF prevColor = infoPtr->clrText;
1696 infoPtr->clrText = color;
1698 if (infoPtr->clrText != prevColor)
1699 TREEVIEW_QueueRefresh(infoPtr);
1701 return (LRESULT)prevColor;
1706 TREEVIEW_GetBkColor(TREEVIEW_INFO *infoPtr)
1709 return (LRESULT)infoPtr->clrBk;
1713 TREEVIEW_SetBkColor(TREEVIEW_INFO *infoPtr, COLORREF newColor)
1715 COLORREF prevColor = infoPtr->clrBk;
1718 infoPtr->clrBk = newColor;
1720 if (newColor != prevColor)
1721 TREEVIEW_QueueRefresh(infoPtr);
1723 return (LRESULT)prevColor;
1728 TREEVIEW_GetInsertMarkColor(TREEVIEW_INFO *infoPtr)
1731 return (LRESULT)infoPtr->clrInsertMark;
1735 TREEVIEW_SetInsertMarkColor(TREEVIEW_INFO *infoPtr, COLORREF color)
1737 COLORREF prevColor = infoPtr->clrInsertMark;
1739 TRACE("%lx\n", color);
1740 infoPtr->clrInsertMark = color;
1742 return (LRESULT)prevColor;
1747 TREEVIEW_SetInsertMark(TREEVIEW_INFO *infoPtr, BOOL wParam, HTREEITEM item)
1749 TRACE("%d %p\n", wParam, item);
1751 if (!TREEVIEW_ValidItem(infoPtr, item))
1754 infoPtr->insertBeforeorAfter = wParam;
1755 infoPtr->insertMarkItem = item;
1757 TREEVIEW_QueueRefresh(infoPtr);
1763 /************************************************************************
1764 * Some serious braindamage here. lParam is a pointer to both the
1765 * input HTREEITEM and the output RECT.
1768 TREEVIEW_GetItemRect(TREEVIEW_INFO *infoPtr, BOOL fTextRect, LPRECT lpRect)
1770 TREEVIEW_ITEM *wineItem;
1771 const HTREEITEM *pItem = (HTREEITEM *)lpRect;
1775 * validate parameters
1781 if (!TREEVIEW_ValidItem(infoPtr, wineItem) || !ISVISIBLE(wineItem))
1785 * If wParam is TRUE return the text size otherwise return
1786 * the whole item size
1790 /* Windows does not send TVN_GETDISPINFO here. */
1792 lpRect->top = wineItem->rect.top;
1793 lpRect->bottom = wineItem->rect.bottom;
1795 lpRect->left = wineItem->textOffset;
1796 lpRect->right = wineItem->textOffset + wineItem->textWidth;
1800 *lpRect = wineItem->rect;
1803 TRACE("%s [L:%d R:%d T:%d B:%d]\n", fTextRect ? "text" : "item",
1804 lpRect->left, lpRect->right, lpRect->top, lpRect->bottom);
1809 static inline LRESULT
1810 TREEVIEW_GetVisibleCount(TREEVIEW_INFO *infoPtr)
1812 /* Suprise! This does not take integral height into account. */
1813 return infoPtr->clientHeight / infoPtr->uItemHeight;
1818 TREEVIEW_GetItemA(TREEVIEW_INFO *infoPtr, LPTVITEMEXA tvItem)
1820 TREEVIEW_ITEM *wineItem;
1822 wineItem = tvItem->hItem;
1823 if (!TREEVIEW_ValidItem(infoPtr, wineItem))
1826 TREEVIEW_UpdateDispInfo(infoPtr, wineItem, tvItem->mask);
1828 if (tvItem->mask & TVIF_CHILDREN)
1829 tvItem->cChildren = wineItem->cChildren;
1831 if (tvItem->mask & TVIF_HANDLE)
1832 tvItem->hItem = wineItem;
1834 if (tvItem->mask & TVIF_IMAGE)
1835 tvItem->iImage = wineItem->iImage;
1837 if (tvItem->mask & TVIF_INTEGRAL)
1838 tvItem->iIntegral = wineItem->iIntegral;
1840 /* undocumented: windows ignores TVIF_PARAM and
1841 * * always sets lParam
1843 tvItem->lParam = wineItem->lParam;
1845 if (tvItem->mask & TVIF_SELECTEDIMAGE)
1846 tvItem->iSelectedImage = wineItem->iSelectedImage;
1848 if (tvItem->mask & TVIF_STATE)
1849 tvItem->state = wineItem->state & tvItem->stateMask;
1851 if (tvItem->mask & TVIF_TEXT)
1852 lstrcpynA(tvItem->pszText, wineItem->pszText, tvItem->cchTextMax);
1854 TRACE("item <%p>, txt %p, img %p, mask %x\n",
1855 wineItem, tvItem->pszText, &tvItem->iImage, tvItem->mask);
1860 /* Beware MSDN Library Visual Studio 6.0. It says -1 on failure, 0 on success,
1861 * which is wrong. */
1863 TREEVIEW_SetItemA(TREEVIEW_INFO *infoPtr, LPTVITEMEXA tvItem)
1865 TREEVIEW_ITEM *wineItem;
1866 TREEVIEW_ITEM originalItem;
1868 wineItem = tvItem->hItem;
1870 TRACE("item %d,mask %x\n", TREEVIEW_GetItemIndex(infoPtr, wineItem),
1873 if (!TREEVIEW_ValidItem(infoPtr, wineItem))
1876 if (!TREEVIEW_DoSetItem(infoPtr, wineItem, tvItem))
1879 /* store the orignal item values */
1880 originalItem = *wineItem;
1882 /* If the text or TVIS_BOLD was changed, and it is visible, recalculate. */
1883 if ((tvItem->mask & TVIF_TEXT
1884 || (tvItem->mask & TVIF_STATE && tvItem->stateMask & TVIS_BOLD))
1885 && ISVISIBLE(wineItem))
1887 TREEVIEW_UpdateDispInfo(infoPtr, wineItem, TVIF_TEXT);
1888 TREEVIEW_ComputeTextWidth(infoPtr, wineItem, 0);
1891 if (tvItem->mask != 0 && ISVISIBLE(wineItem))
1893 /* The refresh updates everything, but we can't wait until then. */
1894 TREEVIEW_ComputeItemInternalMetrics(infoPtr, wineItem);
1896 /* if any of the items values changed, redraw the item */
1897 if(memcmp(&originalItem, wineItem, sizeof(TREEVIEW_ITEM)))
1899 if (tvItem->mask & TVIF_INTEGRAL)
1901 TREEVIEW_RecalculateVisibleOrder(infoPtr, wineItem);
1902 TREEVIEW_UpdateScrollBars(infoPtr);
1904 TREEVIEW_QueueRefresh(infoPtr);
1908 TREEVIEW_UpdateScrollBars(infoPtr);
1909 TREEVIEW_QueueItemRefresh(infoPtr, wineItem);
1918 TREEVIEW_GetItemW(TREEVIEW_INFO *infoPtr, LPTVITEMEXA tvItem)
1920 TREEVIEW_ITEM *wineItem;
1922 iItem = (INT)tvItem->hItem;
1924 wineItem = tvItem->hItem;
1925 if(!TREEVIEW_ValidItem (infoPtr, wineItem))
1928 TREEVIEW_UpdateDispInfo(infoPtr, wineItem, tvItem->mask);
1930 if (tvItem->mask & TVIF_CHILDREN) {
1931 if (TVIF_CHILDREN==I_CHILDRENCALLBACK)
1932 FIXME("I_CHILDRENCALLBACK not supported\n");
1933 tvItem->cChildren = wineItem->cChildren;
1936 if (tvItem->mask & TVIF_HANDLE) {
1937 tvItem->hItem = wineItem;
1939 if (tvItem->mask & TVIF_IMAGE) {
1940 tvItem->iImage = wineItem->iImage;
1942 if (tvItem->mask & TVIF_INTEGRAL) {
1943 tvItem->iIntegral = wineItem->iIntegral;
1945 /* undocumented: windows ignores TVIF_PARAM and
1946 * always sets lParam */
1947 tvItem->lParam = wineItem->lParam;
1948 if (tvItem->mask & TVIF_SELECTEDIMAGE) {
1949 tvItem->iSelectedImage = wineItem->iSelectedImage;
1951 if (tvItem->mask & TVIF_STATE) {
1952 tvItem->state = wineItem->state & tvItem->stateMask;
1955 if (tvItem->mask & TVIF_TEXT) {
1956 if (wineItem->pszText == LPSTR_TEXTCALLBACKW) {
1957 tvItem->pszText = LPSTR_TEXTCALLBACKW; /* FIXME:send notification? */
1958 ERR(" GetItem called with LPSTR_TEXTCALLBACK\n");
1960 else if (wineItem->pszText) {
1961 lstrcpynAtoW(tvItem->pszText, wineItem->pszText, tvItem->cchTextMax);
1965 wineItem->pszText = NULL;
1966 TRACE("item %d<%p>, txt %p, img %p, action %x\n",
1967 iItem, tvItem, tvItem->pszText, &tvItem->iImage, tvItem->mask);
1972 TREEVIEW_GetItemState(TREEVIEW_INFO *infoPtr, HTREEITEM wineItem, UINT mask)
1976 if (!wineItem || !TREEVIEW_ValidItem(infoPtr, wineItem))
1979 return (wineItem->state & mask);
1983 TREEVIEW_GetNextItem(TREEVIEW_INFO *infoPtr, UINT which, HTREEITEM wineItem)
1985 TREEVIEW_ITEM *retval;
1989 /* handle all the global data here */
1992 case TVGN_CHILD: /* Special case: child of 0 is root */
1997 retval = infoPtr->root->firstChild;
2001 retval = infoPtr->selectedItem;
2004 case TVGN_FIRSTVISIBLE:
2005 retval = infoPtr->firstVisible;
2008 case TVGN_DROPHILITE:
2009 retval = infoPtr->dropItem;
2012 case TVGN_LASTVISIBLE:
2013 retval = TREEVIEW_GetLastListItem(infoPtr, infoPtr->root);
2019 TRACE("flags:%x, returns %p\n", which, retval);
2020 return (LRESULT)retval;
2023 if (!TREEVIEW_ValidItem(infoPtr, wineItem))
2029 retval = wineItem->nextSibling;
2032 retval = wineItem->prevSibling;
2035 retval = (wineItem->parent != infoPtr->root) ? wineItem->parent : NULL;
2038 retval = wineItem->firstChild;
2040 case TVGN_NEXTVISIBLE:
2041 retval = TREEVIEW_GetNextListItem(infoPtr, wineItem);
2043 case TVGN_PREVIOUSVISIBLE:
2044 retval = TREEVIEW_GetPrevListItem(infoPtr, wineItem);
2047 TRACE("Unknown msg %x,item %p\n", which, wineItem);
2051 TRACE("flags:%x, item %p;returns %p\n", which, wineItem, retval);
2052 return (LRESULT)retval;
2057 TREEVIEW_GetCount(TREEVIEW_INFO *infoPtr)
2059 TRACE(" %d\n", infoPtr->uNumItems);
2060 return (LRESULT)infoPtr->uNumItems;
2064 TREEVIEW_ToggleItemState(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *item)
2066 if (infoPtr->dwStyle & TVS_CHECKBOXES)
2068 static const unsigned int state_table[] = { 0, 2, 1 };
2072 state = STATEIMAGEINDEX(item->state);
2073 TRACE("state:%x\n", state);
2074 item->state &= ~TVIS_STATEIMAGEMASK;
2077 state = state_table[state];
2079 item->state |= INDEXTOSTATEIMAGEMASK(state);
2081 TRACE("state:%x\n", state);
2082 TREEVIEW_QueueItemRefresh(infoPtr, item);
2087 /* Painting *************************************************************/
2089 /* Draw the lines and expand button for an item. Also draws one section
2090 * of the line from item's parent to item's parent's next sibling. */
2092 TREEVIEW_DrawItemLines(TREEVIEW_INFO *infoPtr, HDC hdc, TREEVIEW_ITEM *item)
2094 LONG centerx, centery;
2095 BOOL lar = ((infoPtr->dwStyle
2096 & (TVS_LINESATROOT|TVS_HASLINES|TVS_HASBUTTONS))
2099 if (!lar && item->iLevel == 0)
2102 centerx = (item->linesOffset + item->stateOffset) / 2;
2103 centery = (item->rect.top + item->rect.bottom) / 2;
2105 if (infoPtr->dwStyle & TVS_HASLINES)
2107 HPEN hOldPen, hNewPen;
2111 * Get a dotted grey pen
2113 hNewPen = CreatePen(PS_DOT, 0, infoPtr->clrLine);
2114 hOldPen = SelectObject(hdc, hNewPen);
2116 MoveToEx(hdc, item->stateOffset, centery, NULL);
2117 LineTo(hdc, centerx - 1, centery);
2119 if (item->prevSibling || item->parent != infoPtr->root)
2121 MoveToEx(hdc, centerx, item->rect.top, NULL);
2122 LineTo(hdc, centerx, centery);
2125 if (item->nextSibling)
2127 MoveToEx(hdc, centerx, centery, NULL);
2128 LineTo(hdc, centerx, item->rect.bottom + 1);
2131 /* Draw the line from our parent to its next sibling. */
2132 parent = item->parent;
2133 while (parent != infoPtr->root)
2135 int pcenterx = (parent->linesOffset + parent->stateOffset) / 2;
2137 if (parent->nextSibling
2138 /* skip top-levels unless TVS_LINESATROOT */
2139 && parent->stateOffset > parent->linesOffset)
2141 MoveToEx(hdc, pcenterx, item->rect.top, NULL);
2142 LineTo(hdc, pcenterx, item->rect.bottom + 1);
2145 parent = parent->parent;
2148 SelectObject(hdc, hOldPen);
2149 DeleteObject(hNewPen);
2153 * Display the (+/-) signs
2156 if (infoPtr->dwStyle & TVS_HASBUTTONS)
2158 if (item->cChildren)
2160 LONG height = item->rect.bottom - item->rect.top;
2161 LONG width = item->stateOffset - item->linesOffset;
2162 LONG rectsize = min(height, width) / 4;
2163 /* plussize = ceil(rectsize * 3/4) */
2164 LONG plussize = (rectsize + 1) * 3 / 4;
2166 HPEN hNewPen = CreatePen(PS_SOLID, 0, infoPtr->clrLine);
2167 HPEN hOldPen = SelectObject(hdc, hNewPen);
2168 HBRUSH hbr = CreateSolidBrush(infoPtr->clrBk);
2169 HBRUSH hbrOld = SelectObject(hdc, hbr);
2171 Rectangle(hdc, centerx - rectsize, centery - rectsize,
2172 centerx + rectsize + 1, centery + rectsize + 1);
2174 SelectObject(hdc, hbrOld);
2177 SelectObject(hdc, hOldPen);
2178 DeleteObject(hNewPen);
2180 MoveToEx(hdc, centerx - plussize + 1, centery, NULL);
2181 LineTo(hdc, centerx + plussize, centery);
2183 if (!(item->state & TVIS_EXPANDED))
2185 MoveToEx(hdc, centerx, centery - plussize + 1, NULL);
2186 LineTo(hdc, centerx, centery + plussize);
2193 TREEVIEW_DrawItem(TREEVIEW_INFO *infoPtr, HDC hdc, TREEVIEW_ITEM *wineItem)
2199 hOldFont = SelectObject(hdc, TREEVIEW_FontForItem(infoPtr, wineItem));
2201 TREEVIEW_UpdateDispInfo(infoPtr, wineItem, CALLBACK_MASK_ALL);
2203 /* The custom draw handler can query the text rectangle,
2205 TREEVIEW_ComputeTextWidth(infoPtr, wineItem, hdc);
2209 if (infoPtr->cdmode & CDRF_NOTIFYITEMDRAW)
2211 cditem = TREEVIEW_SendCustomDrawItemNotify
2212 (infoPtr, hdc, wineItem, CDDS_ITEMPREPAINT);
2213 TRACE("prepaint:cditem-app returns 0x%x\n", cditem);
2215 if (cditem & CDRF_SKIPDEFAULT)
2217 SelectObject(hdc, hOldFont);
2222 if (cditem & CDRF_NEWFONT)
2223 TREEVIEW_ComputeTextWidth(infoPtr, wineItem, hdc);
2225 TREEVIEW_DrawItemLines(infoPtr, hdc, wineItem);
2227 centery = (wineItem->rect.top + wineItem->rect.bottom) / 2;
2230 * Display the images associated with this item
2235 /* State images are displayed to the left of the Normal image
2236 * image number is in state; zero should be `display no image'.
2238 imageIndex = STATEIMAGEINDEX(wineItem->state);
2240 if (infoPtr->himlState && imageIndex)
2242 ImageList_Draw(infoPtr->himlState, imageIndex, hdc,
2243 wineItem->stateOffset,
2244 centery - infoPtr->stateImageHeight / 2,
2248 /* Now, draw the normal image; can be either selected or
2249 * non-selected image.
2252 if ((wineItem->state & TVIS_SELECTED) && (wineItem->iSelectedImage))
2254 /* The item is curently selected */
2255 imageIndex = wineItem->iSelectedImage;
2259 /* The item is not selected */
2260 imageIndex = wineItem->iImage;
2263 if (infoPtr->himlNormal)
2265 int ovlIdx = wineItem->state & TVIS_OVERLAYMASK;
2267 ImageList_Draw(infoPtr->himlNormal, imageIndex, hdc,
2268 wineItem->imageOffset,
2269 centery - infoPtr->normalImageHeight / 2,
2270 ILD_NORMAL | ovlIdx);
2276 * Display the text associated with this item
2279 /* Don't paint item's text if it's being edited */
2280 if (!infoPtr->hwndEdit || (infoPtr->selectedItem != wineItem))
2282 if (wineItem->pszText)
2284 COLORREF oldTextColor = 0;
2287 BOOL inFocus = (GetFocus() == infoPtr->hwnd);
2290 oldBkMode = SetBkMode(hdc, TRANSPARENT);
2292 /* - If item is drop target or it is selected and window is in focus -
2293 * use blue background (COLOR_HIGHLIGHT).
2294 * - If item is selected, window is not in focus, but it has style
2295 * TVS_SHOWSELALWAYS - use grey background (COLOR_BTNFACE)
2296 * - Otherwise - don't fill background
2298 if ((wineItem->state & TVIS_DROPHILITED) || ((wineItem == infoPtr->focusedItem) && !(wineItem->state & TVIS_SELECTED)) ||
2299 ((wineItem->state & TVIS_SELECTED) && (!infoPtr->focusedItem) &&
2300 (inFocus || (infoPtr->dwStyle & TVS_SHOWSELALWAYS))))
2302 if ((wineItem->state & TVIS_DROPHILITED) || inFocus)
2304 hbrBk = CreateSolidBrush(GetSysColor(COLOR_HIGHLIGHT));
2306 SetTextColor(hdc, GetSysColor(COLOR_HIGHLIGHTTEXT));
2310 hbrBk = CreateSolidBrush(GetSysColor(COLOR_BTNFACE));
2312 if (infoPtr->clrText == -1)
2314 SetTextColor(hdc, GetSysColor(COLOR_WINDOWTEXT));
2316 oldTextColor = SetTextColor(hdc, infoPtr->clrText);
2321 if (infoPtr->clrText == -1)
2323 SetTextColor(hdc, GetSysColor(COLOR_WINDOWTEXT));
2325 oldTextColor = SetTextColor(hdc, infoPtr->clrText);
2328 rcText.top = wineItem->rect.top;
2329 rcText.bottom = wineItem->rect.bottom;
2330 rcText.left = wineItem->textOffset;
2331 rcText.right = rcText.left + wineItem->textWidth + 4;
2335 FillRect(hdc, &rcText, hbrBk);
2336 DeleteObject(hbrBk);
2339 /* Draw the box arround the selected item */
2340 if ((wineItem == infoPtr->selectedItem) && inFocus)
2342 HPEN hNewPen = CreatePen(PS_DOT, 0,
2343 GetSysColor(COLOR_WINDOWTEXT));
2344 HPEN hOldPen = SelectObject(hdc, hNewPen);
2345 INT rop = SetROP2(hdc, R2_XORPEN);
2348 points[4].x = points[0].x = rcText.left;
2349 points[4].y = points[0].y = rcText.top;
2350 points[1].x = rcText.right - 1;
2351 points[1].y = rcText.top;
2352 points[2].x = rcText.right - 1;
2353 points[2].y = rcText.bottom - 1;
2354 points[3].x = rcText.left;
2355 points[3].y = rcText.bottom - 1;
2357 Polyline(hdc, points, 5);
2360 SelectObject(hdc, hOldPen);
2361 DeleteObject(hNewPen);
2364 InflateRect(&rcText, -2, -1); /* allow for the focus rect */
2369 lstrlenA(wineItem->pszText),
2371 DT_CENTER | DT_VCENTER | DT_SINGLELINE | DT_NOPREFIX);
2373 /* Restore the hdc state */
2374 SetTextColor(hdc, oldTextColor);
2376 if (oldBkMode != TRANSPARENT)
2377 SetBkMode(hdc, oldBkMode);
2381 /* Draw insertion mark if necessary */
2383 if (infoPtr->insertMarkItem)
2384 TRACE("item:%d,mark:%d\n",
2385 TREEVIEW_GetItemIndex(infoPtr, wineItem),
2386 (int)infoPtr->insertMarkItem);
2388 if (wineItem == infoPtr->insertMarkItem)
2390 HPEN hNewPen, hOldPen;
2394 hNewPen = CreatePen(PS_SOLID, 2, infoPtr->clrInsertMark);
2395 hOldPen = SelectObject(hdc, hNewPen);
2397 if (infoPtr->insertBeforeorAfter)
2398 offset = wineItem->rect.bottom - 1;
2400 offset = wineItem->rect.top + 1;
2402 left = wineItem->textOffset - 2;
2403 right = wineItem->textOffset + wineItem->textWidth + 2;
2405 MoveToEx(hdc, left, offset - 3, NULL);
2406 LineTo(hdc, left, offset + 4);
2408 MoveToEx(hdc, left, offset, NULL);
2409 LineTo(hdc, right + 1, offset);
2411 MoveToEx(hdc, right, offset + 3, NULL);
2412 LineTo(hdc, right, offset - 4);
2414 SelectObject(hdc, hOldPen);
2415 DeleteObject(hNewPen);
2418 if (cditem & CDRF_NOTIFYPOSTPAINT)
2420 cditem = TREEVIEW_SendCustomDrawItemNotify
2421 (infoPtr, hdc, wineItem, CDDS_ITEMPOSTPAINT);
2422 TRACE("postpaint:cditem-app returns 0x%x\n", cditem);
2425 SelectObject(hdc, hOldFont);
2428 /* Computes treeHeight and treeWidth and updates the scroll bars.
2431 TREEVIEW_UpdateScrollBars(TREEVIEW_INFO *infoPtr)
2433 TREEVIEW_ITEM *wineItem;
2434 HWND hwnd = infoPtr->hwnd;
2438 LONG scrollX = infoPtr->scrollX;
2440 infoPtr->treeWidth = 0;
2441 infoPtr->treeHeight = 0;
2443 /* We iterate through all visible items in order to get the tree height
2445 wineItem = infoPtr->root->firstChild;
2447 while (wineItem != NULL)
2449 if (ISVISIBLE(wineItem))
2451 /* actually we draw text at textOffset + 2 */
2452 if (2+wineItem->textOffset+wineItem->textWidth > infoPtr->treeWidth)
2453 infoPtr->treeWidth = wineItem->textOffset+wineItem->textWidth+2;
2455 /* This is scroll-adjusted, but we fix this below. */
2456 infoPtr->treeHeight = wineItem->rect.bottom;
2459 wineItem = TREEVIEW_GetNextListItem(infoPtr, wineItem);
2462 /* Fix the scroll adjusted treeHeight and treeWidth. */
2463 if (infoPtr->root->firstChild)
2464 infoPtr->treeHeight -= infoPtr->root->firstChild->rect.top;
2466 infoPtr->treeWidth += infoPtr->scrollX;
2468 /* Adding one scroll bar may take up enough space that it forces us
2469 * to add the other as well. */
2470 if (infoPtr->treeHeight > infoPtr->clientHeight)
2474 if (infoPtr->treeWidth
2475 > infoPtr->clientWidth - GetSystemMetrics(SM_CXVSCROLL))
2478 else if (infoPtr->treeWidth > infoPtr->clientWidth)
2481 if (!vert && horz && infoPtr->treeHeight
2482 > infoPtr->clientHeight - GetSystemMetrics(SM_CYVSCROLL))
2485 si.cbSize = sizeof(SCROLLINFO);
2486 si.fMask = SIF_POS|SIF_RANGE|SIF_PAGE;
2491 infoPtr->uInternalStatus |= TV_VSCROLL;
2493 si.nPage = TREEVIEW_GetVisibleCount(infoPtr);
2494 si.nPos = infoPtr->firstVisible->visibleOrder;
2495 si.nMax = infoPtr->maxVisibleOrder - 1;
2497 SetScrollInfo(hwnd, SB_VERT, &si, TRUE);
2501 if (infoPtr->uInternalStatus & TV_VSCROLL)
2502 ShowScrollBar(hwnd, SB_VERT, FALSE);
2504 infoPtr->uInternalStatus &= ~TV_VSCROLL;
2509 infoPtr->uInternalStatus |= TV_HSCROLL;
2511 si.nPage = infoPtr->clientWidth;
2512 si.nPos = infoPtr->scrollX;
2513 si.nMax = infoPtr->treeWidth - 1;
2515 if (si.nPos > si.nMax - max( si.nPage-1, 0 ))
2517 si.nPos = si.nMax - max( si.nPage-1, 0 );
2521 SetScrollInfo(hwnd, SB_HORZ, &si, TRUE);
2525 if (infoPtr->uInternalStatus & TV_HSCROLL)
2526 ShowScrollBar(hwnd, SB_HORZ, FALSE);
2531 if (infoPtr->scrollX != scrollX)
2533 TREEVIEW_HScroll(infoPtr,
2534 MAKEWPARAM(SB_THUMBPOSITION, scrollX));
2538 infoPtr->uInternalStatus &= ~TV_HSCROLL;
2541 /* CtrlSpy doesn't mention this, but CorelDRAW's object manager needs it. */
2543 TREEVIEW_EraseBackground(TREEVIEW_INFO *infoPtr, HDC hDC)
2545 HBRUSH hBrush = CreateSolidBrush(infoPtr->clrBk);
2548 GetClientRect(infoPtr->hwnd, &rect);
2549 FillRect(hDC, &rect, hBrush);
2550 DeleteObject(hBrush);
2556 TREEVIEW_Refresh(TREEVIEW_INFO *infoPtr, HDC hdc, RECT *rc)
2558 HWND hwnd = infoPtr->hwnd;
2560 TREEVIEW_ITEM *wineItem;
2562 if (infoPtr->clientHeight == 0 || infoPtr->clientWidth == 0)
2564 TRACE("empty window\n");
2568 infoPtr->cdmode = TREEVIEW_SendCustomDrawNotify(infoPtr, CDDS_PREPAINT,
2571 if (infoPtr->cdmode == CDRF_SKIPDEFAULT)
2573 ReleaseDC(hwnd, hdc);
2577 for (wineItem = infoPtr->root->firstChild;
2579 wineItem = TREEVIEW_GetNextListItem(infoPtr, wineItem))
2581 if (ISVISIBLE(wineItem))
2583 /* Avoid unneeded calculations */
2584 if (wineItem->rect.top > rect.bottom)
2586 if (wineItem->rect.bottom < rect.top)
2589 TREEVIEW_DrawItem(infoPtr, hdc, wineItem);
2593 TREEVIEW_UpdateScrollBars(infoPtr);
2595 if (infoPtr->cdmode & CDRF_NOTIFYPOSTPAINT)
2597 TREEVIEW_SendCustomDrawNotify(infoPtr, CDDS_POSTPAINT, hdc, rect);
2601 TREEVIEW_QueueRefresh(TREEVIEW_INFO *infoPtr)
2603 InvalidateRect(infoPtr->hwnd, NULL, TRUE);
2606 /* It be that item->rect is out of date. If so, we invalidate the wrong area,
2607 * but then whoever updates item->rect knows that they must invalidate after
2610 TREEVIEW_QueueItemRefresh(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *item)
2613 InvalidateRect(infoPtr->hwnd, &item->rect, TRUE);
2617 TREEVIEW_Paint(TREEVIEW_INFO *infoPtr, WPARAM wParam)
2628 GetUpdateRect(infoPtr->hwnd, &rc, TRUE);
2632 hdc = BeginPaint(infoPtr->hwnd, &ps);
2636 if(infoPtr->bRedraw) /* WM_SETREDRAW sets bRedraw */
2637 TREEVIEW_Refresh(infoPtr, hdc, &rc);
2640 EndPaint(infoPtr->hwnd, &ps);
2646 /* Sorting **************************************************************/
2648 /***************************************************************************
2649 * Forward the DPA local callback to the treeview owner callback
2652 TREEVIEW_CallBackCompare(TREEVIEW_ITEM *first, TREEVIEW_ITEM *second, LPTVSORTCB pCallBackSort)
2654 /* Forward the call to the client-defined callback */
2655 return pCallBackSort->lpfnCompare(first->lParam,
2657 pCallBackSort->lParam);
2660 /***************************************************************************
2661 * Treeview native sort routine: sort on item text.
2664 TREEVIEW_SortOnName(TREEVIEW_ITEM *first, TREEVIEW_ITEM *second,
2665 TREEVIEW_INFO *infoPtr)
2667 TREEVIEW_UpdateDispInfo(infoPtr, first, TVIF_TEXT);
2668 TREEVIEW_UpdateDispInfo(infoPtr, second, TVIF_TEXT);
2670 return strcasecmp(first->pszText, second->pszText);
2673 /* Returns the number of physical children belonging to item. */
2675 TREEVIEW_CountChildren(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *item)
2680 for (hti = item->firstChild; hti != NULL; hti = hti->nextSibling)
2686 /* Returns a DPA containing a pointer to each physical child of item in
2687 * sibling order. If item has no children, an empty DPA is returned. */
2689 TREEVIEW_BuildChildDPA(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *item)
2691 HTREEITEM child = item->firstChild;
2693 HDPA list = DPA_Create(8);
2694 if (list == 0) return NULL;
2696 for (child = item->firstChild; child != NULL; child = child->nextSibling)
2698 if (DPA_InsertPtr(list, INT_MAX, child) == -1)
2708 /***************************************************************************
2709 * Setup the treeview structure with regards of the sort method
2710 * and sort the children of the TV item specified in lParam
2711 * fRecurse: currently unused. Should be zero.
2712 * parent: if pSort!=NULL, should equal pSort->hParent.
2713 * otherwise, item which child items are to be sorted.
2714 * pSort: sort method info. if NULL, sort on item text.
2715 * if non-NULL, sort on item's lParam content, and let the
2716 * application decide what that means. See also TVM_SORTCHILDRENCB.
2720 TREEVIEW_Sort(TREEVIEW_INFO *infoPtr, BOOL fRecurse, HTREEITEM parent,
2724 PFNDPACOMPARE pfnCompare;
2727 /* undocumented feature: TVI_ROOT means `sort the whole tree' */
2728 if (parent == TVI_ROOT)
2729 parent = infoPtr->root;
2731 /* Check for a valid handle to the parent item */
2732 if (!TREEVIEW_ValidItem(infoPtr, parent))
2734 ERR("invalid item hParent=%x\n", (INT)parent);
2740 pfnCompare = (PFNDPACOMPARE)TREEVIEW_CallBackCompare;
2741 lpCompare = (LPARAM)pSort;
2745 pfnCompare = (PFNDPACOMPARE)TREEVIEW_SortOnName;
2746 lpCompare = (LPARAM)infoPtr;
2749 cChildren = TREEVIEW_CountChildren(infoPtr, parent);
2751 /* Make sure there is something to sort */
2754 /* TREEVIEW_ITEM rechaining */
2757 HTREEITEM nextItem = 0;
2758 HTREEITEM prevItem = 0;
2760 HDPA sortList = TREEVIEW_BuildChildDPA(infoPtr, parent);
2762 if (sortList == NULL)
2765 /* let DPA sort the list */
2766 DPA_Sort(sortList, pfnCompare, lpCompare);
2768 /* The order of DPA entries has been changed, so fixup the
2769 * nextSibling and prevSibling pointers. */
2771 item = (HTREEITEM)DPA_GetPtr(sortList, count++);
2772 while ((nextItem = (HTREEITEM)DPA_GetPtr(sortList, count++)) != NULL)
2774 /* link the two current item toghether */
2775 item->nextSibling = nextItem;
2776 nextItem->prevSibling = item;
2778 if (prevItem == NULL)
2780 /* this is the first item, update the parent */
2781 parent->firstChild = item;
2782 item->prevSibling = NULL;
2786 /* fix the back chaining */
2787 item->prevSibling = prevItem;
2790 /* get ready for the next one */
2795 /* the last item is pointed to by item and never has a sibling */
2796 item->nextSibling = NULL;
2797 parent->lastChild = item;
2799 DPA_Destroy(sortList);
2801 TREEVIEW_VerifyTree(infoPtr);
2803 if (parent->state & TVIS_EXPANDED)
2805 int visOrder = infoPtr->firstVisible->visibleOrder;
2807 TREEVIEW_RecalculateVisibleOrder(infoPtr, parent);
2809 if (TREEVIEW_IsChildOf(parent, infoPtr->firstVisible))
2811 TREEVIEW_ITEM *item;
2813 for (item = infoPtr->root->firstChild; item != NULL;
2814 item = TREEVIEW_GetNextListItem(infoPtr, item))
2816 if (item->visibleOrder == visOrder)
2820 TREEVIEW_SetFirstVisible(infoPtr, item, FALSE);
2823 TREEVIEW_QueueRefresh(infoPtr);
2832 /***************************************************************************
2833 * Setup the treeview structure with regards of the sort method
2834 * and sort the children of the TV item specified in lParam
2837 TREEVIEW_SortChildrenCB(TREEVIEW_INFO *infoPtr, WPARAM wParam, LPTVSORTCB pSort)
2839 return TREEVIEW_Sort(infoPtr, wParam, pSort->hParent, pSort);
2843 /***************************************************************************
2844 * Sort the children of the TV item specified in lParam.
2847 TREEVIEW_SortChildren(TREEVIEW_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
2849 return TREEVIEW_Sort(infoPtr, (BOOL)wParam, (HTREEITEM)lParam, NULL);
2853 /* Expansion/Collapse ***************************************************/
2856 TREEVIEW_SendExpanding(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *wineItem,
2859 return !TREEVIEW_SendTreeviewNotify(infoPtr, TVN_ITEMEXPANDINGA, action,
2860 TVIF_HANDLE | TVIF_STATE | TVIF_PARAM
2861 | TVIF_IMAGE | TVIF_SELECTEDIMAGE,
2866 TREEVIEW_SendExpanded(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *wineItem,
2869 TREEVIEW_SendTreeviewNotify(infoPtr, TVN_ITEMEXPANDEDA, action,
2870 TVIF_HANDLE | TVIF_STATE | TVIF_PARAM
2871 | TVIF_IMAGE | TVIF_SELECTEDIMAGE,
2876 /* This corresponds to TVM_EXPAND with TVE_COLLAPSE.
2877 * bRemoveChildren corresponds to TVE_COLLAPSERESET. */
2879 TREEVIEW_Collapse(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *wineItem,
2880 BOOL bRemoveChildren, BOOL bUser)
2882 UINT action = TVE_COLLAPSE | (bRemoveChildren ? TVE_COLLAPSERESET : 0);
2883 BOOL bSetSelection, bSetFirstVisible;
2885 TRACE("TVE_COLLAPSE %p %s\n", wineItem, TREEVIEW_ItemName(wineItem));
2887 if (!(wineItem->state & TVIS_EXPANDED) || wineItem->firstChild == NULL)
2891 TREEVIEW_SendExpanding(infoPtr, wineItem, action);
2893 wineItem->state &= ~TVIS_EXPANDED;
2896 TREEVIEW_SendExpanded(infoPtr, wineItem, action);
2898 bSetSelection = (infoPtr->selectedItem != NULL
2899 && TREEVIEW_IsChildOf(wineItem, infoPtr->selectedItem));
2901 bSetFirstVisible = (infoPtr->firstVisible != NULL
2902 && TREEVIEW_IsChildOf(wineItem, infoPtr->firstVisible));
2904 if (bRemoveChildren)
2906 TRACE("TVE_COLLAPSERESET\n");
2907 wineItem->state &= ~TVIS_EXPANDEDONCE;
2908 TREEVIEW_RemoveAllChildren(infoPtr, wineItem);
2911 if (wineItem->firstChild)
2913 TREEVIEW_ITEM *item, *sibling;
2915 sibling = TREEVIEW_GetNextListItem(infoPtr, wineItem);
2917 for (item = wineItem->firstChild; item != sibling;
2918 item = TREEVIEW_GetNextListItem(infoPtr, item))
2920 item->visibleOrder = -1;
2924 TREEVIEW_RecalculateVisibleOrder(infoPtr, wineItem);
2926 TREEVIEW_SetFirstVisible(infoPtr, bSetFirstVisible ? wineItem
2927 : infoPtr->firstVisible, TRUE);
2931 /* Don't call DoSelectItem, it sends notifications. */
2932 if (TREEVIEW_ValidItem(infoPtr, infoPtr->selectedItem))
2933 infoPtr->selectedItem->state &= ~TVIS_SELECTED;
2934 wineItem->state |= TVIS_SELECTED;
2935 infoPtr->selectedItem = wineItem;
2937 TREEVIEW_EnsureVisible(infoPtr, wineItem, FALSE);
2940 TREEVIEW_UpdateScrollBars(infoPtr);
2941 TREEVIEW_QueueRefresh(infoPtr);
2947 TREEVIEW_Expand(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *wineItem,
2948 BOOL bExpandPartial, BOOL bUser)
2952 if (!TREEVIEW_HasChildren(infoPtr, wineItem)
2953 || wineItem->state & TVIS_EXPANDED)
2956 TRACE("TVE_EXPAND %p %s\n", wineItem, TREEVIEW_ItemName(wineItem));
2958 if (bUser || !(wineItem->state & TVIS_EXPANDEDONCE))
2960 if (!TREEVIEW_SendExpanding(infoPtr, wineItem, TVE_EXPAND))
2962 TRACE(" TVN_ITEMEXPANDING returned TRUE, exiting...\n");
2966 wineItem->state |= TVIS_EXPANDED;
2967 TREEVIEW_SendExpanded(infoPtr, wineItem, TVE_EXPAND);
2968 wineItem->state |= TVIS_EXPANDEDONCE;
2972 /* this item has already been expanded */
2973 wineItem->state |= TVIS_EXPANDED;
2977 FIXME("TVE_EXPANDPARTIAL not implemented\n");
2979 TREEVIEW_RecalculateVisibleOrder(infoPtr, wineItem);
2980 TREEVIEW_UpdateSubTree(infoPtr, wineItem);
2981 TREEVIEW_UpdateScrollBars(infoPtr);
2983 /* Scroll up so that as many children as possible are visible.
2984 * This looses when expanding causes an HScroll bar to appear, but we
2985 * don't know that yet, so the last item is obscured. */
2986 if (wineItem->firstChild != NULL)
2988 int nChildren = wineItem->lastChild->visibleOrder
2989 - wineItem->firstChild->visibleOrder + 1;
2991 int visible_pos = wineItem->visibleOrder
2992 - infoPtr->firstVisible->visibleOrder;
2994 int rows_below = TREEVIEW_GetVisibleCount(infoPtr) - visible_pos - 1;
2996 if (visible_pos > 0 && nChildren > rows_below)
2998 int scroll = nChildren - rows_below;
3000 if (scroll > visible_pos)
3001 scroll = visible_pos;
3005 TREEVIEW_ITEM *newFirstVisible
3006 = TREEVIEW_GetListItem(infoPtr, infoPtr->firstVisible,
3010 TREEVIEW_SetFirstVisible(infoPtr, newFirstVisible, TRUE);
3015 TREEVIEW_QueueRefresh(infoPtr);
3021 TREEVIEW_Toggle(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *wineItem, BOOL bUser)
3025 if (wineItem->state & TVIS_EXPANDED)
3026 return TREEVIEW_Collapse(infoPtr, wineItem, FALSE, bUser);
3028 return TREEVIEW_Expand(infoPtr, wineItem, FALSE, bUser);
3032 TREEVIEW_ExpandAll(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *item)
3034 TREEVIEW_Expand(infoPtr, item, FALSE, TRUE);
3036 for (item = item->firstChild; item != NULL; item = item->nextSibling)
3038 if (TREEVIEW_HasChildren(infoPtr, item))
3039 TREEVIEW_ExpandAll(infoPtr, item);
3043 /* Note:If the specified item is the child of a collapsed parent item,
3044 the parent's list of child items is (recursively) expanded to reveal the
3045 specified item. This is mentioned for TREEVIEW_SelectItem; don't
3046 know if it also applies here.
3050 TREEVIEW_ExpandMsg(TREEVIEW_INFO *infoPtr, UINT flag, HTREEITEM wineItem)
3052 if (!TREEVIEW_ValidItem(infoPtr, wineItem))
3055 TRACE("For (%s) item:%d, flags %x, state:%d\n",
3056 TREEVIEW_ItemName(wineItem), flag,
3057 TREEVIEW_GetItemIndex(infoPtr, wineItem), wineItem->state);
3059 switch (flag & TVE_TOGGLE)
3062 return TREEVIEW_Collapse(infoPtr, wineItem, flag & TVE_COLLAPSERESET,
3066 return TREEVIEW_Expand(infoPtr, wineItem, flag & TVE_EXPANDPARTIAL,
3070 return TREEVIEW_Toggle(infoPtr, wineItem, TRUE);
3077 TRACE("Exiting, Item %p state is now %d...\n", wineItem, wineItem->state);
3081 /* Hit-Testing **********************************************************/
3083 static TREEVIEW_ITEM *
3084 TREEVIEW_HitTestPoint(TREEVIEW_INFO *infoPtr, POINT pt)
3086 TREEVIEW_ITEM *wineItem;
3089 if (!infoPtr->firstVisible)
3092 row = pt.y / infoPtr->uItemHeight + infoPtr->firstVisible->visibleOrder;
3094 for (wineItem = infoPtr->firstVisible; wineItem != NULL;
3095 wineItem = TREEVIEW_GetNextListItem(infoPtr, wineItem))
3097 if (row >= wineItem->visibleOrder
3098 && row < wineItem->visibleOrder + wineItem->iIntegral)
3106 TREEVIEW_HitTest(TREEVIEW_INFO *infoPtr, LPTVHITTESTINFO lpht)
3108 TREEVIEW_ITEM *wineItem;
3114 GetClientRect(infoPtr->hwnd, &rect);
3121 status |= TVHT_TOLEFT;
3123 else if (x > rect.right)
3125 status |= TVHT_TORIGHT;
3130 status |= TVHT_ABOVE;
3132 else if (y > rect.bottom)
3134 status |= TVHT_BELOW;
3139 lpht->flags = status;
3140 return (LRESULT)(HTREEITEM)NULL;
3143 wineItem = TREEVIEW_HitTestPoint(infoPtr, lpht->pt);
3146 lpht->flags = TVHT_NOWHERE;
3147 return (LRESULT)(HTREEITEM)NULL;
3150 if (x >= wineItem->textOffset + wineItem->textWidth)
3152 lpht->flags = TVHT_ONITEMRIGHT;
3154 else if (x >= wineItem->textOffset)
3156 lpht->flags = TVHT_ONITEMLABEL;
3158 else if (x >= wineItem->imageOffset)
3160 lpht->flags = TVHT_ONITEMICON;
3162 else if (x >= wineItem->stateOffset)
3164 lpht->flags = TVHT_ONITEMSTATEICON;
3166 else if (x >= wineItem->linesOffset && infoPtr->dwStyle & TVS_HASBUTTONS)
3168 lpht->flags = TVHT_ONITEMBUTTON;
3172 lpht->flags = TVHT_ONITEMINDENT;
3175 lpht->hItem = wineItem;
3176 TRACE("(%ld,%ld):result %x\n", lpht->pt.x, lpht->pt.y, lpht->flags);
3178 return (LRESULT)wineItem;
3181 /* Item Label Editing ***************************************************/
3184 TREEVIEW_GetEditControl(TREEVIEW_INFO *infoPtr)
3186 return infoPtr->hwndEdit;
3189 static LRESULT CALLBACK
3190 TREEVIEW_Edit_SubclassProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
3192 TREEVIEW_INFO *infoPtr;
3193 BOOL bCancel = FALSE;
3200 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(GetParent(hwnd));
3202 TRACE("WM_PAINT start\n");
3203 rc = CallWindowProcA(infoPtr->wpEditOrig, hwnd, uMsg, wParam,
3205 TRACE("WM_PAINT done\n");
3211 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(GetParent(hwnd));
3212 if (infoPtr->bIgnoreEditKillFocus)
3219 return DLGC_WANTARROWS | DLGC_WANTALLKEYS;
3222 if (wParam == (WPARAM)VK_ESCAPE)
3227 else if (wParam == (WPARAM)VK_RETURN)
3235 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(GetParent(hwnd));
3237 return CallWindowProcA(infoPtr->wpEditOrig, hwnd, uMsg, wParam,
3242 /* Processing TVN_ENDLABELEDIT message could kill the focus */
3243 /* eg. Using a messagebox */
3245 infoPtr = TREEVIEW_GetInfoPtr(GetParent(hwnd));
3246 infoPtr->bIgnoreEditKillFocus = TRUE;
3247 TREEVIEW_EndEditLabelNow(infoPtr, bCancel || !infoPtr->bLabelChanged);
3248 infoPtr->bIgnoreEditKillFocus = FALSE;
3254 /* should handle edit control messages here */
3257 TREEVIEW_Command(TREEVIEW_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
3259 TRACE("%x %ld\n", wParam, lParam);
3261 switch (HIWORD(wParam))
3266 * Adjust the edit window size
3269 TREEVIEW_ITEM *editItem = infoPtr->selectedItem;
3270 HDC hdc = GetDC(infoPtr->hwndEdit);
3273 HFONT hFont, hOldFont = 0;
3275 infoPtr->bLabelChanged = TRUE;
3277 len = GetWindowTextA(infoPtr->hwndEdit, buffer, sizeof(buffer));
3279 /* Select font to get the right dimension of the string */
3280 hFont = SendMessageA(infoPtr->hwndEdit, WM_GETFONT, 0, 0);
3283 hOldFont = SelectObject(hdc, hFont);
3286 if (GetTextExtentPoint32A(hdc, buffer, strlen(buffer), &sz))
3288 TEXTMETRICA textMetric;
3290 /* Add Extra spacing for the next character */
3291 GetTextMetricsA(hdc, &textMetric);
3292 sz.cx += (textMetric.tmMaxCharWidth * 2);
3294 sz.cx = max(sz.cx, textMetric.tmMaxCharWidth * 3);
3296 infoPtr->clientWidth - editItem->textOffset + 2);
3298 SetWindowPos(infoPtr->hwndEdit,
3303 editItem->rect.bottom - editItem->rect.top + 3,
3304 SWP_NOMOVE | SWP_DRAWFRAME);
3309 SelectObject(hdc, hOldFont);
3312 ReleaseDC(infoPtr->hwnd, hdc);
3317 return SendMessageA(GetParent(infoPtr->hwnd), WM_COMMAND, wParam, lParam);
3324 TREEVIEW_EditLabelA(TREEVIEW_INFO *infoPtr, HTREEITEM hItem)
3326 HWND hwnd = infoPtr->hwnd;
3329 TREEVIEW_ITEM *editItem = hItem;
3330 HINSTANCE hinst = GetWindowLongA(hwnd, GWL_HINSTANCE);
3333 TEXTMETRICA textMetric;
3335 TRACE("%x %p\n", (unsigned)hwnd, hItem);
3336 if (!TREEVIEW_ValidItem(infoPtr, editItem))
3339 if (infoPtr->hwndEdit)
3340 return infoPtr->hwndEdit;
3342 infoPtr->bLabelChanged = FALSE;
3344 /* Make sure that edit item is selected */
3345 TREEVIEW_DoSelectItem(infoPtr, TVGN_CARET, hItem, TVC_UNKNOWN);
3346 TREEVIEW_EnsureVisible(infoPtr, hItem, TRUE);
3348 TREEVIEW_UpdateDispInfo(infoPtr, editItem, TVIF_TEXT);
3351 /* Select the font to get appropriate metric dimensions */
3352 if (infoPtr->hFont != 0)
3354 hOldFont = SelectObject(hdc, infoPtr->hFont);
3357 /* Get string length in pixels */
3358 GetTextExtentPoint32A(hdc, editItem->pszText, strlen(editItem->pszText),
3361 /* Add Extra spacing for the next character */
3362 GetTextMetricsA(hdc, &textMetric);
3363 sz.cx += (textMetric.tmMaxCharWidth * 2);
3365 sz.cx = max(sz.cx, textMetric.tmMaxCharWidth * 3);
3366 sz.cx = min(sz.cx, infoPtr->clientWidth - editItem->textOffset + 2);
3368 if (infoPtr->hFont != 0)
3370 SelectObject(hdc, hOldFont);
3373 ReleaseDC(hwnd, hdc);
3374 hwndEdit = CreateWindowExA(WS_EX_LEFT,
3377 WS_CHILD | WS_BORDER | ES_AUTOHSCROLL |
3378 WS_CLIPSIBLINGS | ES_WANTRETURN |
3379 ES_LEFT, editItem->textOffset - 2,
3380 editItem->rect.top - 1, sz.cx + 3,
3381 editItem->rect.bottom -
3382 editItem->rect.top + 3, hwnd, 0, hinst, 0);
3383 /* FIXME: (HMENU)IDTVEDIT,pcs->hInstance,0); */
3385 infoPtr->hwndEdit = hwndEdit;
3387 /* Get a 2D border. */
3388 SetWindowLongA(hwndEdit, GWL_EXSTYLE,
3389 GetWindowLongA(hwndEdit, GWL_EXSTYLE) & ~WS_EX_CLIENTEDGE);
3390 SetWindowLongA(hwndEdit, GWL_STYLE,
3391 GetWindowLongA(hwndEdit, GWL_STYLE) | WS_BORDER);
3393 SendMessageA(hwndEdit, WM_SETFONT, TREEVIEW_FontForItem(infoPtr, editItem),
3396 infoPtr->wpEditOrig = (WNDPROC)SetWindowLongA(hwndEdit, GWL_WNDPROC,
3398 TREEVIEW_Edit_SubclassProc);
3400 if (TREEVIEW_BeginLabelEditNotify(infoPtr, editItem))
3402 DestroyWindow(hwndEdit);
3403 infoPtr->hwndEdit = 0;
3407 infoPtr->selectedItem = hItem;
3408 SetWindowTextA(hwndEdit, editItem->pszText);
3410 SendMessageA(hwndEdit, EM_SETSEL, 0, -1);
3411 ShowWindow(hwndEdit, SW_SHOW);
3418 TREEVIEW_EndEditLabelNow(TREEVIEW_INFO *infoPtr, BOOL bCancel)
3420 HWND hwnd = infoPtr->hwnd;
3421 TREEVIEW_ITEM *editedItem = infoPtr->selectedItem;
3424 char tmpText[1024] = { '\0' };
3427 if (!infoPtr->hwndEdit)
3430 tvdi.hdr.hwndFrom = hwnd;
3431 tvdi.hdr.idFrom = GetWindowLongA(hwnd, GWL_ID);
3432 tvdi.hdr.code = TVN_ENDLABELEDITA;
3434 tvdi.item.hItem = editedItem;
3435 tvdi.item.state = editedItem->state;
3436 tvdi.item.lParam = editedItem->lParam;
3440 iLength = GetWindowTextA(infoPtr->hwndEdit, tmpText, 1023);
3442 if (iLength >= 1023)
3444 ERR("Insuficient space to retrieve new item label.");
3447 tvdi.item.pszText = tmpText;
3448 tvdi.item.cchTextMax = iLength + 1;
3452 tvdi.item.pszText = NULL;
3453 tvdi.item.cchTextMax = 0;
3456 bCommit = (BOOL)SendMessageA(infoPtr->hwndNotify,
3458 (WPARAM)tvdi.hdr.idFrom, (LPARAM)&tvdi);
3460 if (!bCancel && bCommit) /* Apply the changes */
3462 if (strcmp(tmpText, editedItem->pszText) != 0)
3464 if (NULL == COMCTL32_ReAlloc(editedItem->pszText, iLength + 1))
3466 ERR("OutOfMemory, cannot allocate space for label");
3467 DestroyWindow(infoPtr->hwndEdit);
3468 infoPtr->hwndEdit = 0;
3473 editedItem->cchTextMax = iLength + 1;
3474 lstrcpyA(editedItem->pszText, tmpText);
3479 ShowWindow(infoPtr->hwndEdit, SW_HIDE);
3480 DestroyWindow(infoPtr->hwndEdit);
3481 infoPtr->hwndEdit = 0;
3486 TREEVIEW_HandleTimer(TREEVIEW_INFO *infoPtr, WPARAM wParam)
3488 if (wParam != TV_EDIT_TIMER)
3490 ERR("got unknown timer\n");
3494 KillTimer(infoPtr->hwnd, TV_EDIT_TIMER);
3495 infoPtr->Timer &= ~TV_EDIT_TIMER_SET;
3497 TREEVIEW_EditLabelA(infoPtr, infoPtr->selectedItem);
3503 /* Mouse Tracking/Drag **************************************************/
3505 /***************************************************************************
3506 * This is quite unusual piece of code, but that's how it's implemented in
3510 TREEVIEW_TrackMouse(TREEVIEW_INFO *infoPtr, POINT pt)
3512 INT cxDrag = GetSystemMetrics(SM_CXDRAG);
3513 INT cyDrag = GetSystemMetrics(SM_CYDRAG);
3517 r.top = pt.y - cyDrag;
3518 r.left = pt.x - cxDrag;
3519 r.bottom = pt.y + cyDrag;
3520 r.right = pt.x + cxDrag;
3522 SetCapture(infoPtr->hwnd);
3526 if (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_NOYIELD))
3528 if (msg.message == WM_MOUSEMOVE)
3530 pt.x = SLOWORD(msg.lParam);
3531 pt.y = SHIWORD(msg.lParam);
3532 if (PtInRect(&r, pt))
3540 else if (msg.message >= WM_LBUTTONDOWN &&
3541 msg.message <= WM_RBUTTONDBLCLK)
3543 if (msg.message == WM_RBUTTONUP)
3544 TREEVIEW_RButtonUp(infoPtr, &pt);
3548 DispatchMessageA(&msg);
3551 if (GetCapture() != infoPtr->hwnd)
3561 TREEVIEW_LButtonDoubleClick(TREEVIEW_INFO *infoPtr, LPARAM lParam)
3563 TREEVIEW_ITEM *wineItem;
3567 SetFocus(infoPtr->hwnd);
3569 if (infoPtr->Timer & TV_EDIT_TIMER_SET)
3571 /* If there is pending 'edit label' event - kill it now */
3572 KillTimer(infoPtr->hwnd, TV_EDIT_TIMER);
3575 hit.pt.x = SLOWORD(lParam);
3576 hit.pt.y = SHIWORD(lParam);
3578 wineItem = (TREEVIEW_ITEM *)TREEVIEW_HitTest(infoPtr, &hit);
3581 TRACE("item %d\n", TREEVIEW_GetItemIndex(infoPtr, wineItem));
3583 if (TREEVIEW_SendSimpleNotify(infoPtr, NM_DBLCLK) == FALSE)
3587 case TVHT_ONITEMRIGHT:
3588 /* FIXME: we should not have sent NM_DBLCLK in this case. */
3591 case TVHT_ONITEMINDENT:
3592 if (!(infoPtr->dwStyle & TVS_HASLINES))
3598 int level = hit.pt.x / infoPtr->uIndent;
3599 if (!(infoPtr->dwStyle & TVS_LINESATROOT)) level++;
3601 while (wineItem->iLevel > level)
3603 wineItem = wineItem->parent;
3609 case TVHT_ONITEMLABEL:
3610 case TVHT_ONITEMICON:
3611 case TVHT_ONITEMBUTTON:
3612 TREEVIEW_Toggle(infoPtr, wineItem, TRUE);
3615 case TVHT_ONITEMSTATEICON:
3616 if (infoPtr->dwStyle & TVS_CHECKBOXES)
3617 TREEVIEW_ToggleItemState(infoPtr, wineItem);
3619 TREEVIEW_Toggle(infoPtr, wineItem, TRUE);
3628 TREEVIEW_LButtonDown(TREEVIEW_INFO *infoPtr, LPARAM lParam)
3630 HWND hwnd = infoPtr->hwnd;
3635 /* If Edit control is active - kill it and return.
3636 * The best way to do it is to set focus to itself.
3637 * Edit control subclassed procedure will automatically call
3640 if (infoPtr->hwndEdit)
3646 ht.pt.x = SLOWORD(lParam);
3647 ht.pt.y = SHIWORD(lParam);
3649 TREEVIEW_HitTest(infoPtr, &ht);
3650 TRACE("item %d\n", TREEVIEW_GetItemIndex(infoPtr, ht.hItem));
3652 /* update focusedItem and redraw both items */
3653 if(ht.hItem && (ht.flags & TVHT_ONITEM))
3655 infoPtr->focusedItem = ht.hItem;
3656 InvalidateRect(hwnd, &(((HTREEITEM)(ht.hItem))->rect), TRUE);
3658 if(infoPtr->selectedItem)
3659 InvalidateRect(hwnd, &(infoPtr->selectedItem->rect), TRUE);
3662 bTrack = (ht.flags & TVHT_ONITEM)
3663 && !(infoPtr->dwStyle & TVS_DISABLEDRAGDROP);
3665 /* Send NM_CLICK right away */
3667 if (TREEVIEW_SendSimpleNotify(infoPtr, NM_CLICK))
3670 if (ht.flags & TVHT_ONITEMBUTTON)
3672 TREEVIEW_Toggle(infoPtr, ht.hItem, TRUE);
3676 { /* if TREEVIEW_TrackMouse == 1 dragging occured and the cursor left the dragged item's rectangle */
3677 if (TREEVIEW_TrackMouse(infoPtr, ht.pt))
3679 TREEVIEW_SendTreeviewDnDNotify(infoPtr, TVN_BEGINDRAGA, ht.hItem,
3681 infoPtr->dropItem = ht.hItem;
3683 /* clean up focusedItem as we dragged and won't select this item */
3684 if(infoPtr->focusedItem)
3686 /* refresh the item that was focused */
3687 tempItem = infoPtr->focusedItem;
3688 infoPtr->focusedItem = 0;
3689 InvalidateRect(infoPtr->hwnd, &tempItem->rect, TRUE);
3691 /* refresh the selected item to return the filled background */
3692 InvalidateRect(infoPtr->hwnd, &(infoPtr->selectedItem->rect), TRUE);
3699 if (TREEVIEW_SendSimpleNotify(infoPtr, NM_CLICK))
3703 * If the style allows editing and the node is already selected
3704 * and the click occured on the item label...
3706 if ((infoPtr->dwStyle & TVS_EDITLABELS) &&
3707 (ht.flags & TVHT_ONITEMLABEL) && (infoPtr->selectedItem == ht.hItem))
3709 if (infoPtr->Timer & TV_EDIT_TIMER_SET)
3710 KillTimer(hwnd, TV_EDIT_TIMER);
3712 SetTimer(hwnd, TV_EDIT_TIMER, GetDoubleClickTime(), 0);
3713 infoPtr->Timer |= TV_EDIT_TIMER_SET;
3715 else if (ht.flags & TVHT_ONITEM) /* select the item if the hit was inside of the icon or text */
3718 * if we are TVS_SINGLEEXPAND then we want this single click to
3719 * do a bunch of things.
3721 if((infoPtr->dwStyle & TVS_SINGLEEXPAND) &&
3722 (infoPtr->hwndEdit == 0))
3724 TREEVIEW_ITEM *SelItem;
3727 * Send the notification
3729 TREEVIEW_SendTreeviewNotify(infoPtr, TVN_SINGLEEXPAND, TVIF_HANDLE | TVIF_PARAM,
3733 * Close the previous selection all the way to the root
3734 * as long as the new selection is not a child
3736 if((infoPtr->selectedItem)
3737 && (infoPtr->selectedItem != ht.hItem))
3739 BOOL closeit = TRUE;
3742 /* determine if the hitItem is a child of the currently selected item */
3743 while(closeit && SelItem && TREEVIEW_ValidItem(infoPtr, SelItem) && (SelItem != infoPtr->root))
3745 closeit = (SelItem != infoPtr->selectedItem);
3746 SelItem = SelItem->parent;
3751 if(TREEVIEW_ValidItem(infoPtr, infoPtr->selectedItem))
3752 SelItem = infoPtr->selectedItem;
3754 while(SelItem && (SelItem != ht.hItem) && TREEVIEW_ValidItem(infoPtr, SelItem) && (SelItem != infoPtr->root))
3756 TREEVIEW_Collapse(infoPtr, SelItem, FALSE, FALSE);
3757 SelItem = SelItem->parent;
3763 * Expand the current item
3765 TREEVIEW_Expand(infoPtr, ht.hItem, TVE_TOGGLE, FALSE);
3768 /* Select the current item */
3769 TREEVIEW_DoSelectItem(infoPtr, TVGN_CARET, ht.hItem, TVC_BYMOUSE);
3771 else if (ht.flags & TVHT_ONITEMSTATEICON)
3773 /* TVS_CHECKBOXES requires us to toggle the current state */
3774 if (infoPtr->dwStyle & TVS_CHECKBOXES)
3775 TREEVIEW_ToggleItemState(infoPtr, ht.hItem);
3785 TREEVIEW_RButtonDown(TREEVIEW_INFO *infoPtr, LPARAM lParam)
3789 if (infoPtr->hwndEdit)
3791 SetFocus(infoPtr->hwnd);
3795 ht.pt.x = SLOWORD(lParam);
3796 ht.pt.y = SHIWORD(lParam);
3798 TREEVIEW_HitTest(infoPtr, &ht);
3800 if (TREEVIEW_TrackMouse(infoPtr, ht.pt))
3804 TREEVIEW_SendTreeviewDnDNotify(infoPtr, TVN_BEGINRDRAGA, ht.hItem,
3806 infoPtr->dropItem = ht.hItem;
3811 SetFocus(infoPtr->hwnd);
3812 TREEVIEW_SendSimpleNotify(infoPtr, NM_RCLICK);
3819 TREEVIEW_RButtonUp(TREEVIEW_INFO *infoPtr, LPPOINT pPt)
3826 TREEVIEW_CreateDragImage(TREEVIEW_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
3828 TREEVIEW_ITEM *dragItem = (HTREEITEM)lParam;
3832 HBITMAP hbmp, hOldbmp;
3839 if (!(infoPtr->himlNormal))
3842 if (!dragItem || !TREEVIEW_ValidItem(infoPtr, dragItem))
3845 TREEVIEW_UpdateDispInfo(infoPtr, dragItem, TVIF_TEXT);
3847 hwtop = GetDesktopWindow();
3848 htopdc = GetDC(hwtop);
3849 hdc = CreateCompatibleDC(htopdc);
3851 hOldFont = SelectObject(hdc, infoPtr->hFont);
3852 GetTextExtentPoint32A(hdc, dragItem->pszText, lstrlenA(dragItem->pszText),
3854 TRACE("%ld %ld %s %d\n", size.cx, size.cy, dragItem->pszText,
3855 lstrlenA(dragItem->pszText));
3856 hbmp = CreateCompatibleBitmap(htopdc, size.cx, size.cy);
3857 hOldbmp = SelectObject(hdc, hbmp);
3859 ImageList_GetIconSize(infoPtr->himlNormal, &cx, &cy);
3864 infoPtr->dragList = ImageList_Create(size.cx, size.cy, ILC_COLOR, 10, 10);
3865 ImageList_Draw(infoPtr->himlNormal, dragItem->iImage, hdc, 0, 0,
3869 ImageList_GetImageInfo (infoPtr->himlNormal, dragItem->hItem, &iminfo);
3870 ImageList_AddMasked (infoPtr->dragList, iminfo.hbmImage, CLR_DEFAULT);
3873 /* draw item text */
3875 SetRect(&rc, cx, 0, size.cx, size.cy);
3876 DrawTextA(hdc, dragItem->pszText, lstrlenA(dragItem->pszText), &rc,
3878 SelectObject(hdc, hOldFont);
3879 SelectObject(hdc, hOldbmp);
3881 ImageList_Add(infoPtr->dragList, hbmp, 0);
3885 ReleaseDC(hwtop, htopdc);
3887 return (LRESULT)infoPtr->dragList;
3890 /* Selection ************************************************************/
3893 TREEVIEW_DoSelectItem(TREEVIEW_INFO *infoPtr, INT action, HTREEITEM newSelect,
3896 TREEVIEW_ITEM *prevSelect;
3899 assert(newSelect == NULL || TREEVIEW_ValidItem(infoPtr, newSelect));
3901 TRACE("Entering item %p (%s), flag %x, cause %x, state %d\n",
3902 newSelect, TREEVIEW_ItemName(newSelect), action, cause,
3903 newSelect ? newSelect->state : 0);
3905 /* reset and redraw focusedItem if focusedItem was set so we don't */
3906 /* have to worry about the previously focused item when we set a new one */
3907 if(infoPtr->focusedItem)
3909 rcFocused = (infoPtr->focusedItem)->rect;
3910 infoPtr->focusedItem = 0;
3911 InvalidateRect(infoPtr->hwnd, &rcFocused, TRUE);
3917 prevSelect = infoPtr->selectedItem;
3919 if (prevSelect == newSelect)
3922 if (TREEVIEW_SendTreeviewNotify(infoPtr,
3925 TVIF_HANDLE | TVIF_STATE | TVIF_PARAM,
3931 prevSelect->state &= ~TVIS_SELECTED;
3933 newSelect->state |= TVIS_SELECTED;
3935 infoPtr->selectedItem = newSelect;
3937 TREEVIEW_EnsureVisible(infoPtr, infoPtr->selectedItem, FALSE);
3939 TREEVIEW_SendTreeviewNotify(infoPtr,
3942 TVIF_HANDLE | TVIF_STATE | TVIF_PARAM,
3945 TREEVIEW_QueueItemRefresh(infoPtr, prevSelect);
3946 TREEVIEW_QueueItemRefresh(infoPtr, newSelect);
3949 case TVGN_DROPHILITE:
3950 prevSelect = infoPtr->dropItem;
3953 prevSelect->state &= ~TVIS_DROPHILITED;
3955 infoPtr->dropItem = newSelect;
3958 newSelect->state |= TVIS_DROPHILITED;
3960 TREEVIEW_QueueItemRefresh(infoPtr, prevSelect);
3961 TREEVIEW_QueueItemRefresh(infoPtr, newSelect);
3964 case TVGN_FIRSTVISIBLE:
3965 TREEVIEW_EnsureVisible(infoPtr, newSelect, FALSE);
3966 TREEVIEW_SetFirstVisible(infoPtr, newSelect, TRUE);
3967 TREEVIEW_QueueRefresh(infoPtr);
3971 TRACE("Leaving state %d\n", newSelect ? newSelect->state : 0);
3975 /* FIXME: handle NM_KILLFOCUS etc */
3977 TREEVIEW_SelectItem(TREEVIEW_INFO *infoPtr, INT wParam, HTREEITEM item)
3979 if (item != NULL && !TREEVIEW_ValidItem(infoPtr, item))
3982 TRACE("%p (%s) %d\n", item, TREEVIEW_ItemName(item), wParam);
3984 if (!TREEVIEW_DoSelectItem(infoPtr, wParam, item, TVC_UNKNOWN))
3990 /* Scrolling ************************************************************/
3993 TREEVIEW_EnsureVisible(TREEVIEW_INFO *infoPtr, HTREEITEM item, BOOL bHScroll)
3995 HTREEITEM newFirstVisible = NULL;
3998 if (!TREEVIEW_ValidItem(infoPtr, item))
4001 if (!ISVISIBLE(item))
4003 /* Expand parents as necessary. */
4006 /* see if we are trying to ensure that root is vislble */
4007 if((item != infoPtr->root) && TREEVIEW_ValidItem(infoPtr, item))
4008 parent = item->parent;
4010 parent = item; /* this item is the topmost item */
4012 while (parent != infoPtr->root)
4014 if (!(parent->state & TVIS_EXPANDED))
4015 TREEVIEW_Expand(infoPtr, parent, FALSE, FALSE);
4017 parent = parent->parent;
4021 TRACE("%p (%s) %ld - %ld\n", item, TREEVIEW_ItemName(item), item->visibleOrder,
4022 infoPtr->firstVisible->visibleOrder);
4024 visible_pos = item->visibleOrder - infoPtr->firstVisible->visibleOrder;
4026 if (visible_pos < 0)
4028 /* item is before the start of the list: put it at the top. */
4029 newFirstVisible = item;
4031 else if (visible_pos >= TREEVIEW_GetVisibleCount(infoPtr)
4032 /* Sometimes, before we are displayed, GVC is 0, causing us to
4033 * spuriously scroll up. */
4036 /* item is past the end of the list. */
4037 int scroll = visible_pos - TREEVIEW_GetVisibleCount(infoPtr);
4039 newFirstVisible = TREEVIEW_GetListItem(infoPtr, infoPtr->firstVisible,
4045 /* Scroll window so item's text is visible as much as possible */
4046 /* Calculation of amount of extra space is taken from EditLabel code */
4048 TEXTMETRICA textMetric;
4049 HDC hdc = GetWindowDC(infoPtr->hwnd);
4051 x = item->textWidth;
4053 GetTextMetricsA(hdc, &textMetric);
4054 ReleaseDC(infoPtr->hwnd, hdc);
4056 x += (textMetric.tmMaxCharWidth * 2);
4057 x = max(x, textMetric.tmMaxCharWidth * 3);
4059 if (item->textOffset < 0)
4060 pos = item->textOffset;
4061 else if (item->textOffset + x > infoPtr->clientWidth)
4063 if (x > infoPtr->clientWidth)
4064 pos = item->textOffset;
4066 pos = item->textOffset + x - infoPtr->clientWidth;
4071 TREEVIEW_HScroll(infoPtr, MAKEWPARAM(SB_THUMBPOSITION, infoPtr->scrollX + pos));
4074 if (newFirstVisible != NULL && newFirstVisible != infoPtr->firstVisible)
4076 TREEVIEW_SetFirstVisible(infoPtr, newFirstVisible, TRUE);
4085 TREEVIEW_SetFirstVisible(TREEVIEW_INFO *infoPtr,
4086 TREEVIEW_ITEM *newFirstVisible,
4087 BOOL bUpdateScrollPos)
4091 TRACE("%p: %s\n", newFirstVisible, TREEVIEW_ItemName(newFirstVisible));
4093 if (newFirstVisible != NULL)
4095 /* Prevent an empty gap from appearing at the bottom... */
4096 gap_size = TREEVIEW_GetVisibleCount(infoPtr)
4097 - infoPtr->maxVisibleOrder + newFirstVisible->visibleOrder;
4101 newFirstVisible = TREEVIEW_GetListItem(infoPtr, newFirstVisible,
4104 /* ... unless we just don't have enough items. */
4105 if (newFirstVisible == NULL)
4106 newFirstVisible = infoPtr->root->firstChild;
4110 if (infoPtr->firstVisible != newFirstVisible)
4112 if (infoPtr->firstVisible == NULL || newFirstVisible == NULL)
4114 infoPtr->firstVisible = newFirstVisible;
4115 TREEVIEW_QueueRefresh(infoPtr);
4119 TREEVIEW_ITEM *item;
4120 int scroll = infoPtr->uItemHeight *
4121 (infoPtr->firstVisible->visibleOrder
4122 - newFirstVisible->visibleOrder);
4124 infoPtr->firstVisible = newFirstVisible;
4126 for (item = infoPtr->root->firstChild; item != NULL;
4127 item = TREEVIEW_GetNextListItem(infoPtr, item))
4129 item->rect.top += scroll;
4130 item->rect.bottom += scroll;
4133 if (bUpdateScrollPos)
4134 SetScrollPos(infoPtr->hwnd, SB_VERT,
4135 newFirstVisible->visibleOrder, TRUE);
4137 ScrollWindow(infoPtr->hwnd, 0, scroll, NULL, NULL);
4138 UpdateWindow(infoPtr->hwnd);
4143 /************************************************************************
4144 * VScroll is always in units of visible items. i.e. we always have a
4145 * visible item aligned to the top of the control. (Unless we have no
4149 TREEVIEW_VScroll(TREEVIEW_INFO *infoPtr, WPARAM wParam)
4151 TREEVIEW_ITEM *oldFirstVisible = infoPtr->firstVisible;
4152 TREEVIEW_ITEM *newFirstVisible = NULL;
4154 int nScrollCode = LOWORD(wParam);
4156 TRACE("wp %x\n", wParam);
4158 if (!(infoPtr->uInternalStatus & TV_VSCROLL))
4161 if (infoPtr->hwndEdit)
4162 SetFocus(infoPtr->hwnd);
4164 if (!oldFirstVisible)
4166 assert(infoPtr->root->firstChild == NULL);
4170 switch (nScrollCode)
4173 newFirstVisible = infoPtr->root->firstChild;
4177 newFirstVisible = TREEVIEW_GetLastListItem(infoPtr, infoPtr->root);
4181 newFirstVisible = TREEVIEW_GetPrevListItem(infoPtr, oldFirstVisible);
4185 newFirstVisible = TREEVIEW_GetNextListItem(infoPtr, oldFirstVisible);
4189 newFirstVisible = TREEVIEW_GetListItem(infoPtr, oldFirstVisible,
4190 -max(1, TREEVIEW_GetVisibleCount(infoPtr)));
4194 newFirstVisible = TREEVIEW_GetListItem(infoPtr, oldFirstVisible,
4195 max(1, TREEVIEW_GetVisibleCount(infoPtr)));
4199 case SB_THUMBPOSITION:
4200 newFirstVisible = TREEVIEW_GetListItem(infoPtr,
4201 infoPtr->root->firstChild,
4202 (LONG)(SHORT)HIWORD(wParam));
4209 if (newFirstVisible != NULL)
4211 if (newFirstVisible != oldFirstVisible)
4212 TREEVIEW_SetFirstVisible(infoPtr, newFirstVisible,
4213 nScrollCode != SB_THUMBTRACK);
4214 else if (nScrollCode == SB_THUMBPOSITION)
4215 SetScrollPos(infoPtr->hwnd, SB_VERT,
4216 newFirstVisible->visibleOrder, TRUE);
4223 TREEVIEW_HScroll(TREEVIEW_INFO *infoPtr, WPARAM wParam)
4226 int scrollX = infoPtr->scrollX;
4227 int nScrollCode = LOWORD(wParam);
4229 TRACE("wp %x\n", wParam);
4231 if (!(infoPtr->uInternalStatus & TV_HSCROLL))
4234 if (infoPtr->hwndEdit)
4235 SetFocus(infoPtr->hwnd);
4237 maxWidth = infoPtr->treeWidth - infoPtr->clientWidth;
4238 /* shall never occur */
4245 switch (nScrollCode)
4248 scrollX -= infoPtr->uItemHeight;
4251 scrollX += infoPtr->uItemHeight;
4254 scrollX -= infoPtr->clientWidth;
4257 scrollX += infoPtr->clientWidth;
4261 case SB_THUMBPOSITION:
4262 scrollX = (int)(SHORT)HIWORD(wParam);
4269 if (scrollX > maxWidth)
4271 else if (scrollX < 0)
4275 if (scrollX != infoPtr->scrollX)
4277 TREEVIEW_ITEM *item;
4278 LONG scroll_pixels = infoPtr->scrollX - scrollX;
4280 for (item = infoPtr->root->firstChild; item != NULL;
4281 item = TREEVIEW_GetNextListItem(infoPtr, item))
4283 item->linesOffset += scroll_pixels;
4284 item->stateOffset += scroll_pixels;
4285 item->imageOffset += scroll_pixels;
4286 item->textOffset += scroll_pixels;
4289 ScrollWindow(infoPtr->hwnd, scroll_pixels, 0, NULL, NULL);
4290 infoPtr->scrollX = scrollX;
4291 UpdateWindow(infoPtr->hwnd);
4294 if (nScrollCode != SB_THUMBTRACK)
4295 SetScrollPos(infoPtr->hwnd, SB_HORZ, scrollX, TRUE);
4301 TREEVIEW_MouseWheel(TREEVIEW_INFO *infoPtr, WPARAM wParam)
4304 UINT pulScrollLines = 3;
4306 if (infoPtr->firstVisible == NULL)
4309 SystemParametersInfoW(SPI_GETWHEELSCROLLLINES, 0, &pulScrollLines, 0);
4311 gcWheelDelta = -(short)HIWORD(wParam);
4312 pulScrollLines *= (gcWheelDelta / WHEEL_DELTA);
4314 if (abs(gcWheelDelta) >= WHEEL_DELTA && pulScrollLines)
4316 int newDy = infoPtr->firstVisible->visibleOrder + pulScrollLines;
4317 int maxDy = infoPtr->maxVisibleOrder;
4325 TREEVIEW_VScroll(infoPtr, MAKEWPARAM(SB_THUMBPOSITION, newDy));
4330 /* Create/Destroy *******************************************************/
4333 TREEVIEW_Create(HWND hwnd)
4336 TREEVIEW_INFO *infoPtr;
4338 TRACE("wnd %x, style %lx\n", hwnd, GetWindowLongA(hwnd, GWL_STYLE));
4340 infoPtr = (TREEVIEW_INFO *)COMCTL32_Alloc(sizeof(TREEVIEW_INFO));
4342 if (infoPtr == NULL)
4344 ERR("could not allocate info memory!\n");
4348 SetWindowLongA(hwnd, 0, (DWORD)infoPtr);
4350 infoPtr->hwnd = hwnd;
4351 infoPtr->dwStyle = GetWindowLongA(hwnd, GWL_STYLE);
4352 infoPtr->uInternalStatus = 0;
4354 infoPtr->uNumItems = 0;
4355 infoPtr->cdmode = 0;
4356 infoPtr->uScrollTime = 300; /* milliseconds */
4357 infoPtr->bRedraw = TRUE;
4359 GetClientRect(hwnd, &rcClient);
4361 /* No scroll bars yet. */
4362 infoPtr->clientWidth = rcClient.right;
4363 infoPtr->clientHeight = rcClient.bottom;
4365 infoPtr->treeWidth = 0;
4366 infoPtr->treeHeight = 0;
4368 infoPtr->uIndent = 19;
4369 infoPtr->selectedItem = 0;
4370 infoPtr->focusedItem = 0;
4372 infoPtr->firstVisible = 0;
4373 infoPtr->maxVisibleOrder = 0;
4374 infoPtr->dropItem = 0;
4375 infoPtr->insertMarkItem = 0;
4376 infoPtr->insertBeforeorAfter = 0;
4379 infoPtr->scrollX = 0;
4381 infoPtr->clrBk = GetSysColor(COLOR_WINDOW);
4382 infoPtr->clrText = -1; /* use system color */
4383 infoPtr->clrLine = RGB(128, 128, 128);
4384 infoPtr->clrInsertMark = GetSysColor(COLOR_BTNTEXT);
4388 infoPtr->hwndEdit = 0;
4389 infoPtr->wpEditOrig = NULL;
4390 infoPtr->bIgnoreEditKillFocus = FALSE;
4391 infoPtr->bLabelChanged = FALSE;
4393 infoPtr->himlNormal = NULL;
4394 infoPtr->himlState = NULL;
4395 infoPtr->normalImageWidth = 0;
4396 infoPtr->normalImageHeight = 0;
4397 infoPtr->stateImageWidth = 0;
4398 infoPtr->stateImageHeight = 0;
4400 infoPtr->items = DPA_Create(16);
4402 infoPtr->hFont = GetStockObject(DEFAULT_GUI_FONT);
4403 infoPtr->hBoldFont = TREEVIEW_CreateBoldFont(infoPtr->hFont);
4405 infoPtr->uItemHeight = TREEVIEW_NaturalHeight(infoPtr);
4407 infoPtr->root = TREEVIEW_AllocateItem(infoPtr);
4408 infoPtr->root->state = TVIS_EXPANDED;
4409 infoPtr->root->iLevel = -1;
4410 infoPtr->root->visibleOrder = -1;
4412 infoPtr->hwndNotify = GetParent(hwnd);
4414 infoPtr->bTransparent = ( GetWindowLongA( hwnd, GWL_STYLE) & TBSTYLE_FLAT);
4417 infoPtr->hwndToolTip = 0;
4418 if (!(infoPtr->dwStyle & TVS_NOTOOLTIPS))
4419 infoPtr->hwndToolTip = COMCTL32_CreateToolTip(hwnd);
4421 if (infoPtr->dwStyle & TVS_CHECKBOXES)
4424 HBITMAP hbm, hbmOld;
4428 infoPtr->himlState =
4429 ImageList_Create(16, 16, ILC_COLOR | ILC_MASK, 3, 0);
4431 hdc = CreateCompatibleDC(0);
4432 hbm = CreateCompatibleBitmap(hdc, 48, 16);
4433 hbmOld = SelectObject(hdc, hbm);
4435 rc.left = 0; rc.top = 0;
4436 rc.right = 48; rc.bottom = 16;
4437 FillRect(hdc, &rc, (HBRUSH)(COLOR_WINDOW+1));
4439 rc.left = 18; rc.top = 2;
4440 rc.right = 30; rc.bottom = 14;
4441 DrawFrameControl(hdc, &rc, DFC_BUTTON,
4442 DFCS_BUTTONCHECK|DFCS_FLAT);
4444 rc.left = 34; rc.right = 46;
4445 DrawFrameControl(hdc, &rc, DFC_BUTTON,
4446 DFCS_BUTTONCHECK|DFCS_FLAT|DFCS_CHECKED);
4448 nIndex = ImageList_AddMasked(infoPtr->himlState, hbm,
4449 GetSysColor(COLOR_WINDOW));
4450 TRACE("chckbox index %d\n", nIndex);
4451 SelectObject(hdc, hbmOld);
4455 infoPtr->stateImageWidth = 16;
4456 infoPtr->stateImageHeight = 16;
4463 TREEVIEW_Destroy(TREEVIEW_INFO *infoPtr)
4467 TREEVIEW_RemoveTree(infoPtr);
4469 /* tool tip is automatically destroyed: we are its owner */
4471 /* Restore original windproc. */
4472 if (infoPtr->hwndEdit)
4473 SetWindowLongA(infoPtr->hwndEdit, GWL_WNDPROC,
4474 (LONG)infoPtr->wpEditOrig);
4476 /* Deassociate treeview from the window before doing anything drastic. */
4477 SetWindowLongA(infoPtr->hwnd, 0, (LONG)NULL);
4479 DeleteObject(infoPtr->hBoldFont);
4480 COMCTL32_Free(infoPtr);
4485 /* Miscellaneous Messages ***********************************************/
4488 TREEVIEW_ScrollKeyDown(TREEVIEW_INFO *infoPtr, WPARAM key)
4496 #define SCROLL_ENTRY(dir, code) { ((dir) << 7) | (code) }
4497 SCROLL_ENTRY(SB_VERT, SB_PAGEUP), /* VK_PRIOR */
4498 SCROLL_ENTRY(SB_VERT, SB_PAGEDOWN), /* VK_NEXT */
4499 SCROLL_ENTRY(SB_VERT, SB_BOTTOM), /* VK_END */
4500 SCROLL_ENTRY(SB_VERT, SB_TOP), /* VK_HOME */
4501 SCROLL_ENTRY(SB_HORZ, SB_LINEUP), /* VK_LEFT */
4502 SCROLL_ENTRY(SB_VERT, SB_LINEUP), /* VK_UP */
4503 SCROLL_ENTRY(SB_HORZ, SB_LINEDOWN), /* VK_RIGHT */
4504 SCROLL_ENTRY(SB_VERT, SB_LINEDOWN) /* VK_DOWN */
4508 if (key >= VK_PRIOR && key <= VK_DOWN)
4510 unsigned char code = scroll[key - VK_PRIOR].code;
4512 (((code & (1 << 7)) == (SB_HORZ << 7))
4514 : TREEVIEW_VScroll)(infoPtr, code & 0x7F);
4520 /************************************************************************
4523 * VK_UP Move selection to the previous non-hidden item.
4524 * VK_DOWN Move selection to the next non-hidden item.
4525 * VK_HOME Move selection to the first item.
4526 * VK_END Move selection to the last item.
4527 * VK_LEFT If expanded then collapse, otherwise move to parent.
4528 * VK_RIGHT If collapsed then expand, otherwise move to first child.
4530 * VK_SUBTRACT Collapse.
4531 * VK_MULTIPLY Expand all.
4532 * VK_PRIOR Move up GetVisibleCount items.
4533 * VK_NEXT Move down GetVisibleCount items.
4534 * VK_BACK Move to parent.
4535 * CTRL-Left,Right,Up,Down,PgUp,PgDown,Home,End: Scroll without changing selection
4538 TREEVIEW_KeyDown(TREEVIEW_INFO *infoPtr, WPARAM wParam)
4540 /* If it is non-NULL and different, it will be selected and visible. */
4541 TREEVIEW_ITEM *newSelection = NULL;
4543 TREEVIEW_ITEM *prevItem = infoPtr->selectedItem;
4545 TRACE("%x\n", wParam);
4547 if (prevItem == NULL)
4550 if (GetAsyncKeyState(VK_CONTROL) & 0x8000)
4551 return TREEVIEW_ScrollKeyDown(infoPtr, wParam);
4556 newSelection = TREEVIEW_GetPrevListItem(infoPtr, prevItem);
4558 newSelection = infoPtr->root->firstChild;
4562 newSelection = TREEVIEW_GetNextListItem(infoPtr, prevItem);
4566 newSelection = infoPtr->root->firstChild;
4570 newSelection = TREEVIEW_GetLastListItem(infoPtr, infoPtr->root);
4574 if (prevItem->state & TVIS_EXPANDED)
4576 TREEVIEW_Collapse(infoPtr, prevItem, FALSE, TRUE);
4578 else if (prevItem->parent != infoPtr->root)
4580 newSelection = prevItem->parent;
4585 if (TREEVIEW_HasChildren(infoPtr, prevItem))
4587 if (!(prevItem->state & TVIS_EXPANDED))
4588 TREEVIEW_Expand(infoPtr, prevItem, FALSE, TRUE);
4591 newSelection = prevItem->firstChild;
4598 TREEVIEW_ExpandAll(infoPtr, prevItem);
4602 if (!(prevItem->state & TVIS_EXPANDED))
4603 TREEVIEW_Expand(infoPtr, prevItem, FALSE, TRUE);
4607 if (prevItem->state & TVIS_EXPANDED)
4608 TREEVIEW_Collapse(infoPtr, prevItem, FALSE, TRUE);
4613 = TREEVIEW_GetListItem(infoPtr, prevItem,
4614 -TREEVIEW_GetVisibleCount(infoPtr));
4619 = TREEVIEW_GetListItem(infoPtr, prevItem,
4620 TREEVIEW_GetVisibleCount(infoPtr));
4624 newSelection = prevItem->parent;
4625 if (newSelection == infoPtr->root)
4626 newSelection = NULL;
4630 if (infoPtr->dwStyle & TVS_CHECKBOXES)
4631 TREEVIEW_ToggleItemState(infoPtr, prevItem);
4635 if (newSelection && newSelection != prevItem)
4637 if (TREEVIEW_DoSelectItem(infoPtr, TVGN_CARET, newSelection,
4640 TREEVIEW_EnsureVisible(infoPtr, newSelection, FALSE);
4648 TREEVIEW_Size(TREEVIEW_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
4650 if (wParam == SIZE_RESTORED)
4652 infoPtr->clientWidth = SLOWORD(lParam);
4653 infoPtr->clientHeight = SHIWORD(lParam);
4655 TREEVIEW_RecalculateVisibleOrder(infoPtr, NULL);
4656 TREEVIEW_SetFirstVisible(infoPtr, infoPtr->firstVisible, TRUE);
4657 TREEVIEW_UpdateScrollBars(infoPtr);
4661 FIXME("WM_SIZE flag %x %lx not handled\n", wParam, lParam);
4664 TREEVIEW_QueueRefresh(infoPtr);
4669 TREEVIEW_StyleChanged(TREEVIEW_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
4671 TRACE("(%x %lx)\n", wParam, lParam);
4673 if (wParam == GWL_STYLE)
4675 DWORD dwNewStyle = ((LPSTYLESTRUCT)lParam)->styleNew;
4677 /* we have to take special care about tooltips */
4678 if ((infoPtr->dwStyle ^ dwNewStyle) & TVS_NOTOOLTIPS)
4680 if (infoPtr->dwStyle & TVS_NOTOOLTIPS)
4682 infoPtr->hwndToolTip = COMCTL32_CreateToolTip(infoPtr->hwnd);
4687 DestroyWindow(infoPtr->hwndToolTip);
4688 infoPtr->hwndToolTip = 0;
4692 infoPtr->dwStyle = dwNewStyle;
4695 TREEVIEW_UpdateSubTree(infoPtr, infoPtr->root);
4696 TREEVIEW_UpdateScrollBars(infoPtr);
4697 TREEVIEW_QueueRefresh(infoPtr);
4703 TREEVIEW_SetFocus(TREEVIEW_INFO *infoPtr)
4707 if (!infoPtr->selectedItem)
4709 TREEVIEW_DoSelectItem(infoPtr, TVGN_CARET, infoPtr->firstVisible,
4713 TREEVIEW_SendSimpleNotify(infoPtr, NM_SETFOCUS);
4714 TREEVIEW_QueueItemRefresh(infoPtr, infoPtr->selectedItem);
4719 TREEVIEW_KillFocus(TREEVIEW_INFO *infoPtr)
4723 TREEVIEW_SendSimpleNotify(infoPtr, NM_KILLFOCUS);
4724 TREEVIEW_QueueItemRefresh(infoPtr, infoPtr->selectedItem);
4729 static LRESULT WINAPI
4730 TREEVIEW_WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
4732 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
4733 if (infoPtr) TREEVIEW_VerifyTree(infoPtr);
4736 if (uMsg == WM_CREATE)
4737 TREEVIEW_Create(hwnd);
4744 case TVM_CREATEDRAGIMAGE:
4745 return TREEVIEW_CreateDragImage(infoPtr, wParam, lParam);
4747 case TVM_DELETEITEM:
4748 return TREEVIEW_DeleteItem(infoPtr, (HTREEITEM)lParam);
4750 case TVM_EDITLABELA:
4751 return TREEVIEW_EditLabelA(infoPtr, (HTREEITEM)lParam);
4753 case TVM_EDITLABELW:
4754 FIXME("Unimplemented msg TVM_EDITLABELW\n");
4757 case TVM_ENDEDITLABELNOW:
4758 return TREEVIEW_EndEditLabelNow(infoPtr, (BOOL)wParam);
4760 case TVM_ENSUREVISIBLE:
4761 return TREEVIEW_EnsureVisible(infoPtr, (HTREEITEM)lParam, TRUE);
4764 return TREEVIEW_ExpandMsg(infoPtr, (UINT)wParam, (HTREEITEM)lParam);
4766 case TVM_GETBKCOLOR:
4767 return TREEVIEW_GetBkColor(infoPtr);
4770 return TREEVIEW_GetCount(infoPtr);
4772 case TVM_GETEDITCONTROL:
4773 return TREEVIEW_GetEditControl(infoPtr);
4775 case TVM_GETIMAGELIST:
4776 return TREEVIEW_GetImageList(infoPtr, wParam);
4779 return TREEVIEW_GetIndent(infoPtr);
4781 case TVM_GETINSERTMARKCOLOR:
4782 return TREEVIEW_GetInsertMarkColor(infoPtr);
4784 case TVM_GETISEARCHSTRINGA:
4785 FIXME("Unimplemented msg TVM_GETISEARCHSTRINGA\n");
4788 case TVM_GETISEARCHSTRINGW:
4789 FIXME("Unimplemented msg TVM_GETISEARCHSTRINGW\n");
4793 return TREEVIEW_GetItemA(infoPtr, (LPTVITEMEXA)lParam);
4796 return TREEVIEW_GetItemW(infoPtr, (LPTVITEMEXA)lParam);
4798 case TVM_GETITEMHEIGHT:
4799 return TREEVIEW_GetItemHeight(infoPtr);
4801 case TVM_GETITEMRECT:
4802 return TREEVIEW_GetItemRect(infoPtr, (BOOL)wParam, (LPRECT)lParam);
4804 case TVM_GETITEMSTATE:
4805 return TREEVIEW_GetItemState(infoPtr, (HTREEITEM)wParam, (UINT)lParam);
4807 case TVM_GETLINECOLOR:
4808 return TREEVIEW_GetLineColor(infoPtr);
4810 case TVM_GETNEXTITEM:
4811 return TREEVIEW_GetNextItem(infoPtr, (UINT)wParam, (HTREEITEM)lParam);
4813 case TVM_GETSCROLLTIME:
4814 return TREEVIEW_GetScrollTime(infoPtr);
4816 case TVM_GETTEXTCOLOR:
4817 return TREEVIEW_GetTextColor(infoPtr);
4819 case TVM_GETTOOLTIPS:
4820 return TREEVIEW_GetToolTips(infoPtr);
4822 case TVM_GETUNICODEFORMAT:
4823 FIXME("Unimplemented msg TVM_GETUNICODEFORMAT\n");
4826 case TVM_GETVISIBLECOUNT:
4827 return TREEVIEW_GetVisibleCount(infoPtr);
4830 return TREEVIEW_HitTest(infoPtr, (LPTVHITTESTINFO)lParam);
4832 case TVM_INSERTITEMA:
4833 return TREEVIEW_InsertItemA(infoPtr, lParam);
4835 case TVM_INSERTITEMW:
4836 return TREEVIEW_InsertItemW(infoPtr, lParam);
4838 case TVM_SELECTITEM:
4839 return TREEVIEW_SelectItem(infoPtr, (INT)wParam, (HTREEITEM)lParam);
4841 case TVM_SETBKCOLOR:
4842 return TREEVIEW_SetBkColor(infoPtr, (COLORREF)lParam);
4844 case TVM_SETIMAGELIST:
4845 return TREEVIEW_SetImageList(infoPtr, wParam, (HIMAGELIST)lParam);
4848 return TREEVIEW_SetIndent(infoPtr, (UINT)wParam);
4850 case TVM_SETINSERTMARK:
4851 return TREEVIEW_SetInsertMark(infoPtr, (BOOL)wParam, (HTREEITEM)lParam);
4853 case TVM_SETINSERTMARKCOLOR:
4854 return TREEVIEW_SetInsertMarkColor(infoPtr, (COLORREF)lParam);
4857 return TREEVIEW_SetItemA(infoPtr, (LPTVITEMEXA)lParam);
4860 FIXME("Unimplemented msg TVM_SETITEMW\n");
4863 case TVM_SETLINECOLOR:
4864 return TREEVIEW_SetLineColor(infoPtr, (COLORREF)lParam);
4866 case TVM_SETITEMHEIGHT:
4867 return TREEVIEW_SetItemHeight(infoPtr, (INT)(SHORT)wParam);
4869 case TVM_SETSCROLLTIME:
4870 return TREEVIEW_SetScrollTime(infoPtr, (UINT)wParam);
4872 case TVM_SETTEXTCOLOR:
4873 return TREEVIEW_SetTextColor(infoPtr, (COLORREF)lParam);
4875 case TVM_SETTOOLTIPS:
4876 return TREEVIEW_SetToolTips(infoPtr, (HWND)wParam);
4878 case TVM_SETUNICODEFORMAT:
4879 FIXME("Unimplemented msg TVM_SETUNICODEFORMAT\n");
4882 case TVM_SORTCHILDREN:
4883 return TREEVIEW_SortChildren(infoPtr, wParam, lParam);
4885 case TVM_SORTCHILDRENCB:
4886 return TREEVIEW_SortChildrenCB(infoPtr, wParam, (LPTVSORTCB)lParam);
4891 return TREEVIEW_Command(infoPtr, wParam, lParam);
4894 return TREEVIEW_Destroy(infoPtr);
4899 return TREEVIEW_EraseBackground(infoPtr, (HDC)wParam);
4902 return DLGC_WANTARROWS | DLGC_WANTCHARS;
4905 return TREEVIEW_GetFont(infoPtr);
4908 return TREEVIEW_HScroll(infoPtr, wParam);
4911 return TREEVIEW_KeyDown(infoPtr, wParam);
4914 return TREEVIEW_KillFocus(infoPtr);
4916 case WM_LBUTTONDBLCLK:
4917 return TREEVIEW_LButtonDoubleClick(infoPtr, lParam);
4919 case WM_LBUTTONDOWN:
4920 return TREEVIEW_LButtonDown(infoPtr, lParam);
4922 /* WM_MBUTTONDOWN */
4928 /* WM_NOTIFYFORMAT */
4931 return TREEVIEW_Paint(infoPtr, wParam);
4933 /* WM_PRINTCLIENT */
4935 case WM_RBUTTONDOWN:
4936 return TREEVIEW_RButtonDown(infoPtr, lParam);
4939 return TREEVIEW_SetFocus(infoPtr);
4942 return TREEVIEW_SetFont(infoPtr, (HFONT)wParam, (BOOL)lParam);
4945 return TREEVIEW_SetRedraw(infoPtr, wParam, lParam);
4948 return TREEVIEW_Size(infoPtr, wParam, lParam);
4950 case WM_STYLECHANGED:
4951 return TREEVIEW_StyleChanged(infoPtr, wParam, lParam);
4953 /* WM_SYSCOLORCHANGE */
4958 return TREEVIEW_HandleTimer(infoPtr, wParam);
4961 return TREEVIEW_VScroll(infoPtr, wParam);
4963 /* WM_WININICHANGE */
4966 if (wParam & (MK_SHIFT | MK_CONTROL))
4968 return TREEVIEW_MouseWheel(infoPtr, wParam);
4971 TRACE("drawItem\n");
4975 /* This mostly catches MFC and Delphi messages. :( */
4976 if (uMsg >= WM_USER)
4977 TRACE("Unknown msg %04x wp=%08x lp=%08lx\n", uMsg, wParam, lParam);
4979 return DefWindowProcA(hwnd, uMsg, wParam, lParam);
4985 /* Class Registration ***************************************************/
4988 TREEVIEW_Register(void)
4994 ZeroMemory(&wndClass, sizeof(WNDCLASSA));
4995 wndClass.style = CS_GLOBALCLASS | CS_DBLCLKS;
4996 wndClass.lpfnWndProc = (WNDPROC)TREEVIEW_WindowProc;
4997 wndClass.cbClsExtra = 0;
4998 wndClass.cbWndExtra = sizeof(TREEVIEW_INFO *);
5000 wndClass.hCursor = LoadCursorA(0, IDC_ARROWA);
5001 wndClass.hbrBackground = 0;
5002 wndClass.lpszClassName = WC_TREEVIEWA;
5004 RegisterClassA(&wndClass);
5009 TREEVIEW_Unregister(void)
5011 UnregisterClassA(WC_TREEVIEWA, (HINSTANCE) NULL);
5015 /* Tree Verification ****************************************************/
5019 TREEVIEW_VerifyChildren(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *item);
5021 static inline void TREEVIEW_VerifyItemCommon(TREEVIEW_INFO *infoPtr,
5022 TREEVIEW_ITEM *item)
5024 assert(infoPtr != NULL);
5025 assert(item != NULL);
5027 /* both NULL, or both non-null */
5028 assert((item->firstChild == NULL) == (item->lastChild == NULL));
5030 assert(item->firstChild != item);
5031 assert(item->lastChild != item);
5033 if (item->firstChild)
5035 assert(item->firstChild->parent == item);
5036 assert(item->firstChild->prevSibling == NULL);
5039 if (item->lastChild)
5041 assert(item->lastChild->parent == item);
5042 assert(item->lastChild->nextSibling == NULL);
5045 assert(item->nextSibling != item);
5046 if (item->nextSibling)
5048 assert(item->nextSibling->parent == item->parent);
5049 assert(item->nextSibling->prevSibling == item);
5052 assert(item->prevSibling != item);
5053 if (item->prevSibling)
5055 assert(item->prevSibling->parent == item->parent);
5056 assert(item->prevSibling->nextSibling == item);
5061 TREEVIEW_VerifyItem(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *item)
5063 assert(item != NULL);
5065 assert(item->parent != NULL);
5066 assert(item->parent != item);
5067 assert(item->iLevel == item->parent->iLevel + 1);
5069 assert(DPA_GetPtrIndex(infoPtr->items, item) != -1);
5071 TREEVIEW_VerifyItemCommon(infoPtr, item);
5073 TREEVIEW_VerifyChildren(infoPtr, item);
5077 TREEVIEW_VerifyChildren(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *item)
5079 TREEVIEW_ITEM *child;
5080 assert(item != NULL);
5082 for (child = item->firstChild; child != NULL; child = child->nextSibling)
5083 TREEVIEW_VerifyItem(infoPtr, child);
5087 TREEVIEW_VerifyRoot(TREEVIEW_INFO *infoPtr)
5089 TREEVIEW_ITEM *root = infoPtr->root;
5091 assert(root != NULL);
5092 assert(root->iLevel == -1);
5093 assert(root->parent == NULL);
5094 assert(root->prevSibling == NULL);
5096 TREEVIEW_VerifyItemCommon(infoPtr, root);
5098 TREEVIEW_VerifyChildren(infoPtr, root);
5102 TREEVIEW_VerifyTree(TREEVIEW_INFO *infoPtr)
5104 assert(infoPtr != NULL);
5106 TREEVIEW_VerifyRoot(infoPtr);