?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
X11DRV_SetFocus: really don't mess with focus for managed windows.
[wine/multimedia.git] / dlls / comctl32 / treeview.c
blob6d3ee44af04810bf7cdb6d19cb1922a258532f41
1 /* Treeview control
2 *
3 * Copyright 1998 Eric Kohl <ekohl@abo.rhein-zeitung.de>
4 * Copyright 1998,1999 Alex Priem <alexp@sci.kun.nl>
5 * Copyright 1999 Sylvain St-Germain
6 *
7 *
8 * TODO:
9 * Using DPA to store the item ptr would be good.
10 * Node label edition is implemented but something appened in wine in the
11 * two last weeks of march 99 that broke it.
12 * refreshtreeview:
13 -small array containing info about positions.
14 -better implementation of RefreshItem:
15 1) draw lines between parents
16 2) draw items
17 3) draw lines from parent<->items.
18 -implement partial drawing?
19 * -drag&drop: TVM_CREATEDRAGIMAGE should create drag bitmap.
20 * -scrollbars: horizontal scrollbar doesn't work.
21 * -Unicode messages
22 * -check custom draw
23 * -I_CHILDRENCALLBACK
24 * FIXME: check fontsize. (uRealItemHeight)
25 * test focusItem (redraw in different color)
26 uHotItem
27 Edit: needs timer
28 better implementation.
29 * WM_HSCROLL is broken.
30 * use separate routine to get item text/image.
31 *
32 * Separate drawing/calculation.
33 *
34 * FIXMEs (for personal use)
35 Expand: -ctlmacro expands twice ->toggle.
36 -DblClick: ctlmacro.exe's NM_DBLCLK seems to go wrong (returns FALSE).
37 -treehelper: stack corruption makes big window.
38
39 */
40
41
42 #include <string.h>
43 #include "winbase.h"
44 #include "wingdi.h"
45 #include "commctrl.h"
46 #include "treeview.h"
47 #include "comctl32.h"
48 #include "debugtools.h"
49
50 DEFAULT_DEBUG_CHANNEL(treeview)
51
52 /* ffs should be in <string.h>. */
53
54 /* Defines, since they do not need to return previous state, and nr
55 * has no side effects in this file.
56 */
57 #define tv_test_bit(nr,bf) (((LPBYTE)bf)[nr>>3]&(1<<(nr&7)))
58 #define tv_set_bit(nr,bf) ((LPBYTE)bf)[nr>>3]|=(1<<(nr&7))
59 #define tv_clear_bit(nr,bf) ((LPBYTE)bf)[nr>>3]&=~(1<<(nr&7))
60
61
62 #define TREEVIEW_GetInfoPtr(hwnd) \
63 ((TREEVIEW_INFO *) GetWindowLongA( hwnd, 0))
64
65 static BOOL
66 TREEVIEW_SendSimpleNotify (HWND hwnd, UINT code);
67 static BOOL
68 TREEVIEW_SendTreeviewNotify (HWND hwnd, UINT code, UINT action,
69 HTREEITEM oldItem, HTREEITEM newItem);
70 static BOOL
71 TREEVIEW_SendTreeviewDnDNotify (HWND hwnd, UINT code, HTREEITEM dragItem,
72 POINT pt);
73 static BOOL
74 TREEVIEW_SendDispInfoNotify (HWND hwnd, TREEVIEW_ITEM *wineItem,
75 UINT code, UINT what);
76 static BOOL
77 TREEVIEW_SendCustomDrawNotify (HWND hwnd, DWORD dwDrawStage, HDC hdc,
78 RECT rc);
79 static BOOL
80 TREEVIEW_SendCustomDrawItemNotify (HWND hwnd, HDC hdc,
81 TREEVIEW_ITEM *tvItem, UINT uItemDrawState);
82 static LRESULT
83 TREEVIEW_DoSelectItem (HWND hwnd, INT action, HTREEITEM newSelect, INT cause);
84 static void
85 TREEVIEW_Refresh (HWND hwnd, HDC hdc);
86
87 static LRESULT CALLBACK
88 TREEVIEW_Edit_SubclassProc (HWND hwnd, UINT uMsg, WPARAM wParam,
89 LPARAM lParam);
90
91 LRESULT WINAPI
92 TREEVIEW_EndEditLabelNow (HWND hwnd, WPARAM wParam, LPARAM lParam);
93
94
95
96
97 /* helper functions. Work with the assumption that validity of operands
98 is checked beforehand, and that tree state is valid. */
99
100 /* FIXME: MS documentation says `GetNextVisibleItem' returns NULL
101 if not successfull. Probably only applies to dereferencing infoPtr
102 (i.e. we are offered a valid treeview structure)
103 and not whether there is a next `visible' child.
104 FIXME: check other failures.
105 */
106
107 /***************************************************************************
108 * This method returns the TREEVIEW_ITEM object given the handle
109 */
110 static TREEVIEW_ITEM* TREEVIEW_ValidItem(
111 TREEVIEW_INFO *infoPtr,
112 HTREEITEM handle)
113 {
114 if ((!handle) || (handle>infoPtr->uMaxHandle))
115 return NULL;
116
117 if (tv_test_bit ((INT)handle, infoPtr->freeList))
118 return NULL;
119
120 return &infoPtr->items[(INT)handle];
121 }
122
123 /***************************************************************************
124 * This method returns the last expanded child item of a tree node
125 */
126 static TREEVIEW_ITEM *TREEVIEW_GetLastListItem(
127 TREEVIEW_INFO *infoPtr,
128 TREEVIEW_ITEM *tvItem)
129 {
130 TREEVIEW_ITEM *wineItem = tvItem;
131
132 /*
133 * Get this item last sibling
134 */
135 while (wineItem->sibling)
136 wineItem=& infoPtr->items [(INT)wineItem->sibling];
137
138 /*
139 * If the last sibling has expanded children, restart.
140 */
141 if ( ( wineItem->cChildren > 0 ) && ( wineItem->state & TVIS_EXPANDED) )
142 return TREEVIEW_GetLastListItem(
143 infoPtr,
144 &(infoPtr->items[(INT)wineItem->firstChild]));
145
146 return wineItem;
147 }
148
149 /***************************************************************************
150 * This method returns the previous physical item in the list not
151 * considering the tree hierarchy.
152 */
153 static TREEVIEW_ITEM *TREEVIEW_GetPrevListItem(
154 TREEVIEW_INFO *infoPtr,
155 TREEVIEW_ITEM *tvItem)
156 {
157 if (tvItem->upsibling)
158 {
159 /*
160 * This item has a upsibling, get the last item. Since, GetLastListItem
161 * first looks at siblings, we must feed it with the first child.
162 */
163 TREEVIEW_ITEM *upItem = &infoPtr->items[(INT)tvItem->upsibling];
164
165 if ( ( upItem->cChildren > 0 ) && ( upItem->state & TVIS_EXPANDED) )
166 return TREEVIEW_GetLastListItem(
167 infoPtr,
168 &infoPtr->items[(INT)upItem->firstChild]);
169 else
170 return upItem;
171 }
172 else
173 {
174 /*
175 * this item does not have a upsibling, get the parent
176 */
177 if (tvItem->parent)
178 return &infoPtr->items[(INT)tvItem->parent];
179 }
180
181 return NULL;
182 }
183
184
185 /***************************************************************************
186 * This method returns the next physical item in the treeview not
187 * considering the tree hierarchy.
188 */
189 static TREEVIEW_ITEM *TREEVIEW_GetNextListItem(
190 TREEVIEW_INFO *infoPtr,
191 TREEVIEW_ITEM *tvItem)
192 {
193 TREEVIEW_ITEM *wineItem = NULL;
194
195 /*
196 * If this item has children and is expanded, return the first child
197 */
198 if ((tvItem->firstChild) && (tvItem->state & TVIS_EXPANDED))
199 return (& infoPtr->items[(INT)tvItem->firstChild]);
200
201
202 /*
203 * try to get the sibling
204 */
205 if (tvItem->sibling)
206 return (& infoPtr->items[(INT)tvItem->sibling]);
207
208 /*
209 * Otherwise, get the parent's sibling.
210 */
211 wineItem=tvItem;
212 while (wineItem->parent) {
213 wineItem=& infoPtr->items [(INT)wineItem->parent];
214 if (wineItem->sibling)
215 return (& infoPtr->items [(INT)wineItem->sibling]);
216 }
217
218 return NULL;
219 }
220
221 /***************************************************************************
222 * This method returns the nth item starting at the given item. It returns
223 * the last item (or first) we we run out of items.
224 *
225 * Will scroll backward if count is <0.
226 * forward if count is >0.
227 */
228 static TREEVIEW_ITEM *TREEVIEW_GetListItem(
229 TREEVIEW_INFO *infoPtr,
230 TREEVIEW_ITEM *tvItem,
231 LONG count)
232 {
233 TREEVIEW_ITEM *previousItem = NULL;
234 TREEVIEW_ITEM *wineItem = tvItem;
235 LONG iter = 0;
236
237 if (count > 0)
238 {
239 /* Find count item downward */
240 while ((iter++ < count) && (wineItem != NULL))
241 {
242 /* Keep a pointer to the previous in case we ask for more than we got */
243 previousItem = wineItem;
244 wineItem = TREEVIEW_GetNextListItem(infoPtr, wineItem);
245 }
246
247 if (wineItem == NULL)
248 wineItem = previousItem;
249 }
250 else if (count < 0)
251 {
252 /* Find count item upward */
253 while ((iter-- > count) && (wineItem != NULL))
254 {
255 /* Keep a pointer to the previous in case we ask for more than we got */
256 previousItem = wineItem;
257 wineItem = TREEVIEW_GetPrevListItem(infoPtr, wineItem);
258 }
259
260 if (wineItem == NULL)
261 wineItem = previousItem;
262 }
263 else
264 wineItem = NULL;
265
266 return wineItem;
267 }
268
269
270 /***************************************************************************
271 * This method
272 */
273 static void TREEVIEW_RemoveAllChildren(
274 HWND hwnd,
275 TREEVIEW_ITEM *parentItem)
276 {
277 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
278 TREEVIEW_ITEM *killItem;
279 INT kill;
280
281 kill=(INT)parentItem->firstChild;
282 while (kill) {
283 tv_set_bit ( kill, infoPtr->freeList);
284 killItem=& infoPtr->items[kill];
285 if (killItem->pszText!=LPSTR_TEXTCALLBACKA)
286 COMCTL32_Free (killItem->pszText);
287 TREEVIEW_SendTreeviewNotify (hwnd, TVN_DELETEITEMA, 0, (HTREEITEM)kill, 0);
288 if (killItem->firstChild)
289 TREEVIEW_RemoveAllChildren (hwnd, killItem);
290 kill=(INT)killItem->sibling;
291 }
292
293 if (parentItem->cChildren>0) {
294 infoPtr->uNumItems -= parentItem->cChildren;
295 parentItem->firstChild = 0;
296 parentItem->cChildren = 0;
297 }
298
299 }
300
301
302 static void
303 TREEVIEW_RemoveItem (HWND hwnd, TREEVIEW_ITEM *wineItem)
304
305 {
306 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
307 TREEVIEW_ITEM *parentItem, *upsiblingItem, *siblingItem;
308 INT iItem;
309
310 iItem=(INT)wineItem->hItem;
311 tv_set_bit(iItem,infoPtr->freeList);
312 infoPtr->uNumItems--;
313 parentItem=NULL;
314 if (wineItem->pszText!=LPSTR_TEXTCALLBACKA)
315 COMCTL32_Free (wineItem->pszText);
316
317 TREEVIEW_SendTreeviewNotify (hwnd, TVN_DELETEITEMA, 0, (HTREEITEM)iItem, 0);
318
319 if (wineItem->firstChild)
320 TREEVIEW_RemoveAllChildren (hwnd,wineItem);
321
322 if (wineItem->parent) {
323 parentItem=& infoPtr->items [(INT)wineItem->parent];
324 switch (parentItem->cChildren) {
325 case I_CHILDRENCALLBACK:
326 FIXME("we don't handle I_CHILDRENCALLBACK yet\n");
327 break;
328 case 1:
329 parentItem->cChildren=0;
330 parentItem->firstChild=0;
331 return;
332 default:
333 parentItem->cChildren--;
334 if ((INT)parentItem->firstChild==iItem)
335 parentItem->firstChild=wineItem->sibling;
336 }
337 }
338
339 if (iItem==(INT)infoPtr->TopRootItem)
340 infoPtr->TopRootItem=(HTREEITEM)wineItem->sibling;
341 if (wineItem->upsibling) {
342 upsiblingItem=& infoPtr->items [(INT)wineItem->upsibling];
343 upsiblingItem->sibling=wineItem->sibling;
344 }
345 if (wineItem->sibling) {
346 siblingItem=& infoPtr->items [(INT)wineItem->sibling];
347 siblingItem->upsibling=wineItem->upsibling;
348 }
349 }
350
351
352
353
354
355 /* Note:TREEVIEW_RemoveTree doesn't remove infoPtr itself */
356
357 static void TREEVIEW_RemoveTree (HWND hwnd)
358
359 {
360 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
361 TREEVIEW_ITEM *killItem;
362 int i;
363
364 for (i = 1; i <= (INT)infoPtr->uMaxHandle; i++)
365 if (!tv_test_bit (i, infoPtr->freeList)) {
366 killItem = &infoPtr->items[i];
367 if (killItem->pszText != LPSTR_TEXTCALLBACKA)
368 COMCTL32_Free (killItem->pszText);
369 TREEVIEW_SendTreeviewNotify(hwnd, TVN_DELETEITEMA, 0,
370 killItem->hItem, 0);
371 }
372 if (infoPtr->uNumPtrsAlloced) {
373 COMCTL32_Free (infoPtr->items);
374 COMCTL32_Free (infoPtr->freeList);
375 infoPtr->uNumItems = 0;
376 infoPtr->uNumPtrsAlloced = 0;
377 infoPtr->uMaxHandle = 0;
378 infoPtr->TopRootItem = 0;
379 }
380 }
381
382
383
384
385
386
387
388 static LRESULT
389 TREEVIEW_GetImageList (HWND hwnd, WPARAM wParam, LPARAM lParam)
390 {
391 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
392
393 TRACE("\n");
394
395 if ((INT)wParam == TVSIL_NORMAL)
396 return (LRESULT) infoPtr->himlNormal;
397 if ((INT)wParam == TVSIL_STATE)
398 return (LRESULT) infoPtr->himlState;
399
400 return 0;
401 }
402
403 static LRESULT
404 TREEVIEW_SetImageList (HWND hwnd, WPARAM wParam, LPARAM lParam)
405 {
406 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
407 HIMAGELIST himlTemp;
408
409 TRACE("%x,%lx\n", wParam, lParam);
410 switch ((INT)wParam) {
411 case TVSIL_NORMAL:
412 himlTemp = infoPtr->himlNormal;
413 infoPtr->himlNormal = (HIMAGELIST)lParam;
414 return (LRESULT)himlTemp;
415
416 case TVSIL_STATE:
417 himlTemp = infoPtr->himlState;
418 infoPtr->himlState = (HIMAGELIST)lParam;
419 return (LRESULT)himlTemp;
420 }
421
422 return (LRESULT)NULL;
423 }
424
425
426
427 static LRESULT
428 TREEVIEW_SetItemHeight (HWND hwnd, WPARAM wParam)
429 {
430 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
431 INT cx,cy,prevHeight=infoPtr->uItemHeight;
432
433 TRACE("\n");
434 if (wParam==-1) {
435 infoPtr->uItemHeight=-1;
436 return prevHeight;
437 }
438
439 ImageList_GetIconSize (infoPtr->himlNormal, &cx, &cy);
440
441 if (wParam>cy) cy=wParam;
442 infoPtr->uItemHeight=cy;
443
444 if (!( GetWindowLongA( hwnd, GWL_STYLE) & TVS_NONEVENHEIGHT))
445 infoPtr->uItemHeight = (INT) wParam & 0xfffffffe;
446 return prevHeight;
447 }
448
449 static LRESULT
450 TREEVIEW_GetItemHeight (HWND hwnd)
451 {
452 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
453
454 TRACE("\n");
455 return infoPtr->uItemHeight;
456 }
457
458 static LRESULT
459 TREEVIEW_GetLineColor (HWND hwnd, WPARAM wParam, LPARAM lParam)
460 {
461 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
462
463 TRACE("\n");
464 return (LRESULT) infoPtr->clrLine;
465 }
466
467 static LRESULT
468 TREEVIEW_SetLineColor (HWND hwnd, WPARAM wParam, LPARAM lParam)
469 {
470 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
471 COLORREF prevColor=infoPtr->clrLine;
472
473 TRACE("\n");
474 infoPtr->clrLine=(COLORREF) lParam;
475 return (LRESULT) prevColor;
476 }
477
478 static LRESULT
479 TREEVIEW_GetInsertMarkColor (HWND hwnd, WPARAM wParam, LPARAM lParam)
480 {
481 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
482
483 TRACE("\n");
484 return (LRESULT) infoPtr->clrInsertMark;
485 }
486
487 static LRESULT
488 TREEVIEW_SetInsertMarkColor (HWND hwnd, WPARAM wParam, LPARAM lParam)
489 {
490 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
491 COLORREF prevColor=infoPtr->clrInsertMark;
492
493 TRACE("%d %ld\n",wParam,lParam);
494 infoPtr->clrInsertMark=(COLORREF) lParam;
495 return (LRESULT) prevColor;
496 }
497
498 static LRESULT
499 TREEVIEW_SetInsertMark (HWND hwnd, WPARAM wParam, LPARAM lParam)
500 {
501 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
502 HDC hdc;
503
504 FIXME("%d %ld\n",wParam,lParam);
505 if (!TREEVIEW_ValidItem (infoPtr, (HTREEITEM)lParam)) return 0;
506 FIXME("%d %ld\n",wParam,lParam);
507
508 infoPtr->insertBeforeorAfter=(BOOL) wParam;
509 infoPtr->insertMarkItem=(HTREEITEM) lParam;
510
511 hdc = GetDC (hwnd);
512 TREEVIEW_Refresh (hwnd, hdc);
513 ReleaseDC(hwnd,hdc);
514
515 return 1;
516 }
517
518 static LRESULT
519 TREEVIEW_SetTextColor (HWND hwnd, WPARAM wParam, LPARAM lParam)
520 {
521 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
522 COLORREF prevColor=infoPtr->clrText;
523
524 TRACE("\n");
525 infoPtr->clrText=(COLORREF) lParam;
526 return (LRESULT) prevColor;
527 }
528
529 static LRESULT
530 TREEVIEW_GetBkColor (HWND hwnd)
531 {
532 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
533
534 TRACE("\n");
535 return (LRESULT) infoPtr->clrBk;
536 }
537
538 static LRESULT
539 TREEVIEW_SetBkColor (HWND hwnd, WPARAM wParam, LPARAM lParam)
540 {
541 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
542 COLORREF prevColor=infoPtr->clrBk;
543
544 TRACE("\n");
545 infoPtr->clrBk=(COLORREF) lParam;
546 return (LRESULT) prevColor;
547 }
548
549 static LRESULT
550 TREEVIEW_GetTextColor (HWND hwnd)
551 {
552 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
553
554 TRACE("\n");
555 return (LRESULT) infoPtr->clrText;
556 }
557
558
559 /* cdmode: custom draw mode as received from app. in first NMCUSTOMDRAW
560 notification */
561
562 #define TREEVIEW_LEFT_MARGIN 8
563
564
565 static void
566 TREEVIEW_DrawItem (HWND hwnd, HDC hdc, TREEVIEW_ITEM *wineItem)
567 {
568 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
569 DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
570 INT center,xpos,cx,cy, cditem;
571 HFONT hOldFont;
572 UINT uTextJustify = DT_LEFT;
573 RECT r;
574
575
576 if (wineItem->state & TVIS_BOLD)
577 hOldFont = SelectObject (hdc, infoPtr->hBoldFont);
578 else
579 hOldFont = SelectObject (hdc, infoPtr->hFont);
580
581 cditem=0;
582 TRACE ("cdmode:%x\n",infoPtr->cdmode);
583 if (infoPtr->cdmode & CDRF_NOTIFYITEMDRAW) {
584 cditem=TREEVIEW_SendCustomDrawItemNotify
585 (hwnd, hdc, wineItem, CDDS_ITEMPREPAINT);
586 TRACE("prepaint:cditem-app returns 0x%x\n",cditem);
587
588 if (cditem & CDRF_SKIPDEFAULT)
589 return;
590 }
591
592 /*
593 * Set drawing starting points
594 */
595 r = wineItem->rect; /* this item rectangle */
596 center = (r.top+r.bottom)/2; /* this item vertical center */
597 xpos = r.left + TREEVIEW_LEFT_MARGIN;/* horizontal starting point */
598
599 /*
600 * Display the tree hierarchy
601 */
602 if ( dwStyle & TVS_HASLINES)
603 {
604 /*
605 * Write links to parent node
606 * we draw the L starting from the child to the parent
607 *
608 * points[0] is attached to the current item
609 * points[1] is the L corner
610 * points[2] is attached to the parent or the up sibling
611 */
612 if ( dwStyle & TVS_LINESATROOT)
613 {
614 TREEVIEW_ITEM *upNode = NULL;
615 BOOL hasParentOrSibling = TRUE;
616 RECT upRect = {0,0,0,0};
617 HPEN hOldPen, hNewPen;
618 POINT points[3];
619 /*
620 * determine the target location of the line at root, either be linked
621 * to the up sibling or to the parent node.
622 */
623 if (wineItem->upsibling)
624 upNode = TREEVIEW_ValidItem (infoPtr, wineItem->upsibling);
625 else if (wineItem->parent)
626 upNode = TREEVIEW_ValidItem (infoPtr, wineItem->parent);
627 else
628 hasParentOrSibling = FALSE;
629
630 if (upNode)
631 upRect = upNode->rect;
632
633 if ( wineItem->iLevel == 0 )
634 {
635 points[2].x = points[1].x = upRect.left+8;
636 points[0].x = points[2].x + 10;
637 points[2].y = upRect.bottom-3;
638 points[1].y = points[0].y = center;
639 }
640 else
641 {
642 points[2].x = points[1].x = 8 + (20*wineItem->iLevel);
643 points[2].y = ( upNode->cChildren == 0) ?
644 upRect.top : /* is linked to the "L" above */
645 ( wineItem->upsibling != NULL) ?
646 upRect.bottom-3: /* is linked to an icon */
647 upRect.bottom+1; /* is linked to a +/- box */
648 points[1].y = points[0].y = center;
649 points[0].x = points[1].x + 10;
650 }
651
652 /*
653 * Get a dotted pen
654 */
655 hNewPen = CreatePen(PS_DOT, 0, infoPtr->clrLine);
656 hOldPen = SelectObject( hdc, hNewPen );
657
658 if (hasParentOrSibling)
659 Polyline (hdc,points,3);
660 else
661 Polyline (hdc,points,2);
662
663 DeleteObject(hNewPen);
664 SelectObject(hdc, hOldPen);
665 }
666 }
667
668 /*
669 * Display the (+/-) signs
670 */
671 if (wineItem->iLevel != 0)/* update position only for non root node */
672 xpos+=(5*wineItem->iLevel);
673
674 if (( dwStyle & TVS_HASBUTTONS) && ( dwStyle & TVS_HASLINES))
675 {
676 if ( (wineItem->cChildren) ||
677 (wineItem->cChildren == I_CHILDRENCALLBACK))
678 {
679 /* Setup expand box coordinate to facilitate the LMBClick handling */
680 wineItem->expandBox.left = xpos-4;
681 wineItem->expandBox.top = center-4;
682 wineItem->expandBox.right = xpos+5;
683 wineItem->expandBox.bottom = center+5;
684
685 Rectangle (
686 hdc,
687 wineItem->expandBox.left,
688 wineItem->expandBox.top ,
689 wineItem->expandBox.right,
690 wineItem->expandBox.bottom);
691
692 MoveToEx (hdc, xpos-2, center, NULL);
693 LineTo (hdc, xpos+3, center);
694
695 if (!(wineItem->state & TVIS_EXPANDED)) {
696 MoveToEx (hdc, xpos, center-2, NULL);
697 LineTo (hdc, xpos, center+3);
698 }
699 }
700 }
701
702 /*
703 * Display the image associated with this item
704 */
705 xpos += 13; /* update position */
706 if (wineItem->mask & (TVIF_IMAGE|TVIF_SELECTEDIMAGE)) {
707 INT imageIndex;
708 HIMAGELIST *himlp = NULL;
709
710 /* State images are displayed to the left of the Normal image
711 * image number is in state; zero should be `display no image'.
712 * FIXME: that last sentence looks like it needs some checking.
713 */
714 if (infoPtr->himlState)
715 himlp=&infoPtr->himlState;
716 imageIndex=wineItem->state>>12;
717 imageIndex++; /* yeah, right */
718 TRACE ("imindex:%d\n",imageIndex);
719 if ((himlp) && (imageIndex))
720 {
721 imageIndex--; /* see FIXME */
722 ImageList_Draw ( *himlp, imageIndex, hdc, xpos-2, r.top+1, ILD_NORMAL);
723 ImageList_GetIconSize (*himlp, &cx, &cy);
724 wineItem->statebitmap.left=xpos-2;
725 wineItem->statebitmap.right=xpos-2+cx;
726 wineItem->statebitmap.top=r.top+1;
727 wineItem->statebitmap.bottom=r.top+1+cy;
728 xpos+=cx;
729 }
730
731 /* Now, draw the normal image; can be either selected or
732 * non-selected image.
733 */
734
735 himlp=NULL;
736 if (infoPtr->himlNormal)
737 himlp=&infoPtr->himlNormal; /* get the image list */
738
739 imageIndex = wineItem->iImage;
740 if ( (wineItem->state & TVIS_SELECTED) &&
741 (wineItem->iSelectedImage)) {
742
743 /* The item is curently selected */
744 if (wineItem->iSelectedImage == I_IMAGECALLBACK)
745 TREEVIEW_SendDispInfoNotify
746 (hwnd, wineItem, TVN_GETDISPINFOA, TVIF_SELECTEDIMAGE);
747
748 imageIndex = wineItem->iSelectedImage;
749 } else {
750 /* The item is not selected */
751 if (wineItem->iImage == I_IMAGECALLBACK)
752 TREEVIEW_SendDispInfoNotify
753 (hwnd, wineItem, TVN_GETDISPINFOA, TVIF_IMAGE);
754
755 imageIndex = wineItem->iImage;
756 }
757
758 if (himlp)
759 {
760 int ovlIdx = 0;
761
762 if(wineItem->stateMask & TVIS_OVERLAYMASK)
763 ovlIdx = wineItem->state & TVIS_OVERLAYMASK;
764
765 ImageList_Draw ( *himlp, imageIndex, hdc, xpos-2, r.top+1, ILD_NORMAL|ovlIdx);
766 ImageList_GetIconSize (*himlp, &cx, &cy);
767 wineItem->bitmap.left=xpos-2;
768 wineItem->bitmap.right=xpos-2+cx;
769 wineItem->bitmap.top=r.top+1;
770 wineItem->bitmap.bottom=r.top+1+cy;
771 xpos+=cx;
772 }
773 }
774
775
776 /*
777 * Display the text associated with this item
778 */
779 r.left=xpos;
780 if ((wineItem->mask & TVIF_TEXT) && (wineItem->pszText))
781 {
782 COLORREF oldBkColor = 0;
783 COLORREF oldTextColor = 0;
784 INT oldBkMode;
785
786 r.left += 3;
787 r.right -= 3;
788
789 wineItem->text.left = r.left;
790 wineItem->text.right = r.right;
791 wineItem->text.top = r.top;
792 wineItem->text.bottom= r.bottom;
793
794 if (wineItem->pszText== LPSTR_TEXTCALLBACKA) {
795 TRACE("LPSTR_TEXTCALLBACK\n");
796 TREEVIEW_SendDispInfoNotify (hwnd, wineItem, TVN_GETDISPINFOA, TVIF_TEXT);
797 }
798
799 /* Yep, there are some things that need to be straightened out here.
800 Removing the comments around the setTextColor does not give the right
801 results. Dito FillRect.
802 */
803
804
805 /* GetTextExtentPoint32A (hdc, wineItem->pszText,
806 strlen (wineItem->pszText), &size); */
807
808 /* FillRect ( hdc, &wineItem->text, GetSysColorBrush (infoPtr->clrBk));
809 */
810
811
812 if (!(cditem & CDRF_NOTIFYPOSTPAINT) &&
813 (wineItem->state & (TVIS_SELECTED | TVIS_DROPHILITED)) ) {
814 oldBkMode = SetBkMode (hdc, OPAQUE);
815 oldBkColor = SetBkColor (hdc, GetSysColor( COLOR_HIGHLIGHT));
816 oldTextColor = SetTextColor(hdc, GetSysColor( COLOR_HIGHLIGHTTEXT));
817 } else {
818 oldBkMode = SetBkMode (hdc, TRANSPARENT);
819 oldBkColor = SetBkColor (hdc, infoPtr->clrBk);
820 /* oldTextColor = SetTextColor(hdc, infoPtr->clrText); */
821 }
822
823
824
825 /* Draw it */
826 DrawTextA ( hdc,
827 wineItem->pszText,
828 lstrlenA(wineItem->pszText),
829 &wineItem->text,
830 uTextJustify | DT_VCENTER | DT_SINGLELINE );
831
832 /* Obtain the text coordinate */
833 DrawTextA (
834 hdc,
835 wineItem->pszText,
836 lstrlenA(wineItem->pszText),
837 &wineItem->text,
838 uTextJustify | DT_VCENTER | DT_SINGLELINE | DT_CALCRECT);
839
840 /* Restore the hdc state */
841 SetTextColor( hdc, oldTextColor);
842
843 if (oldBkMode != TRANSPARENT)
844 SetBkMode(hdc, oldBkMode);
845 if (wineItem->state & (TVIS_SELECTED | TVIS_DROPHILITED))
846 SetBkColor (hdc, oldBkColor);
847
848 /* Draw the box arround the selected item */
849 if (wineItem->state & TVIS_SELECTED )
850 {
851 HPEN hNewPen = CreatePen(PS_DOT, 0, GetSysColor(COLOR_WINDOWTEXT) );
852 HPEN hOldPen = SelectObject( hdc, hNewPen );
853 POINT points[4];
854
855 points[0].x = wineItem->text.left-1;
856 points[0].y = wineItem->text.top+1;
857 points[1].x = wineItem->text.right;
858 points[1].y = wineItem->text.top+1;
859 points[2].x = wineItem->text.right;
860 points[2].y = wineItem->text.bottom;
861 points[3].x = wineItem->text.left-1;
862 points[3].y = wineItem->text.bottom;
863
864 Polyline (hdc,points,4);
865
866 DeleteObject(hNewPen);
867 SelectObject(hdc, hOldPen);
868 }
869 }
870
871 /* Draw insertion mark if necessary */
872
873 if (infoPtr->insertMarkItem)
874 TRACE ("item:%d,mark:%d\n", (int)wineItem->hItem,
875 (int) infoPtr->insertMarkItem);
876 if (wineItem->hItem==infoPtr->insertMarkItem) {
877 HPEN hNewPen, hOldPen;
878 int offset;
879
880 hNewPen = CreatePen(PS_SOLID, 2, infoPtr->clrInsertMark);
881 hOldPen = SelectObject( hdc, hNewPen );
882
883 if (infoPtr->insertBeforeorAfter)
884 offset=wineItem->text.top+1;
885 else
886 offset=wineItem->text.bottom-1;
887
888 MoveToEx (hdc, wineItem->text.left, offset-3, NULL);
889 LineTo (hdc, wineItem->text.left, offset+3);
890
891 MoveToEx (hdc, wineItem->text.left, offset, NULL);
892 LineTo (hdc, r.right-2, offset);
893
894 MoveToEx (hdc, r.right-2, offset+3, NULL);
895 LineTo (hdc, r.right-2, offset-3);
896
897 DeleteObject(hNewPen);
898
899 SelectObject(hdc, hOldPen);
900 }
901
902 if (cditem & CDRF_NOTIFYPOSTPAINT) {
903 cditem=TREEVIEW_SendCustomDrawItemNotify
904 (hwnd, hdc, wineItem, CDDS_ITEMPOSTPAINT);
905 TRACE("postpaint:cditem-app returns 0x%x\n",cditem);
906 }
907
908 SelectObject (hdc, hOldFont);
909 }
910
911 static LRESULT
912 TREEVIEW_GetItemRect (HWND hwnd, WPARAM wParam, LPARAM lParam)
913 {
914 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
915 TREEVIEW_ITEM *wineItem;
916 HTREEITEM *iItem;
917 LPRECT lpRect = (LPRECT)lParam;
918 HDC hdc;
919
920 TRACE("\n");
921 /*
922 * validate parameters
923 */
924 if (lpRect == NULL)
925 return FALSE;
926
927 if (infoPtr->Timer & TV_REFRESH_TIMER_SET) {
928 hdc = GetDC (hwnd);
929 TREEVIEW_Refresh (hwnd, hdc); /* we want a rect for the current view */
930 ReleaseDC(hwnd,hdc);
931 }
932
933
934 /*
935 * retrieve the item ptr
936 */
937 iItem = (HTREEITEM *) lParam;
938 wineItem = TREEVIEW_ValidItem (infoPtr, *iItem);
939 if ((!wineItem) || (!wineItem->visible))
940 return FALSE;
941
942 /*
943 * If wParam is TRUE return the text size otherwise return
944 * the whole item size
945 */
946 if ((INT) wParam) {
947 lpRect->left = wineItem->text.left;
948 lpRect->right = wineItem->text.right;
949 lpRect->bottom = wineItem->text.bottom;
950 lpRect->top = wineItem->text.top;
951 } else {
952 lpRect->left = wineItem->rect.left;
953 lpRect->right = wineItem->rect.right;
954 lpRect->bottom = wineItem->rect.bottom;
955 lpRect->top = wineItem->rect.top;
956 }
957
958 TRACE("[L:%d R:%d T:%d B:%d]\n",
959 lpRect->left,lpRect->right,
960 lpRect->top,lpRect->bottom);
961
962 return TRUE;
963 }
964
965 static LRESULT
966 TREEVIEW_GetVisibleCount (HWND hwnd, WPARAM wParam, LPARAM lParam)
967
968 {
969 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
970
971 return (LRESULT) infoPtr->uVisibleHeight / infoPtr->uRealItemHeight;
972 }
973
974
975
976 static LRESULT
977 TREEVIEW_SetItemA (HWND hwnd, WPARAM wParam, LPARAM lParam)
978 {
979 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
980 TREEVIEW_ITEM *wineItem;
981 TVITEMEXA *tvItem;
982 INT iItem,len;
983
984 tvItem=(LPTVITEMEXA) lParam;
985 iItem=(INT)tvItem->hItem;
986 TRACE("item %d,mask %x\n",iItem,tvItem->mask);
987
988 wineItem = TREEVIEW_ValidItem (infoPtr, (HTREEITEM)iItem);
989 if (!wineItem) return FALSE;
990
991 if (tvItem->mask & TVIF_CHILDREN) {
992 wineItem->cChildren=tvItem->cChildren;
993 }
994
995 if (tvItem->mask & TVIF_IMAGE) {
996 wineItem->iImage=tvItem->iImage;
997 }
998
999 if (tvItem->mask & TVIF_INTEGRAL) {
1000 wineItem->iIntegral=tvItem->iIntegral;
1001 }
1002
1003 if (tvItem->mask & TVIF_PARAM) {
1004 wineItem->lParam=tvItem->lParam;
1005 }
1006
1007 if (tvItem->mask & TVIF_SELECTEDIMAGE) {
1008 wineItem->iSelectedImage=tvItem->iSelectedImage;
1009 }
1010
1011 if (tvItem->mask & TVIF_STATE) {
1012 TRACE ("prevstate,state,mask:%x,%x,%x\n",wineItem->state,tvItem->state,
1013 tvItem->stateMask);
1014 wineItem->state&= ~tvItem->stateMask;
1015 wineItem->state|= (tvItem->state & tvItem->stateMask);
1016 wineItem->stateMask|= tvItem->stateMask;
1017 }
1018
1019 if (tvItem->mask & TVIF_TEXT) {
1020 if (tvItem->pszText!=LPSTR_TEXTCALLBACKA) {
1021 len=lstrlenA (tvItem->pszText);
1022 if (len>wineItem->cchTextMax)
1023 wineItem->pszText= COMCTL32_ReAlloc (wineItem->pszText, len+1);
1024 lstrcpynA (wineItem->pszText, tvItem->pszText,len+1);
1025 } else {
1026 if (wineItem->cchTextMax) {
1027 COMCTL32_Free (wineItem->pszText);
1028 wineItem->cchTextMax=0;
1029 }
1030 wineItem->pszText=LPSTR_TEXTCALLBACKA;
1031 }
1032 }
1033
1034 wineItem->mask |= tvItem->mask;
1035
1036 return TRUE;
1037 }
1038
1039 static LRESULT
1040 TREEVIEW_GetItemState (HWND hwnd, WPARAM wParam, LPARAM lParam)
1041
1042 {
1043 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
1044 TREEVIEW_ITEM *wineItem;
1045
1046 TRACE("\n");
1047 wineItem = TREEVIEW_ValidItem (infoPtr, (HTREEITEM)wParam);
1048 if (!wineItem) return 0;
1049
1050 return (wineItem->state & lParam);
1051 }
1052
1053
1054
1055
1056 static void
1057 TREEVIEW_Refresh (HWND hwnd, HDC hdc)
1058 {
1059 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
1060 TEXTMETRICA tm;
1061 HBRUSH hbrBk;
1062 RECT rect;
1063 INT iItem, indent, x, y, height, itemHeight;
1064 INT viewtop,viewbottom,viewleft,viewright;
1065 TREEVIEW_ITEM *wineItem, *prevItem;
1066
1067 TRACE("\n");
1068
1069
1070 if (infoPtr->Timer & TV_REFRESH_TIMER_SET) {
1071 KillTimer (hwnd, TV_REFRESH_TIMER);
1072 infoPtr->Timer &= ~TV_REFRESH_TIMER_SET;
1073 }
1074
1075
1076 GetClientRect (hwnd, &rect);
1077 if ((rect.left-rect.right ==0) || (rect.top-rect.bottom==0)) return;
1078
1079 hdc=GetDC (hwnd);
1080
1081 infoPtr->cdmode=TREEVIEW_SendCustomDrawNotify(hwnd,CDDS_PREPAINT,hdc,rect);
1082
1083 if (infoPtr->cdmode==CDRF_SKIPDEFAULT) return;
1084
1085 infoPtr->uVisibleHeight= rect.bottom-rect.top;
1086 infoPtr->uVisibleWidth= rect.right-rect.left;
1087
1088 viewtop=infoPtr->cy;
1089 viewbottom=infoPtr->cy + rect.bottom-rect.top;
1090 viewleft=infoPtr->cx;
1091 viewright=infoPtr->cx + rect.right-rect.left;
1092
1093 TRACE("[%d %d %d %d]\n",viewtop,viewbottom,viewleft,viewright);
1094
1095 /* draw background */
1096
1097 hbrBk = CreateSolidBrush (infoPtr->clrBk);
1098 FillRect(hdc, &rect, hbrBk);
1099 DeleteObject(hbrBk);
1100
1101 ImageList_GetIconSize (infoPtr->himlNormal, &x, &itemHeight);
1102 if (infoPtr->uItemHeight>itemHeight)
1103 itemHeight=infoPtr->uItemHeight;
1104
1105 GetTextMetricsA (hdc, &tm);
1106 if ((tm.tmHeight + tm.tmExternalLeading) > itemHeight)
1107 itemHeight=tm.tmHeight + tm.tmExternalLeading;
1108
1109 infoPtr->uRealItemHeight=itemHeight;
1110
1111 iItem=(INT)infoPtr->TopRootItem;
1112 infoPtr->firstVisible=0;
1113 wineItem=NULL;
1114 indent=0;
1115 x=y=0;
1116
1117 while (iItem) {
1118 prevItem=wineItem;
1119 wineItem= & infoPtr->items[iItem];
1120 wineItem->iLevel=indent;
1121
1122 /* FIXME: remove this in later stage */
1123 /*
1124 if (wineItem->pszText!=LPSTR_TEXTCALLBACK32A)
1125 TRACE (treeview, "%d %d [%d %d %d %d] (%s)\n",y,x,
1126 wineItem->rect.top, wineItem->rect.bottom,
1127 wineItem->rect.left, wineItem->rect.right,
1128 wineItem->pszText);
1129 else
1130 TRACE (treeview, "%d [%d %d %d %d] (CALLBACK)\n",
1131 wineItem->hItem,
1132 wineItem->rect.top, wineItem->rect.bottom,
1133 wineItem->rect.left, wineItem->rect.right);
1134 */
1135
1136 height=itemHeight * wineItem->iIntegral +1;
1137 if ((y >= viewtop) && (y <= viewbottom) &&
1138 (x >= viewleft ) && (x <= viewright)) {
1139 wineItem->visible = TRUE;
1140 wineItem->rect.top = y - infoPtr->cy + rect.top;
1141 wineItem->rect.bottom = wineItem->rect.top + height ;
1142 wineItem->rect.left = x - infoPtr->cx + rect.left;
1143 wineItem->rect.right = rect.right;
1144 if (!infoPtr->firstVisible)
1145 infoPtr->firstVisible=wineItem->hItem;
1146 TREEVIEW_DrawItem (hwnd, hdc, wineItem);
1147 }
1148 else {
1149 wineItem->visible = FALSE;
1150 wineItem->rect.left = wineItem->rect.top = 0;
1151 wineItem->rect.right= wineItem->rect.bottom = 0;
1152 wineItem->text.left = wineItem->text.top = 0;
1153 wineItem->text.right= wineItem->text.bottom = 0;
1154 }
1155
1156 /* look up next item */
1157
1158 if ((wineItem->firstChild) && (wineItem->state & TVIS_EXPANDED)) {
1159 iItem=(INT)wineItem->firstChild;
1160 indent++;
1161 x+=infoPtr->uIndent;
1162 if (x>infoPtr->uTotalWidth)
1163 infoPtr->uTotalWidth=x;
1164 }
1165 else {
1166 iItem=(INT)wineItem->sibling;
1167 while ((!iItem) && (indent>0)) {
1168 indent--;
1169 x-=infoPtr->uIndent;
1170 wineItem=&infoPtr->items[(INT)wineItem->parent];
1171 iItem=(INT)wineItem->sibling;
1172 }
1173 }
1174 y +=height;
1175 } /* while */
1176
1177 /* FIXME: infoPtr->uTotalWidth should also take item label into account */
1178 /* FIXME: or should query item sizes (ie check CDRF_NEWFONT) */
1179
1180 infoPtr->uTotalHeight=y;
1181 if (y >= (viewbottom-viewtop)) {
1182 if (!(infoPtr->uInternalStatus & TV_VSCROLL))
1183 ShowScrollBar (hwnd, SB_VERT, TRUE);
1184 infoPtr->uInternalStatus |=TV_VSCROLL;
1185 SetScrollRange (hwnd, SB_VERT, 0,
1186 y - infoPtr->uVisibleHeight, FALSE);
1187 SetScrollPos (hwnd, SB_VERT, infoPtr->cy, TRUE);
1188 }
1189 else {
1190 if (infoPtr->uInternalStatus & TV_VSCROLL)
1191 ShowScrollBar (hwnd, SB_VERT, FALSE);
1192 infoPtr->uInternalStatus &= ~TV_VSCROLL;
1193 }
1194
1195
1196 if (infoPtr->cdmode & CDRF_NOTIFYPOSTPAINT)
1197 infoPtr->cdmode=TREEVIEW_SendCustomDrawNotify
1198 (hwnd, CDDS_POSTPAINT, hdc, rect);
1199
1200 TRACE("done\n");
1201 }
1202
1203
1204 static LRESULT
1205 TREEVIEW_HandleTimer (HWND hwnd, WPARAM wParam, LPARAM lParam)
1206 {
1207 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
1208
1209 TRACE(" %d\n",wParam);
1210
1211 switch (wParam) {
1212 case TV_REFRESH_TIMER:
1213 KillTimer (hwnd, TV_REFRESH_TIMER);
1214 infoPtr->Timer &= ~TV_REFRESH_TIMER_SET;
1215 InvalidateRect(hwnd, NULL, FALSE);
1216 return 0;
1217 case TV_EDIT_TIMER:
1218 KillTimer (hwnd, TV_EDIT_TIMER);
1219 infoPtr->Timer &= ~TV_EDIT_TIMER_SET;
1220 return 0;
1221 default:
1222 ERR("got unknown timer\n");
1223 }
1224
1225 return 1;
1226 }
1227
1228
1229 static void
1230 TREEVIEW_QueueRefresh (HWND hwnd)
1231
1232 {
1233 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
1234
1235 TRACE("\n");
1236 if (infoPtr->Timer & TV_REFRESH_TIMER_SET) {
1237 KillTimer (hwnd, TV_REFRESH_TIMER);
1238 }
1239
1240 SetTimer (hwnd, TV_REFRESH_TIMER, TV_REFRESH_DELAY, 0);
1241 infoPtr->Timer|=TV_REFRESH_TIMER_SET;
1242 }
1243
1244
1245
1246 static LRESULT
1247 TREEVIEW_GetItemA (HWND hwnd, WPARAM wParam, LPARAM lParam)
1248 {
1249 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
1250 LPTVITEMEXA tvItem;
1251 TREEVIEW_ITEM *wineItem;
1252 INT iItem;
1253
1254 tvItem=(LPTVITEMEXA) lParam;
1255 iItem=(INT)tvItem->hItem;
1256
1257 wineItem = TREEVIEW_ValidItem (infoPtr, (HTREEITEM)iItem);
1258 if (!wineItem) return FALSE;
1259
1260 if (tvItem->mask & TVIF_CHILDREN) {
1261 if (TVIF_CHILDREN==I_CHILDRENCALLBACK)
1262 FIXME("I_CHILDRENCALLBACK not supported\n");
1263 tvItem->cChildren=wineItem->cChildren;
1264 }
1265
1266 if (tvItem->mask & TVIF_HANDLE) {
1267 tvItem->hItem=wineItem->hItem;
1268 }
1269
1270 if (tvItem->mask & TVIF_IMAGE) {
1271 tvItem->iImage=wineItem->iImage;
1272 }
1273
1274 if (tvItem->mask & TVIF_INTEGRAL) {
1275 tvItem->iIntegral=wineItem->iIntegral;
1276 }
1277
1278 /* undocumented: windows ignores TVIF_PARAM and
1279 * always sets lParam
1280 */
1281 tvItem->lParam=wineItem->lParam;
1282
1283 if (tvItem->mask & TVIF_SELECTEDIMAGE) {
1284 tvItem->iSelectedImage=wineItem->iSelectedImage;
1285 }
1286
1287 if (tvItem->mask & TVIF_STATE) {
1288 tvItem->state=wineItem->state & tvItem->stateMask;
1289 }
1290
1291 if (tvItem->mask & TVIF_TEXT) {
1292 if (wineItem->pszText == LPSTR_TEXTCALLBACKA) {
1293 tvItem->pszText = LPSTR_TEXTCALLBACKA; /* FIXME:send notification? */
1294 ERR(" GetItem called with LPSTR_TEXTCALLBACK\n");
1295 }
1296 else if (wineItem->pszText) {
1297 lstrcpynA (tvItem->pszText, wineItem->pszText, tvItem->cchTextMax);
1298 }
1299 }
1300
1301 TRACE("item %d<%p>, txt %p, img %p, action %x\n",
1302 iItem, tvItem, tvItem->pszText, &tvItem->iImage, tvItem->mask);
1303
1304 return TRUE;
1305 }
1306
1307
1308
1309 /* FIXME: check implementation of TVGN_NEXT/TVGN_NEXTVISIBLE */
1310
1311 static LRESULT
1312 TREEVIEW_GetNextItem (HWND hwnd, WPARAM wParam, LPARAM lParam)
1313
1314 {
1315 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
1316 TREEVIEW_ITEM *wineItem, *returnItem;
1317 INT iItem = (INT)lParam, retval = 0, flag = (INT)wParam;
1318 HDC hdc;
1319
1320 switch (flag) {
1321 case TVGN_ROOT:
1322 retval = (INT)infoPtr->TopRootItem;
1323 break;
1324
1325 case TVGN_CARET:
1326 retval = (INT)infoPtr->selectedItem;
1327 break;
1328
1329 case TVGN_FIRSTVISIBLE: /* FIXME:we should only recalculate, not redraw */
1330 hdc = GetDC (hwnd);
1331 TREEVIEW_Refresh (hwnd, hdc);
1332 ReleaseDC(hwnd,hdc);
1333 retval = (INT)infoPtr->firstVisible;
1334 break;
1335
1336 case TVGN_DROPHILITE:
1337 retval = (INT)infoPtr->dropItem;
1338 break;
1339
1340 case TVGN_NEXT:
1341 wineItem = TREEVIEW_ValidItem (infoPtr, (HTREEITEM)iItem);
1342 retval = wineItem ? (INT)wineItem->sibling : 0;
1343 break;
1344
1345 case TVGN_PREVIOUS:
1346 wineItem = TREEVIEW_ValidItem (infoPtr, (HTREEITEM)iItem);
1347 retval = wineItem ? (INT)wineItem->upsibling : 0;
1348 break;
1349
1350 case TVGN_PARENT:
1351 wineItem = TREEVIEW_ValidItem (infoPtr, (HTREEITEM)iItem);
1352 retval = wineItem ? (INT)wineItem->parent : 0;
1353 break;
1354
1355 case TVGN_CHILD:
1356 wineItem = TREEVIEW_ValidItem (infoPtr, (HTREEITEM)iItem);
1357 retval = wineItem ? (INT)wineItem->firstChild : 0;
1358 break;
1359
1360 case TVGN_LASTVISIBLE:
1361 if((wineItem = TREEVIEW_ValidItem (infoPtr, (HTREEITEM)iItem))) {
1362 returnItem = TREEVIEW_GetLastListItem (infoPtr,wineItem);
1363 retval = returnItem ? (INT)returnItem->hItem : 0;
1364 }
1365 break;
1366
1367 case TVGN_NEXTVISIBLE:
1368 if((wineItem = TREEVIEW_ValidItem (infoPtr, (HTREEITEM)iItem))) {
1369 returnItem = TREEVIEW_GetNextListItem (infoPtr,wineItem);
1370 retval = returnItem ? (INT)returnItem->hItem : 0;
1371 }
1372 break;
1373
1374 case TVGN_PREVIOUSVISIBLE:
1375 if((wineItem = TREEVIEW_ValidItem (infoPtr, (HTREEITEM)iItem))) {
1376 returnItem = TREEVIEW_GetPrevListItem (infoPtr, wineItem);
1377 retval = returnItem ? (INT)returnItem->hItem : 0;
1378 }
1379 break;
1380
1381 default:
1382 FIXME("Unknown msg %x,item %x\n", flag,iItem);
1383 break;
1384 }
1385
1386 TRACE("flags %x, item %d returns %d\n", flag, iItem, retval);
1387 return retval;
1388 }
1389
1390
1391 static LRESULT
1392 TREEVIEW_GetCount (HWND hwnd, WPARAM wParam, LPARAM lParam)
1393 {
1394 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
1395
1396 TRACE(" %d\n",infoPtr->uNumItems);
1397 return (LRESULT) infoPtr->uNumItems;
1398 }
1399
1400 /***************************************************************************
1401 * This method does the chaining of the insertion of a treeview item
1402 * before an item.
1403 * If parent is NULL, we're inserting at the root of the list.
1404 */
1405 static void TREEVIEW_InsertBefore(
1406 TREEVIEW_INFO *infoPtr,
1407 TREEVIEW_ITEM *newItem,
1408 TREEVIEW_ITEM *sibling,
1409 TREEVIEW_ITEM *parent)
1410 {
1411 HTREEITEM siblingHandle = 0;
1412 HTREEITEM upSiblingHandle = 0;
1413 TREEVIEW_ITEM *upSibling = NULL;
1414
1415 if (newItem == NULL)
1416 ERR("NULL newItem, impossible condition\n");
1417
1418 if (sibling != NULL) /* Insert before this sibling for this parent */
1419 {
1420 /* Store the new item sibling up sibling and sibling tem handle */
1421 siblingHandle = sibling->hItem;
1422 upSiblingHandle = sibling->upsibling;
1423 /* As well as a pointer to the upsibling sibling object */
1424 if ( (INT)sibling->upsibling != 0 )
1425 upSibling = &infoPtr->items[(INT)sibling->upsibling];
1426
1427 /* Adjust the sibling pointer */
1428 sibling->upsibling = newItem->hItem;
1429
1430 /* Adjust the new item pointers */
1431 newItem->upsibling = upSiblingHandle;
1432 newItem->sibling = siblingHandle;
1433
1434 /* Adjust the up sibling pointer */
1435 if ( upSibling != NULL )
1436 upSibling->sibling = newItem->hItem;
1437 else
1438 /* this item is the first child of this parent, adjust parent pointers */
1439 if (parent)
1440 parent->firstChild = newItem->hItem;
1441 else
1442 infoPtr->TopRootItem= newItem->hItem;
1443 }
1444 else /* Insert as first child of this parent */
1445 if (parent)
1446 parent->firstChild = newItem->hItem;
1447 }
1448
1449 /***************************************************************************
1450 * This method does the chaining of the insertion of a treeview item
1451 * after an item.
1452 * If parent is NULL, we're inserting at the root of the list.
1453 */
1454 static void TREEVIEW_InsertAfter(
1455 TREEVIEW_INFO *infoPtr,
1456 TREEVIEW_ITEM *newItem,
1457 TREEVIEW_ITEM *upSibling,
1458 TREEVIEW_ITEM *parent)
1459 {
1460 HTREEITEM upSiblingHandle = 0;
1461 HTREEITEM siblingHandle = 0;
1462 TREEVIEW_ITEM *sibling = NULL;
1463
1464
1465 if (newItem == NULL)
1466 ERR("NULL newItem, impossible condition\n");
1467
1468 if (upSibling != NULL) /* Insert after this upsibling for this parent */
1469 {
1470 /* Store the new item up sibling and sibling item handle */
1471 upSiblingHandle = upSibling->hItem;
1472 siblingHandle = upSibling->sibling;
1473 /* As well as a pointer to the upsibling sibling object */
1474 if ( (INT)upSibling->sibling != 0 )
1475 sibling = &infoPtr->items[(INT)upSibling->sibling];
1476
1477 /* Adjust the up sibling pointer */
1478 upSibling->sibling = newItem->hItem;
1479
1480 /* Adjust the new item pointers */
1481 newItem->upsibling = upSiblingHandle;
1482 newItem->sibling = siblingHandle;
1483
1484 /* Adjust the sibling pointer */
1485 if ( sibling != NULL )
1486 sibling->upsibling = newItem->hItem;
1487 /*
1488 else
1489 newItem is the last of the level, nothing else to do
1490 */
1491 }
1492 else /* Insert as first child of this parent */
1493 if (parent)
1494 parent->firstChild = newItem->hItem;
1495 }
1496
1497 /***************************************************************************
1498 * Forward the DPA local callback to the treeview owner callback
1499 */
1500 static INT WINAPI TREEVIEW_CallBackCompare(
1501 LPVOID first,
1502 LPVOID second,
1503 LPARAM tvInfoPtr)
1504 {
1505 /* Forward the call to the client define callback */
1506 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr((HWND)tvInfoPtr);
1507 return (infoPtr->pCallBackSort->lpfnCompare)(
1508 ((TREEVIEW_ITEM*)first)->lParam,
1509 ((TREEVIEW_ITEM*)second)->lParam,
1510 infoPtr->pCallBackSort->lParam);
1511 }
1512
1513 /***************************************************************************
1514 * Treeview native sort routine: sort on item text.
1515 */
1516 static INT WINAPI TREEVIEW_SortOnName (
1517 LPVOID first,
1518 LPVOID second,
1519 LPARAM tvInfoPtr)
1520 {
1521 HWND hwnd=(HWND) tvInfoPtr;
1522 char *txt1, *txt2;
1523 TREEVIEW_ITEM *item;
1524
1525
1526 item=(TREEVIEW_ITEM *) first;
1527 if (item->pszText==LPSTR_TEXTCALLBACKA) {
1528 TREEVIEW_SendDispInfoNotify (hwnd, item, TVN_GETDISPINFOA, TVIF_TEXT);
1529 }
1530 txt1=item->pszText;
1531
1532 item=(TREEVIEW_ITEM *) second;
1533 if (item->pszText==LPSTR_TEXTCALLBACKA) {
1534 TREEVIEW_SendDispInfoNotify (hwnd, item, TVN_GETDISPINFOA, TVIF_TEXT);
1535 }
1536 txt2=item->pszText;
1537
1538 return -strcmp (txt1,txt2);
1539 }
1540
1541 /***************************************************************************
1542 * Setup the treeview structure with regards of the sort method
1543 * and sort the children of the TV item specified in lParam
1544 * fRecurse: currently unused. Should be zero.
1545 * parent: if pSort!=NULL, should equal pSort->hParent.
1546 * otherwise, item which child items are to be sorted.
1547 * pSort: sort method info. if NULL, sort on item text.
1548 * if non-NULL, sort on item's lParam content, and let the
1549 * application decide what that means. See also TVM_SORTCHILDRENCB.
1550 */
1551
1552 static LRESULT WINAPI TREEVIEW_Sort (
1553 HWND hwnd,
1554 BOOL fRecurse,
1555 HTREEITEM parent,
1556 LPTVSORTCB pSort
1557 )
1558 {
1559 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
1560 TREEVIEW_ITEM *sortMe = NULL; /* Node for which we sort the children */
1561
1562 /* Obtain the TVSORTBC struct */
1563 infoPtr->pCallBackSort = pSort;
1564
1565 /* undocumented feature: TVI_ROOT means `sort the whole tree' */
1566
1567 if (parent==TVI_ROOT)
1568 parent=infoPtr->TopRootItem;
1569
1570 /* Check for a valid handle to the parent item */
1571 if (!TREEVIEW_ValidItem(infoPtr, parent))
1572 {
1573 ERR ("invalid item hParent=%x\n", (INT)parent);
1574 return FALSE;
1575 }
1576
1577 /* Obtain the parent node to sort */
1578 sortMe = &infoPtr->items[ (INT)parent ];
1579
1580 /* Make sure there is something to sort */
1581 if ( sortMe->cChildren > 1 )
1582 {
1583 /* pointer organization */
1584 HDPA sortList = DPA_Create(sortMe->cChildren);
1585 HTREEITEM itemHandle = sortMe->firstChild;
1586 TREEVIEW_ITEM *itemPtr = & infoPtr->items[ (INT)itemHandle ];
1587
1588 /* TREEVIEW_ITEM rechaining */
1589 INT count = 0;
1590 VOID *item = 0;
1591 VOID *nextItem = 0;
1592 VOID *prevItem = 0;
1593
1594 /* Build the list of item to sort */
1595 do
1596 {
1597 DPA_InsertPtr(
1598 sortList, /* the list */
1599 sortMe->cChildren+1, /* force the insertion to be an append */
1600 itemPtr); /* the ptr to store */
1601
1602 /* Get the next sibling */
1603 itemHandle = itemPtr->sibling;
1604 itemPtr = & infoPtr->items[ (INT)itemHandle ];
1605 } while ( itemHandle != NULL );
1606
1607 /* let DPA perform the sort activity */
1608 if (pSort)
1609 DPA_Sort(
1610 sortList, /* what */
1611 TREEVIEW_CallBackCompare, /* how */
1612 hwnd); /* owner */
1613 else
1614 DPA_Sort (
1615 sortList, /* what */
1616 TREEVIEW_SortOnName, /* how */
1617 hwnd); /* owner */
1618
1619 /*
1620 * Reorganized TREEVIEW_ITEM structures.
1621 * Note that we know we have at least two elements.
1622 */
1623
1624 /* Get the first item and get ready to start... */
1625 item = DPA_GetPtr(sortList, count++);
1626 while ( (nextItem = DPA_GetPtr(sortList, count++)) != NULL )
1627 {
1628 /* link the two current item toghether */
1629 ((TREEVIEW_ITEM*)item)->sibling = ((TREEVIEW_ITEM*)nextItem)->hItem;
1630 ((TREEVIEW_ITEM*)nextItem)->upsibling = ((TREEVIEW_ITEM*)item)->hItem;
1631
1632 if (prevItem == NULL) /* this is the first item, update the parent */
1633 {
1634 sortMe->firstChild = ((TREEVIEW_ITEM*)item)->hItem;
1635 ((TREEVIEW_ITEM*)item)->upsibling = NULL;
1636 }
1637 else /* fix the back chaining */
1638 {
1639 ((TREEVIEW_ITEM*)item)->upsibling = ((TREEVIEW_ITEM*)prevItem)->hItem;
1640 }
1641
1642 /* get ready for the next one */
1643 prevItem = item;
1644 item = nextItem;
1645 }
1646
1647 /* the last item is pointed to by item and never has a sibling */
1648 ((TREEVIEW_ITEM*)item)->sibling = NULL;
1649
1650 DPA_Destroy(sortList);
1651
1652 return TRUE;
1653 }
1654 return FALSE;
1655 }
1656
1657
1658 /***************************************************************************
1659 * Setup the treeview structure with regards of the sort method
1660 * and sort the children of the TV item specified in lParam
1661 */
1662 static LRESULT WINAPI TREEVIEW_SortChildrenCB(
1663 HWND hwnd,
1664 WPARAM wParam,
1665 LPARAM lParam
1666 )
1667 {
1668 LPTVSORTCB pSort=(LPTVSORTCB) lParam;
1669
1670 return TREEVIEW_Sort (hwnd, wParam, pSort->hParent, pSort);
1671 }
1672
1673
1674 /***************************************************************************
1675 * Sort the children of the TV item specified in lParam.
1676 */
1677 static LRESULT WINAPI TREEVIEW_SortChildren (
1678 HWND hwnd,
1679 WPARAM wParam,
1680 LPARAM lParam)
1681 {
1682 return TREEVIEW_Sort (hwnd, (BOOL) wParam, (HTREEITEM) lParam, NULL);
1683 }
1684
1685
1686
1687 /* the method used below isn't the most memory-friendly, but it avoids
1688 a lot of memory reallocations */
1689
1690 /* BTW: we waste handle 0; 0 is not an allowed handle. */
1691
1692 static LRESULT
1693 TREEVIEW_InsertItemA (HWND hwnd, WPARAM wParam, LPARAM lParam)
1694
1695 {
1696 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
1697 TVINSERTSTRUCTA *ptdi;
1698 TVITEMEXA *tvItem;
1699 TREEVIEW_ITEM *wineItem, *parentItem, *prevsib, *sibItem;
1700 INT iItem,listItems,i,len;
1701
1702 /* Item to insert */
1703 ptdi = (LPTVINSERTSTRUCTA) lParam;
1704
1705 /* check if memory is available */
1706
1707 if (infoPtr->uNumPtrsAlloced==0) {
1708 infoPtr->items = COMCTL32_Alloc (TVITEM_ALLOC*sizeof (TREEVIEW_ITEM));
1709 infoPtr->freeList= COMCTL32_Alloc ((1+(TVITEM_ALLOC>>5)) * sizeof (INT));
1710 infoPtr->uNumPtrsAlloced=TVITEM_ALLOC;
1711 infoPtr->TopRootItem=(HTREEITEM)1;
1712 }
1713
1714 /*
1715 * Reallocate contiguous space for items
1716 */
1717 if (infoPtr->uNumItems == (infoPtr->uNumPtrsAlloced-1) ) {
1718 TREEVIEW_ITEM *oldItems = infoPtr->items;
1719 INT *oldfreeList = infoPtr->freeList;
1720
1721 infoPtr->uNumPtrsAlloced*=2;
1722 infoPtr->items = COMCTL32_Alloc (infoPtr->uNumPtrsAlloced*sizeof (TREEVIEW_ITEM));
1723 infoPtr->freeList= COMCTL32_Alloc ((1+(infoPtr->uNumPtrsAlloced>>5))*sizeof (INT));
1724
1725 memcpy (&infoPtr->items[0], &oldItems[0],
1726 infoPtr->uNumPtrsAlloced/2 * sizeof(TREEVIEW_ITEM));
1727 memcpy (&infoPtr->freeList[0], &oldfreeList[0],
1728 (infoPtr->uNumPtrsAlloced>>6) * sizeof(INT));
1729
1730 COMCTL32_Free (oldItems);
1731 COMCTL32_Free (oldfreeList);
1732 }
1733
1734 /*
1735 * Reset infoPtr structure with new stat according to current TV picture
1736 */
1737 iItem=0;
1738 infoPtr->uNumItems++;
1739 if ((INT)infoPtr->uMaxHandle==(infoPtr->uNumItems-1)) {
1740 iItem=infoPtr->uNumItems;
1741 infoPtr->uMaxHandle = (HTREEITEM)((INT)infoPtr->uMaxHandle + 1);
1742 } else { /* check freelist */
1743 for (i=0; i<=infoPtr->uNumPtrsAlloced>>5; i++) {
1744 if (infoPtr->freeList[i]) {
1745 iItem=ffs (infoPtr->freeList[i])-1;
1746 tv_clear_bit(iItem,&infoPtr->freeList[i]);
1747 iItem+=i<<5;
1748 break;
1749 }
1750 }
1751 }
1752
1753 if (TRACE_ON(treeview)) {
1754 for (i=0; i<=infoPtr->uNumPtrsAlloced>>5; i++)
1755 TRACE("%8x\n",infoPtr->freeList[i]);
1756 }
1757
1758 if (!iItem) ERR("Argh -- can't find free item.\n");
1759
1760 /*
1761 * Find the parent item of the new item
1762 */
1763 tvItem= & ptdi->DUMMYUNIONNAME.itemex;
1764 wineItem=& infoPtr->items[iItem];
1765
1766 if ((ptdi->hParent==TVI_ROOT) || (ptdi->hParent==0)) {
1767 parentItem = NULL;
1768 wineItem->parent = 0;
1769 sibItem = &infoPtr->items [(INT)infoPtr->TopRootItem];
1770 listItems = infoPtr->uNumItems;
1771 }
1772 else {
1773 parentItem = &infoPtr->items[(INT)ptdi->hParent];
1774
1775 /* Do the insertion here it if it's the only item of this parent */
1776 if (!parentItem->firstChild)
1777 parentItem->firstChild=(HTREEITEM)iItem;
1778
1779 wineItem->parent = ptdi->hParent;
1780 sibItem = &infoPtr->items [(INT)parentItem->firstChild];
1781 listItems = parentItem->cChildren;
1782 parentItem->cChildren++;
1783 }
1784
1785
1786 /* NOTE: I am moving some setup of the wineItem object that was initialy
1787 * done at the end of the function since some of the values are
1788 * required by the Callback sorting
1789 */
1790
1791 if (tvItem->mask & TVIF_TEXT)
1792 {
1793 /*
1794 * Setup the item text stuff here since it's required by the Sort method
1795 * when the insertion are ordered
1796 */
1797 if (tvItem->pszText!=LPSTR_TEXTCALLBACKA)
1798 {
1799 TRACE("(%p,%s)\n", &tvItem->pszText, tvItem->pszText);
1800 len = lstrlenA (tvItem->pszText)+1;
1801 wineItem->pszText= COMCTL32_Alloc (len+1);
1802 lstrcpyA (wineItem->pszText, tvItem->pszText);
1803 wineItem->cchTextMax=len;
1804 }
1805 else
1806 {
1807 TRACE("LPSTR_TEXTCALLBACK\n");
1808 wineItem->pszText = LPSTR_TEXTCALLBACKA;
1809 wineItem->cchTextMax = 0;
1810 }
1811 }
1812
1813 if (tvItem->mask & TVIF_PARAM)
1814 wineItem->lParam=tvItem->lParam;
1815
1816
1817 wineItem->upsibling=0; /* needed in case we're the first item in a list */
1818 wineItem->sibling=0;
1819 wineItem->firstChild=0;
1820 wineItem->hItem=(HTREEITEM)iItem;
1821
1822 if (listItems!=0) {
1823 prevsib=NULL;
1824
1825 switch ((DWORD) ptdi->hInsertAfter) {
1826 case (DWORD) TVI_FIRST:
1827 if (sibItem==wineItem) break;
1828 if (wineItem->parent) {
1829 wineItem->sibling=parentItem->firstChild;
1830 parentItem->firstChild=(HTREEITEM)iItem;
1831 } else {
1832 wineItem->sibling=infoPtr->TopRootItem;
1833 infoPtr->TopRootItem=(HTREEITEM)iItem;
1834 }
1835 sibItem->upsibling=(HTREEITEM)iItem;
1836 break;
1837
1838 case (DWORD) TVI_SORT:
1839 if (sibItem==wineItem)
1840 /*
1841 * This item is the first child of the level and it
1842 * has already been inserted
1843 */
1844 break;
1845 else
1846 {
1847 TREEVIEW_ITEM *aChild;
1848
1849
1850 TREEVIEW_ITEM *previousChild = NULL;
1851 BOOL bItemInserted = FALSE;
1852
1853 if (parentItem)
1854 aChild = &infoPtr->items[(INT)parentItem->firstChild];
1855 else
1856 aChild = &infoPtr->items[(INT)infoPtr->TopRootItem];
1857
1858 /* lookup the text if using LPSTR_TEXTCALLBACKs */
1859 if (wineItem->pszText==LPSTR_TEXTCALLBACKA) {
1860 TREEVIEW_SendDispInfoNotify (hwnd, wineItem, TVN_GETDISPINFOA, TVIF_TEXT);
1861 }
1862
1863 /* Iterate the parent children to see where we fit in */
1864 while ( aChild != NULL )
1865 {
1866 INT comp;
1867
1868 /* lookup the text if using LPSTR_TEXTCALLBACKs */
1869 if (aChild->pszText==LPSTR_TEXTCALLBACKA) {
1870 TREEVIEW_SendDispInfoNotify (hwnd, aChild, TVN_GETDISPINFOA, TVIF_TEXT);
1871 }
1872
1873 comp = strcmp(wineItem->pszText, aChild->pszText);
1874 if ( comp < 0 ) /* we are smaller than the current one */
1875 {
1876 TREEVIEW_InsertBefore(infoPtr, wineItem, aChild, parentItem);
1877 bItemInserted = TRUE;
1878 break;
1879 }
1880 else if ( comp > 0 ) /* we are bigger than the current one */
1881 {
1882 previousChild = aChild;
1883 aChild = (aChild->sibling == 0) /* This will help us to exit */
1884 ? NULL /* if there is no more sibling */
1885 : &infoPtr->items[(INT)aChild->sibling];
1886
1887 /* Look at the next item */
1888 continue;
1889 }
1890 else if ( comp == 0 )
1891 {
1892 /*
1893 * An item with this name is already existing, therefore,
1894 * we add after the one we found
1895 */
1896 TREEVIEW_InsertAfter(infoPtr, wineItem, aChild, parentItem);
1897 bItemInserted = TRUE;
1898 break;
1899 }
1900 }
1901
1902 /*
1903 * we reach the end of the child list and the item as not
1904 * yet been inserted, therefore, insert it after the last child.
1905 */
1906 if ( (! bItemInserted ) && (aChild == NULL) )
1907 TREEVIEW_InsertAfter(infoPtr, wineItem, previousChild, parentItem);
1908
1909 break;
1910 }
1911
1912
1913 case (DWORD) TVI_LAST:
1914 if (sibItem==wineItem) break;
1915 while (sibItem->sibling) {
1916 prevsib=sibItem;
1917 sibItem=&infoPtr->items [(INT)sibItem->sibling];
1918 }
1919 sibItem->sibling=(HTREEITEM)iItem;
1920 wineItem->upsibling=sibItem->hItem;
1921 break;
1922 default:
1923 while ((sibItem->sibling) && (sibItem->hItem!=ptdi->hInsertAfter))
1924 {
1925 prevsib=sibItem;
1926 sibItem=&infoPtr->items [(INT)sibItem->sibling];
1927 }
1928 if (sibItem->hItem!=ptdi->hInsertAfter) {
1929 ERR("tried to insert item after nonexisting handle %d.\n",
1930 (INT) ptdi->hInsertAfter);
1931 break;
1932 }
1933 prevsib=sibItem;
1934 if (sibItem->sibling) {
1935 sibItem=&infoPtr->items [(INT)sibItem->sibling];
1936 sibItem->upsibling=(HTREEITEM)iItem;
1937 wineItem->sibling=sibItem->hItem;
1938 }
1939 prevsib->sibling=(HTREEITEM)iItem;
1940 wineItem->upsibling=prevsib->hItem;
1941 break;
1942 }
1943 }
1944
1945
1946 /* Fill in info structure */
1947
1948 TRACE("new item %d; parent %d, mask %x\n", iItem,
1949 (INT)wineItem->parent,tvItem->mask);
1950
1951 wineItem->mask=tvItem->mask;
1952 wineItem->iIntegral=1;
1953
1954 if (tvItem->mask & TVIF_CHILDREN) {
1955 wineItem->cChildren=tvItem->cChildren;
1956 if (tvItem->cChildren==I_CHILDRENCALLBACK)
1957 FIXME(" I_CHILDRENCALLBACK not supported\n");
1958 }
1959
1960 wineItem->expandBox.left = 0; /* Initialize the expandBox */
1961 wineItem->expandBox.top = 0;
1962 wineItem->expandBox.right = 0;
1963 wineItem->expandBox.bottom = 0;
1964
1965 if (tvItem->mask & TVIF_IMAGE)
1966 wineItem->iImage=tvItem->iImage;
1967
1968 /* If the application sets TVIF_INTEGRAL without
1969 supplying a TVITEMEX structure, it's toast */
1970
1971 if (tvItem->mask & TVIF_INTEGRAL)
1972 wineItem->iIntegral=tvItem->iIntegral;
1973
1974 if (tvItem->mask & TVIF_SELECTEDIMAGE)
1975 wineItem->iSelectedImage=tvItem->iSelectedImage;
1976
1977 if (tvItem->mask & TVIF_STATE) {
1978 TRACE("item state: %x ->%x\n", wineItem->state, tvItem->state);
1979 TRACE("statemask: %x ->%x\n", wineItem->stateMask, tvItem->stateMask);
1980 wineItem->state=tvItem->state;
1981 wineItem->stateMask=tvItem->stateMask;
1982 }
1983
1984 TREEVIEW_QueueRefresh (hwnd);
1985
1986 return (LRESULT) iItem;
1987 }
1988
1989
1990 static LRESULT
1991 TREEVIEW_InsertItemW(HWND hwnd, WPARAM wParam, LPARAM lParam)
1992 {
1993 TVINSERTSTRUCTW *tvisW;
1994 TVINSERTSTRUCTA tvisA;
1995 LRESULT lRes;
1996
1997 tvisW = (LPTVINSERTSTRUCTW)lParam;
1998
1999 tvisA.hParent = tvisW->hParent;
2000 tvisA.hInsertAfter = tvisW->hInsertAfter;
2001
2002 tvisA.DUMMYUNIONNAME.item.mask = tvisW->DUMMYUNIONNAME.item.mask;
2003 tvisA.DUMMYUNIONNAME.item.hItem = tvisW->DUMMYUNIONNAME.item.hItem;
2004 tvisA.DUMMYUNIONNAME.item.state = tvisW->DUMMYUNIONNAME.item.state;
2005 tvisA.DUMMYUNIONNAME.item.stateMask = tvisW->DUMMYUNIONNAME.item.stateMask;
2006 tvisA.DUMMYUNIONNAME.item.cchTextMax = tvisW->DUMMYUNIONNAME.item.cchTextMax;
2007
2008 if(tvisW->DUMMYUNIONNAME.item.pszText)
2009 {
2010 if (tvisW->DUMMYUNIONNAME.item.pszText!=LPSTR_TEXTCALLBACKW)
2011 {
2012 int len = lstrlenW (tvisW->DUMMYUNIONNAME.item.pszText)+1;
2013 tvisA.DUMMYUNIONNAME.item.pszText = COMCTL32_Alloc (len);
2014 lstrcpyWtoA (tvisA.DUMMYUNIONNAME.item.pszText,
2015 tvisW->DUMMYUNIONNAME.item.pszText );
2016 }
2017 else
2018 {
2019 tvisA.DUMMYUNIONNAME.item.pszText = LPSTR_TEXTCALLBACKA;
2020 tvisA.DUMMYUNIONNAME.item.cchTextMax = 0;
2021 }
2022 }
2023
2024 tvisA.DUMMYUNIONNAME.item.iImage = tvisW->DUMMYUNIONNAME.item.iImage;
2025 tvisA.DUMMYUNIONNAME.item.iSelectedImage = tvisW->DUMMYUNIONNAME.item.iSelectedImage;
2026 tvisA.DUMMYUNIONNAME.item.cChildren = tvisW->DUMMYUNIONNAME.item.cChildren;
2027 tvisA.DUMMYUNIONNAME.item.lParam = tvisW->DUMMYUNIONNAME.item.lParam;
2028
2029 lRes = TREEVIEW_InsertItemA(hwnd,wParam,(LPARAM)&tvisA);
2030
2031 if (tvisA.DUMMYUNIONNAME.item.pszText!=LPSTR_TEXTCALLBACKA)
2032 {
2033 COMCTL32_Free(tvisA.DUMMYUNIONNAME.item.pszText);
2034 }
2035
2036 return lRes;
2037
2038 }
2039
2040
2041 static LRESULT
2042 TREEVIEW_DeleteItem (HWND hwnd, WPARAM wParam, LPARAM lParam)
2043 {
2044 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
2045 INT iItem;
2046 TREEVIEW_ITEM *wineItem;
2047
2048 TRACE("item = %08lx\n", lParam);
2049
2050 if (lParam == (INT)TVI_ROOT) {
2051 TREEVIEW_RemoveTree (hwnd);
2052 } else {
2053 iItem= (INT) lParam;
2054 wineItem = TREEVIEW_ValidItem (infoPtr, (HTREEITEM)iItem);
2055 if (!wineItem) return FALSE;
2056
2057 if (wineItem->pszText==LPSTR_TEXTCALLBACKA)
2058 TRACE("LPSTR_TEXTCALLBACK\n");
2059 else
2060 TRACE("%s\n",wineItem->pszText);
2061 TREEVIEW_RemoveItem (hwnd, wineItem);
2062 }
2063
2064 TREEVIEW_QueueRefresh (hwnd);
2065
2066 return TRUE;
2067 }
2068
2069
2070
2071 static LRESULT
2072 TREEVIEW_GetIndent (HWND hwnd)
2073 {
2074 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
2075
2076 TRACE("\n");
2077 return infoPtr->uIndent;
2078 }
2079
2080 static LRESULT
2081 TREEVIEW_SetIndent (HWND hwnd, WPARAM wParam)
2082 {
2083 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
2084 INT newIndent;
2085
2086 TRACE("\n");
2087 newIndent=(INT) wParam;
2088 if (newIndent < MINIMUM_INDENT) newIndent=MINIMUM_INDENT;
2089 infoPtr->uIndent=newIndent;
2090
2091 return 0;
2092 }
2093
2094 static LRESULT
2095 TREEVIEW_GetToolTips (HWND hwnd)
2096
2097 {
2098 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
2099
2100 TRACE("\n");
2101 return infoPtr->hwndToolTip;
2102 }
2103
2104
2105 static LRESULT
2106 TREEVIEW_SetToolTips (HWND hwnd, WPARAM wParam)
2107
2108 {
2109 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
2110 HWND prevToolTip;
2111
2112 TRACE("\n");
2113 prevToolTip=infoPtr->hwndToolTip;
2114 infoPtr->hwndToolTip= (HWND) wParam;
2115
2116 return prevToolTip;
2117 }
2118
2119
2120 static LRESULT CALLBACK
2121 TREEVIEW_GetEditControl (HWND hwnd)
2122
2123 {
2124 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
2125
2126 return infoPtr->hwndEdit;
2127 }
2128
2129 LRESULT CALLBACK
2130 TREEVIEW_Edit_SubclassProc (HWND hwnd, UINT uMsg, WPARAM wParam,
2131 LPARAM lParam)
2132 {
2133 switch (uMsg)
2134 {
2135 case WM_ERASEBKGND:
2136 {
2137 RECT rc;
2138 HDC hdc = (HDC) wParam;
2139 GetClientRect (hwnd, &rc);
2140 Rectangle (hdc, rc.left, rc.top, rc.right, rc.bottom);
2141 return -1;
2142 }
2143
2144 case WM_GETDLGCODE:
2145 {
2146 return DLGC_WANTARROWS | DLGC_WANTALLKEYS;
2147 }
2148
2149 default:
2150 {
2151 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(GetParent(hwnd));
2152 if (infoPtr!=NULL)
2153 return CallWindowProcA (infoPtr->wpEditOrig, hwnd, uMsg, wParam, lParam);
2154 else
2155 break;
2156
2157 }
2158 }
2159
2160 return 0;
2161 }
2162
2163
2164 /* should handle edit control messages here */
2165
2166 static LRESULT
2167 TREEVIEW_Command (HWND hwnd, WPARAM wParam, LPARAM lParam)
2168
2169 {
2170 TRACE("%x %ld\n",wParam, lParam);
2171
2172 switch (HIWORD(wParam))
2173 {
2174 case EN_UPDATE:
2175 {
2176 /*
2177 * Adjust the edit window size
2178 */
2179 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
2180 TREEVIEW_ITEM *editItem = TREEVIEW_ValidItem(infoPtr, infoPtr->editItem);
2181 INT iLength = GetWindowTextLengthA(infoPtr->hwndEdit);
2182 HDC hdc = GetDC(infoPtr->hwndEdit);
2183 TEXTMETRICA tm;
2184
2185 if ( GetTextMetricsA(hdc, &tm) )
2186 {
2187 LONG newWidth = (iLength * tm.tmAveCharWidth) + 15;
2188
2189 SetWindowPos (
2190 infoPtr->hwndEdit,
2191 HWND_TOP,
2192 editItem->text.left - 2,
2193 editItem->text.top - 1,
2194 newWidth,
2195 editItem->text.bottom - editItem->text.top + 3,
2196 SWP_DRAWFRAME );
2197 }
2198 ReleaseDC(hwnd, hdc);
2199
2200 break;
2201 }
2202
2203 case EN_KILLFOCUS:
2204 /* TREEVIEW_EndEditLabelNow(hwnd, (WPARAM)FALSE, 0);
2205 */
2206 break;
2207
2208 default:
2209 return SendMessageA (GetParent (hwnd), WM_COMMAND, wParam, lParam);
2210 }
2211
2212 return 0;
2213 }
2214
2215 static LRESULT
2216 TREEVIEW_Size (HWND hwnd, WPARAM wParam, LPARAM lParam)
2217
2218 {
2219 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
2220
2221 if (infoPtr->bAutoSize)
2222 {
2223 infoPtr->bAutoSize = FALSE;
2224 return 0;
2225 }
2226 infoPtr->bAutoSize = TRUE;
2227
2228 if (wParam == SIZE_RESTORED)
2229 {
2230 infoPtr->uTotalWidth = LOWORD (lParam);
2231 infoPtr->uTotalHeight = HIWORD (lParam);
2232 } else {
2233 FIXME("WM_SIZE flag %x %lx not handled\n", wParam, lParam);
2234 }
2235
2236 TREEVIEW_QueueRefresh (hwnd);
2237 return 0;
2238 }
2239
2240
2241
2242 static LRESULT
2243 TREEVIEW_StyleChanged (HWND hwnd, WPARAM wParam, LPARAM lParam)
2244 {
2245 HDC hdc;
2246
2247 TRACE("(%x %lx)\n",wParam,lParam);
2248 hdc = GetDC (hwnd);
2249 TREEVIEW_Refresh (hwnd, hdc);
2250 ReleaseDC(hwnd,hdc);
2251
2252 return 0;
2253 }
2254
2255 static LRESULT
2256 TREEVIEW_Create (HWND hwnd, WPARAM wParam, LPARAM lParam)
2257 {
2258 TREEVIEW_INFO *infoPtr;
2259 DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
2260 LOGFONTA logFont;
2261 TEXTMETRICA tm;
2262 HDC hdc;
2263
2264 TRACE("wnd %x, style %lx\n",hwnd,dwStyle);
2265 /* allocate memory for info structure */
2266 infoPtr = (TREEVIEW_INFO *) COMCTL32_Alloc (sizeof(TREEVIEW_INFO));
2267
2268 SetWindowLongA( hwnd, 0, (DWORD)infoPtr);
2269
2270 if (infoPtr == NULL) {
2271 ERR("could not allocate info memory!\n");
2272 return 0;
2273 }
2274
2275 if ((TREEVIEW_INFO*) GetWindowLongA( hwnd, 0) != infoPtr) {
2276 ERR("pointer assignment error!\n");
2277 return 0;
2278 }
2279
2280 hdc=GetDC (hwnd);
2281
2282 /* set default settings */
2283 infoPtr->uInternalStatus=0;
2284 infoPtr->uNumItems=0;
2285 infoPtr->clrBk = GetSysColor (COLOR_WINDOW);
2286 infoPtr->clrText = GetSysColor (COLOR_WINDOWTEXT);
2287 infoPtr->clrLine = GetSysColor (COLOR_WINDOWTEXT);
2288 infoPtr->clrInsertMark = GetSysColor (COLOR_BTNTEXT);
2289 infoPtr->cy = 0;
2290 infoPtr->cx = 0;
2291 infoPtr->uIndent = 15;
2292 infoPtr->himlNormal = NULL;
2293 infoPtr->himlState = NULL;
2294 infoPtr->uItemHeight = -1;
2295 GetTextMetricsA (hdc, &tm);
2296 infoPtr->hFont = GetStockObject (DEFAULT_GUI_FONT);
2297 GetObjectA (infoPtr->hFont, sizeof (LOGFONTA), &logFont);
2298 logFont.lfWeight=FW_BOLD;
2299 infoPtr->hBoldFont = CreateFontIndirectA (&logFont);
2300
2301 infoPtr->items = NULL;
2302 infoPtr->selectedItem=0;
2303 infoPtr->clrText=-1; /* use system color */
2304 infoPtr->dropItem=0;
2305 infoPtr->insertMarkItem=0;
2306 infoPtr->insertBeforeorAfter=0;
2307 infoPtr->pCallBackSort=NULL;
2308 infoPtr->uScrollTime = 300; /* milliseconds */
2309 infoPtr->wpEditOrig = NULL; /* we haven't subclassed anything yet */
2310
2311 infoPtr->hwndToolTip=0;
2312 if (!(dwStyle & TVS_NOTOOLTIPS)) { /* Create tooltip control */
2313 TTTOOLINFOA ti;
2314
2315 infoPtr->hwndToolTip =
2316 CreateWindowExA (0, TOOLTIPS_CLASSA, NULL, 0,
2317 CW_USEDEFAULT, CW_USEDEFAULT,
2318 CW_USEDEFAULT, CW_USEDEFAULT,
2319 hwnd, 0, 0, 0);
2320
2321 /* Send NM_TOOLTIPSCREATED notification */
2322 if (infoPtr->hwndToolTip) {
2323 NMTOOLTIPSCREATED nmttc;
2324
2325 nmttc.hdr.hwndFrom = hwnd;
2326 nmttc.hdr.idFrom = GetWindowLongA( hwnd, GWL_ID);
2327 nmttc.hdr.code = NM_TOOLTIPSCREATED;
2328 nmttc.hwndToolTips = infoPtr->hwndToolTip;
2329
2330 SendMessageA (GetParent (hwnd), WM_NOTIFY,
2331 (WPARAM) GetWindowLongA( hwnd, GWL_ID), (LPARAM)&nmttc);
2332 }
2333
2334 ZeroMemory (&ti, sizeof(TTTOOLINFOA));
2335 ti.cbSize = sizeof(TTTOOLINFOA);
2336 ti.uFlags = TTF_IDISHWND | TTF_TRACK | TTF_TRANSPARENT ;
2337 ti.hwnd = hwnd;
2338 ti.uId = 0;
2339 ti.lpszText = "Test"; /* LPSTR_TEXTCALLBACK; */
2340 SetRectEmpty (&ti.rect);
2341
2342 SendMessageA (infoPtr->hwndToolTip, TTM_ADDTOOLA, 0, (LPARAM)&ti);
2343 }
2344
2345 infoPtr->hwndEdit = CreateWindowExA (
2346 WS_EX_LEFT,
2347 "EDIT",
2348 0,
2349 WS_CHILD | WS_BORDER | ES_AUTOHSCROLL |
2350 ES_WANTRETURN | ES_LEFT,
2351 0, 0, 0, 0,
2352 hwnd,
2353 0,0,0); /* FIXME: (HMENU)IDTVEDIT,pcs->hInstance,0);*/
2354
2355 SendMessageA ( infoPtr->hwndEdit, WM_SETFONT, infoPtr->hFont, FALSE);
2356 infoPtr->wpEditOrig = (WNDPROC)SetWindowLongA (
2357 infoPtr->hwndEdit,
2358 GWL_WNDPROC,
2359 (LONG) TREEVIEW_Edit_SubclassProc);
2360
2361 if (dwStyle & TVS_CHECKBOXES) {
2362 HBITMAP hbmLoad;
2363 int nIndex;
2364
2365 infoPtr->himlState =
2366 ImageList_Create (16, 16,ILC_COLOR|ILC_MASK, 15, 1);
2367
2368 hbmLoad = LoadBitmapA (COMCTL32_hModule, MAKEINTRESOURCEA(IDT_CHECK));
2369 TRACE ("%x\n",hbmLoad);
2370 nIndex = ImageList_AddMasked (infoPtr->himlState, hbmLoad, CLR_DEFAULT);
2371 TRACE ("%d\n",nIndex);
2372 DeleteObject (hbmLoad);
2373 }
2374 ReleaseDC (hwnd, hdc);
2375 return 0;
2376 }
2377
2378
2379
2380 static LRESULT
2381 TREEVIEW_Destroy (HWND hwnd)
2382 {
2383 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
2384
2385 TRACE("\n");
2386 TREEVIEW_RemoveTree (hwnd);
2387 SetWindowLongA (hwnd, 0, (DWORD)NULL);
2388
2389 if (infoPtr->Timer & TV_REFRESH_TIMER_SET)
2390 KillTimer (hwnd, TV_REFRESH_TIMER);
2391 if (infoPtr->hwndToolTip)
2392 DestroyWindow (infoPtr->hwndToolTip);
2393
2394 COMCTL32_Free (infoPtr);
2395 return 0;
2396 }
2397
2398
2399 static LRESULT
2400 TREEVIEW_Paint (HWND hwnd, WPARAM wParam, LPARAM lParam)
2401 {
2402 HDC hdc;
2403 PAINTSTRUCT ps;
2404
2405 TRACE("\n");
2406 hdc = wParam==0 ? BeginPaint (hwnd, &ps) : (HDC)wParam;
2407 TREEVIEW_Refresh (hwnd, hdc);
2408 ReleaseDC(hwnd,hdc);
2409 if(!wParam) EndPaint (hwnd, &ps);
2410 TRACE("done\n");
2411
2412 return DefWindowProcA (hwnd, WM_PAINT, wParam, lParam);
2413 }
2414
2415 static LRESULT
2416 TREEVIEW_SetFocus (HWND hwnd, WPARAM wParam, LPARAM lParam)
2417 {
2418 TREEVIEW_SendSimpleNotify (hwnd, NM_SETFOCUS);
2419 InvalidateRect(hwnd, NULL, FALSE);
2420 return 0;
2421 }
2422
2423 static LRESULT
2424 TREEVIEW_KillFocus (HWND hwnd, WPARAM wParam, LPARAM lParam)
2425 {
2426 TREEVIEW_SendSimpleNotify (hwnd, NM_KILLFOCUS);
2427 InvalidateRect(hwnd, NULL, FALSE);
2428 return 0;
2429 }
2430
2431 static LRESULT
2432 TREEVIEW_EraseBackground (HWND hwnd, WPARAM wParam, LPARAM lParam)
2433 {
2434 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
2435 HBRUSH hBrush = CreateSolidBrush (infoPtr->clrBk);
2436 RECT rect;
2437
2438 TRACE("\n");
2439 GetClientRect (hwnd, &rect);
2440 FillRect ((HDC)wParam, &rect, hBrush);
2441 DeleteObject (hBrush);
2442 return TRUE;
2443 }
2444
2445
2446
2447
2448
2449
2450 /* Notifications */
2451
2452
2453
2454
2455
2456 static BOOL
2457 TREEVIEW_SendSimpleNotify (HWND hwnd, UINT code)
2458 {
2459 NMHDR nmhdr;
2460
2461 TRACE("%x\n",code);
2462 nmhdr.hwndFrom = hwnd;
2463 nmhdr.idFrom = GetWindowLongA( hwnd, GWL_ID);
2464 nmhdr.code = code;
2465
2466 return (BOOL) SendMessageA (GetParent (hwnd), WM_NOTIFY,
2467 (WPARAM)nmhdr.idFrom, (LPARAM)&nmhdr);
2468 }
2469
2470
2471
2472 static BOOL
2473 TREEVIEW_SendTreeviewNotify (HWND hwnd, UINT code, UINT action,
2474 HTREEITEM oldItem, HTREEITEM newItem)
2475
2476 {
2477 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
2478 NMTREEVIEWA nmhdr;
2479 TREEVIEW_ITEM *wineItem;
2480
2481 TRACE("code:%x action:%x olditem:%x newitem:%x\n",
2482 code,action,(INT)oldItem,(INT)newItem);
2483 nmhdr.hdr.hwndFrom = hwnd;
2484 nmhdr.hdr.idFrom = GetWindowLongA( hwnd, GWL_ID);
2485 nmhdr.hdr.code = code;
2486 nmhdr.action = action;
2487 if (oldItem) {
2488 wineItem=& infoPtr->items[(INT)oldItem];
2489 nmhdr.itemOld.mask = wineItem->mask;
2490 nmhdr.itemOld.hItem = wineItem->hItem;
2491 nmhdr.itemOld.state = wineItem->state;
2492 nmhdr.itemOld.stateMask = wineItem->stateMask;
2493 nmhdr.itemOld.iImage = wineItem->iImage;
2494 nmhdr.itemOld.pszText = wineItem->pszText;
2495 nmhdr.itemOld.cchTextMax= wineItem->cchTextMax;
2496 nmhdr.itemOld.iImage = wineItem->iImage;
2497 nmhdr.itemOld.iSelectedImage = wineItem->iSelectedImage;
2498 nmhdr.itemOld.cChildren = wineItem->cChildren;
2499 nmhdr.itemOld.lParam = wineItem->lParam;
2500 }
2501
2502 if (newItem) {
2503 wineItem=& infoPtr->items[(INT)newItem];
2504 nmhdr.itemNew.mask = wineItem->mask;
2505 nmhdr.itemNew.hItem = wineItem->hItem;
2506 nmhdr.itemNew.state = wineItem->state;
2507 nmhdr.itemNew.stateMask = wineItem->stateMask;
2508 nmhdr.itemNew.iImage = wineItem->iImage;
2509 nmhdr.itemNew.pszText = wineItem->pszText;
2510 nmhdr.itemNew.cchTextMax= wineItem->cchTextMax;
2511 nmhdr.itemNew.iImage = wineItem->iImage;
2512 nmhdr.itemNew.iSelectedImage = wineItem->iSelectedImage;
2513 nmhdr.itemNew.cChildren = wineItem->cChildren;
2514 nmhdr.itemNew.lParam = wineItem->lParam;
2515 }
2516
2517 nmhdr.ptDrag.x = 0;
2518 nmhdr.ptDrag.y = 0;
2519
2520 return (BOOL)SendMessageA (GetParent (hwnd), WM_NOTIFY,
2521 (WPARAM) GetWindowLongA( hwnd, GWL_ID), (LPARAM)&nmhdr);
2522
2523 }
2524
2525 static BOOL
2526 TREEVIEW_SendTreeviewDnDNotify (HWND hwnd, UINT code, HTREEITEM dragItem,
2527 POINT pt)
2528 {
2529 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
2530 NMTREEVIEWA nmhdr;
2531 TREEVIEW_ITEM *wineItem;
2532
2533 TRACE("code:%x dragitem:%x\n", code,(INT)dragItem);
2534
2535 nmhdr.hdr.hwndFrom = hwnd;
2536 nmhdr.hdr.idFrom = GetWindowLongA( hwnd, GWL_ID);
2537 nmhdr.hdr.code = code;
2538 nmhdr.action = 0;
2539 wineItem=& infoPtr->items[(INT)dragItem];
2540 nmhdr.itemNew.mask = wineItem->mask;
2541 nmhdr.itemNew.hItem = wineItem->hItem;
2542 nmhdr.itemNew.state = wineItem->state;
2543 nmhdr.itemNew.lParam = wineItem->lParam;
2544
2545 nmhdr.ptDrag.x = pt.x;
2546 nmhdr.ptDrag.y = pt.y;
2547
2548 return (BOOL)SendMessageA (GetParent (hwnd), WM_NOTIFY,
2549 (WPARAM) GetWindowLongA( hwnd, GWL_ID), (LPARAM)&nmhdr);
2550
2551 }
2552
2553
2554
2555 static BOOL
2556 TREEVIEW_SendDispInfoNotify (HWND hwnd, TREEVIEW_ITEM *wineItem,
2557 UINT code, UINT what)
2558 {
2559 NMTVDISPINFOA tvdi;
2560 BOOL retval;
2561 char *buf;
2562
2563 TRACE("item %d, action %x, state %d\n",
2564 (INT)wineItem->hItem,
2565 what,
2566 (INT)wineItem->state);
2567
2568 tvdi.hdr.hwndFrom = hwnd;
2569 tvdi.hdr.idFrom = GetWindowLongA( hwnd, GWL_ID);
2570 tvdi.hdr.code = code;
2571 tvdi.item.mask = what;
2572 tvdi.item.hItem = wineItem->hItem;
2573 tvdi.item.state = wineItem->state;
2574 tvdi.item.lParam = wineItem->lParam;
2575 tvdi.item.pszText = COMCTL32_Alloc (128*sizeof(char));
2576 tvdi.item.cchTextMax = 128;
2577 buf = tvdi.item.pszText;
2578
2579 retval=(BOOL)SendMessageA (
2580 GetParent(hwnd),
2581 WM_NOTIFY,
2582 (WPARAM)tvdi.hdr.idFrom,
2583 (LPARAM)&tvdi);
2584
2585 if (what & TVIF_TEXT) {
2586 wineItem->pszText = tvdi.item.pszText;
2587 if (buf==tvdi.item.pszText) {
2588 wineItem->cchTextMax = 128;
2589 } else {
2590 TRACE("user-supplied buffer\n");
2591 COMCTL32_Free (buf);
2592 wineItem->cchTextMax = 0;
2593 }
2594 }
2595 if (what & TVIF_SELECTEDIMAGE)
2596 wineItem->iSelectedImage = tvdi.item.iSelectedImage;
2597 if (what & TVIF_IMAGE)
2598 wineItem->iImage = tvdi.item.iImage;
2599 if (what & TVIF_CHILDREN)
2600 wineItem->cChildren = tvdi.item.cChildren;
2601
2602 return retval;
2603 }
2604
2605
2606
2607 static BOOL
2608 TREEVIEW_SendCustomDrawNotify (HWND hwnd, DWORD dwDrawStage, HDC hdc,
2609 RECT rc)
2610 {
2611 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
2612 NMTVCUSTOMDRAW nmcdhdr;
2613 LPNMCUSTOMDRAW nmcd;
2614
2615 TRACE("drawstage:%lx hdc:%x\n", dwDrawStage, hdc);
2616
2617 nmcd= & nmcdhdr.nmcd;
2618 nmcd->hdr.hwndFrom = hwnd;
2619 nmcd->hdr.idFrom = GetWindowLongA( hwnd, GWL_ID);
2620 nmcd->hdr.code = NM_CUSTOMDRAW;
2621 nmcd->dwDrawStage= dwDrawStage;
2622 nmcd->hdc = hdc;
2623 nmcd->rc.left = rc.left;
2624 nmcd->rc.right = rc.right;
2625 nmcd->rc.bottom = rc.bottom;
2626 nmcd->rc.top = rc.top;
2627 nmcd->dwItemSpec = 0;
2628 nmcd->uItemState = 0;
2629 nmcd->lItemlParam= 0;
2630 nmcdhdr.clrText = infoPtr->clrText;
2631 nmcdhdr.clrTextBk= infoPtr->clrBk;
2632 nmcdhdr.iLevel = 0;
2633
2634 return (BOOL)SendMessageA (GetParent (hwnd), WM_NOTIFY,
2635 (WPARAM) GetWindowLongA( hwnd, GWL_ID), (LPARAM)&nmcdhdr);
2636
2637 }
2638
2639
2640
2641 /* FIXME: need to find out when the flags in uItemState need to be set */
2642
2643 static BOOL
2644 TREEVIEW_SendCustomDrawItemNotify (HWND hwnd, HDC hdc,
2645 TREEVIEW_ITEM *wineItem, UINT uItemDrawState)
2646 {
2647 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
2648 NMTVCUSTOMDRAW nmcdhdr;
2649 LPNMCUSTOMDRAW nmcd;
2650 DWORD dwDrawStage,dwItemSpec;
2651 UINT uItemState;
2652 INT retval;
2653
2654 dwDrawStage=CDDS_ITEM | uItemDrawState;
2655 dwItemSpec=(DWORD)wineItem->hItem;
2656 uItemState=0;
2657 if (wineItem->hItem==infoPtr->selectedItem) uItemState|=CDIS_SELECTED;
2658 if (wineItem->hItem==infoPtr->focusItem) uItemState|=CDIS_FOCUS;
2659 if (wineItem->hItem==infoPtr->hotItem) uItemState|=CDIS_HOT;
2660
2661 nmcd= & nmcdhdr.nmcd;
2662 nmcd->hdr.hwndFrom = hwnd;
2663 nmcd->hdr.idFrom = GetWindowLongA( hwnd, GWL_ID);
2664 nmcd->hdr.code = NM_CUSTOMDRAW;
2665 nmcd->dwDrawStage= dwDrawStage;
2666 nmcd->hdc = hdc;
2667 nmcd->rc.left = wineItem->rect.left;
2668 nmcd->rc.right = wineItem->rect.right;
2669 nmcd->rc.bottom = wineItem->rect.bottom;
2670 nmcd->rc.top = wineItem->rect.top;
2671 nmcd->dwItemSpec = dwItemSpec;
2672 nmcd->uItemState = uItemState;
2673 nmcd->lItemlParam= wineItem->lParam;
2674 nmcdhdr.clrText = infoPtr->clrText;
2675 nmcdhdr.clrTextBk= infoPtr->clrBk;
2676 nmcdhdr.iLevel = wineItem->iLevel;
2677
2678 TRACE("drawstage:%lx hdc:%x item:%lx, itemstate:%x, lItemlParam:%lx\n",
2679 nmcd->dwDrawStage, nmcd->hdc, nmcd->dwItemSpec,
2680 nmcd->uItemState, nmcd->lItemlParam);
2681
2682 retval=SendMessageA (GetParent (hwnd), WM_NOTIFY,
2683 (WPARAM) GetWindowLongA( hwnd, GWL_ID), (LPARAM)&nmcdhdr);
2684
2685 infoPtr->clrText=nmcdhdr.clrText;
2686 infoPtr->clrBk =nmcdhdr.clrTextBk;
2687 return (BOOL) retval;
2688 }
2689
2690
2691
2692 /* Note:If the specified item is the child of a collapsed parent item,
2693 the parent's list of child items is (recursively) expanded to reveal the
2694 specified item. This is mentioned for TREEVIEW_SelectItem; don't
2695 know if it also applies here.
2696 */
2697
2698 static LRESULT
2699 TREEVIEW_Expand (HWND hwnd, WPARAM wParam, LPARAM lParam)
2700 {
2701 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
2702 TREEVIEW_ITEM *wineItem;
2703 UINT flag;
2704 INT expand;
2705
2706 flag = (UINT) wParam;
2707 expand = (INT) lParam;
2708
2709 wineItem = TREEVIEW_ValidItem (infoPtr, (HTREEITEM)expand);
2710
2711 if (!wineItem)
2712 return 0;
2713 if (!wineItem->cChildren)
2714 return 0;
2715
2716 if (wineItem->pszText==LPSTR_TEXTCALLBACKA)
2717 TRACE ("For item %d, flags %d, state %d\n",
2718 expand, flag, wineItem->state);
2719 else
2720 TRACE("For (%s) item:%d, flags %x, state:%d\n",
2721 wineItem->pszText, flag, expand, wineItem->state);
2722
2723 if (wineItem->cChildren==I_CHILDRENCALLBACK) {
2724 FIXME("we don't handle I_CHILDRENCALLBACK yet\n");
2725 return 0;
2726 }
2727
2728 if (flag == TVE_TOGGLE) { /* FIXME: check exact behaviour here */
2729 flag &= ~TVE_TOGGLE; /* ie: bitwise ops or 'case' ops */
2730 if (wineItem->state & TVIS_EXPANDED)
2731 flag |= TVE_COLLAPSE;
2732 else
2733 flag |= TVE_EXPAND;
2734 }
2735
2736 switch (flag)
2737 {
2738 case TVE_COLLAPSERESET:
2739 TRACE(" case TVE_COLLAPSERESET\n");
2740 if (!wineItem->state & TVIS_EXPANDED)
2741 return 0;
2742
2743 wineItem->state &= ~(TVIS_EXPANDEDONCE | TVIS_EXPANDED);
2744 TREEVIEW_RemoveAllChildren (hwnd, wineItem);
2745 break;
2746
2747 case TVE_COLLAPSE:
2748 TRACE(" case TVE_COLLAPSE\n");
2749 if (!wineItem->state & TVIS_EXPANDED)
2750 return 0;
2751
2752 wineItem->state &= ~TVIS_EXPANDED;
2753 break;
2754
2755 case TVE_EXPAND:
2756 TRACE(" case TVE_EXPAND\n");
2757 if (wineItem->state & TVIS_EXPANDED)
2758 return 0;
2759
2760 TRACE(" is not expanded...\n");
2761
2762 if (!(wineItem->state & TVIS_EXPANDEDONCE))
2763 {
2764 TRACE(" and has never been expanded...\n");
2765 wineItem->state |= TVIS_EXPANDED;
2766
2767 /* this item has never been expanded */
2768 if (TREEVIEW_SendTreeviewNotify (
2769 hwnd,
2770 TVN_ITEMEXPANDINGA,
2771 TVE_EXPAND,
2772 0,
2773 (HTREEITEM)expand))
2774 {
2775 TRACE(" TVN_ITEMEXPANDINGA returned TRUE, exiting...\n");
2776 return FALSE;
2777 }
2778
2779 /* FIXME
2780 * Since the TVN_ITEMEXPANDINGA message may has caused the parent to
2781 * insert new items which in turn may have cause items placeholder
2782 * reallocation, I reassign the current item pointer so we have
2783 * something valid to work with...
2784 * However, this should not be necessary,
2785 * investigation required in TREEVIEW_InsertItemA
2786 */
2787 wineItem = TREEVIEW_ValidItem (infoPtr, (HTREEITEM)expand);
2788 if (! wineItem)
2789 {
2790 ERR(
2791 "Catastropic situation, cannot retreive item #%d\n",
2792 expand);
2793 return FALSE;
2794 }
2795
2796 wineItem->state |= TVIS_EXPANDEDONCE;
2797 TRACE(" TVN_ITEMEXPANDINGA sent...\n");
2798
2799 TREEVIEW_SendTreeviewNotify (
2800 hwnd,
2801 TVN_ITEMEXPANDEDA,
2802 TVE_EXPAND,
2803 0,
2804 (HTREEITEM)expand);
2805
2806 TRACE(" TVN_ITEMEXPANDEDA sent...\n");
2807
2808 }
2809 else
2810 {
2811 /* this item has already been expanded */
2812 wineItem->state |= TVIS_EXPANDED;
2813 }
2814 break;
2815
2816 case TVE_EXPANDPARTIAL:
2817 TRACE(" case TVE_EXPANDPARTIAL\n");
2818 FIXME("TVE_EXPANDPARTIAL not implemented\n");
2819 wineItem->state ^=TVIS_EXPANDED;
2820 wineItem->state |=TVIS_EXPANDEDONCE;
2821 break;
2822 }
2823
2824 TRACE("Exiting, Item %d state is now %d...\n",
2825 expand,
2826 wineItem->state);
2827
2828 TREEVIEW_QueueRefresh (hwnd);
2829 return TRUE;
2830 }
2831
2832
2833
2834 static TREEVIEW_ITEM *
2835 TREEVIEW_HitTestPoint (HWND hwnd, POINT pt)
2836 {
2837 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
2838 TREEVIEW_ITEM *wineItem;
2839 RECT rect;
2840
2841 GetClientRect (hwnd, &rect);
2842
2843 if (!infoPtr->firstVisible) return NULL;
2844
2845 wineItem=&infoPtr->items [(INT)infoPtr->firstVisible];
2846
2847 while ((wineItem!=NULL) && (pt.y > wineItem->rect.bottom))
2848 wineItem=TREEVIEW_GetNextListItem (infoPtr,wineItem);
2849
2850 if (!wineItem)
2851 return NULL;
2852
2853 return wineItem;
2854 }
2855
2856
2857
2858
2859 static LRESULT
2860 TREEVIEW_HitTest (HWND hwnd, LPARAM lParam)
2861 {
2862 LPTVHITTESTINFO lpht=(LPTVHITTESTINFO) lParam;
2863 TREEVIEW_ITEM *wineItem;
2864 RECT rect;
2865 UINT status,x,y;
2866
2867 GetClientRect (hwnd, &rect);
2868 status=0;
2869 x=lpht->pt.x;
2870 y=lpht->pt.y;
2871 if (x < rect.left) status|=TVHT_TOLEFT;
2872 if (x > rect.right) status|=TVHT_TORIGHT;
2873 if (y < rect.top ) status|=TVHT_ABOVE;
2874 if (y > rect.bottom) status|=TVHT_BELOW;
2875
2876 if (status) {
2877 lpht->flags=status;
2878 return 0;
2879 }
2880
2881 wineItem=TREEVIEW_HitTestPoint (hwnd, lpht->pt);
2882 if (!wineItem) {
2883 lpht->flags=TVHT_NOWHERE;
2884 return 0;
2885 }
2886
2887 lpht->flags=0;
2888
2889 if (x < wineItem->expandBox.left) {
2890 lpht->flags |= TVHT_ONITEMINDENT;
2891 goto done;
2892 }
2893 if ( PtInRect ( &wineItem->expandBox, lpht->pt)) {
2894 lpht->flags |= TVHT_ONITEMBUTTON;
2895 goto done;
2896 }
2897 if ( PtInRect ( &wineItem->bitmap, lpht->pt)) {
2898 lpht->flags |= TVHT_ONITEMICON;
2899 goto done;
2900 }
2901 if ( PtInRect ( &wineItem->statebitmap, lpht->pt)) {
2902 lpht->flags |= TVHT_ONITEMSTATEICON;
2903 goto done;
2904 }
2905 if ( PtInRect ( &wineItem->text, lpht->pt)) {
2906 lpht->flags |= TVHT_ONITEMLABEL;
2907 goto done;
2908 }
2909
2910 lpht->flags|=TVHT_ONITEMRIGHT;
2911
2912
2913 done:
2914 lpht->hItem=wineItem->hItem;
2915 TRACE ("(%ld,%ld):result %x\n",lpht->pt.x,lpht->pt.y,lpht->flags);
2916
2917 return (LRESULT) wineItem->hItem;
2918 }
2919
2920 LRESULT WINAPI
2921 TREEVIEW_EndEditLabelNow (HWND hwnd, WPARAM wParam, LPARAM lParam)
2922 {
2923 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
2924 TREEVIEW_ITEM *editedItem = TREEVIEW_ValidItem (infoPtr, infoPtr->editItem);
2925 BOOL bRevert = (BOOL)wParam;
2926 BOOL bReturn = ! bRevert;
2927
2928 if ( ! (BOOL)wParam ) /* wParam is set to true to cancel the edition */
2929 {
2930 if ( TREEVIEW_SendDispInfoNotify( /* return true to cancel edition */
2931 hwnd,
2932 editedItem,
2933 TVN_ENDLABELEDITA,
2934 0))
2935 {
2936 bRevert = TRUE;
2937 bReturn = FALSE;
2938 }
2939 }
2940
2941 if (bRevert == FALSE) /* Apply the changes */
2942 {
2943 char tmpText[1024];
2944 int iLength = GetWindowTextA(infoPtr->hwndEdit, tmpText, 1023);
2945 bReturn = FALSE;
2946
2947 if (iLength == 0)
2948 {
2949 ERR("Problem retreiving new item label.");
2950 }
2951 else if (iLength >= 1023)
2952 {
2953 ERR(
2954 "Insuficient space to retrieve new item label, new label ignored.");
2955 }
2956 else
2957 {
2958 if (strcmp( tmpText, editedItem->pszText ) == 0)
2959 /* Do nothing if the label has not changed */
2960 bReturn = TRUE;
2961 else
2962 {
2963 LPSTR tmpLabel = COMCTL32_Alloc( iLength+1 );
2964
2965 if ( tmpLabel == NULL )
2966 ERR(
2967 "OutOfMemory, cannot allocate space for label");
2968 else
2969 {
2970 COMCTL32_Free(editedItem->pszText);
2971 editedItem->pszText = tmpLabel;
2972 lstrcpyA( editedItem->pszText, tmpText);
2973 bReturn = TRUE;
2974 }
2975 }
2976 }
2977
2978 ShowWindow(infoPtr->hwndEdit, SW_HIDE);
2979 EnableWindow(infoPtr->hwndEdit, FALSE);
2980 infoPtr->editItem = 0;
2981 }
2982
2983 return bReturn;
2984 }
2985
2986
2987
2988 static LRESULT
2989 TREEVIEW_LButtonDoubleClick (HWND hwnd, WPARAM wParam, LPARAM lParam)
2990 {
2991 TREEVIEW_ITEM *wineItem;
2992 POINT pt;
2993
2994 TRACE("\n");
2995 pt.x = (INT)LOWORD(lParam);
2996 pt.y = (INT)HIWORD(lParam);
2997 SetFocus (hwnd);
2998
2999 wineItem=TREEVIEW_HitTestPoint (hwnd, pt);
3000 if (!wineItem) return 0;
3001 TRACE("item %d \n",(INT)wineItem->hItem);
3002
3003 if (TREEVIEW_SendSimpleNotify (hwnd, NM_DBLCLK)!=TRUE) { /* FIXME!*/
3004 TREEVIEW_Expand (hwnd, (WPARAM) TVE_TOGGLE, (LPARAM) wineItem->hItem);
3005 }
3006 return TRUE;
3007 }
3008
3009
3010 static LRESULT
3011 TREEVIEW_LButtonDown (HWND hwnd, WPARAM wParam, LPARAM lParam)
3012 {
3013 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
3014 INT iItem;
3015 TVHITTESTINFO ht;
3016
3017 ht.pt.x = (INT)LOWORD(lParam);
3018 ht.pt.y = (INT)HIWORD(lParam);
3019
3020 SetFocus (hwnd);
3021 iItem=TREEVIEW_HitTest (hwnd, (LPARAM) &ht);
3022 TRACE("item %d \n",iItem);
3023
3024 if (ht.flags & TVHT_ONITEMBUTTON) {
3025 TREEVIEW_Expand (hwnd, (WPARAM) TVE_TOGGLE, (LPARAM) iItem);
3026 }
3027 else
3028 {
3029 infoPtr->uInternalStatus|=TV_LDRAG;
3030 }
3031
3032 return 0;
3033 }
3034
3035 static LRESULT
3036 TREEVIEW_LButtonUp (HWND hwnd, WPARAM wParam, LPARAM lParam)
3037 {
3038 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
3039 INT iItem;
3040 TREEVIEW_ITEM *wineItem;
3041 TVHITTESTINFO ht;
3042
3043 ht.pt.x = (INT)LOWORD(lParam);
3044 ht.pt.y = (INT)HIWORD(lParam);
3045
3046 TRACE("\n");
3047
3048 /* Return true to cancel default behaviour */
3049 if ( TREEVIEW_SendSimpleNotify (hwnd, NM_CLICK) )
3050 return 0;
3051
3052 /* Get the item */
3053 iItem = TREEVIEW_HitTest (hwnd, (LPARAM) &ht);
3054 TRACE ("%d\n",iItem);
3055 if (!iItem)
3056 return 0;
3057
3058 wineItem = TREEVIEW_ValidItem(infoPtr, (HTREEITEM)iItem);
3059
3060 infoPtr->uInternalStatus &= ~(TV_LDRAG | TV_LDRAGGING);
3061
3062 /*
3063 * If the style allow editing and the node is already selected
3064 * and the click occured on the item label...
3065 */
3066 if ( ( GetWindowLongA( hwnd, GWL_STYLE) & TVS_EDITLABELS ) &&
3067 ( wineItem->state & TVIS_SELECTED ) &&
3068 ( ht.flags & TVHT_ONITEMLABEL ))
3069 {
3070 if ( infoPtr->editItem == 0 ) /* If we are not curently editing */
3071 {
3072 if ( TREEVIEW_SendDispInfoNotify( /* Return true to cancel edition */
3073 hwnd,
3074 wineItem,
3075 TVN_BEGINLABELEDITA,
3076 0))
3077 {
3078 return 0;
3079 }
3080
3081 TRACE("Edit started for %s.\n", wineItem->pszText);
3082 infoPtr->editItem = wineItem->hItem;
3083
3084 SetWindowPos (
3085 infoPtr->hwndEdit,
3086 HWND_TOP,
3087 wineItem->text.left - 2,
3088 wineItem->text.top - 1,
3089 wineItem->text.right - wineItem->text.left + 20 ,
3090 wineItem->text.bottom - wineItem->text.top + 3,
3091 SWP_DRAWFRAME );
3092
3093 SetWindowTextA( infoPtr->hwndEdit, wineItem->pszText );
3094 SendMessageA ( infoPtr->hwndEdit, EM_SETSEL, 0, -1 );
3095 SetFocus ( infoPtr->hwndEdit);
3096 ShowWindow ( infoPtr->hwndEdit, SW_SHOW);
3097 }
3098 }
3099 else if ( infoPtr->editItem != 0 ) /* If we are curently editing */
3100 {
3101 TREEVIEW_EndEditLabelNow(hwnd, (WPARAM)FALSE, 0);
3102 }
3103 else if ( ht.flags & (TVHT_ONITEMLABEL | TVHT_ONITEMICON))
3104 {
3105 TREEVIEW_DoSelectItem ( hwnd, TVGN_CARET, (HTREEITEM)iItem, TVC_BYMOUSE);
3106 }
3107
3108 if (ht.flags & TVHT_ONITEMSTATEICON) {
3109 DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
3110
3111
3112 if (dwStyle & TVS_CHECKBOXES) { /* TVS_CHECKBOXES requires _us_ */
3113 int state; /* to toggle the current state */
3114 state=1-(wineItem->state>>12);
3115 TRACE ("state:%x\n", state);
3116 wineItem->state&= ~TVIS_STATEIMAGEMASK;
3117 wineItem->state|=state<<12;
3118 TRACE ("state:%x\n", wineItem->state);
3119 TREEVIEW_QueueRefresh (hwnd);
3120 }
3121 }
3122 return 0;
3123 }
3124
3125
3126 static LRESULT
3127 TREEVIEW_RButtonDown (HWND hwnd, WPARAM wParam, LPARAM lParam)
3128 {
3129 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
3130
3131 TRACE("\n");
3132 infoPtr->uInternalStatus|=TV_RDRAG;
3133 return 0;
3134 }
3135
3136 static LRESULT
3137 TREEVIEW_RButtonUp (HWND hwnd, WPARAM wParam, LPARAM lParam)
3138 {
3139 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
3140
3141 TRACE("\n");
3142 if (TREEVIEW_SendSimpleNotify (hwnd, NM_RCLICK)) return 0;
3143 infoPtr->uInternalStatus&= ~(TV_RDRAG | TV_RDRAGGING);
3144 return 0;
3145 }
3146
3147
3148 static LRESULT
3149 TREEVIEW_MouseMove (HWND hwnd, WPARAM wParam, LPARAM lParam)
3150 {
3151 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
3152 TREEVIEW_ITEM *hotItem;
3153 POINT pt;
3154
3155 pt.x=(INT) LOWORD (lParam);
3156 pt.y=(INT) HIWORD (lParam);
3157 hotItem=TREEVIEW_HitTestPoint (hwnd, pt);
3158 if (!hotItem) return 0;
3159 infoPtr->focusItem=hotItem->hItem;
3160
3161 if ( GetWindowLongA( hwnd, GWL_STYLE) & TVS_DISABLEDRAGDROP) return 0;
3162
3163 if (infoPtr->uInternalStatus & TV_LDRAG) {
3164 TREEVIEW_SendTreeviewDnDNotify (hwnd, TVN_BEGINDRAGA, hotItem->hItem, pt);
3165 infoPtr->uInternalStatus &= ~TV_LDRAG;
3166 infoPtr->uInternalStatus |= TV_LDRAGGING;
3167 infoPtr->dropItem=hotItem->hItem;
3168 return 0;
3169 }
3170
3171 if (infoPtr->uInternalStatus & TV_RDRAG) {
3172 TREEVIEW_SendTreeviewDnDNotify (hwnd, TVN_BEGINRDRAGA, hotItem->hItem, pt);
3173 infoPtr->uInternalStatus &= ~TV_RDRAG;
3174 infoPtr->uInternalStatus |= TV_RDRAGGING;
3175 infoPtr->dropItem=hotItem->hItem;
3176 return 0;
3177 }
3178
3179 return 0;
3180 }
3181
3182
3183 static LRESULT
3184 TREEVIEW_CreateDragImage (HWND hwnd, WPARAM wParam, LPARAM lParam)
3185 {
3186 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
3187 TREEVIEW_ITEM *dragItem;
3188 INT cx,cy;
3189 HDC hdc,htopdc;
3190 HWND hwtop;
3191 HBITMAP hbmp,hOldbmp;
3192 SIZE size;
3193 RECT rc;
3194 HFONT hOldFont;
3195 char *itemtxt;
3196
3197 TRACE("\n");
3198 if (!(infoPtr->himlNormal)) return 0;
3199 dragItem=TREEVIEW_ValidItem (infoPtr, (HTREEITEM) lParam);
3200
3201 if (!dragItem) return 0;
3202
3203 if (dragItem->pszText==LPSTR_TEXTCALLBACKA) {
3204 TREEVIEW_SendDispInfoNotify (hwnd, dragItem, TVN_GETDISPINFOA, TVIF_TEXT);
3205 }
3206 itemtxt=dragItem->pszText;
3207
3208 hwtop=GetDesktopWindow ();
3209 htopdc= GetDC (hwtop);
3210 hdc=CreateCompatibleDC (htopdc);
3211
3212 hOldFont=SelectObject (hdc, infoPtr->hFont);
3213 GetTextExtentPoint32A (hdc, itemtxt, lstrlenA (itemtxt), &size);
3214 TRACE("%d %d %s %d\n",size.cx,size.cy,itemtxt,lstrlenA(itemtxt));
3215 hbmp=CreateCompatibleBitmap (htopdc, size.cx, size.cy);
3216 hOldbmp=SelectObject (hdc, hbmp);
3217
3218 ImageList_GetIconSize (infoPtr->himlNormal, &cx, &cy);
3219 size.cx+=cx;
3220 if (cy>size.cy) size.cy=cy;
3221
3222 infoPtr->dragList=ImageList_Create (size.cx, size.cy, ILC_COLOR, 10, 10);
3223 ImageList_Draw (infoPtr->himlNormal, dragItem->iImage, hdc, 0, 0, ILD_NORMAL);
3224
3225 /*
3226 ImageList_GetImageInfo (infoPtr->himlNormal, dragItem->hItem, &iminfo);
3227 ImageList_AddMasked (infoPtr->dragList, iminfo.hbmImage, CLR_DEFAULT);
3228 */
3229
3230 /* draw item text */
3231
3232 SetRect (&rc, cx, 0, size.cx,size.cy);
3233 DrawTextA (hdc, itemtxt, lstrlenA (itemtxt), &rc, DT_LEFT);
3234 SelectObject (hdc, hOldFont);
3235 SelectObject (hdc, hOldbmp);
3236
3237 ImageList_Add (infoPtr->dragList, hbmp, 0);
3238
3239 DeleteDC (hdc);
3240 DeleteObject (hbmp);
3241 ReleaseDC (hwtop, htopdc);
3242
3243 return (LRESULT)infoPtr->dragList;
3244 }
3245
3246
3247 static LRESULT
3248 TREEVIEW_DoSelectItem (HWND hwnd, INT action, HTREEITEM newSelect, INT cause)
3249
3250 {
3251 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
3252 TREEVIEW_ITEM *prevItem,*wineItem;
3253 INT prevSelect;
3254
3255 wineItem = TREEVIEW_ValidItem (infoPtr, (HTREEITEM)newSelect);
3256
3257 TRACE("Entering item %d, flag %x, cause %x, state %d\n",
3258 (INT)newSelect,
3259 action,
3260 cause,
3261 wineItem->state);
3262
3263 if ( (wineItem) && (wineItem->parent))
3264 {
3265 /*
3266 * If the item has a collapse parent expand the parent so he
3267 * can expose the item
3268 */
3269 TREEVIEW_ITEM *parentItem = TREEVIEW_ValidItem (infoPtr, wineItem->parent);
3270 if ( !(parentItem->state & TVIS_EXPANDED))
3271 TREEVIEW_Expand (hwnd, TVE_EXPAND, (LPARAM) wineItem->parent);
3272 }
3273
3274 switch (action)
3275 {
3276 case TVGN_CARET:
3277 prevSelect=(INT)infoPtr->selectedItem;
3278
3279 if ((HTREEITEM)prevSelect==newSelect)
3280 return FALSE;
3281
3282 prevItem= TREEVIEW_ValidItem (infoPtr, (HTREEITEM)prevSelect);
3283
3284 if (newSelect)
3285 if (TREEVIEW_SendTreeviewNotify(
3286 hwnd,
3287 TVN_SELCHANGINGA,
3288 cause,
3289 (HTREEITEM)prevSelect,
3290 (HTREEITEM)newSelect))
3291 return FALSE; /* FIXME: OK? */
3292
3293 if (prevItem)
3294 prevItem->state &= ~TVIS_SELECTED;
3295 if (wineItem)
3296 wineItem->state |= TVIS_SELECTED;
3297
3298 infoPtr->selectedItem=(HTREEITEM)newSelect;
3299
3300 TREEVIEW_SendTreeviewNotify(
3301 hwnd,
3302 TVN_SELCHANGEDA,
3303 cause,
3304 (HTREEITEM)prevSelect,
3305 (HTREEITEM)newSelect);
3306
3307 break;
3308
3309 case TVGN_DROPHILITE:
3310 prevItem= TREEVIEW_ValidItem (infoPtr, infoPtr->dropItem);
3311
3312 if (prevItem)
3313 prevItem->state &= ~TVIS_DROPHILITED;
3314
3315 infoPtr->dropItem=(HTREEITEM)newSelect;
3316
3317 if (wineItem)
3318 wineItem->state |=TVIS_DROPHILITED;
3319
3320 break;
3321
3322 case TVGN_FIRSTVISIBLE:
3323 FIXME("FIRSTVISIBLE not implemented\n");
3324 break;
3325 }
3326
3327 TREEVIEW_QueueRefresh (hwnd);
3328
3329 TRACE("Leaving state %d\n", wineItem->state);
3330 return TRUE;
3331 }
3332
3333 /* FIXME: handle NM_KILLFocus etc */
3334 static LRESULT
3335 TREEVIEW_SelectItem (HWND hwnd, WPARAM wParam, LPARAM lParam)
3336
3337 {
3338 return TREEVIEW_DoSelectItem (hwnd, wParam, (HTREEITEM) lParam, TVC_UNKNOWN);
3339 }
3340
3341
3342
3343
3344 static LRESULT
3345 TREEVIEW_GetFont (HWND hwnd, WPARAM wParam, LPARAM lParam)
3346
3347 {
3348 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
3349
3350 TRACE("%x\n",infoPtr->hFont);
3351 return infoPtr->hFont;
3352 }
3353
3354 static LRESULT
3355 TREEVIEW_SetFont (HWND hwnd, WPARAM wParam, LPARAM lParam)
3356
3357 {
3358 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
3359 TEXTMETRICA tm;
3360 LOGFONTA logFont;
3361 HFONT hFont, hOldFont;
3362 INT height;
3363 HDC hdc;
3364
3365 TRACE("%x %lx\n",wParam, lParam);
3366
3367 infoPtr->hFont = (HFONT)wParam;
3368
3369 hFont = infoPtr->hFont ? infoPtr->hFont : GetStockObject (SYSTEM_FONT);
3370
3371 GetObjectA (infoPtr->hFont, sizeof (LOGFONTA), &logFont);
3372 logFont.lfWeight=FW_BOLD;
3373 infoPtr->hBoldFont = CreateFontIndirectA (&logFont);
3374
3375 hdc = GetDC (0);
3376 hOldFont = SelectObject (hdc, hFont);
3377 GetTextMetricsA (hdc, &tm);
3378 height= tm.tmHeight + tm.tmExternalLeading;
3379 if (height>infoPtr->uRealItemHeight)
3380 infoPtr->uRealItemHeight=height;
3381 SelectObject (hdc, hOldFont);
3382 ReleaseDC (0, hdc);
3383
3384 if (lParam)
3385 TREEVIEW_QueueRefresh (hwnd);
3386
3387 return 0;
3388 }
3389
3390
3391
3392 static LRESULT
3393 TREEVIEW_VScroll (HWND hwnd, WPARAM wParam, LPARAM lParam)
3394
3395 {
3396 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
3397 int maxHeight;
3398
3399 TRACE("wp %x, lp %lx\n", wParam, lParam);
3400 if (!infoPtr->uInternalStatus & TV_VSCROLL) return FALSE;
3401
3402 switch (LOWORD (wParam)) {
3403 case SB_LINEUP:
3404 if (!infoPtr->cy) return FALSE;
3405 infoPtr->cy -= infoPtr->uRealItemHeight;
3406 if (infoPtr->cy < 0) infoPtr->cy=0;
3407 break;
3408 case SB_LINEDOWN:
3409 maxHeight=infoPtr->uTotalHeight-infoPtr->uVisibleHeight;
3410 if (infoPtr->cy == maxHeight) return FALSE;
3411 infoPtr->cy += infoPtr->uRealItemHeight;
3412 if (infoPtr->cy > maxHeight)
3413 infoPtr->cy = maxHeight;
3414 break;
3415 case SB_PAGEUP:
3416 if (!infoPtr->cy) return FALSE;
3417 infoPtr->cy -= infoPtr->uVisibleHeight;
3418 if (infoPtr->cy < 0) infoPtr->cy=0;
3419 break;
3420 case SB_PAGEDOWN:
3421 maxHeight=infoPtr->uTotalHeight-infoPtr->uVisibleHeight;
3422 if (infoPtr->cy == maxHeight) return FALSE;
3423 infoPtr->cy += infoPtr->uVisibleHeight;
3424 if (infoPtr->cy > maxHeight)
3425 infoPtr->cy = maxHeight;
3426 break;
3427 case SB_THUMBTRACK:
3428 infoPtr->cy = HIWORD (wParam);
3429 break;
3430
3431 }
3432
3433 TREEVIEW_QueueRefresh (hwnd);
3434 return TRUE;
3435 }
3436
3437 static LRESULT
3438 TREEVIEW_HScroll (HWND hwnd, WPARAM wParam, LPARAM lParam)
3439 {
3440 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
3441 int maxWidth;
3442
3443 TRACE("wp %lx, lp %x\n", lParam, wParam);
3444
3445 if (!infoPtr->uInternalStatus & TV_HSCROLL) return FALSE;
3446
3447 switch (LOWORD (wParam)) {
3448 case SB_LINEUP:
3449 if (!infoPtr->cx) return FALSE;
3450 infoPtr->cx -= infoPtr->uRealItemHeight;
3451 if (infoPtr->cx < 0) infoPtr->cx=0;
3452 break;
3453 case SB_LINEDOWN:
3454 maxWidth=infoPtr->uTotalWidth-infoPtr->uVisibleWidth;
3455 if (infoPtr->cx == maxWidth) return FALSE;
3456 infoPtr->cx += infoPtr->uRealItemHeight; /*FIXME */
3457 if (infoPtr->cx > maxWidth)
3458 infoPtr->cx = maxWidth;
3459 break;
3460 case SB_PAGEUP:
3461 if (!infoPtr->cx) return FALSE;
3462 infoPtr->cx -= infoPtr->uVisibleWidth;
3463 if (infoPtr->cx < 0) infoPtr->cx=0;
3464 break;
3465 case SB_PAGEDOWN:
3466 maxWidth=infoPtr->uTotalWidth-infoPtr->uVisibleWidth;
3467 if (infoPtr->cx == maxWidth) return FALSE;
3468 infoPtr->cx += infoPtr->uVisibleWidth;
3469 if (infoPtr->cx > maxWidth)
3470 infoPtr->cx = maxWidth;
3471 break;
3472 case SB_THUMBTRACK:
3473 infoPtr->cx = HIWORD (wParam);
3474 break;
3475
3476 }
3477
3478 TREEVIEW_QueueRefresh (hwnd);
3479 return TRUE;
3480 }
3481
3482 static LRESULT TREEVIEW_MouseWheel (HWND hwnd, WPARAM wParam, LPARAM lParam)
3483 {
3484
3485 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
3486 short gcWheelDelta = 0;
3487 UINT pulScrollLines = 3;
3488
3489 SystemParametersInfoW(SPI_GETWHEELSCROLLLINES,0, &pulScrollLines, 0);
3490
3491 gcWheelDelta -= (short) HIWORD(wParam);
3492 pulScrollLines *= (gcWheelDelta / WHEEL_DELTA);
3493
3494 if (abs(gcWheelDelta) >= WHEEL_DELTA && pulScrollLines)
3495 {
3496 int wheelDy = pulScrollLines * infoPtr->uRealItemHeight;
3497 int newDy = infoPtr->cy + wheelDy;
3498 int maxDy = infoPtr->uTotalHeight - infoPtr->uVisibleHeight;
3499
3500 if (newDy > maxDy) newDy = maxDy;
3501 if (newDy < 0) newDy = 0;
3502
3503 if (newDy == infoPtr->cy) return TRUE;
3504
3505 TREEVIEW_VScroll(hwnd, MAKEWPARAM(SB_THUMBTRACK,newDy),0);
3506 }
3507 return TRUE;
3508 }
3509
3510 static LRESULT
3511 TREEVIEW_KeyDown (HWND hwnd, WPARAM wParam, LPARAM lParam)
3512 {
3513 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
3514 HTREEITEM hNewSelection = 0;
3515 INT scrollNeeds = -1;
3516 INT cyChangeNeeds = -1;
3517 INT prevSelect = (INT)infoPtr->selectedItem;
3518
3519 TREEVIEW_ITEM *prevItem =
3520 (prevSelect != 0 ) ?
3521 TREEVIEW_ValidItem (infoPtr, (HTREEITEM)prevSelect) :
3522 NULL;
3523
3524 TREEVIEW_ITEM *newItem = NULL;
3525
3526 TRACE("%x %lx\n",wParam, lParam);
3527
3528 if (prevSelect == 0)
3529 return FALSE;
3530
3531 switch (wParam) {
3532 case VK_UP:
3533 newItem=TREEVIEW_GetPrevListItem (infoPtr, prevItem);
3534
3535 if (!newItem)
3536 newItem=& infoPtr->items[(INT)infoPtr->TopRootItem];
3537
3538 hNewSelection = newItem->hItem;
3539
3540 if (! newItem->visible)
3541 scrollNeeds = SB_LINEUP;
3542 break;
3543
3544 case VK_DOWN:
3545 newItem=TREEVIEW_GetNextListItem (infoPtr, prevItem);
3546
3547 if (!newItem)
3548 newItem=prevItem;
3549
3550 hNewSelection = newItem->hItem;
3551
3552 if (! newItem->visible)
3553 scrollNeeds = SB_LINEDOWN;
3554
3555 break;
3556
3557 case VK_HOME:
3558 newItem = &infoPtr->items[(INT)infoPtr->TopRootItem];
3559 hNewSelection = newItem->hItem;
3560 cyChangeNeeds = 0;
3561 break;
3562
3563 case VK_END:
3564 newItem = &infoPtr->items[(INT)infoPtr->TopRootItem];
3565 newItem = TREEVIEW_GetLastListItem (infoPtr, newItem);
3566 hNewSelection = newItem->hItem;
3567
3568 if (! newItem->visible)
3569 cyChangeNeeds = infoPtr->uTotalHeight-infoPtr->uVisibleHeight;
3570
3571 break;
3572
3573 case VK_LEFT:
3574 if ( (prevItem->cChildren > 0) && (prevItem->state & TVIS_EXPANDED) )
3575 {
3576 TREEVIEW_Expand(hwnd, TVE_COLLAPSE, prevSelect );
3577 }
3578 else if ((INT)prevItem->parent)
3579 {
3580 newItem = (& infoPtr->items[(INT)prevItem->parent]);
3581 if (! newItem->visible)
3582 /* FIXME find a way to make this item the first visible... */
3583 newItem = NULL;
3584
3585 hNewSelection = newItem->hItem;
3586 }
3587
3588 break;
3589
3590 case VK_RIGHT:
3591 if ( ( prevItem->cChildren > 0) ||
3592 ( prevItem->cChildren == I_CHILDRENCALLBACK))
3593 {
3594 if (! (prevItem->state & TVIS_EXPANDED))
3595 TREEVIEW_Expand(hwnd, TVE_EXPAND, prevSelect );
3596 else
3597 {
3598 newItem = (& infoPtr->items[(INT)prevItem->firstChild]);
3599 hNewSelection = newItem->hItem;
3600 }
3601 }
3602
3603 break;
3604
3605 case VK_ADD:
3606 if (! (prevItem->state & TVIS_EXPANDED))
3607 TREEVIEW_Expand(hwnd, TVE_EXPAND, prevSelect );
3608 break;
3609
3610 case VK_SUBTRACT:
3611 if (prevItem->state & TVIS_EXPANDED)
3612 TREEVIEW_Expand(hwnd, TVE_COLLAPSE, prevSelect );
3613 break;
3614
3615 case VK_PRIOR:
3616
3617 newItem=TREEVIEW_GetListItem(
3618 infoPtr,
3619 prevItem,
3620 -1*(TREEVIEW_GetVisibleCount(hwnd,0,0)-3));
3621 if (!newItem)
3622 newItem=prevItem;
3623
3624 hNewSelection = newItem->hItem;
3625
3626 if (! newItem->visible)
3627 scrollNeeds = SB_PAGEUP;
3628
3629 break;
3630
3631 case VK_NEXT:
3632 newItem=TREEVIEW_GetListItem(
3633 infoPtr,
3634 prevItem,
3635 TREEVIEW_GetVisibleCount(hwnd,0,0)-3);
3636
3637 if (!newItem)
3638 newItem=prevItem;
3639
3640 hNewSelection = newItem->hItem;
3641
3642 if (! newItem->visible)
3643 scrollNeeds = SB_PAGEDOWN;
3644
3645 break;
3646
3647 case VK_BACK:
3648
3649 case VK_RETURN:
3650
3651 default:
3652 FIXME("%x not implemented\n", wParam);
3653 break;
3654 }
3655
3656 if (hNewSelection)
3657 {
3658 /*
3659 This works but does not send notification...
3660
3661 prevItem->state &= ~TVIS_SELECTED;
3662 newItem->state |= TVIS_SELECTED;
3663 infoPtr->selectedItem = hNewSelection;
3664 TREEVIEW_QueueRefresh (hwnd);
3665 */
3666
3667 if ( TREEVIEW_DoSelectItem(
3668 hwnd,
3669 TVGN_CARET,
3670 (HTREEITEM)hNewSelection,
3671 TVC_BYKEYBOARD))
3672 {
3673 /* If selection change is allowed for the new item, perform scrolling */
3674 if (scrollNeeds != -1)
3675 TREEVIEW_VScroll(hwnd, scrollNeeds, 0);
3676
3677 if (cyChangeNeeds != -1)
3678 infoPtr->cy = cyChangeNeeds;
3679
3680 /* FIXME: Something happen in the load the in the two weeks before
3681 april 1st 1999 which makes this SetFocus mandatory otherwise, the focus
3682 is lost... However the SetFocus should not be required...*/
3683
3684 SetFocus(hwnd);
3685 }
3686 }
3687
3688 return FALSE;
3689 }
3690
3691
3692 static LRESULT
3693 TREEVIEW_GetScrollTime (HWND hwnd)
3694 {
3695 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
3696
3697 return infoPtr->uScrollTime;
3698 }
3699
3700
3701 static LRESULT
3702 TREEVIEW_SetScrollTime (HWND hwnd, UINT uScrollTime)
3703 {
3704 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
3705 UINT uOldScrollTime = infoPtr->uScrollTime;
3706
3707 infoPtr->uScrollTime = min (uScrollTime, 100);
3708
3709 return uOldScrollTime;
3710 }
3711
3712
3713 static LRESULT WINAPI
3714 TREEVIEW_WindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
3715 {
3716 if (uMsg==WM_CREATE)
3717 return TREEVIEW_Create (hwnd, wParam, lParam);
3718
3719 if (!TREEVIEW_GetInfoPtr(hwnd))
3720 return DefWindowProcA (hwnd, uMsg, wParam, lParam);
3721
3722 switch (uMsg) {
3723
3724 case TVM_INSERTITEMA:
3725 return TREEVIEW_InsertItemA (hwnd, wParam, lParam);
3726
3727 case TVM_INSERTITEMW:
3728 return TREEVIEW_InsertItemW(hwnd,wParam,lParam);;
3729
3730 case TVM_DELETEITEM:
3731 return TREEVIEW_DeleteItem (hwnd, wParam, lParam);
3732
3733 case TVM_EXPAND:
3734 return TREEVIEW_Expand (hwnd, wParam, lParam);
3735
3736 case TVM_GETITEMRECT:
3737 return TREEVIEW_GetItemRect (hwnd, wParam, lParam);
3738
3739 case TVM_GETCOUNT:
3740 return TREEVIEW_GetCount (hwnd, wParam, lParam);
3741
3742 case TVM_GETINDENT:
3743 return TREEVIEW_GetIndent (hwnd);
3744
3745 case TVM_SETINDENT:
3746 return TREEVIEW_SetIndent (hwnd, wParam);
3747
3748 case TVM_GETIMAGELIST:
3749 return TREEVIEW_GetImageList (hwnd, wParam, lParam);
3750
3751 case TVM_SETIMAGELIST:
3752 return TREEVIEW_SetImageList (hwnd, wParam, lParam);
3753
3754 case TVM_GETNEXTITEM:
3755 return TREEVIEW_GetNextItem (hwnd, wParam, lParam);
3756
3757 case TVM_SELECTITEM:
3758 return TREEVIEW_SelectItem (hwnd, wParam, lParam);
3759
3760 case TVM_GETITEMA:
3761 return TREEVIEW_GetItemA (hwnd, wParam, lParam);
3762
3763 case TVM_GETITEMW:
3764 FIXME("Unimplemented msg TVM_GETITEMW\n");
3765 return 0;
3766
3767 case TVM_SETITEMA:
3768 return TREEVIEW_SetItemA (hwnd, wParam, lParam);
3769
3770 case TVM_SETITEMW:
3771 FIXME("Unimplemented msg TVM_SETITEMW\n");
3772 return 0;
3773
3774 case TVM_EDITLABELA:
3775 FIXME("Unimplemented msg TVM_EDITLABELA \n");
3776 return 0;
3777
3778 case TVM_EDITLABELW:
3779 FIXME("Unimplemented msg TVM_EDITLABELW \n");
3780 return 0;
3781
3782 case TVM_GETEDITCONTROL:
3783 return TREEVIEW_GetEditControl (hwnd);
3784
3785 case TVM_GETVISIBLECOUNT:
3786 return TREEVIEW_GetVisibleCount (hwnd, wParam, lParam);
3787
3788 case TVM_HITTEST:
3789 return TREEVIEW_HitTest (hwnd, lParam);
3790
3791 case TVM_CREATEDRAGIMAGE:
3792 return TREEVIEW_CreateDragImage (hwnd, wParam, lParam);
3793
3794 case TVM_SORTCHILDREN:
3795 return TREEVIEW_SortChildren (hwnd, wParam, lParam);
3796
3797 case TVM_ENSUREVISIBLE:
3798 FIXME("Unimplemented msg TVM_ENSUREVISIBLE\n");
3799 return 0;
3800
3801 case TVM_SORTCHILDRENCB:
3802 return TREEVIEW_SortChildrenCB(hwnd, wParam, lParam);
3803
3804 case TVM_ENDEDITLABELNOW:
3805 return TREEVIEW_EndEditLabelNow (hwnd, wParam, lParam);
3806
3807 case TVM_GETISEARCHSTRINGA:
3808 FIXME("Unimplemented msg TVM_GETISEARCHSTRINGA\n");
3809 return 0;
3810
3811 case TVM_GETISEARCHSTRINGW:
3812 FIXME("Unimplemented msg TVM_GETISEARCHSTRINGW\n");
3813 return 0;
3814
3815 case TVM_GETTOOLTIPS:
3816 return TREEVIEW_GetToolTips (hwnd);
3817
3818 case TVM_SETTOOLTIPS:
3819 return TREEVIEW_SetToolTips (hwnd, wParam);
3820
3821 case TVM_SETINSERTMARK:
3822 return TREEVIEW_SetInsertMark (hwnd,wParam, lParam);
3823
3824 case TVM_SETITEMHEIGHT:
3825 return TREEVIEW_SetItemHeight (hwnd, wParam);
3826
3827 case TVM_GETITEMHEIGHT:
3828 return TREEVIEW_GetItemHeight (hwnd);
3829
3830 case TVM_SETBKCOLOR:
3831 return TREEVIEW_SetBkColor (hwnd, wParam, lParam);
3832
3833 case TVM_SETTEXTCOLOR:
3834 return TREEVIEW_SetTextColor (hwnd, wParam, lParam);
3835
3836 case TVM_GETBKCOLOR:
3837 return TREEVIEW_GetBkColor (hwnd);
3838
3839 case TVM_GETTEXTCOLOR:
3840 return TREEVIEW_GetTextColor (hwnd);
3841
3842 case TVM_SETSCROLLTIME:
3843 return TREEVIEW_SetScrollTime (hwnd, (UINT)wParam);
3844
3845 case TVM_GETSCROLLTIME:
3846 return TREEVIEW_GetScrollTime (hwnd);
3847
3848 case TVM_GETITEMSTATE:
3849 return TREEVIEW_GetItemState (hwnd,wParam, lParam);
3850
3851 case TVM_GETLINECOLOR:
3852 return TREEVIEW_GetLineColor (hwnd,wParam, lParam);
3853
3854 case TVM_SETLINECOLOR:
3855 return TREEVIEW_SetLineColor (hwnd,wParam, lParam);
3856
3857 case TVM_SETINSERTMARKCOLOR:
3858 return TREEVIEW_SetInsertMarkColor (hwnd,wParam, lParam);
3859
3860 case TVM_GETINSERTMARKCOLOR:
3861 return TREEVIEW_GetInsertMarkColor (hwnd,wParam, lParam);
3862
3863 case TVM_SETUNICODEFORMAT:
3864 FIXME("Unimplemented msg TVM_SETUNICODEFORMAT\n");
3865 return 0;
3866
3867 case TVM_GETUNICODEFORMAT:
3868 FIXME("Unimplemented msg TVM_GETUNICODEFORMAT\n");
3869 return 0;
3870
3871 case WM_COMMAND:
3872 return TREEVIEW_Command (hwnd, wParam, lParam);
3873
3874 case WM_DESTROY:
3875 return TREEVIEW_Destroy (hwnd);
3876
3877 /* case WM_ENABLE: */
3878
3879 case WM_ERASEBKGND:
3880 return TREEVIEW_EraseBackground (hwnd, wParam, lParam);
3881
3882 case WM_GETDLGCODE:
3883 return DLGC_WANTARROWS | DLGC_WANTCHARS;
3884
3885 case WM_PAINT:
3886 return TREEVIEW_Paint (hwnd, wParam, lParam);
3887
3888 case WM_GETFONT:
3889 return TREEVIEW_GetFont (hwnd, wParam, lParam);
3890
3891 case WM_SETFONT:
3892 return TREEVIEW_SetFont (hwnd, wParam, lParam);
3893
3894 case WM_KEYDOWN:
3895 return TREEVIEW_KeyDown (hwnd, wParam, lParam);
3896
3897 case WM_SETFOCUS:
3898 return TREEVIEW_SetFocus (hwnd, wParam, lParam);
3899
3900 case WM_KILLFOCUS:
3901 return TREEVIEW_KillFocus (hwnd, wParam, lParam);
3902
3903 case WM_LBUTTONDOWN:
3904 return TREEVIEW_LButtonDown (hwnd, wParam, lParam);
3905
3906 case WM_LBUTTONUP:
3907 return TREEVIEW_LButtonUp (hwnd, wParam, lParam);
3908
3909 case WM_LBUTTONDBLCLK:
3910 return TREEVIEW_LButtonDoubleClick (hwnd, wParam, lParam);
3911
3912 case WM_RBUTTONDOWN:
3913 return TREEVIEW_RButtonDown (hwnd, wParam, lParam);
3914
3915 case WM_RBUTTONUP:
3916 return TREEVIEW_RButtonUp (hwnd, wParam, lParam);
3917
3918 case WM_MOUSEMOVE:
3919 return TREEVIEW_MouseMove (hwnd, wParam, lParam);
3920
3921 case WM_STYLECHANGED:
3922 return TREEVIEW_StyleChanged (hwnd, wParam, lParam);
3923
3924 /* case WM_SYSCOLORCHANGE: */
3925 /* case WM_SETREDRAW: */
3926
3927 case WM_TIMER:
3928 return TREEVIEW_HandleTimer (hwnd, wParam, lParam);
3929
3930 case WM_SIZE:
3931 return TREEVIEW_Size (hwnd, wParam,lParam);
3932
3933 case WM_HSCROLL:
3934 return TREEVIEW_HScroll (hwnd, wParam, lParam);
3935 case WM_VSCROLL:
3936 return TREEVIEW_VScroll (hwnd, wParam, lParam);
3937
3938 case WM_MOUSEWHEEL:
3939 if (wParam & (MK_SHIFT | MK_CONTROL))
3940 return DefWindowProcA( hwnd, uMsg, wParam, lParam );
3941 return TREEVIEW_MouseWheel (hwnd, wParam, lParam);
3942
3943 case WM_DRAWITEM:
3944 TRACE ("drawItem\n");
3945 return DefWindowProcA (hwnd, uMsg, wParam, lParam);
3946
3947 default:
3948 if (uMsg >= WM_USER)
3949 FIXME("Unknown msg %04x wp=%08x lp=%08lx\n",
3950 uMsg, wParam, lParam);
3951 return DefWindowProcA (hwnd, uMsg, wParam, lParam);
3952 }
3953 return 0;
3954 }
3955
3956
3957 VOID
3958 TREEVIEW_Register (void)
3959 {
3960 WNDCLASSA wndClass;
3961
3962 TRACE("\n");
3963
3964 ZeroMemory (&wndClass, sizeof(WNDCLASSA));
3965 wndClass.style = CS_GLOBALCLASS | CS_DBLCLKS;
3966 wndClass.lpfnWndProc = (WNDPROC)TREEVIEW_WindowProc;
3967 wndClass.cbClsExtra = 0;
3968 wndClass.cbWndExtra = sizeof(TREEVIEW_INFO *);
3969 wndClass.hCursor = LoadCursorA (0, IDC_ARROWA);
3970 wndClass.hbrBackground = 0;
3971 wndClass.lpszClassName = WC_TREEVIEWA;
3972
3973 RegisterClassA (&wndClass);
3974 }
3975
3976
3977 VOID
3978 TREEVIEW_Unregister (void)
3979 {
3980 UnregisterClassA (WC_TREEVIEWA, (HINSTANCE)NULL);
3981 }
3982
3983
3984
Maarten's multimedia branch