3 * Copyright 1998 Eric Kohl <ekohl@abo.rhein-zeitung.de>
4 * Copyright 1998,1999 Alex Priem <alexp@sci.kun.nl>
5 * Copyright 1999 Sylvain St-Germain
6 * Copyright 2002 CodeWeavers, Aric Stewart
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24 * Note that TREEVIEW_INFO * and HTREEITEM are the same thing.
26 * Note2: If item's text == LPSTR_TEXTCALLBACKA we allocate buffer
27 * of size TEXT_CALLBACK_SIZE in DoSetItem.
28 * We use callbackMask to keep track of fields to be updated.
31 * missing notifications: TVN_GETINFOTIP, TVN_KEYDOWN,
34 * missing styles: TVS_INFOTIP, TVS_RTLREADING,
36 * missing item styles: TVIS_EXPANDPARTIAL, TVIS_EX_FLAT,
39 * Make the insertion mark look right.
40 * Scroll (instead of repaint) as much as possible.
59 #include "wine/debug.h"
60 #include "wine/exception.h"
62 WINE_DEFAULT_DEBUG_CHANNEL(treeview
);
64 /* internal structures */
65 typedef struct tagTREEVIEW_INFO
68 HWND hwndNotify
; /* Owner window to send notifications to */
73 UINT uNumItems
; /* number of valid TREEVIEW_ITEMs */
74 INT cdmode
; /* last custom draw setting */
75 UINT uScrollTime
; /* max. time for scrolling in milliseconds */
76 BOOL bRedraw
; /* if FALSE we validate but don't redraw in TREEVIEW_Paint() */
78 UINT uItemHeight
; /* item height */
81 LONG clientWidth
; /* width of control window */
82 LONG clientHeight
; /* height of control window */
84 LONG treeWidth
; /* width of visible tree items */
85 LONG treeHeight
; /* height of visible tree items */
87 UINT uIndent
; /* indentation in pixels */
88 HTREEITEM selectedItem
; /* handle to selected item or 0 if none */
89 HTREEITEM hotItem
; /* handle currently under cursor, 0 if none */
90 HTREEITEM focusedItem
; /* item that was under the cursor when WM_LBUTTONDOWN was received */
91 HTREEITEM editItem
; /* item being edited with builtin edit box */
93 HTREEITEM firstVisible
; /* handle to item whose top edge is at y = 0 */
95 HTREEITEM dropItem
; /* handle to item selected by drag cursor */
96 HTREEITEM insertMarkItem
; /* item after which insertion mark is placed */
97 BOOL insertBeforeorAfter
; /* flag used by TVM_SETINSERTMARK */
98 HIMAGELIST dragList
; /* Bitmap of dragged item */
104 COLORREF clrInsertMark
;
108 HFONT hUnderlineFont
;
109 HFONT hBoldUnderlineFont
;
114 WNDPROC wpEditOrig
; /* orig window proc for subclassing edit */
115 BOOL bIgnoreEditKillFocus
;
118 BOOL bNtfUnicode
; /* TRUE if should send NOTIFY with W */
119 HIMAGELIST himlNormal
;
120 int normalImageHeight
;
121 int normalImageWidth
;
122 HIMAGELIST himlState
;
123 int stateImageHeight
;
127 DWORD lastKeyPressTimestamp
;
129 INT nSearchParamLength
;
130 WCHAR szSearchParam
[ MAX_PATH
];
133 typedef struct _TREEITEM
/* HTREEITEM is a _TREEINFO *. */
135 HTREEITEM parent
; /* handle to parent or 0 if at root */
136 HTREEITEM nextSibling
; /* handle to next item in list, 0 if last */
137 HTREEITEM firstChild
; /* handle to first child or 0 if no child */
149 int iIntegral
; /* item height multiplier (1 is normal) */
150 int iLevel
; /* indentation level:0=root level */
152 HTREEITEM prevSibling
; /* handle to prev item in list, 0 if first */
158 LONG textWidth
; /* horizontal text extent for pszText */
159 LONG visibleOrder
; /* Depth-first numbering of the items whose ancestors are all expanded,
160 corresponding to a top-to-bottom ordering in the tree view.
161 Each item takes up "item.iIntegral" spots in the visible order.
162 0 is the root's first child. */
163 const TREEVIEW_INFO
*infoPtr
; /* tree data this item belongs to */
166 /******** Defines that TREEVIEW_ProcessLetterKeys uses ****************/
167 #define KEY_DELAY 450
169 /* bitflags for infoPtr->uInternalStatus */
171 #define TV_HSCROLL 0x01 /* treeview too large to fit in window */
172 #define TV_VSCROLL 0x02 /* (horizontal/vertical) */
173 #define TV_LDRAG 0x04 /* Lbutton pushed to start drag */
174 #define TV_LDRAGGING 0x08 /* Lbutton pushed, mouse moved. */
175 #define TV_RDRAG 0x10 /* ditto Rbutton */
176 #define TV_RDRAGGING 0x20
178 /* bitflags for infoPtr->timer */
180 #define TV_EDIT_TIMER 2
181 #define TV_EDIT_TIMER_SET 2
183 #define TEXT_CALLBACK_SIZE 260
185 #define TREEVIEW_LEFT_MARGIN 8
187 #define MINIMUM_INDENT 19
189 #define CALLBACK_MASK_ALL (TVIF_TEXT|TVIF_CHILDREN|TVIF_IMAGE|TVIF_SELECTEDIMAGE)
191 #define STATEIMAGEINDEX(x) (((x) >> 12) & 0x0f)
192 #define OVERLAYIMAGEINDEX(x) (((x) >> 8) & 0x0f)
193 #define ISVISIBLE(x) ((x)->visibleOrder >= 0)
195 #define GETLINECOLOR(x) ((x) == CLR_DEFAULT ? comctl32_color.clrGrayText : (x))
196 #define GETBKCOLOR(x) ((x) == CLR_NONE ? comctl32_color.clrWindow : (x))
197 #define GETTXTCOLOR(x) ((x) == CLR_NONE ? comctl32_color.clrWindowText : (x))
198 #define GETINSCOLOR(x) ((x) == CLR_DEFAULT ? comctl32_color.clrBtnText : (x))
200 static const WCHAR themeClass
[] = L
"Treeview";
203 typedef VOID (*TREEVIEW_ItemEnumFunc
)(TREEVIEW_INFO
*, TREEVIEW_ITEM
*,LPVOID
);
206 static VOID
TREEVIEW_Invalidate(const TREEVIEW_INFO
*, const TREEVIEW_ITEM
*);
208 static LRESULT
TREEVIEW_DoSelectItem(TREEVIEW_INFO
*, INT
, HTREEITEM
, INT
);
209 static VOID
TREEVIEW_SetFirstVisible(TREEVIEW_INFO
*, TREEVIEW_ITEM
*, BOOL
);
210 static LRESULT
TREEVIEW_EnsureVisible(TREEVIEW_INFO
*, HTREEITEM
, BOOL
);
211 static LRESULT
TREEVIEW_EndEditLabelNow(TREEVIEW_INFO
*infoPtr
, BOOL bCancel
);
212 static VOID
TREEVIEW_UpdateScrollBars(TREEVIEW_INFO
*infoPtr
);
213 static LRESULT
TREEVIEW_HScroll(TREEVIEW_INFO
*, WPARAM
);
215 /* Random Utilities *****************************************************/
216 static void TREEVIEW_VerifyTree(TREEVIEW_INFO
*infoPtr
);
218 /* Returns the treeview private data if hwnd is a treeview.
219 * Otherwise returns an undefined value. */
220 static inline TREEVIEW_INFO
*
221 TREEVIEW_GetInfoPtr(HWND hwnd
)
223 return (TREEVIEW_INFO
*)GetWindowLongPtrW(hwnd
, 0);
226 /* Don't call this. Nothing wants an item index. */
228 TREEVIEW_GetItemIndex(const TREEVIEW_INFO
*infoPtr
, HTREEITEM handle
)
230 return DPA_GetPtrIndex(infoPtr
->items
, handle
);
233 /* Checks if item has changed and needs to be redrawn */
234 static inline BOOL
item_changed (const TREEVIEW_ITEM
*tiOld
, const TREEVIEW_ITEM
*tiNew
,
235 const TVITEMEXW
*tvChange
)
237 /* Number of children has changed */
238 if ((tvChange
->mask
& TVIF_CHILDREN
) && (tiOld
->cChildren
!= tiNew
->cChildren
))
241 /* Image has changed and it's not a callback */
242 if ((tvChange
->mask
& TVIF_IMAGE
) && (tiOld
->iImage
!= tiNew
->iImage
) &&
243 tiNew
->iImage
!= I_IMAGECALLBACK
)
246 /* Selected image has changed and it's not a callback */
247 if ((tvChange
->mask
& TVIF_SELECTEDIMAGE
) && (tiOld
->iSelectedImage
!= tiNew
->iSelectedImage
) &&
248 tiNew
->iSelectedImage
!= I_IMAGECALLBACK
)
251 if ((tvChange
->mask
& TVIF_EXPANDEDIMAGE
) && (tiOld
->iExpandedImage
!= tiNew
->iExpandedImage
) &&
252 tiNew
->iExpandedImage
!= I_IMAGECALLBACK
)
255 /* Text has changed and it's not a callback */
256 if ((tvChange
->mask
& TVIF_TEXT
) && (tiOld
->pszText
!= tiNew
->pszText
) &&
257 tiNew
->pszText
!= LPSTR_TEXTCALLBACKW
)
260 /* Indent has changed */
261 if ((tvChange
->mask
& TVIF_INTEGRAL
) && (tiOld
->iIntegral
!= tiNew
->iIntegral
))
264 /* Item state has changed */
265 if ((tvChange
->mask
& TVIF_STATE
) && ((tiOld
->state
^ tiNew
->state
) & tvChange
->stateMask
))
271 /***************************************************************************
272 * This method checks that handle is an item for this tree.
275 TREEVIEW_ValidItem(const TREEVIEW_INFO
*infoPtr
, HTREEITEM handle
)
277 if (TREEVIEW_GetItemIndex(infoPtr
, handle
) == -1)
279 TRACE("invalid item %p\n", handle
);
287 TREEVIEW_CreateBoldFont(HFONT hOrigFont
)
291 GetObjectW(hOrigFont
, sizeof(font
), &font
);
292 font
.lfWeight
= FW_BOLD
;
293 return CreateFontIndirectW(&font
);
297 TREEVIEW_CreateUnderlineFont(HFONT hOrigFont
)
301 GetObjectW(hOrigFont
, sizeof(font
), &font
);
302 font
.lfUnderline
= TRUE
;
303 return CreateFontIndirectW(&font
);
307 TREEVIEW_CreateBoldUnderlineFont(HFONT hfont
)
311 GetObjectW(hfont
, sizeof(font
), &font
);
312 font
.lfWeight
= FW_BOLD
;
313 font
.lfUnderline
= TRUE
;
314 return CreateFontIndirectW(&font
);
318 TREEVIEW_FontForItem(const TREEVIEW_INFO
*infoPtr
, const TREEVIEW_ITEM
*item
)
320 if ((infoPtr
->dwStyle
& TVS_TRACKSELECT
) && (item
== infoPtr
->hotItem
))
321 return item
->state
& TVIS_BOLD
? infoPtr
->hBoldUnderlineFont
: infoPtr
->hUnderlineFont
;
322 if (item
->state
& TVIS_BOLD
)
323 return infoPtr
->hBoldFont
;
324 return infoPtr
->hFont
;
327 /* for trace/debugging purposes only */
329 TREEVIEW_ItemName(const TREEVIEW_ITEM
*item
)
331 if (item
== NULL
) return "<null item>";
332 if (item
->pszText
== LPSTR_TEXTCALLBACKW
) return "<callback>";
333 if (item
->pszText
== NULL
) return "<null>";
334 return debugstr_w(item
->pszText
);
337 /* An item is not a child of itself. */
339 TREEVIEW_IsChildOf(const TREEVIEW_ITEM
*parent
, const TREEVIEW_ITEM
*child
)
343 child
= child
->parent
;
344 if (child
== parent
) return TRUE
;
345 } while (child
!= NULL
);
351 TREEVIEW_IsFullRowSelect(const TREEVIEW_INFO
*infoPtr
)
353 return !(infoPtr
->dwStyle
& TVS_HASLINES
) && (infoPtr
->dwStyle
& TVS_FULLROWSELECT
);
357 TREEVIEW_IsItemHit(const TREEVIEW_INFO
*infoPtr
, const TVHITTESTINFO
*ht
)
359 if (TREEVIEW_IsFullRowSelect(infoPtr
))
360 return ht
->flags
& (TVHT_ONITEMINDENT
| TVHT_ONITEMBUTTON
| TVHT_ONITEM
| TVHT_ONITEMRIGHT
);
362 return ht
->flags
& TVHT_ONITEM
;
365 /* Tree Traversal *******************************************************/
367 /***************************************************************************
368 * This method returns the last expanded sibling or child child item
371 static TREEVIEW_ITEM
*
372 TREEVIEW_GetLastListItem(const TREEVIEW_INFO
*infoPtr
, TREEVIEW_ITEM
*item
)
374 if (!item
) return NULL
;
376 while (item
->lastChild
)
378 if (item
->state
& TVIS_EXPANDED
)
379 item
= item
->lastChild
;
384 if (item
== infoPtr
->root
)
390 /***************************************************************************
391 * This method returns the previous non-hidden item in the list not
392 * considering the tree hierarchy.
394 static TREEVIEW_ITEM
*
395 TREEVIEW_GetPrevListItem(const TREEVIEW_INFO
*infoPtr
, const TREEVIEW_ITEM
*tvItem
)
397 if (tvItem
->prevSibling
)
399 /* This item has a prevSibling, get the last item in the sibling's tree. */
400 TREEVIEW_ITEM
*upItem
= tvItem
->prevSibling
;
402 if ((upItem
->state
& TVIS_EXPANDED
) && upItem
->lastChild
!= NULL
)
403 return TREEVIEW_GetLastListItem(infoPtr
, upItem
->lastChild
);
409 /* this item does not have a prevSibling, get the parent */
410 return (tvItem
->parent
!= infoPtr
->root
) ? tvItem
->parent
: NULL
;
415 /***************************************************************************
416 * This method returns the next physical item in the treeview not
417 * considering the tree hierarchy.
419 static TREEVIEW_ITEM
*
420 TREEVIEW_GetNextListItem(const TREEVIEW_INFO
*infoPtr
, const TREEVIEW_ITEM
*tvItem
)
423 * If this item has children and is expanded, return the first child
425 if ((tvItem
->state
& TVIS_EXPANDED
) && tvItem
->firstChild
!= NULL
)
427 return tvItem
->firstChild
;
432 * try to get the sibling
434 if (tvItem
->nextSibling
)
435 return tvItem
->nextSibling
;
438 * Otherwise, get the parent's sibling.
440 while (tvItem
->parent
)
442 tvItem
= tvItem
->parent
;
444 if (tvItem
->nextSibling
)
445 return tvItem
->nextSibling
;
451 /***************************************************************************
452 * This method returns the nth item starting at the given item. It returns
453 * the last item (or first) we we run out of items.
455 * Will scroll backward if count is <0.
456 * forward if count is >0.
458 static TREEVIEW_ITEM
*
459 TREEVIEW_GetListItem(const TREEVIEW_INFO
*infoPtr
, TREEVIEW_ITEM
*item
,
462 TREEVIEW_ITEM
*(*next_item
)(const TREEVIEW_INFO
*, const TREEVIEW_ITEM
*);
463 TREEVIEW_ITEM
*previousItem
;
465 assert(item
!= NULL
);
469 next_item
= TREEVIEW_GetNextListItem
;
474 next_item
= TREEVIEW_GetPrevListItem
;
482 item
= next_item(infoPtr
, item
);
484 } while (--count
&& item
!= NULL
);
487 return item
? item
: previousItem
;
490 /* Notifications ************************************************************/
492 static INT
get_notifycode(const TREEVIEW_INFO
*infoPtr
, INT code
)
494 if (!infoPtr
->bNtfUnicode
) {
496 case TVN_SELCHANGINGW
: return TVN_SELCHANGINGA
;
497 case TVN_SELCHANGEDW
: return TVN_SELCHANGEDA
;
498 case TVN_GETDISPINFOW
: return TVN_GETDISPINFOA
;
499 case TVN_SETDISPINFOW
: return TVN_SETDISPINFOA
;
500 case TVN_ITEMEXPANDINGW
: return TVN_ITEMEXPANDINGA
;
501 case TVN_ITEMEXPANDEDW
: return TVN_ITEMEXPANDEDA
;
502 case TVN_BEGINDRAGW
: return TVN_BEGINDRAGA
;
503 case TVN_BEGINRDRAGW
: return TVN_BEGINRDRAGA
;
504 case TVN_DELETEITEMW
: return TVN_DELETEITEMA
;
505 case TVN_BEGINLABELEDITW
: return TVN_BEGINLABELEDITA
;
506 case TVN_ENDLABELEDITW
: return TVN_ENDLABELEDITA
;
507 case TVN_GETINFOTIPW
: return TVN_GETINFOTIPA
;
514 TREEVIEW_SendRealNotify(const TREEVIEW_INFO
*infoPtr
, UINT code
, NMHDR
*hdr
)
516 TRACE("code=%d, hdr=%p\n", code
, hdr
);
518 hdr
->hwndFrom
= infoPtr
->hwnd
;
519 hdr
->idFrom
= GetWindowLongPtrW(infoPtr
->hwnd
, GWLP_ID
);
520 hdr
->code
= get_notifycode(infoPtr
, code
);
522 return SendMessageW(infoPtr
->hwndNotify
, WM_NOTIFY
, hdr
->idFrom
, (LPARAM
)hdr
);
526 TREEVIEW_SendSimpleNotify(const TREEVIEW_INFO
*infoPtr
, UINT code
)
529 return TREEVIEW_SendRealNotify(infoPtr
, code
, &hdr
);
533 TREEVIEW_TVItemFromItem(const TREEVIEW_INFO
*infoPtr
, UINT mask
, TVITEMW
*tvItem
, TREEVIEW_ITEM
*item
)
536 tvItem
->hItem
= item
;
537 tvItem
->state
= item
->state
;
538 tvItem
->stateMask
= 0;
539 tvItem
->iImage
= item
->iImage
;
540 tvItem
->iSelectedImage
= item
->iSelectedImage
;
541 tvItem
->cChildren
= item
->cChildren
;
542 tvItem
->lParam
= item
->lParam
;
546 if (!infoPtr
->bNtfUnicode
)
548 tvItem
->cchTextMax
= WideCharToMultiByte( CP_ACP
, 0, item
->pszText
, -1, NULL
, 0, NULL
, NULL
);
549 tvItem
->pszText
= Alloc (tvItem
->cchTextMax
);
550 WideCharToMultiByte( CP_ACP
, 0, item
->pszText
, -1, (LPSTR
)tvItem
->pszText
, tvItem
->cchTextMax
, 0, 0 );
554 tvItem
->cchTextMax
= item
->cchTextMax
;
555 tvItem
->pszText
= item
->pszText
;
560 tvItem
->cchTextMax
= 0;
561 tvItem
->pszText
= NULL
;
566 TREEVIEW_SendTreeviewNotify(const TREEVIEW_INFO
*infoPtr
, UINT code
, UINT action
,
567 UINT mask
, HTREEITEM oldItem
, HTREEITEM newItem
)
572 TRACE("code:%d action:0x%x olditem:%p newitem:%p\n",
573 code
, action
, oldItem
, newItem
);
575 memset(&nmhdr
, 0, sizeof(NMTREEVIEWW
));
576 nmhdr
.action
= action
;
579 TREEVIEW_TVItemFromItem(infoPtr
, mask
, &nmhdr
.itemOld
, oldItem
);
582 TREEVIEW_TVItemFromItem(infoPtr
, mask
, &nmhdr
.itemNew
, newItem
);
587 ret
= TREEVIEW_SendRealNotify(infoPtr
, code
, &nmhdr
.hdr
);
588 if (!infoPtr
->bNtfUnicode
)
590 Free(nmhdr
.itemOld
.pszText
);
591 Free(nmhdr
.itemNew
.pszText
);
597 TREEVIEW_SendTreeviewDnDNotify(const TREEVIEW_INFO
*infoPtr
, UINT code
,
598 HTREEITEM dragItem
, POINT pt
)
602 TRACE("code:%d dragitem:%p\n", code
, dragItem
);
605 nmhdr
.itemNew
.mask
= TVIF_STATE
| TVIF_PARAM
| TVIF_HANDLE
;
606 nmhdr
.itemNew
.hItem
= dragItem
;
607 nmhdr
.itemNew
.state
= dragItem
->state
;
608 nmhdr
.itemNew
.lParam
= dragItem
->lParam
;
610 nmhdr
.ptDrag
.x
= pt
.x
;
611 nmhdr
.ptDrag
.y
= pt
.y
;
613 return TREEVIEW_SendRealNotify(infoPtr
, code
, &nmhdr
.hdr
);
618 TREEVIEW_SendCustomDrawNotify(const TREEVIEW_INFO
*infoPtr
, DWORD dwDrawStage
,
621 NMTVCUSTOMDRAW nmcdhdr
;
624 TRACE("drawstage %#lx, hdc %p\n", dwDrawStage
, hdc
);
626 nmcd
= &nmcdhdr
.nmcd
;
627 nmcd
->dwDrawStage
= dwDrawStage
;
630 nmcd
->dwItemSpec
= 0;
631 nmcd
->uItemState
= 0;
632 nmcd
->lItemlParam
= 0;
633 nmcdhdr
.clrText
= infoPtr
->clrText
;
634 nmcdhdr
.clrTextBk
= infoPtr
->clrBk
;
637 return TREEVIEW_SendRealNotify(infoPtr
, NM_CUSTOMDRAW
, &nmcdhdr
.nmcd
.hdr
);
640 /* FIXME: need to find out when the flags in uItemState need to be set */
643 TREEVIEW_SendCustomDrawItemNotify(const TREEVIEW_INFO
*infoPtr
, HDC hdc
,
644 TREEVIEW_ITEM
*item
, UINT uItemDrawState
,
645 NMTVCUSTOMDRAW
*nmcdhdr
)
649 DWORD_PTR dwItemSpec
;
652 dwDrawStage
= CDDS_ITEM
| uItemDrawState
;
653 dwItemSpec
= (DWORD_PTR
)item
;
655 if (item
->state
& TVIS_SELECTED
)
656 uItemState
|= CDIS_SELECTED
;
657 if (item
== infoPtr
->selectedItem
)
658 uItemState
|= CDIS_FOCUS
;
659 if (item
== infoPtr
->hotItem
)
660 uItemState
|= CDIS_HOT
;
662 nmcd
= &nmcdhdr
->nmcd
;
663 nmcd
->dwDrawStage
= dwDrawStage
;
665 nmcd
->rc
= item
->rect
;
666 nmcd
->dwItemSpec
= dwItemSpec
;
667 nmcd
->uItemState
= uItemState
;
668 nmcd
->lItemlParam
= item
->lParam
;
669 nmcdhdr
->iLevel
= item
->iLevel
;
671 TRACE("drawstage %#lx hdc:%p item:%Ix, itemstate:0x%x, lItemlParam:%Ix\n",
672 nmcd
->dwDrawStage
, nmcd
->hdc
, nmcd
->dwItemSpec
,
673 nmcd
->uItemState
, nmcd
->lItemlParam
);
675 return TREEVIEW_SendRealNotify(infoPtr
, NM_CUSTOMDRAW
, &nmcdhdr
->nmcd
.hdr
);
679 TREEVIEW_BeginLabelEditNotify(const TREEVIEW_INFO
*infoPtr
, TREEVIEW_ITEM
*editItem
)
684 TREEVIEW_TVItemFromItem(infoPtr
, TVIF_HANDLE
| TVIF_STATE
| TVIF_PARAM
| TVIF_TEXT
,
685 &tvdi
.item
, editItem
);
687 ret
= TREEVIEW_SendRealNotify(infoPtr
, TVN_BEGINLABELEDITW
, &tvdi
.hdr
);
689 if (!infoPtr
->bNtfUnicode
)
690 Free(tvdi
.item
.pszText
);
696 TREEVIEW_UpdateDispInfo(const TREEVIEW_INFO
*infoPtr
, TREEVIEW_ITEM
*item
,
699 NMTVDISPINFOEXW callback
;
701 TRACE("mask=0x%x, callbackmask=0x%x\n", mask
, item
->callbackMask
);
702 mask
&= item
->callbackMask
;
704 if (mask
== 0) return;
706 /* 'state' always contains valid value, as well as 'lParam'.
707 * All other parameters are uninitialized.
709 callback
.item
.pszText
= item
->pszText
;
710 callback
.item
.cchTextMax
= item
->cchTextMax
;
711 callback
.item
.mask
= mask
;
712 callback
.item
.hItem
= item
;
713 callback
.item
.state
= item
->state
;
714 callback
.item
.lParam
= item
->lParam
;
716 /* If text is changed we need to recalculate textWidth */
717 if (mask
& TVIF_TEXT
)
720 TREEVIEW_SendRealNotify(infoPtr
, TVN_GETDISPINFOW
, &callback
.hdr
);
721 TRACE("resulting code 0x%08x\n", callback
.hdr
.code
);
723 /* It may have changed due to a call to SetItem. */
724 mask
&= item
->callbackMask
;
726 if ((mask
& TVIF_TEXT
) && callback
.item
.pszText
!= item
->pszText
)
728 /* Instead of copying text into our buffer user specified his own */
729 if (!infoPtr
->bNtfUnicode
&& (callback
.hdr
.code
== TVN_GETDISPINFOA
)) {
732 int len
= MultiByteToWideChar( CP_ACP
, 0,
733 (LPSTR
)callback
.item
.pszText
, -1,
735 buflen
= max((len
)*sizeof(WCHAR
), TEXT_CALLBACK_SIZE
);
736 newText
= ReAlloc(item
->pszText
, buflen
);
738 TRACE("returned str %s, len=%d, buflen=%d\n",
739 debugstr_a((LPSTR
)callback
.item
.pszText
), len
, buflen
);
743 item
->pszText
= newText
;
744 MultiByteToWideChar( CP_ACP
, 0,
745 (LPSTR
)callback
.item
.pszText
, -1,
746 item
->pszText
, buflen
/sizeof(WCHAR
));
747 item
->cchTextMax
= buflen
/sizeof(WCHAR
);
749 /* If realloc fails we have nothing to do, but keep original text */
752 int len
= max(lstrlenW(callback
.item
.pszText
) + 1,
754 LPWSTR newText
= ReAlloc(item
->pszText
, len
*sizeof(WCHAR
));
756 TRACE("returned wstr %s, len=%d\n",
757 debugstr_w(callback
.item
.pszText
), len
);
761 item
->pszText
= newText
;
762 lstrcpyW(item
->pszText
, callback
.item
.pszText
);
763 item
->cchTextMax
= len
;
765 /* If realloc fails we have nothing to do, but keep original text */
768 else if (mask
& TVIF_TEXT
) {
769 /* User put text into our buffer, that is ok unless A string */
770 if (!infoPtr
->bNtfUnicode
&& (callback
.hdr
.code
== TVN_GETDISPINFOA
)) {
773 int len
= MultiByteToWideChar( CP_ACP
, 0,
774 (LPSTR
)callback
.item
.pszText
, -1,
776 buflen
= max((len
)*sizeof(WCHAR
), TEXT_CALLBACK_SIZE
);
777 newText
= Alloc(buflen
);
779 TRACE("same buffer str %s, len=%d, buflen=%d\n",
780 debugstr_a((LPSTR
)callback
.item
.pszText
), len
, buflen
);
784 LPWSTR oldText
= item
->pszText
;
785 item
->pszText
= newText
;
786 MultiByteToWideChar( CP_ACP
, 0,
787 (LPSTR
)callback
.item
.pszText
, -1,
788 item
->pszText
, buflen
/sizeof(WCHAR
));
789 item
->cchTextMax
= buflen
/sizeof(WCHAR
);
795 if (mask
& TVIF_IMAGE
)
796 item
->iImage
= callback
.item
.iImage
;
798 if (mask
& TVIF_SELECTEDIMAGE
)
799 item
->iSelectedImage
= callback
.item
.iSelectedImage
;
801 if (mask
& TVIF_EXPANDEDIMAGE
)
802 item
->iExpandedImage
= callback
.item
.iExpandedImage
;
804 if (mask
& TVIF_CHILDREN
)
805 item
->cChildren
= callback
.item
.cChildren
;
807 if (callback
.item
.mask
& TVIF_STATE
)
809 item
->state
&= ~callback
.item
.stateMask
;
810 item
->state
|= (callback
.item
.state
& callback
.item
.stateMask
);
813 /* These members are now permanently set. */
814 if (callback
.item
.mask
& TVIF_DI_SETITEM
)
815 item
->callbackMask
&= ~callback
.item
.mask
;
818 /***************************************************************************
819 * This function uses cChildren field to decide whether the item has
821 * Note: if this returns TRUE, the child items may not actually exist,
822 * they could be virtual.
824 * Just use item->firstChild to check for physical children.
827 TREEVIEW_HasChildren(const TREEVIEW_INFO
*infoPtr
, TREEVIEW_ITEM
*item
)
829 TREEVIEW_UpdateDispInfo(infoPtr
, item
, TVIF_CHILDREN
);
830 /* Protect for a case when callback field is not changed by a host,
831 otherwise negative values trigger normal notifications. */
832 return item
->cChildren
!= 0 && item
->cChildren
!= I_CHILDRENCALLBACK
;
835 static INT
TREEVIEW_NotifyFormat (TREEVIEW_INFO
*infoPtr
, HWND hwndFrom
, UINT nCommand
)
839 TRACE("(hwndFrom=%p, nCommand=%d)\n", hwndFrom
, nCommand
);
841 if (nCommand
!= NF_REQUERY
) return 0;
843 format
= SendMessageW(hwndFrom
, WM_NOTIFYFORMAT
, (WPARAM
)infoPtr
->hwnd
, NF_QUERY
);
844 TRACE("format=%d\n", format
);
846 /* Invalid format returned by NF_QUERY defaults to ANSI*/
847 if (format
!= NFR_ANSI
&& format
!= NFR_UNICODE
)
850 infoPtr
->bNtfUnicode
= (format
== NFR_UNICODE
);
855 /* Item Position ********************************************************/
857 /* Compute linesOffset, stateOffset, imageOffset, textOffset of an item. */
859 TREEVIEW_ComputeItemInternalMetrics(const TREEVIEW_INFO
*infoPtr
, TREEVIEW_ITEM
*item
)
861 /* has TVS_LINESATROOT and (TVS_HASLINES|TVS_HASBUTTONS) */
862 BOOL lar
= ((infoPtr
->dwStyle
& (TVS_LINESATROOT
|TVS_HASLINES
|TVS_HASBUTTONS
))
865 item
->linesOffset
= infoPtr
->uIndent
* (lar
? item
->iLevel
: item
->iLevel
- 1)
867 item
->stateOffset
= item
->linesOffset
+ infoPtr
->uIndent
;
868 item
->imageOffset
= item
->stateOffset
869 + (STATEIMAGEINDEX(item
->state
) ? infoPtr
->stateImageWidth
: 0);
870 item
->textOffset
= item
->imageOffset
+ infoPtr
->normalImageWidth
;
874 TREEVIEW_ComputeTextWidth(const TREEVIEW_INFO
*infoPtr
, TREEVIEW_ITEM
*item
, HDC hDC
)
880 /* DRAW's OM docker creates items like this */
881 if (item
->pszText
== NULL
)
893 hdc
= GetDC(infoPtr
->hwnd
);
894 hOldFont
= SelectObject(hdc
, TREEVIEW_FontForItem(infoPtr
, item
));
897 GetTextExtentPoint32W(hdc
, item
->pszText
, lstrlenW(item
->pszText
), &sz
);
898 item
->textWidth
= sz
.cx
;
902 SelectObject(hdc
, hOldFont
);
908 TREEVIEW_ComputeItemRect(const TREEVIEW_INFO
*infoPtr
, TREEVIEW_ITEM
*item
)
910 item
->rect
.top
= infoPtr
->uItemHeight
*
911 (item
->visibleOrder
- infoPtr
->firstVisible
->visibleOrder
);
913 item
->rect
.bottom
= item
->rect
.top
914 + infoPtr
->uItemHeight
* item
->iIntegral
- 1;
917 item
->rect
.right
= infoPtr
->clientWidth
;
920 /* We know that only items after start need their order updated. */
922 TREEVIEW_RecalculateVisibleOrder(TREEVIEW_INFO
*infoPtr
, TREEVIEW_ITEM
*start
)
929 start
= infoPtr
->root
->firstChild
;
933 order
= start
->visibleOrder
;
935 for (item
= start
; item
!= NULL
;
936 item
= TREEVIEW_GetNextListItem(infoPtr
, item
))
938 if (!ISVISIBLE(item
) && order
> 0)
939 TREEVIEW_ComputeItemInternalMetrics(infoPtr
, item
);
940 item
->visibleOrder
= order
;
941 order
+= item
->iIntegral
;
944 infoPtr
->maxVisibleOrder
= order
;
946 for (item
= infoPtr
->root
->firstChild
; item
!= NULL
;
947 item
= TREEVIEW_GetNextListItem(infoPtr
, item
))
949 TREEVIEW_ComputeItemRect(infoPtr
, item
);
954 /* Update metrics of all items in selected subtree.
955 * root must be expanded
958 TREEVIEW_UpdateSubTree(const TREEVIEW_INFO
*infoPtr
, TREEVIEW_ITEM
*root
)
960 TREEVIEW_ITEM
*sibling
;
964 if (!root
->firstChild
|| !(root
->state
& TVIS_EXPANDED
))
967 root
->state
&= ~TVIS_EXPANDED
;
968 sibling
= TREEVIEW_GetNextListItem(infoPtr
, root
);
969 root
->state
|= TVIS_EXPANDED
;
971 hdc
= GetDC(infoPtr
->hwnd
);
972 hOldFont
= SelectObject(hdc
, infoPtr
->hFont
);
974 for (; root
!= sibling
;
975 root
= TREEVIEW_GetNextListItem(infoPtr
, root
))
977 TREEVIEW_ComputeItemInternalMetrics(infoPtr
, root
);
979 if (root
->callbackMask
& TVIF_TEXT
)
980 TREEVIEW_UpdateDispInfo(infoPtr
, root
, TVIF_TEXT
);
982 if (root
->textWidth
== 0)
984 SelectObject(hdc
, TREEVIEW_FontForItem(infoPtr
, root
));
985 TREEVIEW_ComputeTextWidth(infoPtr
, root
, hdc
);
989 SelectObject(hdc
, hOldFont
);
990 ReleaseDC(infoPtr
->hwnd
, hdc
);
993 /* Item Allocation **********************************************************/
995 static TREEVIEW_ITEM
*
996 TREEVIEW_AllocateItem(const TREEVIEW_INFO
*infoPtr
)
998 TREEVIEW_ITEM
*newItem
= Alloc(sizeof(*newItem
));
1003 /* I_IMAGENONE would make more sense but this is neither what is
1004 * documented (MSDN doesn't specify) nor what Windows actually does
1005 * (it sets it to zero)... and I can so imagine an application using
1006 * inc/dec to toggle the images. */
1007 newItem
->iImage
= 0;
1008 newItem
->iSelectedImage
= 0;
1009 newItem
->iExpandedImage
= (WORD
)I_IMAGENONE
;
1010 newItem
->infoPtr
= infoPtr
;
1012 if (DPA_InsertPtr(infoPtr
->items
, INT_MAX
, newItem
) == -1)
1021 /* Exact opposite of TREEVIEW_AllocateItem. In particular, it does not
1022 * free item->pszText. */
1024 TREEVIEW_FreeItem(TREEVIEW_INFO
*infoPtr
, TREEVIEW_ITEM
*item
)
1026 DPA_DeletePtr(infoPtr
->items
, DPA_GetPtrIndex(infoPtr
->items
, item
));
1027 if (infoPtr
->selectedItem
== item
)
1028 infoPtr
->selectedItem
= NULL
;
1029 if (infoPtr
->hotItem
== item
)
1030 infoPtr
->hotItem
= NULL
;
1031 if (infoPtr
->focusedItem
== item
)
1032 infoPtr
->focusedItem
= NULL
;
1033 if (infoPtr
->firstVisible
== item
)
1034 infoPtr
->firstVisible
= NULL
;
1035 if (infoPtr
->dropItem
== item
)
1036 infoPtr
->dropItem
= NULL
;
1037 if (infoPtr
->insertMarkItem
== item
)
1038 infoPtr
->insertMarkItem
= NULL
;
1043 /* Item Insertion *******************************************************/
1045 /***************************************************************************
1046 * This method inserts newItem before sibling as a child of parent.
1047 * sibling can be NULL, but only if parent has no children.
1050 TREEVIEW_InsertBefore(TREEVIEW_ITEM
*newItem
, TREEVIEW_ITEM
*sibling
,
1051 TREEVIEW_ITEM
*parent
)
1053 assert(parent
!= NULL
);
1055 if (sibling
!= NULL
)
1057 assert(sibling
->parent
== parent
);
1059 if (sibling
->prevSibling
!= NULL
)
1060 sibling
->prevSibling
->nextSibling
= newItem
;
1062 newItem
->prevSibling
= sibling
->prevSibling
;
1063 sibling
->prevSibling
= newItem
;
1066 newItem
->prevSibling
= NULL
;
1068 newItem
->nextSibling
= sibling
;
1070 if (parent
->firstChild
== sibling
)
1071 parent
->firstChild
= newItem
;
1073 if (parent
->lastChild
== NULL
)
1074 parent
->lastChild
= newItem
;
1077 /***************************************************************************
1078 * This method inserts newItem after sibling as a child of parent.
1079 * sibling can be NULL, but only if parent has no children.
1082 TREEVIEW_InsertAfter(TREEVIEW_ITEM
*newItem
, TREEVIEW_ITEM
*sibling
,
1083 TREEVIEW_ITEM
*parent
)
1085 assert(parent
!= NULL
);
1087 if (sibling
!= NULL
)
1089 assert(sibling
->parent
== parent
);
1091 if (sibling
->nextSibling
!= NULL
)
1092 sibling
->nextSibling
->prevSibling
= newItem
;
1094 newItem
->nextSibling
= sibling
->nextSibling
;
1095 sibling
->nextSibling
= newItem
;
1098 newItem
->nextSibling
= NULL
;
1100 newItem
->prevSibling
= sibling
;
1102 if (parent
->lastChild
== sibling
)
1103 parent
->lastChild
= newItem
;
1105 if (parent
->firstChild
== NULL
)
1106 parent
->firstChild
= newItem
;
1110 TREEVIEW_DoSetItemT(const TREEVIEW_INFO
*infoPtr
, TREEVIEW_ITEM
*item
,
1111 const TVITEMEXW
*tvItem
, BOOL isW
)
1113 UINT callbackClear
= 0;
1114 UINT callbackSet
= 0;
1116 TRACE("item %p\n", item
);
1117 /* Do this first in case it fails. */
1118 if (tvItem
->mask
& TVIF_TEXT
)
1120 item
->textWidth
= 0; /* force width recalculation */
1122 /* Covers != TEXTCALLBACKA too, and undocumented: pszText of NULL also means TEXTCALLBACK */
1123 if (tvItem
->pszText
!= LPSTR_TEXTCALLBACKW
&& tvItem
->pszText
!= NULL
)
1128 len
= lstrlenW(tvItem
->pszText
) + 1;
1130 len
= MultiByteToWideChar(CP_ACP
, 0, (LPSTR
)tvItem
->pszText
, -1, NULL
, 0);
1132 /* Allocate new block to make pointer comparison in item_changed() work. */
1133 newText
= Alloc(len
* sizeof(WCHAR
));
1135 if (newText
== NULL
) return FALSE
;
1137 callbackClear
|= TVIF_TEXT
;
1139 Free(item
->pszText
);
1140 item
->pszText
= newText
;
1141 item
->cchTextMax
= len
;
1143 lstrcpynW(item
->pszText
, tvItem
->pszText
, len
);
1145 MultiByteToWideChar(CP_ACP
, 0, (LPSTR
)tvItem
->pszText
, -1,
1146 item
->pszText
, len
);
1148 TRACE("setting text %s, item %p\n", debugstr_w(item
->pszText
), item
);
1152 callbackSet
|= TVIF_TEXT
;
1153 item
->pszText
= ReAlloc(item
->pszText
, TEXT_CALLBACK_SIZE
* sizeof(WCHAR
));
1154 item
->cchTextMax
= TEXT_CALLBACK_SIZE
;
1155 TRACE("setting callback, item %p\n", item
);
1159 if (tvItem
->mask
& TVIF_CHILDREN
)
1161 item
->cChildren
= tvItem
->cChildren
;
1163 if (item
->cChildren
== I_CHILDRENCALLBACK
)
1164 callbackSet
|= TVIF_CHILDREN
;
1166 callbackClear
|= TVIF_CHILDREN
;
1169 if (tvItem
->mask
& TVIF_IMAGE
)
1171 item
->iImage
= tvItem
->iImage
;
1173 if (item
->iImage
== I_IMAGECALLBACK
)
1174 callbackSet
|= TVIF_IMAGE
;
1176 callbackClear
|= TVIF_IMAGE
;
1179 if (tvItem
->mask
& TVIF_SELECTEDIMAGE
)
1181 item
->iSelectedImage
= tvItem
->iSelectedImage
;
1183 if (item
->iSelectedImage
== I_IMAGECALLBACK
)
1184 callbackSet
|= TVIF_SELECTEDIMAGE
;
1186 callbackClear
|= TVIF_SELECTEDIMAGE
;
1189 if (tvItem
->mask
& TVIF_EXPANDEDIMAGE
)
1191 item
->iExpandedImage
= tvItem
->iExpandedImage
;
1193 if (item
->iExpandedImage
== I_IMAGECALLBACK
)
1194 callbackSet
|= TVIF_EXPANDEDIMAGE
;
1196 callbackClear
|= TVIF_EXPANDEDIMAGE
;
1199 if (tvItem
->mask
& TVIF_PARAM
)
1200 item
->lParam
= tvItem
->lParam
;
1202 /* If the application sets TVIF_INTEGRAL without
1203 * supplying a TVITEMEX structure, it's toast. */
1204 if (tvItem
->mask
& TVIF_INTEGRAL
)
1205 item
->iIntegral
= tvItem
->iIntegral
;
1207 if (tvItem
->mask
& TVIF_STATE
)
1209 TRACE("prevstate 0x%x, state 0x%x, mask 0x%x\n", item
->state
, tvItem
->state
,
1211 item
->state
&= ~tvItem
->stateMask
;
1212 item
->state
|= (tvItem
->state
& tvItem
->stateMask
);
1215 if (tvItem
->mask
& TVIF_STATEEX
)
1217 FIXME("New extended state: 0x%x\n", tvItem
->uStateEx
);
1220 item
->callbackMask
|= callbackSet
;
1221 item
->callbackMask
&= ~callbackClear
;
1226 /* Note that the new item is pre-zeroed. */
1228 TREEVIEW_InsertItemT(TREEVIEW_INFO
*infoPtr
, const TVINSERTSTRUCTW
*ptdi
, BOOL isW
)
1230 const TVITEMEXW
*tvItem
= &ptdi
->itemex
;
1231 HTREEITEM insertAfter
;
1232 TREEVIEW_ITEM
*newItem
, *parentItem
;
1233 BOOL bTextUpdated
= FALSE
;
1235 if (ptdi
->hParent
== TVI_ROOT
|| ptdi
->hParent
== 0)
1237 parentItem
= infoPtr
->root
;
1241 parentItem
= ptdi
->hParent
;
1243 if (!TREEVIEW_ValidItem(infoPtr
, parentItem
))
1245 WARN("invalid parent %p\n", parentItem
);
1250 insertAfter
= ptdi
->hInsertAfter
;
1252 /* Validate this now for convenience. */
1253 switch ((DWORD_PTR
)insertAfter
)
1255 case (DWORD_PTR
)TVI_FIRST
:
1256 case (DWORD_PTR
)TVI_LAST
:
1257 case (DWORD_PTR
)TVI_SORT
:
1261 if (!TREEVIEW_ValidItem(infoPtr
, insertAfter
) ||
1262 insertAfter
->parent
!= parentItem
)
1264 WARN("invalid insert after %p\n", insertAfter
);
1265 insertAfter
= TVI_LAST
;
1269 TRACE("parent %p position %p: %s\n", parentItem
, insertAfter
,
1270 (tvItem
->mask
& TVIF_TEXT
)
1271 ? ((tvItem
->pszText
== LPSTR_TEXTCALLBACKW
) ? "<callback>"
1272 : (isW
? debugstr_w(tvItem
->pszText
) : debugstr_a((LPSTR
)tvItem
->pszText
)))
1275 newItem
= TREEVIEW_AllocateItem(infoPtr
);
1276 if (newItem
== NULL
)
1279 newItem
->parent
= parentItem
;
1280 newItem
->iIntegral
= 1;
1281 newItem
->visibleOrder
= -1;
1283 if (!TREEVIEW_DoSetItemT(infoPtr
, newItem
, tvItem
, isW
))
1286 /* After this point, nothing can fail. (Except for TVI_SORT.) */
1288 infoPtr
->uNumItems
++;
1290 switch ((DWORD_PTR
)insertAfter
)
1292 case (DWORD_PTR
)TVI_FIRST
:
1294 TREEVIEW_ITEM
*originalFirst
= parentItem
->firstChild
;
1295 TREEVIEW_InsertBefore(newItem
, parentItem
->firstChild
, parentItem
);
1296 if (infoPtr
->firstVisible
== originalFirst
)
1297 TREEVIEW_SetFirstVisible(infoPtr
, newItem
, TRUE
);
1301 case (DWORD_PTR
)TVI_LAST
:
1302 TREEVIEW_InsertAfter(newItem
, parentItem
->lastChild
, parentItem
);
1305 /* hInsertAfter names a specific item we want to insert after */
1307 TREEVIEW_InsertAfter(newItem
, insertAfter
, insertAfter
->parent
);
1310 case (DWORD_PTR
)TVI_SORT
:
1312 TREEVIEW_ITEM
*aChild
;
1313 TREEVIEW_ITEM
*previousChild
= NULL
;
1314 TREEVIEW_ITEM
*originalFirst
= parentItem
->firstChild
;
1315 BOOL bItemInserted
= FALSE
;
1317 aChild
= parentItem
->firstChild
;
1319 bTextUpdated
= TRUE
;
1320 TREEVIEW_UpdateDispInfo(infoPtr
, newItem
, TVIF_TEXT
);
1322 /* Iterate the parent children to see where we fit in */
1323 while (aChild
!= NULL
)
1327 TREEVIEW_UpdateDispInfo(infoPtr
, aChild
, TVIF_TEXT
);
1328 comp
= lstrcmpW(newItem
->pszText
, aChild
->pszText
);
1330 if (comp
< 0) /* we are smaller than the current one */
1332 TREEVIEW_InsertBefore(newItem
, aChild
, parentItem
);
1333 if (infoPtr
->firstVisible
== originalFirst
&&
1334 aChild
== originalFirst
)
1335 TREEVIEW_SetFirstVisible(infoPtr
, newItem
, TRUE
);
1336 bItemInserted
= TRUE
;
1339 else if (comp
> 0) /* we are bigger than the current one */
1341 previousChild
= aChild
;
1343 /* This will help us to exit if there is no more sibling */
1344 aChild
= (aChild
->nextSibling
== 0)
1346 : aChild
->nextSibling
;
1348 /* Look at the next item */
1354 * An item with this name is already existing, therefore,
1355 * we add after the one we found
1357 TREEVIEW_InsertAfter(newItem
, aChild
, parentItem
);
1358 bItemInserted
= TRUE
;
1364 * we reach the end of the child list and the item has not
1365 * yet been inserted, therefore, insert it after the last child.
1367 if ((!bItemInserted
) && (aChild
== NULL
))
1368 TREEVIEW_InsertAfter(newItem
, previousChild
, parentItem
);
1375 TRACE("new item %p; parent %p, mask 0x%x\n", newItem
,
1376 newItem
->parent
, tvItem
->mask
);
1378 newItem
->iLevel
= newItem
->parent
->iLevel
+ 1;
1380 if (newItem
->parent
->cChildren
== 0)
1381 newItem
->parent
->cChildren
= 1;
1383 if (infoPtr
->dwStyle
& TVS_CHECKBOXES
)
1385 if (STATEIMAGEINDEX(newItem
->state
) == 0)
1386 newItem
->state
|= INDEXTOSTATEIMAGEMASK(1);
1389 if (infoPtr
->firstVisible
== NULL
)
1390 infoPtr
->firstVisible
= newItem
;
1392 TREEVIEW_VerifyTree(infoPtr
);
1394 if (!infoPtr
->bRedraw
) return (LRESULT
)newItem
;
1396 if (parentItem
== infoPtr
->root
||
1397 (ISVISIBLE(parentItem
) && parentItem
->state
& TVIS_EXPANDED
))
1399 TREEVIEW_ITEM
*item
;
1400 TREEVIEW_ITEM
*prev
= TREEVIEW_GetPrevListItem(infoPtr
, newItem
);
1402 TREEVIEW_RecalculateVisibleOrder(infoPtr
, prev
);
1403 TREEVIEW_ComputeItemInternalMetrics(infoPtr
, newItem
);
1406 TREEVIEW_UpdateDispInfo(infoPtr
, newItem
, TVIF_TEXT
);
1408 TREEVIEW_ComputeTextWidth(infoPtr
, newItem
, 0);
1409 TREEVIEW_UpdateScrollBars(infoPtr
);
1411 * if the item was inserted in a visible part of the tree,
1412 * invalidate it, as well as those after it
1414 for (item
= newItem
;
1416 item
= TREEVIEW_GetNextListItem(infoPtr
, item
))
1417 TREEVIEW_Invalidate(infoPtr
, item
);
1421 /* refresh treeview if newItem is the first item inserted under parentItem */
1422 if (ISVISIBLE(parentItem
) && newItem
->prevSibling
== newItem
->nextSibling
)
1424 /* parent got '+' - update it */
1425 TREEVIEW_Invalidate(infoPtr
, parentItem
);
1429 return (LRESULT
)newItem
;
1432 /* Item Deletion ************************************************************/
1434 TREEVIEW_RemoveItem(TREEVIEW_INFO
*infoPtr
, TREEVIEW_ITEM
*item
);
1437 TREEVIEW_RemoveAllChildren(TREEVIEW_INFO
*infoPtr
, const TREEVIEW_ITEM
*parentItem
)
1439 TREEVIEW_ITEM
*kill
= parentItem
->firstChild
;
1441 while (kill
!= NULL
)
1443 TREEVIEW_ITEM
*next
= kill
->nextSibling
;
1445 TREEVIEW_RemoveItem(infoPtr
, kill
);
1450 assert(parentItem
->cChildren
<= 0); /* I_CHILDRENCALLBACK or 0 */
1451 assert(parentItem
->firstChild
== NULL
);
1452 assert(parentItem
->lastChild
== NULL
);
1456 TREEVIEW_UnlinkItem(const TREEVIEW_ITEM
*item
)
1458 TREEVIEW_ITEM
*parentItem
;
1460 assert(item
!= NULL
);
1461 assert(item
->parent
!= NULL
); /* i.e. it must not be the root */
1463 parentItem
= item
->parent
;
1465 if (parentItem
->firstChild
== item
)
1466 parentItem
->firstChild
= item
->nextSibling
;
1468 if (parentItem
->lastChild
== item
)
1469 parentItem
->lastChild
= item
->prevSibling
;
1471 if (parentItem
->firstChild
== NULL
&& parentItem
->lastChild
== NULL
1472 && parentItem
->cChildren
> 0)
1473 parentItem
->cChildren
= 0;
1475 if (item
->prevSibling
)
1476 item
->prevSibling
->nextSibling
= item
->nextSibling
;
1478 if (item
->nextSibling
)
1479 item
->nextSibling
->prevSibling
= item
->prevSibling
;
1483 TREEVIEW_RemoveItem(TREEVIEW_INFO
*infoPtr
, TREEVIEW_ITEM
*item
)
1485 TRACE("%p, (%s)\n", item
, TREEVIEW_ItemName(item
));
1487 if (item
->firstChild
)
1488 TREEVIEW_RemoveAllChildren(infoPtr
, item
);
1490 TREEVIEW_SendTreeviewNotify(infoPtr
, TVN_DELETEITEMW
, TVC_UNKNOWN
,
1491 TVIF_HANDLE
| TVIF_PARAM
, item
, 0);
1493 TREEVIEW_UnlinkItem(item
);
1495 infoPtr
->uNumItems
--;
1497 if (item
->pszText
!= LPSTR_TEXTCALLBACKW
)
1498 Free(item
->pszText
);
1500 TREEVIEW_FreeItem(infoPtr
, item
);
1504 /* Empty out the tree. */
1506 TREEVIEW_RemoveTree(TREEVIEW_INFO
*infoPtr
)
1508 TREEVIEW_RemoveAllChildren(infoPtr
, infoPtr
->root
);
1510 assert(infoPtr
->uNumItems
== 0); /* root isn't counted in uNumItems */
1514 TREEVIEW_DeleteItem(TREEVIEW_INFO
*infoPtr
, HTREEITEM item
)
1516 TREEVIEW_ITEM
*newSelection
= NULL
;
1517 TREEVIEW_ITEM
*newFirstVisible
= NULL
;
1518 TREEVIEW_ITEM
*parent
, *prev
= NULL
;
1519 BOOL visible
= FALSE
;
1521 if (item
== TVI_ROOT
|| !item
)
1523 TRACE("TVI_ROOT\n");
1524 parent
= infoPtr
->root
;
1525 newSelection
= NULL
;
1527 TREEVIEW_RemoveTree(infoPtr
);
1531 if (!TREEVIEW_ValidItem(infoPtr
, item
))
1534 TRACE("%p (%s)\n", item
, TREEVIEW_ItemName(item
));
1535 parent
= item
->parent
;
1537 if (ISVISIBLE(item
))
1539 prev
= TREEVIEW_GetPrevListItem(infoPtr
, item
);
1543 if (infoPtr
->selectedItem
!= NULL
1544 && (item
== infoPtr
->selectedItem
1545 || TREEVIEW_IsChildOf(item
, infoPtr
->selectedItem
)))
1547 if (item
->nextSibling
)
1548 newSelection
= item
->nextSibling
;
1549 else if (item
->parent
!= infoPtr
->root
)
1550 newSelection
= item
->parent
;
1552 newSelection
= item
->prevSibling
;
1553 TRACE("newSelection = %p\n", newSelection
);
1556 if (infoPtr
->firstVisible
== item
)
1559 if (item
->nextSibling
)
1560 newFirstVisible
= item
->nextSibling
;
1561 else if (item
->prevSibling
)
1562 newFirstVisible
= item
->prevSibling
;
1563 else if (item
->parent
!= infoPtr
->root
)
1564 newFirstVisible
= item
->parent
;
1565 TREEVIEW_SetFirstVisible(infoPtr
, NULL
, TRUE
);
1568 newFirstVisible
= infoPtr
->firstVisible
;
1570 TREEVIEW_RemoveItem(infoPtr
, item
);
1573 /* Don't change if somebody else already has (infoPtr->selectedItem is cleared by FreeItem). */
1574 if (!infoPtr
->selectedItem
&& newSelection
)
1576 if (TREEVIEW_ValidItem(infoPtr
, newSelection
))
1577 TREEVIEW_DoSelectItem(infoPtr
, TVGN_CARET
, newSelection
, TVC_UNKNOWN
);
1580 /* Validate insertMark dropItem.
1581 * hotItem ??? - used for comparison only.
1583 if (!TREEVIEW_ValidItem(infoPtr
, infoPtr
->insertMarkItem
))
1584 infoPtr
->insertMarkItem
= 0;
1586 if (!TREEVIEW_ValidItem(infoPtr
, infoPtr
->dropItem
))
1587 infoPtr
->dropItem
= 0;
1589 if (!TREEVIEW_ValidItem(infoPtr
, newFirstVisible
))
1590 newFirstVisible
= infoPtr
->root
->firstChild
;
1592 TREEVIEW_VerifyTree(infoPtr
);
1595 TREEVIEW_SetFirstVisible(infoPtr
, newFirstVisible
, TRUE
);
1597 if (!infoPtr
->bRedraw
) return TRUE
;
1601 TREEVIEW_RecalculateVisibleOrder(infoPtr
, prev
);
1602 TREEVIEW_UpdateScrollBars(infoPtr
);
1603 TREEVIEW_Invalidate(infoPtr
, NULL
);
1605 else if (ISVISIBLE(parent
) && !TREEVIEW_HasChildren(infoPtr
, parent
))
1607 /* parent lost '+/-' - update it */
1608 TREEVIEW_Invalidate(infoPtr
, parent
);
1615 /* Get/Set Messages *********************************************************/
1617 TREEVIEW_SetRedraw(TREEVIEW_INFO
* infoPtr
, WPARAM wParam
)
1619 infoPtr
->bRedraw
= wParam
!= 0;
1621 if (infoPtr
->bRedraw
)
1623 TREEVIEW_UpdateSubTree(infoPtr
, infoPtr
->root
);
1624 TREEVIEW_RecalculateVisibleOrder(infoPtr
, NULL
);
1625 TREEVIEW_UpdateScrollBars(infoPtr
);
1626 TREEVIEW_Invalidate(infoPtr
, NULL
);
1632 TREEVIEW_GetIndent(const TREEVIEW_INFO
*infoPtr
)
1635 return infoPtr
->uIndent
;
1639 TREEVIEW_SetIndent(TREEVIEW_INFO
*infoPtr
, UINT newIndent
)
1643 if (newIndent
< MINIMUM_INDENT
)
1644 newIndent
= MINIMUM_INDENT
;
1646 if (infoPtr
->uIndent
!= newIndent
)
1648 infoPtr
->uIndent
= newIndent
;
1649 TREEVIEW_UpdateSubTree(infoPtr
, infoPtr
->root
);
1650 TREEVIEW_UpdateScrollBars(infoPtr
);
1651 TREEVIEW_Invalidate(infoPtr
, NULL
);
1659 TREEVIEW_GetToolTips(const TREEVIEW_INFO
*infoPtr
)
1662 return (LRESULT
)infoPtr
->hwndToolTip
;
1666 TREEVIEW_SetToolTips(TREEVIEW_INFO
*infoPtr
, HWND hwndTT
)
1671 prevToolTip
= infoPtr
->hwndToolTip
;
1672 infoPtr
->hwndToolTip
= hwndTT
;
1674 return (LRESULT
)prevToolTip
;
1678 TREEVIEW_SetUnicodeFormat(TREEVIEW_INFO
*infoPtr
, BOOL fUnicode
)
1680 BOOL rc
= infoPtr
->bNtfUnicode
;
1681 infoPtr
->bNtfUnicode
= fUnicode
;
1686 TREEVIEW_GetUnicodeFormat(const TREEVIEW_INFO
*infoPtr
)
1688 return infoPtr
->bNtfUnicode
;
1692 TREEVIEW_GetScrollTime(const TREEVIEW_INFO
*infoPtr
)
1694 return infoPtr
->uScrollTime
;
1698 TREEVIEW_SetScrollTime(TREEVIEW_INFO
*infoPtr
, UINT uScrollTime
)
1700 UINT uOldScrollTime
= infoPtr
->uScrollTime
;
1702 infoPtr
->uScrollTime
= min(uScrollTime
, 100);
1704 return uOldScrollTime
;
1709 TREEVIEW_GetImageList(const TREEVIEW_INFO
*infoPtr
, WPARAM wParam
)
1716 return (LRESULT
)infoPtr
->himlNormal
;
1719 return (LRESULT
)infoPtr
->himlState
;
1726 #define TVHEIGHT_MIN 16
1727 #define TVHEIGHT_FONT_ADJUST 3 /* 2 for focus border + 1 for margin some apps assume */
1729 /* Compute the natural height for items. */
1731 TREEVIEW_NaturalHeight(const TREEVIEW_INFO
*infoPtr
)
1735 HFONT hOldFont
= SelectObject(hdc
, infoPtr
->hFont
);
1738 /* Height is the maximum of:
1739 * 16 (a hack because our fonts are tiny), and
1740 * The text height + border & margin, and
1741 * The size of the normal image list
1743 GetTextMetricsW(hdc
, &tm
);
1744 SelectObject(hdc
, hOldFont
);
1747 height
= TVHEIGHT_MIN
;
1748 if (height
< tm
.tmHeight
+ tm
.tmExternalLeading
+ TVHEIGHT_FONT_ADJUST
)
1749 height
= tm
.tmHeight
+ tm
.tmExternalLeading
+ TVHEIGHT_FONT_ADJUST
;
1750 if (height
< infoPtr
->normalImageHeight
)
1751 height
= infoPtr
->normalImageHeight
;
1753 /* Round down, unless we support odd ("non even") heights. */
1754 if (!(infoPtr
->dwStyle
& TVS_NONEVENHEIGHT
))
1761 TREEVIEW_SetImageList(TREEVIEW_INFO
*infoPtr
, UINT type
, HIMAGELIST himlNew
)
1763 HIMAGELIST himlOld
= 0;
1764 int oldWidth
= infoPtr
->normalImageWidth
;
1765 int oldHeight
= infoPtr
->normalImageHeight
;
1767 TRACE("%u,%p\n", type
, himlNew
);
1772 himlOld
= infoPtr
->himlNormal
;
1773 infoPtr
->himlNormal
= himlNew
;
1776 ImageList_GetIconSize(himlNew
, &infoPtr
->normalImageWidth
,
1777 &infoPtr
->normalImageHeight
);
1780 infoPtr
->normalImageWidth
= 0;
1781 infoPtr
->normalImageHeight
= 0;
1787 himlOld
= infoPtr
->himlState
;
1788 infoPtr
->himlState
= himlNew
;
1791 ImageList_GetIconSize(himlNew
, &infoPtr
->stateImageWidth
,
1792 &infoPtr
->stateImageHeight
);
1795 infoPtr
->stateImageWidth
= 0;
1796 infoPtr
->stateImageHeight
= 0;
1802 ERR("unknown imagelist type %u\n", type
);
1805 if (oldWidth
!= infoPtr
->normalImageWidth
||
1806 oldHeight
!= infoPtr
->normalImageHeight
)
1808 BOOL bRecalcVisible
= FALSE
;
1810 if (oldHeight
!= infoPtr
->normalImageHeight
&&
1811 !infoPtr
->bHeightSet
)
1813 infoPtr
->uItemHeight
= TREEVIEW_NaturalHeight(infoPtr
);
1814 bRecalcVisible
= TRUE
;
1817 if (infoPtr
->normalImageWidth
> MINIMUM_INDENT
&&
1818 infoPtr
->normalImageWidth
!= infoPtr
->uIndent
)
1820 infoPtr
->uIndent
= infoPtr
->normalImageWidth
;
1821 bRecalcVisible
= TRUE
;
1825 TREEVIEW_RecalculateVisibleOrder(infoPtr
, NULL
);
1827 TREEVIEW_UpdateSubTree(infoPtr
, infoPtr
->root
);
1828 TREEVIEW_UpdateScrollBars(infoPtr
);
1831 TREEVIEW_Invalidate(infoPtr
, NULL
);
1833 return (LRESULT
)himlOld
;
1837 TREEVIEW_SetItemHeight(TREEVIEW_INFO
*infoPtr
, INT newHeight
)
1839 INT prevHeight
= infoPtr
->uItemHeight
;
1841 TRACE("new=%d, old=%d\n", newHeight
, prevHeight
);
1842 if (newHeight
== -1)
1844 infoPtr
->uItemHeight
= TREEVIEW_NaturalHeight(infoPtr
);
1845 infoPtr
->bHeightSet
= FALSE
;
1849 if (newHeight
== 0) newHeight
= 1;
1850 infoPtr
->uItemHeight
= newHeight
;
1851 infoPtr
->bHeightSet
= TRUE
;
1854 /* Round down, unless we support odd ("non even") heights. */
1855 if (!(infoPtr
->dwStyle
& TVS_NONEVENHEIGHT
) && infoPtr
->uItemHeight
!= 1)
1857 infoPtr
->uItemHeight
&= ~1;
1858 TRACE("after rounding=%d\n", infoPtr
->uItemHeight
);
1861 if (infoPtr
->uItemHeight
!= prevHeight
)
1863 TREEVIEW_RecalculateVisibleOrder(infoPtr
, NULL
);
1864 TREEVIEW_UpdateScrollBars(infoPtr
);
1865 TREEVIEW_Invalidate(infoPtr
, NULL
);
1872 TREEVIEW_GetItemHeight(const TREEVIEW_INFO
*infoPtr
)
1875 return infoPtr
->uItemHeight
;
1880 TREEVIEW_GetFont(const TREEVIEW_INFO
*infoPtr
)
1882 TRACE("%p\n", infoPtr
->hFont
);
1883 return (LRESULT
)infoPtr
->hFont
;
1888 TREEVIEW_ResetTextWidth(LPVOID pItem
, LPVOID unused
)
1892 ((TREEVIEW_ITEM
*)pItem
)->textWidth
= 0;
1898 TREEVIEW_SetFont(TREEVIEW_INFO
*infoPtr
, HFONT hFont
, BOOL bRedraw
)
1900 UINT uHeight
= infoPtr
->uItemHeight
;
1902 TRACE("%p %i\n", hFont
, bRedraw
);
1904 infoPtr
->hFont
= hFont
? hFont
: infoPtr
->hDefaultFont
;
1906 DeleteObject(infoPtr
->hBoldFont
);
1907 DeleteObject(infoPtr
->hUnderlineFont
);
1908 DeleteObject(infoPtr
->hBoldUnderlineFont
);
1909 infoPtr
->hBoldFont
= TREEVIEW_CreateBoldFont(infoPtr
->hFont
);
1910 infoPtr
->hUnderlineFont
= TREEVIEW_CreateUnderlineFont(infoPtr
->hFont
);
1911 infoPtr
->hBoldUnderlineFont
= TREEVIEW_CreateBoldUnderlineFont(infoPtr
->hFont
);
1913 if (!infoPtr
->bHeightSet
)
1914 infoPtr
->uItemHeight
= TREEVIEW_NaturalHeight(infoPtr
);
1916 if (uHeight
!= infoPtr
->uItemHeight
)
1917 TREEVIEW_RecalculateVisibleOrder(infoPtr
, NULL
);
1919 DPA_EnumCallback(infoPtr
->items
, TREEVIEW_ResetTextWidth
, 0);
1921 TREEVIEW_UpdateSubTree(infoPtr
, infoPtr
->root
);
1922 TREEVIEW_UpdateScrollBars(infoPtr
);
1925 TREEVIEW_Invalidate(infoPtr
, NULL
);
1932 TREEVIEW_GetLineColor(const TREEVIEW_INFO
*infoPtr
)
1935 return (LRESULT
)infoPtr
->clrLine
;
1939 TREEVIEW_SetLineColor(TREEVIEW_INFO
*infoPtr
, COLORREF color
)
1941 COLORREF prevColor
= infoPtr
->clrLine
;
1944 infoPtr
->clrLine
= color
;
1945 return (LRESULT
)prevColor
;
1950 TREEVIEW_GetTextColor(const TREEVIEW_INFO
*infoPtr
)
1953 return (LRESULT
)infoPtr
->clrText
;
1957 TREEVIEW_SetTextColor(TREEVIEW_INFO
*infoPtr
, COLORREF color
)
1959 COLORREF prevColor
= infoPtr
->clrText
;
1962 infoPtr
->clrText
= color
;
1964 if (infoPtr
->clrText
!= prevColor
)
1965 TREEVIEW_Invalidate(infoPtr
, NULL
);
1967 return (LRESULT
)prevColor
;
1972 TREEVIEW_GetBkColor(const TREEVIEW_INFO
*infoPtr
)
1975 return (LRESULT
)infoPtr
->clrBk
;
1979 TREEVIEW_SetBkColor(TREEVIEW_INFO
*infoPtr
, COLORREF newColor
)
1981 COLORREF prevColor
= infoPtr
->clrBk
;
1984 infoPtr
->clrBk
= newColor
;
1986 if (newColor
!= prevColor
)
1987 TREEVIEW_Invalidate(infoPtr
, NULL
);
1989 return (LRESULT
)prevColor
;
1994 TREEVIEW_GetInsertMarkColor(const TREEVIEW_INFO
*infoPtr
)
1997 return (LRESULT
)infoPtr
->clrInsertMark
;
2001 TREEVIEW_SetInsertMarkColor(TREEVIEW_INFO
*infoPtr
, COLORREF color
)
2003 COLORREF prevColor
= infoPtr
->clrInsertMark
;
2005 TRACE("%#lx\n", color
);
2006 infoPtr
->clrInsertMark
= color
;
2008 return (LRESULT
)prevColor
;
2013 TREEVIEW_SetInsertMark(TREEVIEW_INFO
*infoPtr
, BOOL wParam
, HTREEITEM item
)
2015 TRACE("%d %p\n", wParam
, item
);
2017 if (!TREEVIEW_ValidItem(infoPtr
, item
))
2020 infoPtr
->insertBeforeorAfter
= wParam
;
2021 infoPtr
->insertMarkItem
= item
;
2023 TREEVIEW_Invalidate(infoPtr
, NULL
);
2029 /************************************************************************
2030 * Some serious braindamage here. lParam is a pointer to both the
2031 * input HTREEITEM and the output RECT.
2034 TREEVIEW_GetItemRect(const TREEVIEW_INFO
*infoPtr
, BOOL fTextRect
, LPRECT lpRect
)
2036 TREEVIEW_ITEM
*item
;
2037 const HTREEITEM
*pItem
= (HTREEITEM
*)lpRect
;
2045 if (!TREEVIEW_ValidItem(infoPtr
, item
) || !ISVISIBLE(item
))
2049 * If wParam is TRUE return the text size otherwise return
2050 * the whole item size
2054 /* Windows does not send TVN_GETDISPINFO here. */
2056 lpRect
->top
= item
->rect
.top
;
2057 lpRect
->bottom
= item
->rect
.bottom
;
2059 lpRect
->left
= item
->textOffset
;
2060 if (!item
->textWidth
)
2061 TREEVIEW_ComputeTextWidth(infoPtr
, item
, 0);
2063 lpRect
->right
= item
->textOffset
+ item
->textWidth
+ 4;
2067 *lpRect
= item
->rect
;
2070 TRACE("%s [%s]\n", fTextRect
? "text" : "item", wine_dbgstr_rect(lpRect
));
2075 static inline LRESULT
2076 TREEVIEW_GetVisibleCount(const TREEVIEW_INFO
*infoPtr
)
2078 /* Surprise! This does not take integral height into account. */
2079 TRACE("client=%ld, item=%d\n", infoPtr
->clientHeight
, infoPtr
->uItemHeight
);
2080 return infoPtr
->clientHeight
/ infoPtr
->uItemHeight
;
2085 TREEVIEW_GetItemT(const TREEVIEW_INFO
*infoPtr
, LPTVITEMEXW tvItem
, BOOL isW
)
2087 TREEVIEW_ITEM
*item
= tvItem
->hItem
;
2089 if (!TREEVIEW_ValidItem(infoPtr
, item
))
2091 BOOL valid_item
= FALSE
;
2092 if (!item
) return FALSE
;
2096 infoPtr
= item
->infoPtr
;
2097 TRACE("got item from different tree %p, called from %p\n", item
->infoPtr
, infoPtr
);
2098 valid_item
= TREEVIEW_ValidItem(infoPtr
, item
);
2104 if (!valid_item
) return FALSE
;
2107 TREEVIEW_UpdateDispInfo(infoPtr
, item
, tvItem
->mask
);
2109 if (tvItem
->mask
& TVIF_CHILDREN
)
2111 if (item
->cChildren
==I_CHILDRENCALLBACK
)
2112 FIXME("I_CHILDRENCALLBACK not supported\n");
2113 tvItem
->cChildren
= item
->cChildren
;
2116 if (tvItem
->mask
& TVIF_HANDLE
)
2117 tvItem
->hItem
= item
;
2119 if (tvItem
->mask
& TVIF_IMAGE
)
2120 tvItem
->iImage
= item
->iImage
;
2122 if (tvItem
->mask
& TVIF_INTEGRAL
)
2123 tvItem
->iIntegral
= item
->iIntegral
;
2125 /* undocumented: (mask & TVIF_PARAM) ignored and lParam is always set */
2126 tvItem
->lParam
= item
->lParam
;
2128 if (tvItem
->mask
& TVIF_SELECTEDIMAGE
)
2129 tvItem
->iSelectedImage
= item
->iSelectedImage
;
2131 if (tvItem
->mask
& TVIF_EXPANDEDIMAGE
)
2132 tvItem
->iExpandedImage
= item
->iExpandedImage
;
2134 /* undocumented: stateMask and (state & TVIF_STATE) ignored, so state is always set */
2135 tvItem
->state
= item
->state
;
2137 if (tvItem
->mask
& TVIF_TEXT
)
2139 if (item
->pszText
== NULL
)
2141 if (tvItem
->cchTextMax
> 0)
2142 tvItem
->pszText
[0] = '\0';
2146 if (item
->pszText
== LPSTR_TEXTCALLBACKW
)
2148 tvItem
->pszText
= LPSTR_TEXTCALLBACKW
;
2149 FIXME(" GetItem called with LPSTR_TEXTCALLBACK\n");
2153 lstrcpynW(tvItem
->pszText
, item
->pszText
, tvItem
->cchTextMax
);
2158 if (item
->pszText
== LPSTR_TEXTCALLBACKW
)
2160 tvItem
->pszText
= (LPWSTR
)LPSTR_TEXTCALLBACKA
;
2161 FIXME(" GetItem called with LPSTR_TEXTCALLBACK\n");
2165 WideCharToMultiByte(CP_ACP
, 0, item
->pszText
, -1,
2166 (LPSTR
)tvItem
->pszText
, tvItem
->cchTextMax
, NULL
, NULL
);
2171 if (tvItem
->mask
& TVIF_STATEEX
)
2173 FIXME("Extended item state not supported, returning 0.\n");
2174 tvItem
->uStateEx
= 0;
2177 TRACE("item <%p>, txt %p, img %d, mask 0x%x\n",
2178 item
, tvItem
->pszText
, tvItem
->iImage
, tvItem
->mask
);
2183 /* Beware MSDN Library Visual Studio 6.0. It says -1 on failure, 0 on success,
2184 * which is wrong. */
2186 TREEVIEW_SetItemT(TREEVIEW_INFO
*infoPtr
, const TVITEMEXW
*tvItem
, BOOL isW
)
2188 TREEVIEW_ITEM
*item
;
2189 TREEVIEW_ITEM originalItem
;
2191 item
= tvItem
->hItem
;
2193 TRACE("item %d, mask 0x%x\n", TREEVIEW_GetItemIndex(infoPtr
, item
),
2196 if (!TREEVIEW_ValidItem(infoPtr
, item
))
2199 /* Store the original item values. Text buffer will be freed in TREEVIEW_DoSetItemT() below. */
2200 originalItem
= *item
;
2202 if (!TREEVIEW_DoSetItemT(infoPtr
, item
, tvItem
, isW
))
2205 /* If the text or TVIS_BOLD was changed, and it is visible, recalculate. */
2206 if ((tvItem
->mask
& TVIF_TEXT
2207 || (tvItem
->mask
& TVIF_STATE
&& tvItem
->stateMask
& TVIS_BOLD
))
2210 TREEVIEW_UpdateDispInfo(infoPtr
, item
, TVIF_TEXT
);
2211 TREEVIEW_ComputeTextWidth(infoPtr
, item
, 0);
2214 if (tvItem
->mask
!= 0 && ISVISIBLE(item
))
2216 /* The refresh updates everything, but we can't wait until then. */
2217 TREEVIEW_ComputeItemInternalMetrics(infoPtr
, item
);
2219 /* if any of the item's values changed and it's not a callback, redraw the item */
2220 if (item_changed(&originalItem
, item
, tvItem
))
2222 if (tvItem
->mask
& TVIF_INTEGRAL
)
2224 TREEVIEW_RecalculateVisibleOrder(infoPtr
, item
);
2225 TREEVIEW_UpdateScrollBars(infoPtr
);
2227 TREEVIEW_Invalidate(infoPtr
, NULL
);
2231 TREEVIEW_UpdateScrollBars(infoPtr
);
2232 TREEVIEW_Invalidate(infoPtr
, item
);
2241 TREEVIEW_GetItemState(const TREEVIEW_INFO
*infoPtr
, HTREEITEM item
, UINT mask
)
2245 if (!item
|| !TREEVIEW_ValidItem(infoPtr
, item
))
2248 return (item
->state
& mask
);
2252 TREEVIEW_GetNextItem(const TREEVIEW_INFO
*infoPtr
, UINT which
, HTREEITEM item
)
2254 TREEVIEW_ITEM
*retval
;
2258 /* handle all the global data here */
2261 case TVGN_CHILD
: /* Special case: child of 0 is root */
2266 retval
= infoPtr
->root
->firstChild
;
2270 retval
= infoPtr
->selectedItem
;
2273 case TVGN_FIRSTVISIBLE
:
2274 retval
= infoPtr
->firstVisible
;
2277 case TVGN_DROPHILITE
:
2278 retval
= infoPtr
->dropItem
;
2281 case TVGN_LASTVISIBLE
:
2282 retval
= TREEVIEW_GetLastListItem(infoPtr
, infoPtr
->root
);
2288 TRACE("flags:0x%x, returns %p\n", which
, retval
);
2289 return (LRESULT
)retval
;
2292 if (item
== TVI_ROOT
) item
= infoPtr
->root
;
2294 if (!TREEVIEW_ValidItem(infoPtr
, item
))
2300 retval
= item
->nextSibling
;
2303 retval
= item
->prevSibling
;
2306 retval
= (item
->parent
!= infoPtr
->root
) ? item
->parent
: NULL
;
2309 retval
= item
->firstChild
;
2311 case TVGN_NEXTVISIBLE
:
2312 retval
= TREEVIEW_GetNextListItem(infoPtr
, item
);
2314 case TVGN_PREVIOUSVISIBLE
:
2315 retval
= TREEVIEW_GetPrevListItem(infoPtr
, item
);
2318 TRACE("Unknown msg 0x%x, item %p\n", which
, item
);
2322 TRACE("flags: 0x%x, item %p;returns %p\n", which
, item
, retval
);
2323 return (LRESULT
)retval
;
2328 TREEVIEW_GetCount(const TREEVIEW_INFO
*infoPtr
)
2330 TRACE(" %d\n", infoPtr
->uNumItems
);
2331 return (LRESULT
)infoPtr
->uNumItems
;
2335 TREEVIEW_ToggleItemState(const TREEVIEW_INFO
*infoPtr
, TREEVIEW_ITEM
*item
)
2337 if (infoPtr
->dwStyle
& TVS_CHECKBOXES
)
2339 static const unsigned int state_table
[] = { 0, 2, 1 };
2343 state
= STATEIMAGEINDEX(item
->state
);
2344 TRACE("state: 0x%x\n", state
);
2345 item
->state
&= ~TVIS_STATEIMAGEMASK
;
2348 state
= state_table
[state
];
2350 item
->state
|= INDEXTOSTATEIMAGEMASK(state
);
2352 TRACE("state: 0x%x\n", state
);
2353 TREEVIEW_Invalidate(infoPtr
, item
);
2358 /* Painting *************************************************************/
2360 /* Draw the lines and expand button for an item. Also draws one section
2361 * of the line from item's parent to item's parent's next sibling. */
2363 TREEVIEW_DrawItemLines(const TREEVIEW_INFO
*infoPtr
, HDC hdc
, const TREEVIEW_ITEM
*item
)
2365 LONG centerx
, centery
;
2366 BOOL lar
= ((infoPtr
->dwStyle
2367 & (TVS_LINESATROOT
|TVS_HASLINES
|TVS_HASBUTTONS
))
2370 COLORREF clrBk
= GETBKCOLOR(infoPtr
->clrBk
);
2372 if (!lar
&& item
->iLevel
== 0)
2375 hbr
= CreateSolidBrush(clrBk
);
2376 hbrOld
= SelectObject(hdc
, hbr
);
2378 centerx
= (item
->linesOffset
+ item
->stateOffset
) / 2;
2379 centery
= (item
->rect
.top
+ item
->rect
.bottom
) / 2;
2381 if (infoPtr
->dwStyle
& TVS_HASLINES
)
2383 HPEN hOldPen
, hNewPen
;
2387 /* Get a dotted grey pen */
2388 lb
.lbStyle
= BS_SOLID
;
2389 lb
.lbColor
= GETLINECOLOR(infoPtr
->clrLine
);
2390 hNewPen
= ExtCreatePen(PS_COSMETIC
|PS_ALTERNATE
, 1, &lb
, 0, NULL
);
2391 hOldPen
= SelectObject(hdc
, hNewPen
);
2393 /* Make sure the center is on a dot (using +2 instead
2394 * of +1 gives us pixel-by-pixel compat with native) */
2395 centery
= (centery
+ 2) & ~1;
2397 MoveToEx(hdc
, item
->stateOffset
, centery
, NULL
);
2398 LineTo(hdc
, centerx
- 1, centery
);
2400 if (item
->prevSibling
|| item
->parent
!= infoPtr
->root
)
2402 MoveToEx(hdc
, centerx
, item
->rect
.top
, NULL
);
2403 LineTo(hdc
, centerx
, centery
);
2406 if (item
->nextSibling
)
2408 MoveToEx(hdc
, centerx
, centery
, NULL
);
2409 LineTo(hdc
, centerx
, item
->rect
.bottom
+ 1);
2412 /* Draw the line from our parent to its next sibling. */
2413 parent
= item
->parent
;
2414 while (parent
!= infoPtr
->root
)
2416 int pcenterx
= (parent
->linesOffset
+ parent
->stateOffset
) / 2;
2418 if (parent
->nextSibling
2419 /* skip top-levels unless TVS_LINESATROOT */
2420 && parent
->stateOffset
> parent
->linesOffset
)
2422 MoveToEx(hdc
, pcenterx
, item
->rect
.top
, NULL
);
2423 LineTo(hdc
, pcenterx
, item
->rect
.bottom
+ 1);
2426 parent
= parent
->parent
;
2429 SelectObject(hdc
, hOldPen
);
2430 DeleteObject(hNewPen
);
2434 * Display the (+/-) signs
2437 if (infoPtr
->dwStyle
& TVS_HASBUTTONS
)
2439 if (item
->cChildren
)
2441 HTHEME theme
= GetWindowTheme(infoPtr
->hwnd
);
2444 RECT glyphRect
= item
->rect
;
2445 glyphRect
.left
= item
->linesOffset
;
2446 glyphRect
.right
= item
->stateOffset
;
2447 DrawThemeBackground (theme
, hdc
, TVP_GLYPH
,
2448 (item
->state
& TVIS_EXPANDED
) ? GLPS_OPENED
: GLPS_CLOSED
,
2453 LONG height
= item
->rect
.bottom
- item
->rect
.top
;
2454 LONG width
= item
->stateOffset
- item
->linesOffset
;
2455 LONG rectsize
= min(height
, width
) / 4;
2456 /* plussize = ceil(rectsize * 3/4) */
2457 LONG plussize
= (rectsize
+ 1) * 3 / 4;
2459 HPEN new_pen
= CreatePen(PS_SOLID
, 0, GETLINECOLOR(infoPtr
->clrLine
));
2460 HPEN old_pen
= SelectObject(hdc
, new_pen
);
2462 Rectangle(hdc
, centerx
- rectsize
- 1, centery
- rectsize
- 1,
2463 centerx
+ rectsize
+ 2, centery
+ rectsize
+ 2);
2465 SelectObject(hdc
, old_pen
);
2466 DeleteObject(new_pen
);
2468 /* draw +/- signs with current text color */
2469 new_pen
= CreatePen(PS_SOLID
, 0, GETTXTCOLOR(infoPtr
->clrText
));
2470 old_pen
= SelectObject(hdc
, new_pen
);
2472 if (height
< 18 || width
< 18)
2474 MoveToEx(hdc
, centerx
- plussize
+ 1, centery
, NULL
);
2475 LineTo(hdc
, centerx
+ plussize
, centery
);
2477 if (!(item
->state
& TVIS_EXPANDED
) ||
2478 (item
->state
& TVIS_EXPANDPARTIAL
))
2480 MoveToEx(hdc
, centerx
, centery
- plussize
+ 1, NULL
);
2481 LineTo(hdc
, centerx
, centery
+ plussize
);
2486 Rectangle(hdc
, centerx
- plussize
+ 1, centery
- 1,
2487 centerx
+ plussize
, centery
+ 2);
2489 if (!(item
->state
& TVIS_EXPANDED
) ||
2490 (item
->state
& TVIS_EXPANDPARTIAL
))
2492 Rectangle(hdc
, centerx
- 1, centery
- plussize
+ 1,
2493 centerx
+ 2, centery
+ plussize
);
2494 SetPixel(hdc
, centerx
- 1, centery
, clrBk
);
2495 SetPixel(hdc
, centerx
+ 1, centery
, clrBk
);
2499 SelectObject(hdc
, old_pen
);
2500 DeleteObject(new_pen
);
2504 SelectObject(hdc
, hbrOld
);
2509 TREEVIEW_DrawItem(const TREEVIEW_INFO
*infoPtr
, HDC hdc
, TREEVIEW_ITEM
*item
)
2513 COLORREF oldTextColor
, oldTextBkColor
;
2515 BOOL inFocus
= (GetFocus() == infoPtr
->hwnd
);
2516 NMTVCUSTOMDRAW nmcdhdr
;
2518 TREEVIEW_UpdateDispInfo(infoPtr
, item
, CALLBACK_MASK_ALL
);
2520 /* - If item is drop target or it is selected and window is in focus -
2521 * use blue background (COLOR_HIGHLIGHT).
2522 * - If item is selected, window is not in focus, but it has style
2523 * TVS_SHOWSELALWAYS - use grey background (COLOR_BTNFACE)
2524 * - Otherwise - use background color
2526 if ((item
->state
& TVIS_DROPHILITED
) || ((item
== infoPtr
->focusedItem
) && !(item
->state
& TVIS_SELECTED
)) ||
2527 ((item
->state
& TVIS_SELECTED
) && (!infoPtr
->focusedItem
|| item
== infoPtr
->focusedItem
) &&
2528 (inFocus
|| (infoPtr
->dwStyle
& TVS_SHOWSELALWAYS
))))
2530 if ((item
->state
& TVIS_DROPHILITED
) || inFocus
)
2532 nmcdhdr
.clrTextBk
= comctl32_color
.clrHighlight
;
2533 nmcdhdr
.clrText
= comctl32_color
.clrHighlightText
;
2537 nmcdhdr
.clrTextBk
= comctl32_color
.clrBtnFace
;
2538 nmcdhdr
.clrText
= GETTXTCOLOR(infoPtr
->clrText
);
2543 nmcdhdr
.clrTextBk
= GETBKCOLOR(infoPtr
->clrBk
);
2544 if ((infoPtr
->dwStyle
& TVS_TRACKSELECT
) && (item
== infoPtr
->hotItem
))
2545 nmcdhdr
.clrText
= comctl32_color
.clrHighlight
;
2547 nmcdhdr
.clrText
= GETTXTCOLOR(infoPtr
->clrText
);
2550 hOldFont
= SelectObject(hdc
, TREEVIEW_FontForItem(infoPtr
, item
));
2551 oldTextColor
= SetTextColor(hdc
, nmcdhdr
.clrText
);
2552 oldTextBkColor
= SetBkColor(hdc
, nmcdhdr
.clrTextBk
);
2554 /* The custom draw handler can query the text rectangle,
2556 /* should already be known, set to 0 when changed */
2557 if (!item
->textWidth
)
2558 TREEVIEW_ComputeTextWidth(infoPtr
, item
, hdc
);
2562 if (infoPtr
->cdmode
& CDRF_NOTIFYITEMDRAW
)
2564 cditem
= TREEVIEW_SendCustomDrawItemNotify
2565 (infoPtr
, hdc
, item
, CDDS_ITEMPREPAINT
, &nmcdhdr
);
2566 TRACE("prepaint:cditem-app returns 0x%x\n", cditem
);
2568 if (cditem
& CDRF_SKIPDEFAULT
)
2570 SelectObject(hdc
, hOldFont
);
2575 if (cditem
& CDRF_NEWFONT
)
2576 TREEVIEW_ComputeTextWidth(infoPtr
, item
, hdc
);
2578 if (TREEVIEW_IsFullRowSelect(infoPtr
))
2580 HBRUSH brush
= CreateSolidBrush(nmcdhdr
.clrTextBk
);
2581 FillRect(hdc
, &item
->rect
, brush
);
2582 DeleteObject(brush
);
2585 TREEVIEW_DrawItemLines(infoPtr
, hdc
, item
);
2587 /* reset colors. Custom draw handler can change them */
2588 SetTextColor(hdc
, nmcdhdr
.clrText
);
2589 SetBkColor(hdc
, nmcdhdr
.clrTextBk
);
2591 centery
= (item
->rect
.top
+ item
->rect
.bottom
) / 2;
2594 * Display the images associated with this item
2599 /* State images are displayed to the left of the Normal image
2600 * image number is in state; zero should be `display no image'.
2602 imageIndex
= STATEIMAGEINDEX(item
->state
);
2604 if (infoPtr
->himlState
&& imageIndex
)
2606 ImageList_Draw(infoPtr
->himlState
, imageIndex
, hdc
,
2608 centery
- infoPtr
->stateImageHeight
/ 2,
2612 /* Now, draw the normal image; can be either selected,
2613 * non-selected or expanded image.
2616 if ((item
->state
& TVIS_SELECTED
) && (item
->iSelectedImage
>= 0))
2618 /* The item is currently selected */
2619 imageIndex
= item
->iSelectedImage
;
2621 else if ((item
->state
& TVIS_EXPANDED
) && (item
->iExpandedImage
!= (WORD
)I_IMAGENONE
))
2623 /* The item is currently not selected but expanded */
2624 imageIndex
= item
->iExpandedImage
;
2628 /* The item is not selected and not expanded */
2629 imageIndex
= item
->iImage
;
2632 if (infoPtr
->himlNormal
)
2634 UINT style
= item
->state
& TVIS_CUT
? ILD_SELECTED
: ILD_NORMAL
;
2636 style
|= item
->state
& TVIS_OVERLAYMASK
;
2638 ImageList_DrawEx(infoPtr
->himlNormal
, imageIndex
, hdc
,
2639 item
->imageOffset
, centery
- infoPtr
->normalImageHeight
/ 2,
2641 TREEVIEW_IsFullRowSelect(infoPtr
) ? nmcdhdr
.clrTextBk
: infoPtr
->clrBk
,
2642 item
->state
& TVIS_CUT
? GETBKCOLOR(infoPtr
->clrBk
) : CLR_DEFAULT
,
2649 * Display the text associated with this item
2652 /* Don't paint item's text if it's being edited */
2653 if (!infoPtr
->hwndEdit
|| (infoPtr
->selectedItem
!= item
))
2661 rcText
.top
= item
->rect
.top
;
2662 rcText
.bottom
= item
->rect
.bottom
;
2663 rcText
.left
= item
->textOffset
;
2664 rcText
.right
= rcText
.left
+ item
->textWidth
+ 4;
2666 TRACE("drawing text %s at (%s)\n",
2667 debugstr_w(item
->pszText
), wine_dbgstr_rect(&rcText
));
2670 GetTextExtentPoint32W(hdc
, item
->pszText
, lstrlenW(item
->pszText
), &sz
);
2672 align
= SetTextAlign(hdc
, TA_LEFT
| TA_TOP
);
2673 ExtTextOutW(hdc
, rcText
.left
+ 2, (rcText
.top
+ rcText
.bottom
- sz
.cy
) / 2,
2674 ETO_CLIPPED
| ETO_OPAQUE
,
2677 lstrlenW(item
->pszText
),
2679 SetTextAlign(hdc
, align
);
2681 /* Draw focus box around the selected item */
2682 if ((item
== infoPtr
->selectedItem
) && inFocus
)
2684 DrawFocusRect(hdc
,&rcText
);
2689 /* Draw insertion mark if necessary */
2691 if (infoPtr
->insertMarkItem
)
2692 TRACE("item:%d,mark:%p\n",
2693 TREEVIEW_GetItemIndex(infoPtr
, item
),
2694 infoPtr
->insertMarkItem
);
2696 if (item
== infoPtr
->insertMarkItem
)
2698 HPEN hNewPen
, hOldPen
;
2702 hNewPen
= CreatePen(PS_SOLID
, 2, GETINSCOLOR(infoPtr
->clrInsertMark
));
2703 hOldPen
= SelectObject(hdc
, hNewPen
);
2705 if (infoPtr
->insertBeforeorAfter
)
2706 offset
= item
->rect
.bottom
- 1;
2708 offset
= item
->rect
.top
+ 1;
2710 left
= item
->textOffset
- 2;
2711 right
= item
->textOffset
+ item
->textWidth
+ 2;
2713 MoveToEx(hdc
, left
, offset
- 3, NULL
);
2714 LineTo(hdc
, left
, offset
+ 4);
2716 MoveToEx(hdc
, left
, offset
, NULL
);
2717 LineTo(hdc
, right
+ 1, offset
);
2719 MoveToEx(hdc
, right
, offset
+ 3, NULL
);
2720 LineTo(hdc
, right
, offset
- 4);
2722 SelectObject(hdc
, hOldPen
);
2723 DeleteObject(hNewPen
);
2726 /* Restore the hdc state */
2727 SetTextColor(hdc
, oldTextColor
);
2728 SetBkColor(hdc
, oldTextBkColor
);
2729 SelectObject(hdc
, hOldFont
);
2731 if (cditem
& CDRF_NOTIFYPOSTPAINT
)
2733 cditem
= TREEVIEW_SendCustomDrawItemNotify
2734 (infoPtr
, hdc
, item
, CDDS_ITEMPOSTPAINT
, &nmcdhdr
);
2735 TRACE("postpaint:cditem-app returns 0x%x\n", cditem
);
2739 /* Computes treeHeight and treeWidth and updates the scroll bars.
2742 TREEVIEW_UpdateScrollBars(TREEVIEW_INFO
*infoPtr
)
2744 TREEVIEW_ITEM
*item
;
2745 HWND hwnd
= infoPtr
->hwnd
;
2749 LONG scrollX
= infoPtr
->scrollX
;
2751 infoPtr
->treeWidth
= 0;
2752 infoPtr
->treeHeight
= 0;
2754 /* We iterate through all visible items in order to get the tree height
2756 item
= infoPtr
->root
->firstChild
;
2758 while (item
!= NULL
)
2760 if (ISVISIBLE(item
))
2762 /* actually we draw text at textOffset + 2 */
2763 if (2+item
->textOffset
+item
->textWidth
> infoPtr
->treeWidth
)
2764 infoPtr
->treeWidth
= item
->textOffset
+item
->textWidth
+2;
2766 /* This is scroll-adjusted, but we fix this below. */
2767 infoPtr
->treeHeight
= item
->rect
.bottom
;
2770 item
= TREEVIEW_GetNextListItem(infoPtr
, item
);
2773 /* Fix the scroll adjusted treeHeight and treeWidth. */
2774 if (infoPtr
->root
->firstChild
)
2775 infoPtr
->treeHeight
-= infoPtr
->root
->firstChild
->rect
.top
;
2777 infoPtr
->treeWidth
+= infoPtr
->scrollX
;
2779 if (infoPtr
->dwStyle
& TVS_NOSCROLL
) return;
2781 /* Adding one scroll bar may take up enough space that it forces us
2782 * to add the other as well. */
2783 if (infoPtr
->treeHeight
> infoPtr
->clientHeight
)
2787 if (infoPtr
->treeWidth
2788 > infoPtr
->clientWidth
- GetSystemMetrics(SM_CXVSCROLL
))
2791 else if (infoPtr
->treeWidth
> infoPtr
->clientWidth
|| infoPtr
->scrollX
> 0)
2794 if (!vert
&& horz
&& infoPtr
->treeHeight
2795 > infoPtr
->clientHeight
- GetSystemMetrics(SM_CYVSCROLL
))
2798 if (horz
&& (infoPtr
->dwStyle
& TVS_NOHSCROLL
)) horz
= FALSE
;
2800 si
.cbSize
= sizeof(SCROLLINFO
);
2801 si
.fMask
= SIF_POS
|SIF_RANGE
|SIF_PAGE
;
2806 si
.nPage
= TREEVIEW_GetVisibleCount(infoPtr
);
2807 if ( si
.nPage
&& NULL
!= infoPtr
->firstVisible
)
2809 si
.nPos
= infoPtr
->firstVisible
->visibleOrder
;
2810 si
.nMax
= infoPtr
->maxVisibleOrder
- 1;
2812 SetScrollInfo(hwnd
, SB_VERT
, &si
, TRUE
);
2814 if (!(infoPtr
->uInternalStatus
& TV_VSCROLL
))
2815 ShowScrollBar(hwnd
, SB_VERT
, TRUE
);
2816 infoPtr
->uInternalStatus
|= TV_VSCROLL
;
2820 if (infoPtr
->uInternalStatus
& TV_VSCROLL
)
2821 ShowScrollBar(hwnd
, SB_VERT
, FALSE
);
2822 infoPtr
->uInternalStatus
&= ~TV_VSCROLL
;
2827 if (infoPtr
->uInternalStatus
& TV_VSCROLL
)
2828 ShowScrollBar(hwnd
, SB_VERT
, FALSE
);
2829 infoPtr
->uInternalStatus
&= ~TV_VSCROLL
;
2834 si
.nPage
= infoPtr
->clientWidth
;
2835 si
.nPos
= infoPtr
->scrollX
;
2836 si
.nMax
= infoPtr
->treeWidth
- 1;
2838 if (si
.nPos
> si
.nMax
- max( si
.nPage
-1, 0 ))
2840 si
.nPos
= si
.nMax
- max( si
.nPage
-1, 0 );
2844 if (!(infoPtr
->uInternalStatus
& TV_HSCROLL
))
2845 ShowScrollBar(hwnd
, SB_HORZ
, TRUE
);
2846 infoPtr
->uInternalStatus
|= TV_HSCROLL
;
2848 SetScrollInfo(hwnd
, SB_HORZ
, &si
, TRUE
);
2849 TREEVIEW_HScroll(infoPtr
,
2850 MAKEWPARAM(SB_THUMBPOSITION
, scrollX
));
2854 if (infoPtr
->uInternalStatus
& TV_HSCROLL
)
2855 ShowScrollBar(hwnd
, SB_HORZ
, FALSE
);
2856 infoPtr
->uInternalStatus
&= ~TV_HSCROLL
;
2859 if (infoPtr
->scrollX
!= 0)
2861 TREEVIEW_HScroll(infoPtr
,
2862 MAKEWPARAM(SB_THUMBPOSITION
, scrollX
));
2867 infoPtr
->uInternalStatus
&= ~TV_HSCROLL
;
2871 TREEVIEW_FillBkgnd(const TREEVIEW_INFO
*infoPtr
, HDC hdc
, const RECT
*rc
)
2874 COLORREF clrBk
= GETBKCOLOR(infoPtr
->clrBk
);
2876 hBrush
= CreateSolidBrush(clrBk
);
2877 FillRect(hdc
, rc
, hBrush
);
2878 DeleteObject(hBrush
);
2881 /* CtrlSpy doesn't mention this, but CorelDRAW's object manager needs it. */
2883 TREEVIEW_EraseBackground(const TREEVIEW_INFO
*infoPtr
, HDC hdc
)
2887 TRACE("%p\n", infoPtr
);
2889 GetClientRect(infoPtr
->hwnd
, &rect
);
2890 TREEVIEW_FillBkgnd(infoPtr
, hdc
, &rect
);
2896 TREEVIEW_Refresh(TREEVIEW_INFO
*infoPtr
, HDC hdc
, const RECT
*rc
)
2898 HWND hwnd
= infoPtr
->hwnd
;
2900 TREEVIEW_ITEM
*item
;
2903 if (infoPtr
->clientHeight
== 0 || infoPtr
->clientWidth
== 0)
2905 TRACE("empty window\n");
2909 infoPtr
->cdmode
= TREEVIEW_SendCustomDrawNotify(infoPtr
, CDDS_PREPAINT
,
2912 if (infoPtr
->cdmode
== CDRF_SKIPDEFAULT
)
2914 ReleaseDC(hwnd
, hdc
);
2918 if (infoPtr
->dwStyle
& TVS_HASBUTTONS
&& (theme
= GetWindowTheme(infoPtr
->hwnd
)))
2920 if (IsThemeBackgroundPartiallyTransparent(theme
, TVP_GLYPH
, 0))
2921 DrawThemeParentBackground(infoPtr
->hwnd
, hdc
, NULL
);
2924 for (item
= infoPtr
->root
->firstChild
;
2926 item
= TREEVIEW_GetNextListItem(infoPtr
, item
))
2928 if (ISVISIBLE(item
))
2930 /* Avoid unneeded calculations */
2931 if (item
->rect
.top
> rect
.bottom
)
2933 if (item
->rect
.bottom
< rect
.top
)
2936 TREEVIEW_DrawItem(infoPtr
, hdc
, item
);
2940 TREEVIEW_UpdateScrollBars(infoPtr
);
2942 if (infoPtr
->cdmode
& CDRF_NOTIFYPOSTPAINT
)
2944 TREEVIEW_SendCustomDrawNotify(infoPtr
, CDDS_POSTPAINT
, hdc
, rect
);
2948 TREEVIEW_InvalidateItem(const TREEVIEW_INFO
*infoPtr
, const TREEVIEW_ITEM
*item
)
2950 if (item
) InvalidateRect(infoPtr
->hwnd
, &item
->rect
, TRUE
);
2954 TREEVIEW_Invalidate(const TREEVIEW_INFO
*infoPtr
, const TREEVIEW_ITEM
*item
)
2957 InvalidateRect(infoPtr
->hwnd
, &item
->rect
, TRUE
);
2959 InvalidateRect(infoPtr
->hwnd
, NULL
, TRUE
);
2962 static BOOL
TREEVIEW_InitThemedCheckboxes(TREEVIEW_INFO
*info
)
2964 HBITMAP bitmap
, old_bitmap
;
2965 HDC hdc
, hdc_screen
;
2970 if (!GetWindowTheme(info
->hwnd
))
2973 theme
= OpenThemeDataForDpi(NULL
, L
"Button", GetDpiForWindow(info
->hwnd
));
2977 hdc_screen
= GetDC(0);
2978 hdc
= CreateCompatibleDC(hdc_screen
);
2979 GetThemePartSize(theme
, hdc
, BP_CHECKBOX
, 0, NULL
, TS_DRAW
, &size
);
2980 bitmap
= CreateCompatibleBitmap(hdc_screen
, size
.cx
* 3, size
.cy
);
2981 old_bitmap
= SelectObject(hdc
, bitmap
);
2983 SetRect(&rect
, 0, 0, size
.cx
* 3, size
.cy
);
2984 FillRect(hdc
, &rect
, (HBRUSH
)(COLOR_WINDOW
+ 1));
2986 rect
.left
= size
.cx
;
2987 rect
.right
= rect
.left
+ size
.cx
;
2988 DrawThemeBackground(theme
, hdc
, BP_CHECKBOX
, CBS_UNCHECKEDNORMAL
, &rect
, NULL
);
2990 rect
.left
= size
.cx
* 2;
2991 rect
.right
= rect
.left
+ size
.cx
;
2992 DrawThemeBackground(theme
, hdc
, BP_CHECKBOX
, CBS_CHECKEDNORMAL
, &rect
, NULL
);
2994 SelectObject(hdc
, old_bitmap
);
2995 info
->himlState
= ImageList_Create(size
.cx
, size
.cy
, ILC_COLOR32
, 3, 0);
2996 ImageList_Add(info
->himlState
, bitmap
, NULL
);
2998 DeleteObject(bitmap
);
3000 ReleaseDC(0, hdc_screen
);
3001 CloseThemeData(theme
);
3003 info
->stateImageWidth
= size
.cx
;
3004 info
->stateImageHeight
= size
.cy
;
3009 TREEVIEW_InitCheckboxes(TREEVIEW_INFO
*infoPtr
)
3011 int nIndex
, width
, height
;
3013 HBITMAP hbm
, hbmOld
;
3016 if (TREEVIEW_InitThemedCheckboxes(infoPtr
))
3019 width
= 12 * GetDpiForWindow(infoPtr
->hwnd
) / 96 + 1;
3021 infoPtr
->himlState
= ImageList_Create(width
, height
, ILC_COLOR
| ILC_MASK
, 3, 0);
3023 hdcScreen
= GetDC(0);
3025 hdc
= CreateCompatibleDC(hdcScreen
);
3026 hbm
= CreateCompatibleBitmap(hdcScreen
, width
* 3, height
);
3027 hbmOld
= SelectObject(hdc
, hbm
);
3029 SetRect(&rc
, 0, 0, width
* 3, height
);
3030 FillRect(hdc
, &rc
, (HBRUSH
)(COLOR_WINDOW
+1));
3033 rc
.right
= rc
.left
+ width
;
3034 DrawFrameControl(hdc
, &rc
, DFC_BUTTON
, DFCS_BUTTONCHECK
| DFCS_MONO
);
3036 rc
.left
= width
* 2;
3037 rc
.right
= rc
.left
+ width
;
3038 DrawFrameControl(hdc
, &rc
, DFC_BUTTON
, DFCS_BUTTONCHECK
| DFCS_MONO
| DFCS_CHECKED
);
3040 SelectObject(hdc
, hbmOld
);
3041 nIndex
= ImageList_AddMasked(infoPtr
->himlState
, hbm
,
3042 comctl32_color
.clrWindow
);
3043 TRACE("checkbox index %d\n", nIndex
);
3047 ReleaseDC(0, hdcScreen
);
3049 infoPtr
->stateImageWidth
= width
;
3050 infoPtr
->stateImageHeight
= height
;
3054 TREEVIEW_ResetImageStateIndex(TREEVIEW_INFO
*infoPtr
, TREEVIEW_ITEM
*item
)
3056 TREEVIEW_ITEM
*child
= item
->firstChild
;
3058 item
->state
&= ~TVIS_STATEIMAGEMASK
;
3059 item
->state
|= INDEXTOSTATEIMAGEMASK(1);
3063 TREEVIEW_ITEM
*next
= child
->nextSibling
;
3064 TREEVIEW_ResetImageStateIndex(infoPtr
, child
);
3070 TREEVIEW_Paint(TREEVIEW_INFO
*infoPtr
, HDC hdc_ref
)
3076 TRACE("(%p %p)\n", infoPtr
, hdc_ref
);
3078 if ((infoPtr
->dwStyle
& TVS_CHECKBOXES
) && !infoPtr
->himlState
)
3080 TREEVIEW_InitCheckboxes(infoPtr
);
3081 TREEVIEW_ResetImageStateIndex(infoPtr
, infoPtr
->root
);
3083 TREEVIEW_EndEditLabelNow(infoPtr
, TRUE
);
3084 TREEVIEW_UpdateSubTree(infoPtr
, infoPtr
->root
);
3085 TREEVIEW_UpdateScrollBars(infoPtr
);
3086 TREEVIEW_Invalidate(infoPtr
, NULL
);
3092 GetClientRect(infoPtr
->hwnd
, &rc
);
3093 TREEVIEW_FillBkgnd(infoPtr
, hdc
, &rc
);
3097 hdc
= BeginPaint(infoPtr
->hwnd
, &ps
);
3100 TREEVIEW_FillBkgnd(infoPtr
, hdc
, &rc
);
3103 if(infoPtr
->bRedraw
) /* WM_SETREDRAW sets bRedraw */
3104 TREEVIEW_Refresh(infoPtr
, hdc
, &rc
);
3107 EndPaint(infoPtr
->hwnd
, &ps
);
3113 TREEVIEW_PrintClient(TREEVIEW_INFO
*infoPtr
, HDC hdc
, DWORD options
)
3117 FIXME("Partial Stub: (hdc=%p options=%#lx)\n", hdc
, options
);
3119 TREEVIEW_EraseBackground(infoPtr
, hdc
);
3120 GetClientRect(infoPtr
->hwnd
, &rc
);
3121 TREEVIEW_Refresh(infoPtr
, hdc
, &rc
);
3126 /* Sorting **************************************************************/
3128 /***************************************************************************
3129 * Forward the DPA local callback to the treeview owner callback
3132 TREEVIEW_CallBackCompare(const TREEVIEW_ITEM
*first
, const TREEVIEW_ITEM
*second
,
3133 const TVSORTCB
*pCallBackSort
)
3135 /* Forward the call to the client-defined callback */
3136 return pCallBackSort
->lpfnCompare(first
->lParam
,
3138 pCallBackSort
->lParam
);
3141 /***************************************************************************
3142 * Treeview native sort routine: sort on item text.
3145 TREEVIEW_SortOnName(TREEVIEW_ITEM
*first
, TREEVIEW_ITEM
*second
,
3146 const TREEVIEW_INFO
*infoPtr
)
3148 TREEVIEW_UpdateDispInfo(infoPtr
, first
, TVIF_TEXT
);
3149 TREEVIEW_UpdateDispInfo(infoPtr
, second
, TVIF_TEXT
);
3151 if(first
->pszText
&& second
->pszText
)
3152 return lstrcmpiW(first
->pszText
, second
->pszText
);
3153 else if(first
->pszText
)
3155 else if(second
->pszText
)
3161 /* Returns the number of physical children belonging to item. */
3163 TREEVIEW_CountChildren(const TREEVIEW_ITEM
*item
)
3168 for (hti
= item
->firstChild
; hti
!= NULL
; hti
= hti
->nextSibling
)
3174 /* Returns a DPA containing a pointer to each physical child of item in
3175 * sibling order. If item has no children, an empty DPA is returned. */
3177 TREEVIEW_BuildChildDPA(const TREEVIEW_ITEM
*item
)
3181 HDPA list
= DPA_Create(8);
3182 if (list
== 0) return NULL
;
3184 for (child
= item
->firstChild
; child
!= NULL
; child
= child
->nextSibling
)
3186 if (DPA_InsertPtr(list
, INT_MAX
, child
) == -1)
3196 /***************************************************************************
3197 * Setup the treeview structure with regards of the sort method
3198 * and sort the children of the TV item specified in lParam
3199 * fRecurse: currently unused. Should be zero.
3200 * parent: if pSort!=NULL, should equal pSort->hParent.
3201 * otherwise, item which child items are to be sorted.
3202 * pSort: sort method info. if NULL, sort on item text.
3203 * if non-NULL, sort on item's lParam content, and let the
3204 * application decide what that means. See also TVM_SORTCHILDRENCB.
3208 TREEVIEW_Sort(TREEVIEW_INFO
*infoPtr
, HTREEITEM parent
,
3212 PFNDPACOMPARE pfnCompare
;
3215 /* undocumented feature: TVI_ROOT or NULL means `sort the whole tree' */
3216 if (parent
== TVI_ROOT
|| parent
== NULL
)
3217 parent
= infoPtr
->root
;
3219 /* Check for a valid handle to the parent item */
3220 if (!TREEVIEW_ValidItem(infoPtr
, parent
))
3222 ERR("invalid item hParent=%p\n", parent
);
3228 pfnCompare
= (PFNDPACOMPARE
)TREEVIEW_CallBackCompare
;
3229 lpCompare
= (LPARAM
)pSort
;
3233 pfnCompare
= (PFNDPACOMPARE
)TREEVIEW_SortOnName
;
3234 lpCompare
= (LPARAM
)infoPtr
;
3237 cChildren
= TREEVIEW_CountChildren(parent
);
3239 /* Make sure there is something to sort */
3242 /* TREEVIEW_ITEM rechaining */
3245 HTREEITEM nextItem
= 0;
3246 HTREEITEM prevItem
= 0;
3248 HDPA sortList
= TREEVIEW_BuildChildDPA(parent
);
3250 if (sortList
== NULL
)
3253 /* let DPA sort the list */
3254 DPA_Sort(sortList
, pfnCompare
, lpCompare
);
3256 /* The order of DPA entries has been changed, so fixup the
3257 * nextSibling and prevSibling pointers. */
3259 item
= DPA_GetPtr(sortList
, count
++);
3260 while ((nextItem
= DPA_GetPtr(sortList
, count
++)) != NULL
)
3262 /* link the two current item together */
3263 item
->nextSibling
= nextItem
;
3264 nextItem
->prevSibling
= item
;
3266 if (prevItem
== NULL
)
3268 /* this is the first item, update the parent */
3269 parent
->firstChild
= item
;
3270 item
->prevSibling
= NULL
;
3274 /* fix the back chaining */
3275 item
->prevSibling
= prevItem
;
3278 /* get ready for the next one */
3283 /* the last item is pointed to by item and never has a sibling */
3284 item
->nextSibling
= NULL
;
3285 parent
->lastChild
= item
;
3287 DPA_Destroy(sortList
);
3289 TREEVIEW_VerifyTree(infoPtr
);
3291 if (parent
->state
& TVIS_EXPANDED
)
3293 int visOrder
= infoPtr
->firstVisible
->visibleOrder
;
3295 if (parent
== infoPtr
->root
)
3296 TREEVIEW_RecalculateVisibleOrder(infoPtr
, NULL
);
3298 TREEVIEW_RecalculateVisibleOrder(infoPtr
, parent
);
3300 if (TREEVIEW_IsChildOf(parent
, infoPtr
->firstVisible
))
3302 TREEVIEW_ITEM
*item
;
3304 for (item
= infoPtr
->root
->firstChild
; item
!= NULL
;
3305 item
= TREEVIEW_GetNextListItem(infoPtr
, item
))
3307 if (item
->visibleOrder
== visOrder
)
3311 if (!item
) item
= parent
->firstChild
;
3312 TREEVIEW_SetFirstVisible(infoPtr
, item
, FALSE
);
3315 TREEVIEW_Invalidate(infoPtr
, NULL
);
3324 /***************************************************************************
3325 * Setup the treeview structure with regards of the sort method
3326 * and sort the children of the TV item specified in lParam
3329 TREEVIEW_SortChildrenCB(TREEVIEW_INFO
*infoPtr
, LPTVSORTCB pSort
)
3331 return TREEVIEW_Sort(infoPtr
, pSort
->hParent
, pSort
);
3335 /***************************************************************************
3336 * Sort the children of the TV item specified in lParam.
3339 TREEVIEW_SortChildren(TREEVIEW_INFO
*infoPtr
, LPARAM lParam
)
3341 return TREEVIEW_Sort(infoPtr
, (HTREEITEM
)lParam
, NULL
);
3345 /* Expansion/Collapse ***************************************************/
3348 TREEVIEW_SendExpanding(const TREEVIEW_INFO
*infoPtr
, TREEVIEW_ITEM
*item
,
3351 return !TREEVIEW_SendTreeviewNotify(infoPtr
, TVN_ITEMEXPANDINGW
, action
,
3352 TVIF_HANDLE
| TVIF_STATE
| TVIF_PARAM
3353 | TVIF_IMAGE
| TVIF_SELECTEDIMAGE
,
3358 TREEVIEW_SendExpanded(const TREEVIEW_INFO
*infoPtr
, TREEVIEW_ITEM
*item
,
3361 TREEVIEW_SendTreeviewNotify(infoPtr
, TVN_ITEMEXPANDEDW
, action
,
3362 TVIF_HANDLE
| TVIF_STATE
| TVIF_PARAM
3363 | TVIF_IMAGE
| TVIF_SELECTEDIMAGE
,
3368 /* This corresponds to TVM_EXPAND with TVE_COLLAPSE.
3369 * bRemoveChildren corresponds to TVE_COLLAPSERESET. */
3371 TREEVIEW_Collapse(TREEVIEW_INFO
*infoPtr
, TREEVIEW_ITEM
*item
,
3372 BOOL bRemoveChildren
, BOOL bUser
)
3374 UINT action
= TVE_COLLAPSE
| (bRemoveChildren
? TVE_COLLAPSERESET
: 0);
3375 BOOL bSetSelection
, bSetFirstVisible
;
3377 LONG scrollDist
= 0;
3378 TREEVIEW_ITEM
*nextItem
= NULL
, *tmpItem
;
3381 TRACE("TVE_COLLAPSE %p %s\n", item
, TREEVIEW_ItemName(item
));
3383 if (!TREEVIEW_HasChildren(infoPtr
, item
))
3387 TREEVIEW_SendExpanding(infoPtr
, item
, action
);
3389 if (item
->firstChild
== NULL
)
3392 wasExpanded
= (item
->state
& TVIS_EXPANDED
) != 0;
3393 item
->state
&= ~TVIS_EXPANDED
;
3395 if (wasExpanded
&& bUser
)
3396 TREEVIEW_SendExpanded(infoPtr
, item
, action
);
3398 bSetSelection
= (infoPtr
->selectedItem
!= NULL
3399 && TREEVIEW_IsChildOf(item
, infoPtr
->selectedItem
));
3401 bSetFirstVisible
= (infoPtr
->firstVisible
!= NULL
3402 && TREEVIEW_IsChildOf(item
, infoPtr
->firstVisible
));
3407 if (tmpItem
->nextSibling
)
3409 nextItem
= tmpItem
->nextSibling
;
3412 tmpItem
= tmpItem
->parent
;
3416 scrollDist
= nextItem
->rect
.top
;
3418 if (bRemoveChildren
)
3420 INT old_cChildren
= item
->cChildren
;
3421 TRACE("TVE_COLLAPSERESET\n");
3422 item
->state
&= ~TVIS_EXPANDEDONCE
;
3423 TREEVIEW_RemoveAllChildren(infoPtr
, item
);
3424 item
->cChildren
= old_cChildren
;
3429 if (item
->firstChild
)
3431 TREEVIEW_ITEM
*i
, *sibling
;
3433 sibling
= TREEVIEW_GetNextListItem(infoPtr
, item
);
3435 for (i
= item
->firstChild
; i
!= sibling
;
3436 i
= TREEVIEW_GetNextListItem(infoPtr
, i
))
3438 i
->visibleOrder
= -1;
3442 TREEVIEW_RecalculateVisibleOrder(infoPtr
, item
);
3445 scrollDist
= -(scrollDist
- nextItem
->rect
.top
);
3449 /* Don't call DoSelectItem, it sends notifications. */
3450 if (TREEVIEW_ValidItem(infoPtr
, infoPtr
->selectedItem
))
3451 infoPtr
->selectedItem
->state
&= ~TVIS_SELECTED
;
3452 item
->state
|= TVIS_SELECTED
;
3453 infoPtr
->selectedItem
= item
;
3456 TREEVIEW_UpdateScrollBars(infoPtr
);
3458 scrollRect
.left
= 0;
3459 scrollRect
.right
= infoPtr
->clientWidth
;
3460 scrollRect
.bottom
= infoPtr
->clientHeight
;
3464 scrollRect
.top
= nextItem
->rect
.top
;
3466 ScrollWindowEx (infoPtr
->hwnd
, 0, scrollDist
, &scrollRect
, &scrollRect
,
3467 NULL
, NULL
, SW_ERASE
| SW_INVALIDATE
);
3468 TREEVIEW_Invalidate(infoPtr
, item
);
3470 scrollRect
.top
= item
->rect
.top
;
3471 InvalidateRect(infoPtr
->hwnd
, &scrollRect
, TRUE
);
3474 TREEVIEW_SetFirstVisible(infoPtr
,
3475 bSetFirstVisible
? item
: infoPtr
->firstVisible
,
3482 TREEVIEW_Expand(TREEVIEW_INFO
*infoPtr
, TREEVIEW_ITEM
*item
,
3483 BOOL partial
, BOOL user
)
3486 LONG orgNextTop
= 0;
3488 TREEVIEW_ITEM
*nextItem
, *tmpItem
;
3489 BOOL sendsNotifications
;
3491 TRACE("(%p, %p, partial=%d, %d)\n", infoPtr
, item
, partial
, user
);
3493 if (!TREEVIEW_HasChildren(infoPtr
, item
))
3496 tmpItem
= item
; nextItem
= NULL
;
3499 if (tmpItem
->nextSibling
)
3501 nextItem
= tmpItem
->nextSibling
;
3504 tmpItem
= tmpItem
->parent
;
3508 orgNextTop
= nextItem
->rect
.top
;
3510 TRACE("TVE_EXPAND %p %s\n", item
, TREEVIEW_ItemName(item
));
3512 sendsNotifications
= user
|| ((item
->cChildren
!= 0) &&
3513 !(item
->state
& TVIS_EXPANDEDONCE
));
3514 if (sendsNotifications
)
3516 if (!TREEVIEW_SendExpanding(infoPtr
, item
, TVE_EXPAND
))
3518 TRACE(" TVN_ITEMEXPANDING returned TRUE, exiting...\n");
3522 if (!item
->firstChild
)
3525 item
->state
|= TVIS_EXPANDED
;
3528 FIXME("TVE_EXPANDPARTIAL not implemented\n");
3530 if (ISVISIBLE(item
))
3532 TREEVIEW_RecalculateVisibleOrder(infoPtr
, item
);
3533 TREEVIEW_UpdateSubTree(infoPtr
, item
);
3534 TREEVIEW_UpdateScrollBars(infoPtr
);
3536 scrollRect
.left
= 0;
3537 scrollRect
.bottom
= infoPtr
->treeHeight
;
3538 scrollRect
.right
= infoPtr
->clientWidth
;
3541 scrollDist
= nextItem
->rect
.top
- orgNextTop
;
3542 scrollRect
.top
= orgNextTop
;
3544 ScrollWindowEx (infoPtr
->hwnd
, 0, scrollDist
, &scrollRect
, NULL
,
3545 NULL
, NULL
, SW_ERASE
| SW_INVALIDATE
);
3546 TREEVIEW_Invalidate (infoPtr
, item
);
3548 scrollRect
.top
= item
->rect
.top
;
3549 InvalidateRect(infoPtr
->hwnd
, &scrollRect
, FALSE
);
3552 /* Scroll up so that as many children as possible are visible.
3553 * This fails when expanding causes an HScroll bar to appear, but we
3554 * don't know that yet, so the last item is obscured. */
3555 if (item
->firstChild
!= NULL
)
3557 int nChildren
= item
->lastChild
->visibleOrder
3558 - item
->firstChild
->visibleOrder
+ 1;
3560 int visible_pos
= item
->visibleOrder
3561 - infoPtr
->firstVisible
->visibleOrder
;
3563 int rows_below
= TREEVIEW_GetVisibleCount(infoPtr
) - visible_pos
- 1;
3565 if (visible_pos
> 0 && nChildren
> rows_below
)
3567 int scroll
= nChildren
- rows_below
;
3569 if (scroll
> visible_pos
)
3570 scroll
= visible_pos
;
3574 TREEVIEW_ITEM
*newFirstVisible
3575 = TREEVIEW_GetListItem(infoPtr
, infoPtr
->firstVisible
,
3579 TREEVIEW_SetFirstVisible(infoPtr
, newFirstVisible
, TRUE
);
3585 if (sendsNotifications
) {
3586 TREEVIEW_SendExpanded(infoPtr
, item
, TVE_EXPAND
);
3587 item
->state
|= TVIS_EXPANDEDONCE
;
3593 /* Handler for TVS_SINGLEEXPAND behaviour. Used on response
3594 to mouse messages and TVM_SELECTITEM.
3596 selection - previously selected item, used to collapse a part of a tree
3597 item - new selected item
3599 static void TREEVIEW_SingleExpand(TREEVIEW_INFO
*infoPtr
,
3600 HTREEITEM selection
, HTREEITEM item
)
3602 TREEVIEW_ITEM
*prev
, *curr
;
3604 if ((infoPtr
->dwStyle
& TVS_SINGLEEXPAND
) == 0 || infoPtr
->hwndEdit
|| !item
) return;
3606 TREEVIEW_SendTreeviewNotify(infoPtr
, TVN_SINGLEEXPAND
, TVC_UNKNOWN
, TVIF_HANDLE
| TVIF_PARAM
, item
, 0);
3609 * Close the previous item and its ancestors as long as they are not
3610 * ancestors of the current item
3612 for (prev
= selection
; prev
&& TREEVIEW_ValidItem(infoPtr
, prev
); prev
= prev
->parent
)
3614 for (curr
= item
; curr
&& TREEVIEW_ValidItem(infoPtr
, curr
); curr
= curr
->parent
)
3619 TREEVIEW_Collapse(infoPtr
, prev
, FALSE
, TRUE
);
3624 * Expand the current item
3626 TREEVIEW_Expand(infoPtr
, item
, FALSE
, TRUE
);
3630 TREEVIEW_Toggle(TREEVIEW_INFO
*infoPtr
, TREEVIEW_ITEM
*item
, BOOL user
)
3632 TRACE("item=%p, user=%d\n", item
, user
);
3634 if (item
->state
& TVIS_EXPANDED
)
3635 return TREEVIEW_Collapse(infoPtr
, item
, FALSE
, user
);
3637 return TREEVIEW_Expand(infoPtr
, item
, FALSE
, user
);
3641 TREEVIEW_ExpandAll(TREEVIEW_INFO
*infoPtr
, TREEVIEW_ITEM
*item
)
3643 TREEVIEW_Expand(infoPtr
, item
, FALSE
, TRUE
);
3645 for (item
= item
->firstChild
; item
!= NULL
; item
= item
->nextSibling
)
3647 if (TREEVIEW_HasChildren(infoPtr
, item
))
3648 TREEVIEW_ExpandAll(infoPtr
, item
);
3652 /* Note:If the specified item is the child of a collapsed parent item,
3653 the parent's list of child items is (recursively) expanded to reveal the
3654 specified item. This is mentioned for TREEVIEW_SelectItem; don't
3655 know if it also applies here.
3659 TREEVIEW_ExpandMsg(TREEVIEW_INFO
*infoPtr
, UINT flag
, HTREEITEM item
)
3661 if (!TREEVIEW_ValidItem(infoPtr
, item
))
3664 TRACE("For (%s) item:%d, flags 0x%x, state:%d\n",
3665 TREEVIEW_ItemName(item
), TREEVIEW_GetItemIndex(infoPtr
, item
),
3668 switch (flag
& TVE_TOGGLE
)
3671 return TREEVIEW_Collapse(infoPtr
, item
, flag
& TVE_COLLAPSERESET
,
3675 return TREEVIEW_Expand(infoPtr
, item
, flag
& TVE_EXPANDPARTIAL
,
3679 return TREEVIEW_Toggle(infoPtr
, item
, FALSE
);
3686 /* Hit-Testing **********************************************************/
3688 static TREEVIEW_ITEM
*
3689 TREEVIEW_HitTestPoint(const TREEVIEW_INFO
*infoPtr
, POINT pt
)
3691 TREEVIEW_ITEM
*item
;
3694 if (!infoPtr
->firstVisible
)
3697 row
= pt
.y
/ infoPtr
->uItemHeight
+ infoPtr
->firstVisible
->visibleOrder
;
3699 for (item
= infoPtr
->firstVisible
; item
!= NULL
;
3700 item
= TREEVIEW_GetNextListItem(infoPtr
, item
))
3702 if (row
>= item
->visibleOrder
3703 && row
< item
->visibleOrder
+ item
->iIntegral
)
3710 static TREEVIEW_ITEM
*
3711 TREEVIEW_HitTest(const TREEVIEW_INFO
*infoPtr
, LPTVHITTESTINFO lpht
)
3713 TREEVIEW_ITEM
*item
;
3719 GetClientRect(infoPtr
->hwnd
, &rect
);
3726 status
|= TVHT_TOLEFT
;
3728 else if (x
> rect
.right
)
3730 status
|= TVHT_TORIGHT
;
3735 status
|= TVHT_ABOVE
;
3737 else if (y
> rect
.bottom
)
3739 status
|= TVHT_BELOW
;
3744 lpht
->flags
= status
;
3748 item
= TREEVIEW_HitTestPoint(infoPtr
, lpht
->pt
);
3751 lpht
->flags
= TVHT_NOWHERE
;
3755 if (!item
->textWidth
)
3756 TREEVIEW_ComputeTextWidth(infoPtr
, item
, 0);
3758 if (x
>= item
->textOffset
+ item
->textWidth
)
3760 lpht
->flags
= TVHT_ONITEMRIGHT
;
3762 else if (x
>= item
->textOffset
)
3764 lpht
->flags
= TVHT_ONITEMLABEL
;
3766 else if (x
>= item
->imageOffset
)
3768 lpht
->flags
= TVHT_ONITEMICON
;
3770 else if (x
>= item
->stateOffset
)
3772 lpht
->flags
= TVHT_ONITEMSTATEICON
;
3774 else if (x
>= item
->linesOffset
&& infoPtr
->dwStyle
& TVS_HASBUTTONS
)
3776 lpht
->flags
= TVHT_ONITEMBUTTON
;
3780 lpht
->flags
= TVHT_ONITEMINDENT
;
3784 TRACE("(%ld, %ld) : result 0x%x\n", lpht
->pt
.x
, lpht
->pt
.y
, lpht
->flags
);
3789 /* Item Label Editing ***************************************************/
3792 TREEVIEW_GetEditControl(const TREEVIEW_INFO
*infoPtr
)
3794 return (LRESULT
)infoPtr
->hwndEdit
;
3797 static LRESULT CALLBACK
3798 TREEVIEW_Edit_SubclassProc(HWND hwnd
, UINT uMsg
, WPARAM wParam
, LPARAM lParam
)
3800 TREEVIEW_INFO
*infoPtr
= TREEVIEW_GetInfoPtr(GetParent(hwnd
));
3801 BOOL bCancel
= FALSE
;
3807 TRACE("WM_PAINT start\n");
3808 rc
= CallWindowProcW(infoPtr
->wpEditOrig
, hwnd
, uMsg
, wParam
,
3810 TRACE("WM_PAINT done\n");
3814 if (infoPtr
->bIgnoreEditKillFocus
)
3820 WNDPROC editProc
= infoPtr
->wpEditOrig
;
3821 infoPtr
->wpEditOrig
= 0;
3822 SetWindowLongPtrW(hwnd
, GWLP_WNDPROC
, (DWORD_PTR
)editProc
);
3823 return CallWindowProcW(editProc
, hwnd
, uMsg
, wParam
, lParam
);
3827 return DLGC_WANTARROWS
| DLGC_WANTALLKEYS
;
3830 if (wParam
== VK_ESCAPE
)
3835 else if (wParam
== VK_RETURN
)
3842 return CallWindowProcW(infoPtr
->wpEditOrig
, hwnd
, uMsg
, wParam
, lParam
);
3845 /* Processing TVN_ENDLABELEDIT message could kill the focus */
3846 /* eg. Using a messagebox */
3848 infoPtr
->bIgnoreEditKillFocus
= TRUE
;
3849 TREEVIEW_EndEditLabelNow(infoPtr
, bCancel
|| !infoPtr
->bLabelChanged
);
3850 infoPtr
->bIgnoreEditKillFocus
= FALSE
;
3856 /* should handle edit control messages here */
3859 TREEVIEW_Command(TREEVIEW_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
3861 TRACE("code 0x%x, id=0x%x, handle %Ix\n", HIWORD(wParam
), LOWORD(wParam
), lParam
);
3863 switch (HIWORD(wParam
))
3868 * Adjust the edit window size
3871 TREEVIEW_ITEM
*editItem
= infoPtr
->editItem
;
3872 HDC hdc
= GetDC(infoPtr
->hwndEdit
);
3874 HFONT hFont
, hOldFont
= 0;
3876 TRACE("edit=%p\n", infoPtr
->hwndEdit
);
3878 if (!IsWindow(infoPtr
->hwndEdit
) || !hdc
) return FALSE
;
3880 infoPtr
->bLabelChanged
= TRUE
;
3882 GetWindowTextW(infoPtr
->hwndEdit
, buffer
, ARRAY_SIZE(buffer
));
3884 /* Select font to get the right dimension of the string */
3885 hFont
= (HFONT
)SendMessageW(infoPtr
->hwndEdit
, WM_GETFONT
, 0, 0);
3889 hOldFont
= SelectObject(hdc
, hFont
);
3892 if (GetTextExtentPoint32W(hdc
, buffer
, lstrlenW(buffer
), &sz
))
3894 TEXTMETRICW textMetric
;
3896 /* Add Extra spacing for the next character */
3897 GetTextMetricsW(hdc
, &textMetric
);
3898 sz
.cx
+= (textMetric
.tmMaxCharWidth
* 2);
3900 sz
.cx
= max(sz
.cx
, textMetric
.tmMaxCharWidth
* 3);
3902 infoPtr
->clientWidth
- editItem
->textOffset
+ 2);
3904 SetWindowPos(infoPtr
->hwndEdit
,
3909 editItem
->rect
.bottom
- editItem
->rect
.top
+ 3,
3910 SWP_NOMOVE
| SWP_DRAWFRAME
);
3915 SelectObject(hdc
, hOldFont
);
3918 ReleaseDC(infoPtr
->hwnd
, hdc
);
3922 /* apparently we should respect passed handle value */
3923 if (infoPtr
->hwndEdit
!= (HWND
)lParam
) return FALSE
;
3925 TREEVIEW_EndEditLabelNow(infoPtr
, FALSE
);
3929 return SendMessageW(infoPtr
->hwndNotify
, WM_COMMAND
, wParam
, lParam
);
3936 TREEVIEW_EditLabel(TREEVIEW_INFO
*infoPtr
, HTREEITEM hItem
)
3938 HWND hwnd
= infoPtr
->hwnd
;
3941 HINSTANCE hinst
= (HINSTANCE
)GetWindowLongPtrW(hwnd
, GWLP_HINSTANCE
);
3944 TEXTMETRICW textMetric
;
3946 TRACE("%p %p\n", hwnd
, hItem
);
3947 if (!(infoPtr
->dwStyle
& TVS_EDITLABELS
))
3950 if (!TREEVIEW_ValidItem(infoPtr
, hItem
))
3953 if (infoPtr
->hwndEdit
)
3954 return infoPtr
->hwndEdit
;
3956 infoPtr
->bLabelChanged
= FALSE
;
3958 /* make edit item visible */
3959 TREEVIEW_EnsureVisible(infoPtr
, hItem
, TRUE
);
3961 TREEVIEW_UpdateDispInfo(infoPtr
, hItem
, TVIF_TEXT
);
3964 /* Select the font to get appropriate metric dimensions */
3965 if (infoPtr
->hFont
!= 0)
3967 hOldFont
= SelectObject(hdc
, infoPtr
->hFont
);
3970 /* Get string length in pixels */
3972 GetTextExtentPoint32W(hdc
, hItem
->pszText
, lstrlenW(hItem
->pszText
),
3975 GetTextExtentPoint32A(hdc
, "", 0, &sz
);
3977 /* Add Extra spacing for the next character */
3978 GetTextMetricsW(hdc
, &textMetric
);
3979 sz
.cx
+= (textMetric
.tmMaxCharWidth
* 2);
3981 sz
.cx
= max(sz
.cx
, textMetric
.tmMaxCharWidth
* 3);
3982 sz
.cx
= min(sz
.cx
, infoPtr
->clientWidth
- hItem
->textOffset
+ 2);
3984 if (infoPtr
->hFont
!= 0)
3986 SelectObject(hdc
, hOldFont
);
3989 ReleaseDC(hwnd
, hdc
);
3991 infoPtr
->editItem
= hItem
;
3993 hwndEdit
= CreateWindowExW(WS_EX_LEFT
,
3996 WS_CHILD
| WS_BORDER
| ES_AUTOHSCROLL
|
3997 WS_CLIPSIBLINGS
| ES_WANTRETURN
|
3998 ES_LEFT
, hItem
->textOffset
- 2,
3999 hItem
->rect
.top
- 1, sz
.cx
+ 3,
4000 hItem
->rect
.bottom
-
4001 hItem
->rect
.top
+ 3, hwnd
, 0, hinst
, 0);
4002 /* FIXME: (HMENU)IDTVEDIT,pcs->hInstance,0); */
4004 infoPtr
->hwndEdit
= hwndEdit
;
4006 /* Get a 2D border. */
4007 SetWindowLongW(hwndEdit
, GWL_EXSTYLE
,
4008 GetWindowLongW(hwndEdit
, GWL_EXSTYLE
) & ~WS_EX_CLIENTEDGE
);
4009 SetWindowLongW(hwndEdit
, GWL_STYLE
,
4010 GetWindowLongW(hwndEdit
, GWL_STYLE
) | WS_BORDER
);
4012 SendMessageW(hwndEdit
, WM_SETFONT
,
4013 (WPARAM
)TREEVIEW_FontForItem(infoPtr
, hItem
), FALSE
);
4015 infoPtr
->wpEditOrig
= (WNDPROC
)SetWindowLongPtrW(hwndEdit
, GWLP_WNDPROC
,
4017 TREEVIEW_Edit_SubclassProc
);
4018 SendMessageW(hwndEdit
, EM_SETLIMITTEXT
, MAX_PATH
- 1, 0);
4020 SetWindowTextW(hwndEdit
, hItem
->pszText
);
4022 if (TREEVIEW_BeginLabelEditNotify(infoPtr
, hItem
))
4024 DestroyWindow(hwndEdit
);
4025 infoPtr
->hwndEdit
= 0;
4026 infoPtr
->editItem
= NULL
;
4031 SendMessageW(hwndEdit
, EM_SETSEL
, 0, -1);
4032 ShowWindow(hwndEdit
, SW_SHOW
);
4039 TREEVIEW_EndEditLabelNow(TREEVIEW_INFO
*infoPtr
, BOOL bCancel
)
4041 TREEVIEW_ITEM
*editedItem
= infoPtr
->editItem
;
4044 WCHAR tmpText
[MAX_PATH
] = { '\0' };
4048 if (!IsWindow(infoPtr
->hwndEdit
)) return FALSE
;
4051 tvdi
.item
.hItem
= editedItem
;
4052 tvdi
.item
.state
= editedItem
->state
;
4053 tvdi
.item
.lParam
= editedItem
->lParam
;
4057 if (!infoPtr
->bNtfUnicode
)
4058 iLength
= GetWindowTextA(infoPtr
->hwndEdit
, (LPSTR
)tmpText
, ARRAY_SIZE(tmpText
));
4060 iLength
= GetWindowTextW(infoPtr
->hwndEdit
, tmpText
, ARRAY_SIZE(tmpText
));
4062 tvdi
.item
.mask
= TVIF_TEXT
;
4063 tvdi
.item
.pszText
= tmpText
;
4064 tvdi
.item
.cchTextMax
= ARRAY_SIZE(tmpText
);
4068 tvdi
.item
.pszText
= NULL
;
4069 tvdi
.item
.cchTextMax
= 0;
4072 bCommit
= TREEVIEW_SendRealNotify(infoPtr
, TVN_ENDLABELEDITW
, &tvdi
.hdr
);
4074 if (!bCancel
&& bCommit
) /* Apply the changes */
4076 if (!infoPtr
->bNtfUnicode
)
4078 DWORD len
= MultiByteToWideChar( CP_ACP
, 0, (LPSTR
)tvdi
.item
.pszText
, -1, NULL
, 0 );
4079 newText
= Alloc(len
* sizeof(WCHAR
));
4080 MultiByteToWideChar( CP_ACP
, 0, (LPSTR
)tvdi
.item
.pszText
, -1, newText
, len
);
4084 newText
= tvdi
.item
.pszText
;
4086 if (lstrcmpW(newText
, editedItem
->pszText
) != 0)
4088 WCHAR
*ptr
= ReAlloc(editedItem
->pszText
, sizeof(WCHAR
)*(iLength
+ 1));
4091 ERR("OutOfMemory, cannot allocate space for label\n");
4092 if (newText
!= tmpText
) Free(newText
);
4093 DestroyWindow(infoPtr
->hwndEdit
);
4094 infoPtr
->hwndEdit
= 0;
4095 infoPtr
->editItem
= NULL
;
4100 editedItem
->pszText
= ptr
;
4101 editedItem
->cchTextMax
= iLength
+ 1;
4102 lstrcpyW(editedItem
->pszText
, newText
);
4103 TREEVIEW_ComputeTextWidth(infoPtr
, editedItem
, 0);
4106 if (newText
!= tmpText
) Free(newText
);
4109 ShowWindow(infoPtr
->hwndEdit
, SW_HIDE
);
4110 DestroyWindow(infoPtr
->hwndEdit
);
4111 infoPtr
->hwndEdit
= 0;
4112 infoPtr
->editItem
= NULL
;
4117 TREEVIEW_HandleTimer(TREEVIEW_INFO
*infoPtr
, WPARAM wParam
)
4119 if (wParam
!= TV_EDIT_TIMER
)
4121 ERR("got unknown timer\n");
4125 KillTimer(infoPtr
->hwnd
, TV_EDIT_TIMER
);
4126 infoPtr
->Timer
&= ~TV_EDIT_TIMER_SET
;
4128 TREEVIEW_EditLabel(infoPtr
, infoPtr
->selectedItem
);
4134 /* Mouse Tracking/Drag **************************************************/
4136 /***************************************************************************
4137 * This is quite unusual piece of code, but that's how it's implemented in
4141 TREEVIEW_TrackMouse(const TREEVIEW_INFO
*infoPtr
, POINT pt
)
4143 INT cxDrag
= GetSystemMetrics(SM_CXDRAG
);
4144 INT cyDrag
= GetSystemMetrics(SM_CYDRAG
);
4148 r
.top
= pt
.y
- cyDrag
;
4149 r
.left
= pt
.x
- cxDrag
;
4150 r
.bottom
= pt
.y
+ cyDrag
;
4151 r
.right
= pt
.x
+ cxDrag
;
4153 SetCapture(infoPtr
->hwnd
);
4157 if (PeekMessageW(&msg
, 0, 0, 0, PM_REMOVE
| PM_NOYIELD
))
4159 if (msg
.message
== WM_MOUSEMOVE
)
4161 pt
.x
= (short)LOWORD(msg
.lParam
);
4162 pt
.y
= (short)HIWORD(msg
.lParam
);
4163 if (PtInRect(&r
, pt
))
4171 else if (msg
.message
>= WM_LBUTTONDOWN
&&
4172 msg
.message
<= WM_RBUTTONDBLCLK
)
4177 DispatchMessageW(&msg
);
4180 if (GetCapture() != infoPtr
->hwnd
)
4190 TREEVIEW_LButtonDoubleClick(TREEVIEW_INFO
*infoPtr
, LPARAM lParam
)
4192 TREEVIEW_ITEM
*item
;
4196 SetFocus(infoPtr
->hwnd
);
4198 if (infoPtr
->Timer
& TV_EDIT_TIMER_SET
)
4200 /* If there is pending 'edit label' event - kill it now */
4201 KillTimer(infoPtr
->hwnd
, TV_EDIT_TIMER
);
4204 hit
.pt
.x
= (short)LOWORD(lParam
);
4205 hit
.pt
.y
= (short)HIWORD(lParam
);
4207 item
= TREEVIEW_HitTest(infoPtr
, &hit
);
4210 TRACE("item %d\n", TREEVIEW_GetItemIndex(infoPtr
, item
));
4212 if (TREEVIEW_SendSimpleNotify(infoPtr
, NM_DBLCLK
) == FALSE
)
4216 case TVHT_ONITEMRIGHT
:
4217 /* FIXME: we should not have sent NM_DBLCLK in this case. */
4220 case TVHT_ONITEMINDENT
:
4221 if (!(infoPtr
->dwStyle
& TVS_HASLINES
))
4227 int level
= hit
.pt
.x
/ infoPtr
->uIndent
;
4228 if (!(infoPtr
->dwStyle
& TVS_LINESATROOT
)) level
++;
4230 while (item
->iLevel
> level
)
4232 item
= item
->parent
;
4238 case TVHT_ONITEMLABEL
:
4239 case TVHT_ONITEMICON
:
4240 case TVHT_ONITEMBUTTON
:
4241 TREEVIEW_Toggle(infoPtr
, item
, TRUE
);
4244 case TVHT_ONITEMSTATEICON
:
4245 if (infoPtr
->dwStyle
& TVS_CHECKBOXES
)
4246 TREEVIEW_ToggleItemState(infoPtr
, item
);
4248 TREEVIEW_Toggle(infoPtr
, item
, TRUE
);
4257 TREEVIEW_LButtonDown(TREEVIEW_INFO
*infoPtr
, LPARAM lParam
)
4259 BOOL do_track
, do_select
, bDoLabelEdit
;
4260 HWND hwnd
= infoPtr
->hwnd
;
4263 /* If Edit control is active - kill it and return.
4264 * The best way to do it is to set focus to itself.
4265 * Edit control subclassed procedure will automatically call
4268 if (infoPtr
->hwndEdit
)
4274 ht
.pt
.x
= (short)LOWORD(lParam
);
4275 ht
.pt
.y
= (short)HIWORD(lParam
);
4277 TREEVIEW_HitTest(infoPtr
, &ht
);
4278 TRACE("item %d\n", TREEVIEW_GetItemIndex(infoPtr
, ht
.hItem
));
4280 /* update focusedItem and redraw both items */
4285 if (TREEVIEW_IsFullRowSelect(infoPtr
))
4286 do_focus
= ht
.flags
& (TVHT_ONITEMINDENT
| TVHT_ONITEM
| TVHT_ONITEMRIGHT
);
4288 do_focus
= ht
.flags
& TVHT_ONITEM
;
4292 infoPtr
->focusedItem
= ht
.hItem
;
4293 TREEVIEW_InvalidateItem(infoPtr
, infoPtr
->focusedItem
);
4294 TREEVIEW_InvalidateItem(infoPtr
, infoPtr
->selectedItem
);
4298 if (!(infoPtr
->dwStyle
& TVS_DISABLEDRAGDROP
))
4300 if (TREEVIEW_IsFullRowSelect(infoPtr
))
4301 do_track
= ht
.flags
& (TVHT_ONITEMINDENT
| TVHT_ONITEM
| TVHT_ONITEMRIGHT
);
4303 do_track
= ht
.flags
& TVHT_ONITEM
;
4309 * If the style allows editing and the node is already selected
4310 * and the click occurred on the item label...
4312 bDoLabelEdit
= (infoPtr
->dwStyle
& TVS_EDITLABELS
) &&
4313 (ht
.flags
& TVHT_ONITEMLABEL
) && (infoPtr
->selectedItem
== ht
.hItem
);
4315 /* Send NM_CLICK right away */
4316 if (!do_track
&& TREEVIEW_SendSimpleNotify(infoPtr
, NM_CLICK
))
4319 if (ht
.flags
& TVHT_ONITEMBUTTON
)
4321 TREEVIEW_Toggle(infoPtr
, ht
.hItem
, TRUE
);
4325 { /* if TREEVIEW_TrackMouse == 1 dragging occurred and the cursor left the dragged item's rectangle */
4326 if (TREEVIEW_TrackMouse(infoPtr
, ht
.pt
))
4328 TREEVIEW_SendTreeviewDnDNotify(infoPtr
, TVN_BEGINDRAGW
, ht
.hItem
, ht
.pt
);
4329 infoPtr
->dropItem
= ht
.hItem
;
4331 /* clean up focusedItem as we dragged and won't select this item */
4332 if(infoPtr
->focusedItem
)
4334 /* refresh the item that was focused */
4335 TREEVIEW_InvalidateItem(infoPtr
, infoPtr
->focusedItem
);
4336 infoPtr
->focusedItem
= NULL
;
4338 /* refresh the selected item to return the filled background */
4339 TREEVIEW_InvalidateItem(infoPtr
, infoPtr
->selectedItem
);
4346 if (do_track
&& TREEVIEW_SendSimpleNotify(infoPtr
, NM_CLICK
))
4349 if (TREEVIEW_IsFullRowSelect(infoPtr
))
4350 do_select
= ht
.flags
& (TVHT_ONITEMINDENT
| TVHT_ONITEMICON
| TVHT_ONITEMLABEL
| TVHT_ONITEMRIGHT
);
4352 do_select
= ht
.flags
& (TVHT_ONITEMICON
| TVHT_ONITEMLABEL
);
4356 if (infoPtr
->Timer
& TV_EDIT_TIMER_SET
)
4357 KillTimer(hwnd
, TV_EDIT_TIMER
);
4359 SetTimer(hwnd
, TV_EDIT_TIMER
, GetDoubleClickTime(), 0);
4360 infoPtr
->Timer
|= TV_EDIT_TIMER_SET
;
4364 TREEVIEW_ITEM
*selection
= infoPtr
->selectedItem
;
4366 /* Select the current item */
4367 TREEVIEW_DoSelectItem(infoPtr
, TVGN_CARET
, ht
.hItem
, TVC_BYMOUSE
);
4368 TREEVIEW_SingleExpand(infoPtr
, selection
, ht
.hItem
);
4370 else if (ht
.flags
& TVHT_ONITEMSTATEICON
)
4372 /* TVS_CHECKBOXES requires us to toggle the current state */
4373 if (infoPtr
->dwStyle
& TVS_CHECKBOXES
)
4374 TREEVIEW_ToggleItemState(infoPtr
, ht
.hItem
);
4384 TREEVIEW_RButtonDown(TREEVIEW_INFO
*infoPtr
, LPARAM lParam
)
4388 if (infoPtr
->hwndEdit
)
4390 SetFocus(infoPtr
->hwnd
);
4394 ht
.pt
.x
= (short)LOWORD(lParam
);
4395 ht
.pt
.y
= (short)HIWORD(lParam
);
4397 if (TREEVIEW_HitTest(infoPtr
, &ht
))
4399 infoPtr
->focusedItem
= ht
.hItem
;
4400 TREEVIEW_InvalidateItem(infoPtr
, infoPtr
->focusedItem
);
4401 TREEVIEW_InvalidateItem(infoPtr
, infoPtr
->selectedItem
);
4404 if (TREEVIEW_TrackMouse(infoPtr
, ht
.pt
))
4408 TREEVIEW_SendTreeviewDnDNotify(infoPtr
, TVN_BEGINRDRAGW
, ht
.hItem
, ht
.pt
);
4409 infoPtr
->dropItem
= ht
.hItem
;
4414 SetFocus(infoPtr
->hwnd
);
4415 if(!TREEVIEW_SendSimpleNotify(infoPtr
, NM_RCLICK
))
4417 /* Send a WM_CONTEXTMENU message in response to the RBUTTONUP */
4418 SendMessageW(infoPtr
->hwndNotify
, WM_CONTEXTMENU
,
4419 (WPARAM
)infoPtr
->hwnd
, (LPARAM
)GetMessagePos());
4425 TREEVIEW_InvalidateItem(infoPtr
, infoPtr
->focusedItem
);
4426 infoPtr
->focusedItem
= infoPtr
->selectedItem
;
4427 TREEVIEW_InvalidateItem(infoPtr
, infoPtr
->focusedItem
);
4434 TREEVIEW_CreateDragImage(TREEVIEW_INFO
*infoPtr
, LPARAM lParam
)
4436 TREEVIEW_ITEM
*dragItem
= (HTREEITEM
)lParam
;
4440 HBITMAP hbmp
, hOldbmp
;
4447 if (!(infoPtr
->himlNormal
))
4450 if (!dragItem
|| !TREEVIEW_ValidItem(infoPtr
, dragItem
))
4453 TREEVIEW_UpdateDispInfo(infoPtr
, dragItem
, TVIF_TEXT
);
4455 hwtop
= GetDesktopWindow();
4456 htopdc
= GetDC(hwtop
);
4457 hdc
= CreateCompatibleDC(htopdc
);
4459 hOldFont
= SelectObject(hdc
, infoPtr
->hFont
);
4461 if (dragItem
->pszText
)
4462 GetTextExtentPoint32W(hdc
, dragItem
->pszText
, lstrlenW(dragItem
->pszText
),
4465 GetTextExtentPoint32A(hdc
, "", 0, &size
);
4467 TRACE("%ld, %ld, %s\n", size
.cx
, size
.cy
, debugstr_w(dragItem
->pszText
));
4468 hbmp
= CreateCompatibleBitmap(htopdc
, size
.cx
, size
.cy
);
4469 hOldbmp
= SelectObject(hdc
, hbmp
);
4471 ImageList_GetIconSize(infoPtr
->himlNormal
, &cx
, &cy
);
4476 infoPtr
->dragList
= ImageList_Create(size
.cx
, size
.cy
, ILC_COLOR
, 10, 10);
4477 ImageList_Draw(infoPtr
->himlNormal
, dragItem
->iImage
, hdc
, 0, 0,
4481 ImageList_GetImageInfo (infoPtr->himlNormal, dragItem->hItem, &iminfo);
4482 ImageList_AddMasked (infoPtr->dragList, iminfo.hbmImage, CLR_DEFAULT);
4485 /* draw item text */
4487 SetRect(&rc
, cx
, 0, size
.cx
, size
.cy
);
4489 if (dragItem
->pszText
)
4490 DrawTextW(hdc
, dragItem
->pszText
, lstrlenW(dragItem
->pszText
), &rc
,
4493 SelectObject(hdc
, hOldFont
);
4494 SelectObject(hdc
, hOldbmp
);
4496 ImageList_Add(infoPtr
->dragList
, hbmp
, 0);
4500 ReleaseDC(hwtop
, htopdc
);
4502 return (LRESULT
)infoPtr
->dragList
;
4505 /* Selection ************************************************************/
4508 TREEVIEW_DoSelectItem(TREEVIEW_INFO
*infoPtr
, INT action
, HTREEITEM newSelect
,
4511 TREEVIEW_ITEM
*prevSelect
;
4513 assert(newSelect
== NULL
|| TREEVIEW_ValidItem(infoPtr
, newSelect
));
4515 TRACE("Entering item %p (%s), flag 0x%x, cause 0x%x, state 0x%x\n",
4516 newSelect
, TREEVIEW_ItemName(newSelect
), action
, cause
,
4517 newSelect
? newSelect
->state
: 0);
4519 /* reset and redraw focusedItem if focusedItem was set so we don't */
4520 /* have to worry about the previously focused item when we set a new one */
4521 TREEVIEW_InvalidateItem(infoPtr
, infoPtr
->focusedItem
);
4522 infoPtr
->focusedItem
= NULL
;
4526 case TVGN_CARET
|TVSI_NOSINGLEEXPAND
:
4527 FIXME("TVSI_NOSINGLEEXPAND specified.\n");
4530 prevSelect
= infoPtr
->selectedItem
;
4532 if (prevSelect
== newSelect
) {
4533 TREEVIEW_EnsureVisible(infoPtr
, infoPtr
->selectedItem
, FALSE
);
4537 if (TREEVIEW_SendTreeviewNotify(infoPtr
,
4540 TVIF_TEXT
| TVIF_HANDLE
| TVIF_STATE
| TVIF_PARAM
,
4546 prevSelect
->state
&= ~TVIS_SELECTED
;
4548 newSelect
->state
|= TVIS_SELECTED
;
4550 infoPtr
->selectedItem
= newSelect
;
4552 TREEVIEW_EnsureVisible(infoPtr
, infoPtr
->selectedItem
, FALSE
);
4554 TREEVIEW_InvalidateItem(infoPtr
, prevSelect
);
4555 TREEVIEW_InvalidateItem(infoPtr
, newSelect
);
4557 TREEVIEW_SendTreeviewNotify(infoPtr
,
4560 TVIF_TEXT
| TVIF_HANDLE
| TVIF_STATE
| TVIF_PARAM
,
4565 case TVGN_DROPHILITE
:
4566 prevSelect
= infoPtr
->dropItem
;
4569 prevSelect
->state
&= ~TVIS_DROPHILITED
;
4571 infoPtr
->dropItem
= newSelect
;
4574 newSelect
->state
|= TVIS_DROPHILITED
;
4576 TREEVIEW_Invalidate(infoPtr
, prevSelect
);
4577 TREEVIEW_Invalidate(infoPtr
, newSelect
);
4580 case TVGN_FIRSTVISIBLE
:
4581 if (newSelect
!= NULL
)
4583 TREEVIEW_EnsureVisible(infoPtr
, newSelect
, FALSE
);
4584 TREEVIEW_SetFirstVisible(infoPtr
, newSelect
, TRUE
);
4585 TREEVIEW_Invalidate(infoPtr
, NULL
);
4590 TRACE("Leaving state 0x%x\n", newSelect
? newSelect
->state
: 0);
4594 /* FIXME: handle NM_KILLFOCUS etc */
4596 TREEVIEW_SelectItem(TREEVIEW_INFO
*infoPtr
, INT wParam
, HTREEITEM item
)
4598 TREEVIEW_ITEM
*selection
= infoPtr
->selectedItem
;
4600 if (item
&& !TREEVIEW_ValidItem(infoPtr
, item
))
4603 if (item
== infoPtr
->selectedItem
)
4606 TRACE("%p (%s) %d\n", item
, TREEVIEW_ItemName(item
), wParam
);
4608 if (!TREEVIEW_DoSelectItem(infoPtr
, wParam
, item
, TVC_UNKNOWN
))
4611 TREEVIEW_SingleExpand(infoPtr
, selection
, item
);
4616 /*************************************************************************
4617 * TREEVIEW_ProcessLetterKeys
4619 * Processes keyboard messages generated by pressing the letter keys
4621 * What this does is perform a case insensitive search from the
4622 * current position with the following quirks:
4623 * - If two chars or more are pressed in quick succession we search
4624 * for the corresponding string (e.g. 'abc').
4625 * - If there is a delay we wipe away the current search string and
4626 * restart with just that char.
4627 * - If the user keeps pressing the same character, whether slowly or
4628 * fast, so that the search string is entirely composed of this
4629 * character ('aaaaa' for instance), then we search for first item
4630 * that starting with that character.
4631 * - If the user types the above character in quick succession, then
4632 * we must also search for the corresponding string ('aaaaa'), and
4633 * go to that string if there is a match.
4641 * - The current implementation has a list of characters it will
4642 * accept and it ignores everything else. In particular it will
4643 * ignore accentuated characters which seems to match what
4644 * Windows does. But I'm not sure it makes sense to follow
4646 * - We don't sound a beep when the search fails.
4647 * - The search should start from the focused item, not from the selected
4648 * item. One reason for this is to allow for multiple selections in trees.
4649 * But currently infoPtr->focusedItem does not seem very usable.
4653 * TREEVIEW_ProcessLetterKeys
4655 static INT
TREEVIEW_ProcessLetterKeys(TREEVIEW_INFO
*infoPtr
, WPARAM charCode
, LPARAM keyData
)
4658 HTREEITEM endidx
,idx
;
4660 WCHAR buffer
[MAX_PATH
];
4661 DWORD timestamp
,elapsed
;
4663 /* simple parameter checking */
4664 if (!charCode
|| !keyData
) return 0;
4666 /* only allow the valid WM_CHARs through */
4667 if (!iswalnum(charCode
) &&
4668 charCode
!= '.' && charCode
!= '`' && charCode
!= '!' &&
4669 charCode
!= '@' && charCode
!= '#' && charCode
!= '$' &&
4670 charCode
!= '%' && charCode
!= '^' && charCode
!= '&' &&
4671 charCode
!= '*' && charCode
!= '(' && charCode
!= ')' &&
4672 charCode
!= '-' && charCode
!= '_' && charCode
!= '+' &&
4673 charCode
!= '=' && charCode
!= '\\'&& charCode
!= ']' &&
4674 charCode
!= '}' && charCode
!= '[' && charCode
!= '{' &&
4675 charCode
!= '/' && charCode
!= '?' && charCode
!= '>' &&
4676 charCode
!= '<' && charCode
!= ',' && charCode
!= '~')
4679 /* compute how much time elapsed since last keypress */
4680 timestamp
= GetTickCount();
4681 if (timestamp
> infoPtr
->lastKeyPressTimestamp
) {
4682 elapsed
=timestamp
-infoPtr
->lastKeyPressTimestamp
;
4684 elapsed
=infoPtr
->lastKeyPressTimestamp
-timestamp
;
4687 /* update the search parameters */
4688 infoPtr
->lastKeyPressTimestamp
=timestamp
;
4689 if (elapsed
< KEY_DELAY
) {
4690 if (infoPtr
->nSearchParamLength
< ARRAY_SIZE(infoPtr
->szSearchParam
)) {
4691 infoPtr
->szSearchParam
[infoPtr
->nSearchParamLength
++]=charCode
;
4693 if (infoPtr
->charCode
!= charCode
) {
4694 infoPtr
->charCode
=charCode
=0;
4697 infoPtr
->charCode
=charCode
;
4698 infoPtr
->szSearchParam
[0]=charCode
;
4699 infoPtr
->nSearchParamLength
=1;
4700 /* Redundant with the 1 char string */
4704 /* and search from the current position */
4706 if (infoPtr
->selectedItem
!= NULL
) {
4707 endidx
=infoPtr
->selectedItem
;
4708 /* if looking for single character match,
4709 * then we must always move forward
4711 if (infoPtr
->nSearchParamLength
== 1)
4712 idx
=TREEVIEW_GetNextListItem(infoPtr
,endidx
);
4717 idx
=infoPtr
->root
->firstChild
;
4720 /* At the end point, sort out wrapping */
4723 /* If endidx is null, stop at the last item (ie top to bottom) */
4727 /* Otherwise, start again at the very beginning */
4728 idx
=infoPtr
->root
->firstChild
;
4730 /* But if we are stopping on the first child, end now! */
4731 if (idx
== endidx
) break;
4735 ZeroMemory(&item
, sizeof(item
));
4736 item
.mask
= TVIF_TEXT
;
4738 item
.pszText
= buffer
;
4739 item
.cchTextMax
= ARRAY_SIZE(buffer
);
4740 TREEVIEW_GetItemT( infoPtr
, &item
, TRUE
);
4742 /* check for a match */
4743 if (wcsnicmp(item
.pszText
,infoPtr
->szSearchParam
,infoPtr
->nSearchParamLength
) == 0) {
4746 } else if ( (charCode
!= 0) && (nItem
== NULL
) &&
4747 (nItem
!= infoPtr
->selectedItem
) &&
4748 (wcsnicmp(item
.pszText
,infoPtr
->szSearchParam
,1) == 0) ) {
4749 /* This would work but we must keep looking for a longer match */
4752 idx
=TREEVIEW_GetNextListItem(infoPtr
,idx
);
4753 } while (idx
!= endidx
);
4755 if (nItem
!= NULL
) {
4756 if (TREEVIEW_DoSelectItem(infoPtr
, TVGN_CARET
, nItem
, TVC_BYKEYBOARD
)) {
4757 TREEVIEW_EnsureVisible(infoPtr
, nItem
, FALSE
);
4764 /* Scrolling ************************************************************/
4767 TREEVIEW_EnsureVisible(TREEVIEW_INFO
*infoPtr
, HTREEITEM item
, BOOL bHScroll
)
4770 BOOL hasFirstVisible
= infoPtr
->firstVisible
!= NULL
;
4771 HTREEITEM newFirstVisible
= NULL
;
4772 int visible_pos
= -1;
4774 if (!TREEVIEW_ValidItem(infoPtr
, item
))
4777 if (!ISVISIBLE(item
))
4779 /* Expand parents as necessary. */
4782 /* see if we are trying to ensure that root is visible */
4783 if((item
!= infoPtr
->root
) && TREEVIEW_ValidItem(infoPtr
, item
))
4784 parent
= item
->parent
;
4786 parent
= item
; /* this item is the topmost item */
4788 while (parent
!= infoPtr
->root
)
4790 if (!(parent
->state
& TVIS_EXPANDED
))
4791 TREEVIEW_Expand(infoPtr
, parent
, FALSE
, TRUE
);
4793 parent
= parent
->parent
;
4797 viscount
= TREEVIEW_GetVisibleCount(infoPtr
);
4799 TRACE("%p (%s) %ld - %ld viscount(%d)\n", item
, TREEVIEW_ItemName(item
), item
->visibleOrder
,
4800 hasFirstVisible
? infoPtr
->firstVisible
->visibleOrder
: -1, viscount
);
4802 if (hasFirstVisible
)
4803 visible_pos
= item
->visibleOrder
- infoPtr
->firstVisible
->visibleOrder
;
4805 if (visible_pos
< 0)
4807 /* item is before the start of the list: put it at the top. */
4808 newFirstVisible
= item
;
4810 else if (visible_pos
>= viscount
4811 /* Sometimes, before we are displayed, GVC is 0, causing us to
4812 * spuriously scroll up. */
4813 && visible_pos
> 0 && !(infoPtr
->dwStyle
& TVS_NOSCROLL
) )
4815 /* item is past the end of the list. */
4816 int scroll
= visible_pos
- viscount
;
4818 newFirstVisible
= TREEVIEW_GetListItem(infoPtr
, infoPtr
->firstVisible
,
4824 /* Scroll window so item's text is visible as much as possible */
4825 /* Calculation of amount of extra space is taken from EditLabel code */
4827 TEXTMETRICW textMetric
;
4828 HDC hdc
= GetWindowDC(infoPtr
->hwnd
);
4830 x
= item
->textWidth
;
4832 GetTextMetricsW(hdc
, &textMetric
);
4833 ReleaseDC(infoPtr
->hwnd
, hdc
);
4835 x
+= (textMetric
.tmMaxCharWidth
* 2);
4836 x
= max(x
, textMetric
.tmMaxCharWidth
* 3);
4838 if (item
->textOffset
< 0)
4839 pos
= item
->textOffset
;
4840 else if (item
->textOffset
+ x
> infoPtr
->clientWidth
)
4842 if (x
> infoPtr
->clientWidth
)
4843 pos
= item
->textOffset
;
4845 pos
= item
->textOffset
+ x
- infoPtr
->clientWidth
;
4850 TREEVIEW_HScroll(infoPtr
, MAKEWPARAM(SB_THUMBPOSITION
, infoPtr
->scrollX
+ pos
));
4853 if (newFirstVisible
!= NULL
&& newFirstVisible
!= infoPtr
->firstVisible
)
4855 TREEVIEW_SetFirstVisible(infoPtr
, newFirstVisible
, TRUE
);
4864 TREEVIEW_SetFirstVisible(TREEVIEW_INFO
*infoPtr
,
4865 TREEVIEW_ITEM
*newFirstVisible
,
4866 BOOL bUpdateScrollPos
)
4870 TRACE("%p: %s\n", newFirstVisible
, TREEVIEW_ItemName(newFirstVisible
));
4872 if (newFirstVisible
!= NULL
)
4874 /* Prevent an empty gap from appearing at the bottom... */
4875 gap_size
= TREEVIEW_GetVisibleCount(infoPtr
)
4876 - infoPtr
->maxVisibleOrder
+ newFirstVisible
->visibleOrder
;
4880 newFirstVisible
= TREEVIEW_GetListItem(infoPtr
, newFirstVisible
,
4883 /* ... unless we just don't have enough items. */
4884 if (newFirstVisible
== NULL
)
4885 newFirstVisible
= infoPtr
->root
->firstChild
;
4889 if (infoPtr
->firstVisible
!= newFirstVisible
)
4891 if (infoPtr
->firstVisible
== NULL
|| newFirstVisible
== NULL
)
4893 infoPtr
->firstVisible
= newFirstVisible
;
4894 TREEVIEW_Invalidate(infoPtr
, NULL
);
4898 TREEVIEW_ITEM
*item
;
4899 int scroll
= infoPtr
->uItemHeight
*
4900 (infoPtr
->firstVisible
->visibleOrder
4901 - newFirstVisible
->visibleOrder
);
4903 infoPtr
->firstVisible
= newFirstVisible
;
4905 for (item
= infoPtr
->root
->firstChild
; item
!= NULL
;
4906 item
= TREEVIEW_GetNextListItem(infoPtr
, item
))
4908 item
->rect
.top
+= scroll
;
4909 item
->rect
.bottom
+= scroll
;
4912 if (bUpdateScrollPos
)
4913 SetScrollPos(infoPtr
->hwnd
, SB_VERT
,
4914 newFirstVisible
->visibleOrder
, TRUE
);
4916 ScrollWindowEx(infoPtr
->hwnd
, 0, scroll
, NULL
, NULL
, NULL
, NULL
, SW_ERASE
| SW_INVALIDATE
);
4921 /************************************************************************
4922 * VScroll is always in units of visible items. i.e. we always have a
4923 * visible item aligned to the top of the control. (Unless we have no
4927 TREEVIEW_VScroll(TREEVIEW_INFO
*infoPtr
, WPARAM wParam
)
4929 TREEVIEW_ITEM
*oldFirstVisible
= infoPtr
->firstVisible
;
4930 TREEVIEW_ITEM
*newFirstVisible
= NULL
;
4932 int nScrollCode
= LOWORD(wParam
);
4934 TRACE("wp %Ix\n", wParam
);
4936 if (!(infoPtr
->uInternalStatus
& TV_VSCROLL
))
4939 if (!oldFirstVisible
)
4941 assert(infoPtr
->root
->firstChild
== NULL
);
4945 switch (nScrollCode
)
4948 newFirstVisible
= infoPtr
->root
->firstChild
;
4952 newFirstVisible
= TREEVIEW_GetLastListItem(infoPtr
, infoPtr
->root
);
4956 newFirstVisible
= TREEVIEW_GetPrevListItem(infoPtr
, oldFirstVisible
);
4960 newFirstVisible
= TREEVIEW_GetNextListItem(infoPtr
, oldFirstVisible
);
4964 newFirstVisible
= TREEVIEW_GetListItem(infoPtr
, oldFirstVisible
,
4965 -max(1, TREEVIEW_GetVisibleCount(infoPtr
)));
4969 newFirstVisible
= TREEVIEW_GetListItem(infoPtr
, oldFirstVisible
,
4970 max(1, TREEVIEW_GetVisibleCount(infoPtr
)));
4974 case SB_THUMBPOSITION
:
4975 newFirstVisible
= TREEVIEW_GetListItem(infoPtr
,
4976 infoPtr
->root
->firstChild
,
4977 (LONG
)(SHORT
)HIWORD(wParam
));
4984 if (newFirstVisible
!= NULL
)
4986 if (newFirstVisible
!= oldFirstVisible
)
4987 TREEVIEW_SetFirstVisible(infoPtr
, newFirstVisible
,
4988 nScrollCode
!= SB_THUMBTRACK
);
4989 else if (nScrollCode
== SB_THUMBPOSITION
)
4990 SetScrollPos(infoPtr
->hwnd
, SB_VERT
,
4991 newFirstVisible
->visibleOrder
, TRUE
);
4998 TREEVIEW_HScroll(TREEVIEW_INFO
*infoPtr
, WPARAM wParam
)
5001 int scrollX
= infoPtr
->scrollX
;
5002 int nScrollCode
= LOWORD(wParam
);
5004 TRACE("wp %Ix\n", wParam
);
5006 if (!(infoPtr
->uInternalStatus
& TV_HSCROLL
))
5009 maxWidth
= infoPtr
->treeWidth
- infoPtr
->clientWidth
;
5010 /* shall never occur */
5017 switch (nScrollCode
)
5020 scrollX
-= infoPtr
->uItemHeight
;
5023 scrollX
+= infoPtr
->uItemHeight
;
5026 scrollX
-= infoPtr
->clientWidth
;
5029 scrollX
+= infoPtr
->clientWidth
;
5033 case SB_THUMBPOSITION
:
5034 scrollX
= (int)(SHORT
)HIWORD(wParam
);
5041 if (scrollX
> maxWidth
)
5043 else if (scrollX
< 0)
5047 if (scrollX
!= infoPtr
->scrollX
)
5049 TREEVIEW_ITEM
*item
;
5050 LONG scroll_pixels
= infoPtr
->scrollX
- scrollX
;
5052 for (item
= infoPtr
->root
->firstChild
; item
!= NULL
;
5053 item
= TREEVIEW_GetNextListItem(infoPtr
, item
))
5055 item
->linesOffset
+= scroll_pixels
;
5056 item
->stateOffset
+= scroll_pixels
;
5057 item
->imageOffset
+= scroll_pixels
;
5058 item
->textOffset
+= scroll_pixels
;
5061 ScrollWindow(infoPtr
->hwnd
, scroll_pixels
, 0, NULL
, NULL
);
5062 infoPtr
->scrollX
= scrollX
;
5063 UpdateWindow(infoPtr
->hwnd
);
5066 if (nScrollCode
!= SB_THUMBTRACK
)
5067 SetScrollPos(infoPtr
->hwnd
, SB_HORZ
, scrollX
, TRUE
);
5073 TREEVIEW_MouseWheel(TREEVIEW_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
5076 INT pulScrollLines
= 3;
5078 if (wParam
& (MK_SHIFT
| MK_CONTROL
))
5079 return DefWindowProcW(infoPtr
->hwnd
, WM_MOUSEWHEEL
, wParam
, lParam
);
5081 if (infoPtr
->firstVisible
== NULL
)
5084 SystemParametersInfoW(SPI_GETWHEELSCROLLLINES
, 0, &pulScrollLines
, 0);
5086 wheelDelta
= GET_WHEEL_DELTA_WPARAM(wParam
);
5087 /* if scrolling changes direction, ignore left overs */
5088 if ((wheelDelta
< 0 && infoPtr
->wheelRemainder
< 0) ||
5089 (wheelDelta
> 0 && infoPtr
->wheelRemainder
> 0))
5090 infoPtr
->wheelRemainder
+= wheelDelta
;
5092 infoPtr
->wheelRemainder
= wheelDelta
;
5094 if (infoPtr
->wheelRemainder
&& pulScrollLines
)
5100 lineScroll
= pulScrollLines
* infoPtr
->wheelRemainder
/ WHEEL_DELTA
;
5101 infoPtr
->wheelRemainder
-= WHEEL_DELTA
* lineScroll
/ pulScrollLines
;
5103 newDy
= infoPtr
->firstVisible
->visibleOrder
- lineScroll
;
5104 maxDy
= infoPtr
->maxVisibleOrder
;
5112 TREEVIEW_VScroll(infoPtr
, MAKEWPARAM(SB_THUMBPOSITION
, newDy
));
5117 /* Create/Destroy *******************************************************/
5120 TREEVIEW_Create(HWND hwnd
, const CREATESTRUCTW
*lpcs
)
5123 TREEVIEW_INFO
*infoPtr
;
5126 TRACE("wnd %p, style %#lx\n", hwnd
, GetWindowLongW(hwnd
, GWL_STYLE
));
5128 if (!(infoPtr
= Alloc(sizeof(*infoPtr
))))
5130 ERR("could not allocate info memory!\n");
5134 SetWindowLongPtrW(hwnd
, 0, (DWORD_PTR
)infoPtr
);
5136 infoPtr
->hwnd
= hwnd
;
5137 infoPtr
->dwStyle
= GetWindowLongW(hwnd
, GWL_STYLE
);
5139 infoPtr
->uNumItems
= 0;
5140 infoPtr
->cdmode
= 0;
5141 infoPtr
->uScrollTime
= 300; /* milliseconds */
5142 infoPtr
->bRedraw
= TRUE
;
5144 GetClientRect(hwnd
, &rcClient
);
5146 /* No scroll bars yet. */
5147 infoPtr
->clientWidth
= rcClient
.right
;
5148 infoPtr
->clientHeight
= rcClient
.bottom
;
5149 infoPtr
->uInternalStatus
= 0;
5151 infoPtr
->treeWidth
= 0;
5152 infoPtr
->treeHeight
= 0;
5154 infoPtr
->uIndent
= MINIMUM_INDENT
;
5155 infoPtr
->selectedItem
= NULL
;
5156 infoPtr
->focusedItem
= NULL
;
5157 infoPtr
->hotItem
= NULL
;
5158 infoPtr
->editItem
= NULL
;
5159 infoPtr
->firstVisible
= NULL
;
5160 infoPtr
->maxVisibleOrder
= 0;
5161 infoPtr
->dropItem
= NULL
;
5162 infoPtr
->insertMarkItem
= NULL
;
5163 infoPtr
->insertBeforeorAfter
= 0;
5166 infoPtr
->scrollX
= 0;
5167 infoPtr
->wheelRemainder
= 0;
5169 infoPtr
->clrBk
= CLR_NONE
; /* use system color */
5170 infoPtr
->clrText
= CLR_NONE
; /* use system color */
5171 infoPtr
->clrLine
= CLR_DEFAULT
;
5172 infoPtr
->clrInsertMark
= CLR_DEFAULT
;
5176 infoPtr
->hwndEdit
= NULL
;
5177 infoPtr
->wpEditOrig
= NULL
;
5178 infoPtr
->bIgnoreEditKillFocus
= FALSE
;
5179 infoPtr
->bLabelChanged
= FALSE
;
5181 infoPtr
->himlNormal
= NULL
;
5182 infoPtr
->himlState
= NULL
;
5183 infoPtr
->normalImageWidth
= 0;
5184 infoPtr
->normalImageHeight
= 0;
5185 infoPtr
->stateImageWidth
= 0;
5186 infoPtr
->stateImageHeight
= 0;
5188 infoPtr
->items
= DPA_Create(16);
5190 SystemParametersInfoW(SPI_GETICONTITLELOGFONT
, sizeof(lf
), &lf
, 0);
5191 infoPtr
->hFont
= infoPtr
->hDefaultFont
= CreateFontIndirectW(&lf
);
5192 infoPtr
->hBoldFont
= TREEVIEW_CreateBoldFont(infoPtr
->hFont
);
5193 infoPtr
->hUnderlineFont
= TREEVIEW_CreateUnderlineFont(infoPtr
->hFont
);
5194 infoPtr
->hBoldUnderlineFont
= TREEVIEW_CreateBoldUnderlineFont(infoPtr
->hFont
);
5195 infoPtr
->hcurHand
= LoadCursorW(NULL
, (LPWSTR
)IDC_HAND
);
5197 infoPtr
->uItemHeight
= TREEVIEW_NaturalHeight(infoPtr
);
5199 infoPtr
->root
= TREEVIEW_AllocateItem(infoPtr
);
5200 infoPtr
->root
->state
= TVIS_EXPANDED
;
5201 infoPtr
->root
->iLevel
= -1;
5202 infoPtr
->root
->visibleOrder
= -1;
5204 infoPtr
->hwndNotify
= lpcs
->hwndParent
;
5205 infoPtr
->hwndToolTip
= 0;
5207 /* Determine what type of notify should be issued (sets infoPtr->bNtfUnicode) */
5208 TREEVIEW_NotifyFormat(infoPtr
, infoPtr
->hwndNotify
, NF_REQUERY
);
5210 if (!(infoPtr
->dwStyle
& TVS_NOTOOLTIPS
))
5211 infoPtr
->hwndToolTip
= CreateWindowExW(0, TOOLTIPS_CLASSW
, NULL
, WS_POPUP
,
5212 CW_USEDEFAULT
, CW_USEDEFAULT
, CW_USEDEFAULT
, CW_USEDEFAULT
,
5215 /* Make sure actual scrollbar state is consistent with uInternalStatus */
5216 ShowScrollBar(hwnd
, SB_VERT
, FALSE
);
5217 ShowScrollBar(hwnd
, SB_HORZ
, FALSE
);
5219 OpenThemeData (hwnd
, themeClass
);
5226 TREEVIEW_Destroy(TREEVIEW_INFO
*infoPtr
)
5230 /* free item data */
5231 TREEVIEW_RemoveTree(infoPtr
);
5232 /* root isn't freed with other items */
5233 TREEVIEW_FreeItem(infoPtr
, infoPtr
->root
);
5234 DPA_Destroy(infoPtr
->items
);
5236 /* Restore original wndproc */
5237 if (infoPtr
->hwndEdit
)
5238 SetWindowLongPtrW(infoPtr
->hwndEdit
, GWLP_WNDPROC
,
5239 (DWORD_PTR
)infoPtr
->wpEditOrig
);
5241 CloseThemeData (GetWindowTheme (infoPtr
->hwnd
));
5243 /* Deassociate treeview from the window before doing anything drastic. */
5244 SetWindowLongPtrW(infoPtr
->hwnd
, 0, 0);
5246 DeleteObject(infoPtr
->hDefaultFont
);
5247 DeleteObject(infoPtr
->hBoldFont
);
5248 DeleteObject(infoPtr
->hUnderlineFont
);
5249 DeleteObject(infoPtr
->hBoldUnderlineFont
);
5250 DestroyWindow(infoPtr
->hwndToolTip
);
5256 /* Miscellaneous Messages ***********************************************/
5259 TREEVIEW_ScrollKeyDown(TREEVIEW_INFO
*infoPtr
, WPARAM key
)
5267 #define SCROLL_ENTRY(dir, code) { ((dir) << 7) | (code) }
5268 SCROLL_ENTRY(SB_VERT
, SB_PAGEUP
), /* VK_PRIOR */
5269 SCROLL_ENTRY(SB_VERT
, SB_PAGEDOWN
), /* VK_NEXT */
5270 SCROLL_ENTRY(SB_VERT
, SB_BOTTOM
), /* VK_END */
5271 SCROLL_ENTRY(SB_VERT
, SB_TOP
), /* VK_HOME */
5272 SCROLL_ENTRY(SB_HORZ
, SB_LINEUP
), /* VK_LEFT */
5273 SCROLL_ENTRY(SB_VERT
, SB_LINEUP
), /* VK_UP */
5274 SCROLL_ENTRY(SB_HORZ
, SB_LINEDOWN
), /* VK_RIGHT */
5275 SCROLL_ENTRY(SB_VERT
, SB_LINEDOWN
) /* VK_DOWN */
5279 if (key
>= VK_PRIOR
&& key
<= VK_DOWN
)
5281 unsigned char code
= scroll
[key
- VK_PRIOR
].code
;
5283 (((code
& (1 << 7)) == (SB_HORZ
<< 7))
5285 : TREEVIEW_VScroll
)(infoPtr
, code
& 0x7F);
5291 /************************************************************************
5294 * VK_UP Move selection to the previous non-hidden item.
5295 * VK_DOWN Move selection to the next non-hidden item.
5296 * VK_HOME Move selection to the first item.
5297 * VK_END Move selection to the last item.
5298 * VK_LEFT If expanded then collapse, otherwise move to parent.
5299 * VK_RIGHT If collapsed then expand, otherwise move to first child.
5301 * VK_SUBTRACT Collapse.
5302 * VK_MULTIPLY Expand all.
5303 * VK_PRIOR Move up GetVisibleCount items.
5304 * VK_NEXT Move down GetVisibleCount items.
5305 * VK_BACK Move to parent.
5306 * CTRL-Left,Right,Up,Down,PgUp,PgDown,Home,End: Scroll without changing selection
5309 TREEVIEW_KeyDown(TREEVIEW_INFO
*infoPtr
, WPARAM wParam
)
5311 /* If it is non-NULL and different, it will be selected and visible. */
5312 TREEVIEW_ITEM
*newSelection
= NULL
;
5313 TREEVIEW_ITEM
*prevItem
= infoPtr
->selectedItem
;
5314 NMTVKEYDOWN nmkeydown
;
5316 TRACE("%Ix\n", wParam
);
5318 nmkeydown
.wVKey
= wParam
;
5319 nmkeydown
.flags
= 0;
5320 TREEVIEW_SendRealNotify(infoPtr
, TVN_KEYDOWN
, &nmkeydown
.hdr
);
5322 if (prevItem
== NULL
)
5325 if (GetAsyncKeyState(VK_CONTROL
) & 0x8000)
5326 return TREEVIEW_ScrollKeyDown(infoPtr
, wParam
);
5331 newSelection
= TREEVIEW_GetPrevListItem(infoPtr
, prevItem
);
5333 newSelection
= infoPtr
->root
->firstChild
;
5337 newSelection
= TREEVIEW_GetNextListItem(infoPtr
, prevItem
);
5341 TREEVIEW_SendSimpleNotify(infoPtr
, NM_RETURN
);
5345 newSelection
= infoPtr
->root
->firstChild
;
5349 newSelection
= TREEVIEW_GetLastListItem(infoPtr
, infoPtr
->root
);
5353 if (prevItem
->state
& TVIS_EXPANDED
)
5355 TREEVIEW_Collapse(infoPtr
, prevItem
, FALSE
, TRUE
);
5357 else if (prevItem
->parent
!= infoPtr
->root
)
5359 newSelection
= prevItem
->parent
;
5364 if (TREEVIEW_HasChildren(infoPtr
, prevItem
))
5366 if (!(prevItem
->state
& TVIS_EXPANDED
))
5367 TREEVIEW_Expand(infoPtr
, prevItem
, FALSE
, TRUE
);
5370 newSelection
= prevItem
->firstChild
;
5377 TREEVIEW_ExpandAll(infoPtr
, prevItem
);
5381 TREEVIEW_Expand(infoPtr
, prevItem
, FALSE
, TRUE
);
5385 TREEVIEW_Collapse(infoPtr
, prevItem
, FALSE
, TRUE
);
5390 = TREEVIEW_GetListItem(infoPtr
, prevItem
,
5391 -TREEVIEW_GetVisibleCount(infoPtr
));
5396 = TREEVIEW_GetListItem(infoPtr
, prevItem
,
5397 TREEVIEW_GetVisibleCount(infoPtr
));
5401 newSelection
= prevItem
->parent
;
5402 if (newSelection
== infoPtr
->root
)
5403 newSelection
= NULL
;
5407 if (infoPtr
->dwStyle
& TVS_CHECKBOXES
)
5408 TREEVIEW_ToggleItemState(infoPtr
, prevItem
);
5412 if (newSelection
&& newSelection
!= prevItem
)
5414 if (TREEVIEW_DoSelectItem(infoPtr
, TVGN_CARET
, newSelection
,
5417 TREEVIEW_EnsureVisible(infoPtr
, newSelection
, FALSE
);
5425 TREEVIEW_MouseLeave (TREEVIEW_INFO
* infoPtr
)
5427 /* remove hot effect from item */
5428 TREEVIEW_InvalidateItem(infoPtr
, infoPtr
->hotItem
);
5429 infoPtr
->hotItem
= NULL
;
5435 TREEVIEW_MouseMove (TREEVIEW_INFO
* infoPtr
, LPARAM lParam
)
5437 TRACKMOUSEEVENT trackinfo
;
5438 TREEVIEW_ITEM
* item
;
5442 if (!(infoPtr
->dwStyle
& TVS_TRACKSELECT
)) return 0;
5444 /* fill in the TRACKMOUSEEVENT struct */
5445 trackinfo
.cbSize
= sizeof(TRACKMOUSEEVENT
);
5446 trackinfo
.dwFlags
= TME_QUERY
;
5447 trackinfo
.hwndTrack
= infoPtr
->hwnd
;
5449 /* call _TrackMouseEvent to see if we are currently tracking for this hwnd */
5450 _TrackMouseEvent(&trackinfo
);
5452 /* Make sure tracking is enabled so we receive a WM_MOUSELEAVE message */
5453 if(!(trackinfo
.dwFlags
& TME_LEAVE
))
5455 trackinfo
.dwFlags
= TME_LEAVE
; /* notify upon leaving */
5456 trackinfo
.hwndTrack
= infoPtr
->hwnd
;
5457 /* do it as fast as possible, minimal systimer latency will be used */
5458 trackinfo
.dwHoverTime
= 1;
5460 /* call TRACKMOUSEEVENT so we receive a WM_MOUSELEAVE message */
5461 /* and can properly deactivate the hot item */
5462 _TrackMouseEvent(&trackinfo
);
5465 ht
.pt
.x
= (short)LOWORD(lParam
);
5466 ht
.pt
.y
= (short)HIWORD(lParam
);
5468 item
= TREEVIEW_HitTest(infoPtr
, &ht
);
5469 item_hit
= TREEVIEW_IsItemHit(infoPtr
, &ht
);
5470 if ((item
!= infoPtr
->hotItem
) || !item_hit
)
5472 /* redraw old hot item */
5473 TREEVIEW_InvalidateItem(infoPtr
, infoPtr
->hotItem
);
5474 infoPtr
->hotItem
= NULL
;
5475 if (item
&& item_hit
)
5477 infoPtr
->hotItem
= item
;
5478 /* redraw new hot item */
5479 TREEVIEW_InvalidateItem(infoPtr
, infoPtr
->hotItem
);
5486 /* Draw themed border */
5487 static BOOL
TREEVIEW_NCPaint (const TREEVIEW_INFO
*infoPtr
, HRGN region
, LPARAM lParam
)
5496 ex_style
= GetWindowLongW(infoPtr
->hwnd
, GWL_EXSTYLE
);
5497 if (!(ex_style
& WS_EX_CLIENTEDGE
))
5498 return DefWindowProcW(infoPtr
->hwnd
, WM_NCPAINT
, (WPARAM
)region
, lParam
);
5500 theme
= GetWindowTheme(infoPtr
->hwnd
);
5502 return DefWindowProcW (infoPtr
->hwnd
, WM_NCPAINT
, (WPARAM
)region
, lParam
);
5504 GetWindowRect(infoPtr
->hwnd
, &r
);
5506 cxEdge
= GetSystemMetrics(SM_CXEDGE
);
5507 cyEdge
= GetSystemMetrics(SM_CYEDGE
);
5508 cliprgn
= CreateRectRgn (r
.left
+ cxEdge
, r
.top
+ cyEdge
,
5509 r
.right
- cxEdge
, r
.bottom
- cyEdge
);
5510 if (region
!= (HRGN
)1)
5511 CombineRgn (cliprgn
, cliprgn
, region
, RGN_AND
);
5512 OffsetRect(&r
, -r
.left
, -r
.top
);
5514 dc
= GetDCEx(infoPtr
->hwnd
, region
, DCX_WINDOW
|DCX_INTERSECTRGN
);
5516 if (IsThemeBackgroundPartiallyTransparent (theme
, 0, 0))
5517 DrawThemeParentBackground(infoPtr
->hwnd
, dc
, &r
);
5518 DrawThemeBackground (theme
, dc
, 0, 0, &r
, 0);
5519 ReleaseDC(infoPtr
->hwnd
, dc
);
5521 /* Call default proc to get the scrollbars etc. painted */
5522 DefWindowProcW (infoPtr
->hwnd
, WM_NCPAINT
, (WPARAM
)cliprgn
, 0);
5523 DeleteObject(cliprgn
);
5529 TREEVIEW_Notify(const TREEVIEW_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
5531 LPNMHDR lpnmh
= (LPNMHDR
)lParam
;
5533 if (lpnmh
->code
== PGN_CALCSIZE
) {
5534 LPNMPGCALCSIZE lppgc
= (LPNMPGCALCSIZE
)lParam
;
5536 if (lppgc
->dwFlag
== PGF_CALCWIDTH
) {
5537 lppgc
->iWidth
= infoPtr
->treeWidth
;
5538 TRACE("got PGN_CALCSIZE, returning horz size = %ld, client= %ld\n",
5539 infoPtr
->treeWidth
, infoPtr
->clientWidth
);
5542 lppgc
->iHeight
= infoPtr
->treeHeight
;
5543 TRACE("got PGN_CALCSIZE, returning vert size = %ld, client = %ld\n", infoPtr
->treeHeight
,
5544 infoPtr
->clientHeight
);
5548 return DefWindowProcW(infoPtr
->hwnd
, WM_NOTIFY
, wParam
, lParam
);
5552 TREEVIEW_Size(TREEVIEW_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
5554 if (wParam
== SIZE_RESTORED
)
5556 infoPtr
->clientWidth
= (short)LOWORD(lParam
);
5557 infoPtr
->clientHeight
= (short)HIWORD(lParam
);
5559 TREEVIEW_RecalculateVisibleOrder(infoPtr
, NULL
);
5560 TREEVIEW_SetFirstVisible(infoPtr
, infoPtr
->firstVisible
, TRUE
);
5561 TREEVIEW_UpdateScrollBars(infoPtr
);
5565 FIXME("WM_SIZE flag %Ix %Ix not handled\n", wParam
, lParam
);
5568 TREEVIEW_Invalidate(infoPtr
, NULL
);
5573 TREEVIEW_StyleChanged(TREEVIEW_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
5575 TRACE("%Ix, %Ix.\n", wParam
, lParam
);
5577 if (wParam
== GWL_STYLE
)
5579 DWORD dwNewStyle
= ((LPSTYLESTRUCT
)lParam
)->styleNew
;
5581 if ((infoPtr
->dwStyle
^ dwNewStyle
) & TVS_CHECKBOXES
)
5583 if (dwNewStyle
& TVS_CHECKBOXES
)
5585 TREEVIEW_InitCheckboxes(infoPtr
);
5586 TRACE("checkboxes enabled\n");
5588 /* set all items to state image index 1 */
5589 TREEVIEW_ResetImageStateIndex(infoPtr
, infoPtr
->root
);
5593 FIXME("tried to disable checkboxes\n");
5597 if ((infoPtr
->dwStyle
^ dwNewStyle
) & TVS_NOTOOLTIPS
)
5599 if (infoPtr
->dwStyle
& TVS_NOTOOLTIPS
)
5601 infoPtr
->hwndToolTip
= COMCTL32_CreateToolTip(infoPtr
->hwnd
);
5602 TRACE("tooltips enabled\n");
5606 DestroyWindow(infoPtr
->hwndToolTip
);
5607 infoPtr
->hwndToolTip
= 0;
5608 TRACE("tooltips disabled\n");
5612 infoPtr
->dwStyle
= dwNewStyle
;
5615 TREEVIEW_EndEditLabelNow(infoPtr
, TRUE
);
5616 TREEVIEW_UpdateSubTree(infoPtr
, infoPtr
->root
);
5617 TREEVIEW_UpdateScrollBars(infoPtr
);
5623 TREEVIEW_SetCursor(const TREEVIEW_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
5625 TREEVIEW_ITEM
* item
;
5629 GetCursorPos(&ht
.pt
);
5630 ScreenToClient(infoPtr
->hwnd
, &ht
.pt
);
5632 item
= TREEVIEW_HitTest(infoPtr
, &ht
);
5634 memset(&nmmouse
, 0, sizeof(nmmouse
));
5637 nmmouse
.dwItemSpec
= (DWORD_PTR
)item
;
5638 nmmouse
.dwItemData
= item
->lParam
;
5642 nmmouse
.dwHitInfo
= lParam
;
5643 if (TREEVIEW_SendRealNotify(infoPtr
, NM_SETCURSOR
, &nmmouse
.hdr
))
5646 if (item
&& (infoPtr
->dwStyle
& TVS_TRACKSELECT
) && TREEVIEW_IsItemHit(infoPtr
, &ht
))
5648 SetCursor(infoPtr
->hcurHand
);
5652 return DefWindowProcW(infoPtr
->hwnd
, WM_SETCURSOR
, wParam
, lParam
);
5656 TREEVIEW_SetFocus(TREEVIEW_INFO
*infoPtr
)
5660 if (!infoPtr
->selectedItem
)
5662 TREEVIEW_DoSelectItem(infoPtr
, TVGN_CARET
, infoPtr
->firstVisible
,
5666 TREEVIEW_Invalidate(infoPtr
, infoPtr
->selectedItem
);
5667 TREEVIEW_SendSimpleNotify(infoPtr
, NM_SETFOCUS
);
5672 TREEVIEW_KillFocus(const TREEVIEW_INFO
*infoPtr
)
5676 TREEVIEW_Invalidate(infoPtr
, infoPtr
->selectedItem
);
5677 UpdateWindow(infoPtr
->hwnd
);
5678 TREEVIEW_SendSimpleNotify(infoPtr
, NM_KILLFOCUS
);
5682 /* update theme after a WM_THEMECHANGED message */
5683 static LRESULT
TREEVIEW_ThemeChanged(const TREEVIEW_INFO
*infoPtr
)
5685 HTHEME theme
= GetWindowTheme (infoPtr
->hwnd
);
5686 CloseThemeData (theme
);
5687 OpenThemeData (infoPtr
->hwnd
, themeClass
);
5688 InvalidateRect (infoPtr
->hwnd
, NULL
, TRUE
);
5693 static LRESULT WINAPI
5694 TREEVIEW_WindowProc(HWND hwnd
, UINT uMsg
, WPARAM wParam
, LPARAM lParam
)
5696 TREEVIEW_INFO
*infoPtr
= TREEVIEW_GetInfoPtr(hwnd
);
5698 TRACE("hwnd %p, msg %04x, wp %Ix, lp %Ix\n", hwnd
, uMsg
, wParam
, lParam
);
5700 if (infoPtr
) TREEVIEW_VerifyTree(infoPtr
);
5703 if (uMsg
== WM_CREATE
)
5704 TREEVIEW_Create(hwnd
, (LPCREATESTRUCTW
)lParam
);
5711 case TVM_CREATEDRAGIMAGE
:
5712 return TREEVIEW_CreateDragImage(infoPtr
, lParam
);
5714 case TVM_DELETEITEM
:
5715 return TREEVIEW_DeleteItem(infoPtr
, (HTREEITEM
)lParam
);
5717 case TVM_EDITLABELA
:
5718 case TVM_EDITLABELW
:
5719 return (LRESULT
)TREEVIEW_EditLabel(infoPtr
, (HTREEITEM
)lParam
);
5721 case TVM_ENDEDITLABELNOW
:
5722 return TREEVIEW_EndEditLabelNow(infoPtr
, (BOOL
)wParam
);
5724 case TVM_ENSUREVISIBLE
:
5725 return TREEVIEW_EnsureVisible(infoPtr
, (HTREEITEM
)lParam
, TRUE
);
5728 return TREEVIEW_ExpandMsg(infoPtr
, (UINT
)wParam
, (HTREEITEM
)lParam
);
5730 case TVM_GETBKCOLOR
:
5731 return TREEVIEW_GetBkColor(infoPtr
);
5734 return TREEVIEW_GetCount(infoPtr
);
5736 case TVM_GETEDITCONTROL
:
5737 return TREEVIEW_GetEditControl(infoPtr
);
5739 case TVM_GETIMAGELIST
:
5740 return TREEVIEW_GetImageList(infoPtr
, wParam
);
5743 return TREEVIEW_GetIndent(infoPtr
);
5745 case TVM_GETINSERTMARKCOLOR
:
5746 return TREEVIEW_GetInsertMarkColor(infoPtr
);
5748 case TVM_GETISEARCHSTRINGA
:
5749 FIXME("Unimplemented msg TVM_GETISEARCHSTRINGA\n");
5752 case TVM_GETISEARCHSTRINGW
:
5753 FIXME("Unimplemented msg TVM_GETISEARCHSTRINGW\n");
5758 return TREEVIEW_GetItemT(infoPtr
, (LPTVITEMEXW
)lParam
,
5759 uMsg
== TVM_GETITEMW
);
5760 case TVM_GETITEMHEIGHT
:
5761 return TREEVIEW_GetItemHeight(infoPtr
);
5763 case TVM_GETITEMRECT
:
5764 return TREEVIEW_GetItemRect(infoPtr
, (BOOL
)wParam
, (LPRECT
)lParam
);
5766 case TVM_GETITEMSTATE
:
5767 return TREEVIEW_GetItemState(infoPtr
, (HTREEITEM
)wParam
, (UINT
)lParam
);
5769 case TVM_GETLINECOLOR
:
5770 return TREEVIEW_GetLineColor(infoPtr
);
5772 case TVM_GETNEXTITEM
:
5773 return TREEVIEW_GetNextItem(infoPtr
, (UINT
)wParam
, (HTREEITEM
)lParam
);
5775 case TVM_GETSCROLLTIME
:
5776 return TREEVIEW_GetScrollTime(infoPtr
);
5778 case TVM_GETTEXTCOLOR
:
5779 return TREEVIEW_GetTextColor(infoPtr
);
5781 case TVM_GETTOOLTIPS
:
5782 return TREEVIEW_GetToolTips(infoPtr
);
5784 case TVM_GETUNICODEFORMAT
:
5785 return TREEVIEW_GetUnicodeFormat(infoPtr
);
5787 case TVM_GETVISIBLECOUNT
:
5788 return TREEVIEW_GetVisibleCount(infoPtr
);
5791 return (LRESULT
)TREEVIEW_HitTest(infoPtr
, (TVHITTESTINFO
*)lParam
);
5793 case TVM_INSERTITEMA
:
5794 case TVM_INSERTITEMW
:
5795 return TREEVIEW_InsertItemT(infoPtr
, (LPTVINSERTSTRUCTW
)lParam
,
5796 uMsg
== TVM_INSERTITEMW
);
5797 case TVM_SELECTITEM
:
5798 return TREEVIEW_SelectItem(infoPtr
, (INT
)wParam
, (HTREEITEM
)lParam
);
5800 case TVM_SETBKCOLOR
:
5801 return TREEVIEW_SetBkColor(infoPtr
, (COLORREF
)lParam
);
5803 case TVM_SETIMAGELIST
:
5804 return TREEVIEW_SetImageList(infoPtr
, wParam
, (HIMAGELIST
)lParam
);
5807 return TREEVIEW_SetIndent(infoPtr
, (UINT
)wParam
);
5809 case TVM_SETINSERTMARK
:
5810 return TREEVIEW_SetInsertMark(infoPtr
, (BOOL
)wParam
, (HTREEITEM
)lParam
);
5812 case TVM_SETINSERTMARKCOLOR
:
5813 return TREEVIEW_SetInsertMarkColor(infoPtr
, (COLORREF
)lParam
);
5817 return TREEVIEW_SetItemT(infoPtr
, (LPTVITEMEXW
)lParam
,
5818 uMsg
== TVM_SETITEMW
);
5819 case TVM_SETLINECOLOR
:
5820 return TREEVIEW_SetLineColor(infoPtr
, (COLORREF
)lParam
);
5822 case TVM_SETITEMHEIGHT
:
5823 return TREEVIEW_SetItemHeight(infoPtr
, (INT
)(SHORT
)wParam
);
5825 case TVM_SETSCROLLTIME
:
5826 return TREEVIEW_SetScrollTime(infoPtr
, (UINT
)wParam
);
5828 case TVM_SETTEXTCOLOR
:
5829 return TREEVIEW_SetTextColor(infoPtr
, (COLORREF
)lParam
);
5831 case TVM_SETTOOLTIPS
:
5832 return TREEVIEW_SetToolTips(infoPtr
, (HWND
)wParam
);
5834 case TVM_SETUNICODEFORMAT
:
5835 return TREEVIEW_SetUnicodeFormat(infoPtr
, (BOOL
)wParam
);
5837 case TVM_SORTCHILDREN
:
5838 return TREEVIEW_SortChildren(infoPtr
, lParam
);
5840 case TVM_SORTCHILDRENCB
:
5841 return TREEVIEW_SortChildrenCB(infoPtr
, (LPTVSORTCB
)lParam
);
5844 return TREEVIEW_ProcessLetterKeys(infoPtr
, wParam
, lParam
);
5847 return TREEVIEW_Command(infoPtr
, wParam
, lParam
);
5850 return TREEVIEW_Destroy(infoPtr
);
5855 return TREEVIEW_EraseBackground(infoPtr
, (HDC
)wParam
);
5858 return DLGC_WANTARROWS
| DLGC_WANTCHARS
;
5861 return TREEVIEW_GetFont(infoPtr
);
5864 return TREEVIEW_HScroll(infoPtr
, wParam
);
5868 return TREEVIEW_KeyDown(infoPtr
, wParam
);
5871 return TREEVIEW_KillFocus(infoPtr
);
5873 case WM_LBUTTONDBLCLK
:
5874 return TREEVIEW_LButtonDoubleClick(infoPtr
, lParam
);
5876 case WM_LBUTTONDOWN
:
5877 return TREEVIEW_LButtonDown(infoPtr
, lParam
);
5879 /* WM_MBUTTONDOWN */
5882 return TREEVIEW_MouseLeave(infoPtr
);
5885 return TREEVIEW_MouseMove(infoPtr
, lParam
);
5887 case WM_NCLBUTTONDOWN
:
5888 if (infoPtr
->hwndEdit
)
5889 SetFocus(infoPtr
->hwnd
);
5893 return TREEVIEW_NCPaint (infoPtr
, (HRGN
)wParam
, lParam
);
5896 return TREEVIEW_Notify(infoPtr
, wParam
, lParam
);
5898 case WM_NOTIFYFORMAT
:
5899 return TREEVIEW_NotifyFormat(infoPtr
, (HWND
)wParam
, (UINT
)lParam
);
5901 case WM_PRINTCLIENT
:
5902 return TREEVIEW_PrintClient(infoPtr
, (HDC
)wParam
, lParam
);
5905 return TREEVIEW_Paint(infoPtr
, (HDC
)wParam
);
5907 case WM_RBUTTONDOWN
:
5908 return TREEVIEW_RButtonDown(infoPtr
, lParam
);
5911 return TREEVIEW_SetCursor(infoPtr
, wParam
, lParam
);
5914 return TREEVIEW_SetFocus(infoPtr
);
5917 return TREEVIEW_SetFont(infoPtr
, (HFONT
)wParam
, (BOOL
)lParam
);
5920 return TREEVIEW_SetRedraw(infoPtr
, wParam
);
5923 return TREEVIEW_Size(infoPtr
, wParam
, lParam
);
5925 case WM_STYLECHANGED
:
5926 return TREEVIEW_StyleChanged(infoPtr
, wParam
, lParam
);
5928 case WM_SYSCOLORCHANGE
:
5929 COMCTL32_RefreshSysColors();
5933 return TREEVIEW_HandleTimer(infoPtr
, wParam
);
5935 case WM_THEMECHANGED
:
5936 return TREEVIEW_ThemeChanged (infoPtr
);
5939 return TREEVIEW_VScroll(infoPtr
, wParam
);
5941 /* WM_WININICHANGE */
5944 return TREEVIEW_MouseWheel(infoPtr
, wParam
, lParam
);
5947 TRACE("drawItem\n");
5951 /* This mostly catches MFC and Delphi messages. :( */
5952 if ((uMsg
>= WM_USER
) && (uMsg
< WM_APP
) && !COMCTL32_IsReflectedMessage(uMsg
))
5953 TRACE("Unknown msg %04x wp %Ix lp %Ix\n", uMsg
, wParam
, lParam
);
5955 return DefWindowProcW(hwnd
, uMsg
, wParam
, lParam
);
5960 /* Class Registration ***************************************************/
5963 TREEVIEW_Register(void)
5969 ZeroMemory(&wndClass
, sizeof(WNDCLASSW
));
5970 wndClass
.style
= CS_GLOBALCLASS
| CS_DBLCLKS
;
5971 wndClass
.lpfnWndProc
= TREEVIEW_WindowProc
;
5972 wndClass
.cbClsExtra
= 0;
5973 wndClass
.cbWndExtra
= sizeof(TREEVIEW_INFO
*);
5975 wndClass
.hCursor
= LoadCursorW(0, (LPWSTR
)IDC_ARROW
);
5976 wndClass
.hbrBackground
= 0;
5977 wndClass
.lpszClassName
= WC_TREEVIEWW
;
5979 RegisterClassW(&wndClass
);
5984 TREEVIEW_Unregister(void)
5986 UnregisterClassW(WC_TREEVIEWW
, NULL
);
5990 /* Tree Verification ****************************************************/
5993 TREEVIEW_VerifyChildren(TREEVIEW_INFO
*infoPtr
, const TREEVIEW_ITEM
*item
);
5995 static inline void TREEVIEW_VerifyItemCommon(TREEVIEW_INFO
*infoPtr
,
5996 const TREEVIEW_ITEM
*item
)
5998 assert(infoPtr
!= NULL
);
5999 assert(item
!= NULL
);
6001 /* both NULL, or both non-null */
6002 assert((item
->firstChild
== NULL
) == (item
->lastChild
== NULL
));
6004 assert(item
->firstChild
!= item
);
6005 assert(item
->lastChild
!= item
);
6007 if (item
->firstChild
)
6009 assert(item
->firstChild
->parent
== item
);
6010 assert(item
->firstChild
->prevSibling
== NULL
);
6013 if (item
->lastChild
)
6015 assert(item
->lastChild
->parent
== item
);
6016 assert(item
->lastChild
->nextSibling
== NULL
);
6019 assert(item
->nextSibling
!= item
);
6020 if (item
->nextSibling
)
6022 assert(item
->nextSibling
->parent
== item
->parent
);
6023 assert(item
->nextSibling
->prevSibling
== item
);
6026 assert(item
->prevSibling
!= item
);
6027 if (item
->prevSibling
)
6029 assert(item
->prevSibling
->parent
== item
->parent
);
6030 assert(item
->prevSibling
->nextSibling
== item
);
6035 TREEVIEW_VerifyItem(TREEVIEW_INFO
*infoPtr
, const TREEVIEW_ITEM
*item
)
6037 assert(item
!= NULL
);
6039 assert(item
->parent
!= NULL
);
6040 assert(item
->parent
!= item
);
6041 assert(item
->iLevel
== item
->parent
->iLevel
+ 1);
6043 assert(DPA_GetPtrIndex(infoPtr
->items
, item
) != -1);
6045 TREEVIEW_VerifyItemCommon(infoPtr
, item
);
6047 TREEVIEW_VerifyChildren(infoPtr
, item
);
6051 TREEVIEW_VerifyChildren(TREEVIEW_INFO
*infoPtr
, const TREEVIEW_ITEM
*item
)
6053 const TREEVIEW_ITEM
*child
;
6054 assert(item
!= NULL
);
6056 for (child
= item
->firstChild
; child
!= NULL
; child
= child
->nextSibling
)
6057 TREEVIEW_VerifyItem(infoPtr
, child
);
6061 TREEVIEW_VerifyRoot(TREEVIEW_INFO
*infoPtr
)
6063 TREEVIEW_ITEM
*root
= infoPtr
->root
;
6065 assert(root
!= NULL
);
6066 assert(root
->iLevel
== -1);
6067 assert(root
->parent
== NULL
);
6068 assert(root
->prevSibling
== NULL
);
6070 TREEVIEW_VerifyItemCommon(infoPtr
, root
);
6072 TREEVIEW_VerifyChildren(infoPtr
, root
);
6076 TREEVIEW_VerifyTree(TREEVIEW_INFO
*infoPtr
)
6078 if (!TRACE_ON(treeview
)) return;
6080 assert(infoPtr
!= NULL
);
6081 TREEVIEW_VerifyRoot(infoPtr
);