?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fixed DC leak.
[wine/multimedia.git] / dlls / comctl32 / treeview.c
blob5d32246d14814f6a45673508bdc0d4bd10787cee
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 infoPtr->cdmode=TREEVIEW_SendCustomDrawNotify(hwnd,CDDS_PREPAINT,hdc,rect);
1080
1081 if (infoPtr->cdmode==CDRF_SKIPDEFAULT) return;
1082
1083 infoPtr->uVisibleHeight= rect.bottom-rect.top;
1084 infoPtr->uVisibleWidth= rect.right-rect.left;
1085
1086 viewtop=infoPtr->cy;
1087 viewbottom=infoPtr->cy + rect.bottom-rect.top;
1088 viewleft=infoPtr->cx;
1089 viewright=infoPtr->cx + rect.right-rect.left;
1090
1091 TRACE("[%d %d %d %d]\n",viewtop,viewbottom,viewleft,viewright);
1092
1093 /* draw background */
1094
1095 hbrBk = CreateSolidBrush (infoPtr->clrBk);
1096 FillRect(hdc, &rect, hbrBk);
1097 DeleteObject(hbrBk);
1098
1099 ImageList_GetIconSize (infoPtr->himlNormal, &x, &itemHeight);
1100 if (infoPtr->uItemHeight>itemHeight)
1101 itemHeight=infoPtr->uItemHeight;
1102
1103 GetTextMetricsA (hdc, &tm);
1104 if ((tm.tmHeight + tm.tmExternalLeading) > itemHeight)
1105 itemHeight=tm.tmHeight + tm.tmExternalLeading;
1106
1107 infoPtr->uRealItemHeight=itemHeight;
1108
1109 iItem=(INT)infoPtr->TopRootItem;
1110 infoPtr->firstVisible=0;
1111 wineItem=NULL;
1112 indent=0;
1113 x=y=0;
1114
1115 while (iItem) {
1116 prevItem=wineItem;
1117 wineItem= & infoPtr->items[iItem];
1118 wineItem->iLevel=indent;
1119
1120 /* FIXME: remove this in later stage */
1121 /*
1122 if (wineItem->pszText!=LPSTR_TEXTCALLBACK32A)
1123 TRACE (treeview, "%d %d [%d %d %d %d] (%s)\n",y,x,
1124 wineItem->rect.top, wineItem->rect.bottom,
1125 wineItem->rect.left, wineItem->rect.right,
1126 wineItem->pszText);
1127 else
1128 TRACE (treeview, "%d [%d %d %d %d] (CALLBACK)\n",
1129 wineItem->hItem,
1130 wineItem->rect.top, wineItem->rect.bottom,
1131 wineItem->rect.left, wineItem->rect.right);
1132 */
1133
1134 height=itemHeight * wineItem->iIntegral +1;
1135 if ((y >= viewtop) && (y <= viewbottom) &&
1136 (x >= viewleft ) && (x <= viewright)) {
1137 wineItem->visible = TRUE;
1138 wineItem->rect.top = y - infoPtr->cy + rect.top;
1139 wineItem->rect.bottom = wineItem->rect.top + height ;
1140 wineItem->rect.left = x - infoPtr->cx + rect.left;
1141 wineItem->rect.right = rect.right;
1142 if (!infoPtr->firstVisible)
1143 infoPtr->firstVisible=wineItem->hItem;
1144 TREEVIEW_DrawItem (hwnd, hdc, wineItem);
1145 }
1146 else {
1147 wineItem->visible = FALSE;
1148 wineItem->rect.left = wineItem->rect.top = 0;
1149 wineItem->rect.right= wineItem->rect.bottom = 0;
1150 wineItem->text.left = wineItem->text.top = 0;
1151 wineItem->text.right= wineItem->text.bottom = 0;
1152 }
1153
1154 /* look up next item */
1155
1156 if ((wineItem->firstChild) && (wineItem->state & TVIS_EXPANDED)) {
1157 iItem=(INT)wineItem->firstChild;
1158 indent++;
1159 x+=infoPtr->uIndent;
1160 if (x>infoPtr->uTotalWidth)
1161 infoPtr->uTotalWidth=x;
1162 }
1163 else {
1164 iItem=(INT)wineItem->sibling;
1165 while ((!iItem) && (indent>0)) {
1166 indent--;
1167 x-=infoPtr->uIndent;
1168 wineItem=&infoPtr->items[(INT)wineItem->parent];
1169 iItem=(INT)wineItem->sibling;
1170 }
1171 }
1172 y +=height;
1173 } /* while */
1174
1175 /* FIXME: infoPtr->uTotalWidth should also take item label into account */
1176 /* FIXME: or should query item sizes (ie check CDRF_NEWFONT) */
1177
1178 infoPtr->uTotalHeight=y;
1179 if (y >= (viewbottom-viewtop)) {
1180 if (!(infoPtr->uInternalStatus & TV_VSCROLL))
1181 ShowScrollBar (hwnd, SB_VERT, TRUE);
1182 infoPtr->uInternalStatus |=TV_VSCROLL;
1183 SetScrollRange (hwnd, SB_VERT, 0,
1184 y - infoPtr->uVisibleHeight, FALSE);
1185 SetScrollPos (hwnd, SB_VERT, infoPtr->cy, TRUE);
1186 }
1187 else {
1188 if (infoPtr->uInternalStatus & TV_VSCROLL)
1189 ShowScrollBar (hwnd, SB_VERT, FALSE);
1190 infoPtr->uInternalStatus &= ~TV_VSCROLL;
1191 }
1192
1193
1194 if (infoPtr->cdmode & CDRF_NOTIFYPOSTPAINT)
1195 infoPtr->cdmode=TREEVIEW_SendCustomDrawNotify
1196 (hwnd, CDDS_POSTPAINT, hdc, rect);
1197
1198 TRACE("done\n");
1199 }
1200
1201
1202 static LRESULT
1203 TREEVIEW_HandleTimer (HWND hwnd, WPARAM wParam, LPARAM lParam)
1204 {
1205 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
1206
1207 TRACE(" %d\n",wParam);
1208
1209 switch (wParam) {
1210 case TV_REFRESH_TIMER:
1211 KillTimer (hwnd, TV_REFRESH_TIMER);
1212 infoPtr->Timer &= ~TV_REFRESH_TIMER_SET;
1213 InvalidateRect(hwnd, NULL, FALSE);
1214 return 0;
1215 case TV_EDIT_TIMER:
1216 KillTimer (hwnd, TV_EDIT_TIMER);
1217 infoPtr->Timer &= ~TV_EDIT_TIMER_SET;
1218 return 0;
1219 default:
1220 ERR("got unknown timer\n");
1221 }
1222
1223 return 1;
1224 }
1225
1226
1227 static void
1228 TREEVIEW_QueueRefresh (HWND hwnd)
1229
1230 {
1231 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
1232
1233 TRACE("\n");
1234 if (infoPtr->Timer & TV_REFRESH_TIMER_SET) {
1235 KillTimer (hwnd, TV_REFRESH_TIMER);
1236 }
1237
1238 SetTimer (hwnd, TV_REFRESH_TIMER, TV_REFRESH_DELAY, 0);
1239 infoPtr->Timer|=TV_REFRESH_TIMER_SET;
1240 }
1241
1242
1243
1244 static LRESULT
1245 TREEVIEW_GetItemA (HWND hwnd, WPARAM wParam, LPARAM lParam)
1246 {
1247 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
1248 LPTVITEMEXA tvItem;
1249 TREEVIEW_ITEM *wineItem;
1250 INT iItem;
1251
1252 tvItem=(LPTVITEMEXA) lParam;
1253 iItem=(INT)tvItem->hItem;
1254
1255 wineItem = TREEVIEW_ValidItem (infoPtr, (HTREEITEM)iItem);
1256 if (!wineItem) return FALSE;
1257
1258 if (tvItem->mask & TVIF_CHILDREN) {
1259 if (TVIF_CHILDREN==I_CHILDRENCALLBACK)
1260 FIXME("I_CHILDRENCALLBACK not supported\n");
1261 tvItem->cChildren=wineItem->cChildren;
1262 }
1263
1264 if (tvItem->mask & TVIF_HANDLE) {
1265 tvItem->hItem=wineItem->hItem;
1266 }
1267
1268 if (tvItem->mask & TVIF_IMAGE) {
1269 tvItem->iImage=wineItem->iImage;
1270 }
1271
1272 if (tvItem->mask & TVIF_INTEGRAL) {
1273 tvItem->iIntegral=wineItem->iIntegral;
1274 }
1275
1276 /* undocumented: windows ignores TVIF_PARAM and
1277 * always sets lParam
1278 */
1279 tvItem->lParam=wineItem->lParam;
1280
1281 if (tvItem->mask & TVIF_SELECTEDIMAGE) {
1282 tvItem->iSelectedImage=wineItem->iSelectedImage;
1283 }
1284
1285 if (tvItem->mask & TVIF_STATE) {
1286 tvItem->state=wineItem->state & tvItem->stateMask;
1287 }
1288
1289 if (tvItem->mask & TVIF_TEXT) {
1290 if (wineItem->pszText == LPSTR_TEXTCALLBACKA) {
1291 tvItem->pszText = LPSTR_TEXTCALLBACKA; /* FIXME:send notification? */
1292 ERR(" GetItem called with LPSTR_TEXTCALLBACK\n");
1293 }
1294 else if (wineItem->pszText) {
1295 lstrcpynA (tvItem->pszText, wineItem->pszText, tvItem->cchTextMax);
1296 }
1297 }
1298
1299 TRACE("item %d<%p>, txt %p, img %p, action %x\n",
1300 iItem, tvItem, tvItem->pszText, &tvItem->iImage, tvItem->mask);
1301
1302 return TRUE;
1303 }
1304
1305
1306
1307 /* FIXME: check implementation of TVGN_NEXT/TVGN_NEXTVISIBLE */
1308
1309 static LRESULT
1310 TREEVIEW_GetNextItem (HWND hwnd, WPARAM wParam, LPARAM lParam)
1311
1312 {
1313 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
1314 TREEVIEW_ITEM *wineItem, *returnItem;
1315 INT iItem = (INT)lParam, retval = 0, flag = (INT)wParam;
1316 HDC hdc;
1317
1318 switch (flag) {
1319 case TVGN_ROOT:
1320 retval = (INT)infoPtr->TopRootItem;
1321 break;
1322
1323 case TVGN_CARET:
1324 retval = (INT)infoPtr->selectedItem;
1325 break;
1326
1327 case TVGN_FIRSTVISIBLE: /* FIXME:we should only recalculate, not redraw */
1328 hdc = GetDC (hwnd);
1329 TREEVIEW_Refresh (hwnd, hdc);
1330 ReleaseDC(hwnd,hdc);
1331 retval = (INT)infoPtr->firstVisible;
1332 break;
1333
1334 case TVGN_DROPHILITE:
1335 retval = (INT)infoPtr->dropItem;
1336 break;
1337
1338 case TVGN_NEXT:
1339 wineItem = TREEVIEW_ValidItem (infoPtr, (HTREEITEM)iItem);
1340 retval = wineItem ? (INT)wineItem->sibling : 0;
1341 break;
1342
1343 case TVGN_PREVIOUS:
1344 wineItem = TREEVIEW_ValidItem (infoPtr, (HTREEITEM)iItem);
1345 retval = wineItem ? (INT)wineItem->upsibling : 0;
1346 break;
1347
1348 case TVGN_PARENT:
1349 wineItem = TREEVIEW_ValidItem (infoPtr, (HTREEITEM)iItem);
1350 retval = wineItem ? (INT)wineItem->parent : 0;
1351 break;
1352
1353 case TVGN_CHILD:
1354 wineItem = TREEVIEW_ValidItem (infoPtr, (HTREEITEM)iItem);
1355 retval = wineItem ? (INT)wineItem->firstChild : 0;
1356 break;
1357
1358 case TVGN_LASTVISIBLE:
1359 if((wineItem = TREEVIEW_ValidItem (infoPtr, (HTREEITEM)iItem))) {
1360 returnItem = TREEVIEW_GetLastListItem (infoPtr,wineItem);
1361 retval = returnItem ? (INT)returnItem->hItem : 0;
1362 }
1363 break;
1364
1365 case TVGN_NEXTVISIBLE:
1366 if((wineItem = TREEVIEW_ValidItem (infoPtr, (HTREEITEM)iItem))) {
1367 returnItem = TREEVIEW_GetNextListItem (infoPtr,wineItem);
1368 retval = returnItem ? (INT)returnItem->hItem : 0;
1369 }
1370 break;
1371
1372 case TVGN_PREVIOUSVISIBLE:
1373 if((wineItem = TREEVIEW_ValidItem (infoPtr, (HTREEITEM)iItem))) {
1374 returnItem = TREEVIEW_GetPrevListItem (infoPtr, wineItem);
1375 retval = returnItem ? (INT)returnItem->hItem : 0;
1376 }
1377 break;
1378
1379 default:
1380 FIXME("Unknown msg %x,item %x\n", flag,iItem);
1381 break;
1382 }
1383
1384 TRACE("flags %x, item %d returns %d\n", flag, iItem, retval);
1385 return retval;
1386 }
1387
1388
1389 static LRESULT
1390 TREEVIEW_GetCount (HWND hwnd, WPARAM wParam, LPARAM lParam)
1391 {
1392 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
1393
1394 TRACE(" %d\n",infoPtr->uNumItems);
1395 return (LRESULT) infoPtr->uNumItems;
1396 }
1397
1398 /***************************************************************************
1399 * This method does the chaining of the insertion of a treeview item
1400 * before an item.
1401 * If parent is NULL, we're inserting at the root of the list.
1402 */
1403 static void TREEVIEW_InsertBefore(
1404 TREEVIEW_INFO *infoPtr,
1405 TREEVIEW_ITEM *newItem,
1406 TREEVIEW_ITEM *sibling,
1407 TREEVIEW_ITEM *parent)
1408 {
1409 HTREEITEM siblingHandle = 0;
1410 HTREEITEM upSiblingHandle = 0;
1411 TREEVIEW_ITEM *upSibling = NULL;
1412
1413 if (newItem == NULL)
1414 ERR("NULL newItem, impossible condition\n");
1415
1416 if (sibling != NULL) /* Insert before this sibling for this parent */
1417 {
1418 /* Store the new item sibling up sibling and sibling tem handle */
1419 siblingHandle = sibling->hItem;
1420 upSiblingHandle = sibling->upsibling;
1421 /* As well as a pointer to the upsibling sibling object */
1422 if ( (INT)sibling->upsibling != 0 )
1423 upSibling = &infoPtr->items[(INT)sibling->upsibling];
1424
1425 /* Adjust the sibling pointer */
1426 sibling->upsibling = newItem->hItem;
1427
1428 /* Adjust the new item pointers */
1429 newItem->upsibling = upSiblingHandle;
1430 newItem->sibling = siblingHandle;
1431
1432 /* Adjust the up sibling pointer */
1433 if ( upSibling != NULL )
1434 upSibling->sibling = newItem->hItem;
1435 else
1436 /* this item is the first child of this parent, adjust parent pointers */
1437 if (parent)
1438 parent->firstChild = newItem->hItem;
1439 else
1440 infoPtr->TopRootItem= newItem->hItem;
1441 }
1442 else /* Insert as first child of this parent */
1443 if (parent)
1444 parent->firstChild = newItem->hItem;
1445 }
1446
1447 /***************************************************************************
1448 * This method does the chaining of the insertion of a treeview item
1449 * after an item.
1450 * If parent is NULL, we're inserting at the root of the list.
1451 */
1452 static void TREEVIEW_InsertAfter(
1453 TREEVIEW_INFO *infoPtr,
1454 TREEVIEW_ITEM *newItem,
1455 TREEVIEW_ITEM *upSibling,
1456 TREEVIEW_ITEM *parent)
1457 {
1458 HTREEITEM upSiblingHandle = 0;
1459 HTREEITEM siblingHandle = 0;
1460 TREEVIEW_ITEM *sibling = NULL;
1461
1462
1463 if (newItem == NULL)
1464 ERR("NULL newItem, impossible condition\n");
1465
1466 if (upSibling != NULL) /* Insert after this upsibling for this parent */
1467 {
1468 /* Store the new item up sibling and sibling item handle */
1469 upSiblingHandle = upSibling->hItem;
1470 siblingHandle = upSibling->sibling;
1471 /* As well as a pointer to the upsibling sibling object */
1472 if ( (INT)upSibling->sibling != 0 )
1473 sibling = &infoPtr->items[(INT)upSibling->sibling];
1474
1475 /* Adjust the up sibling pointer */
1476 upSibling->sibling = newItem->hItem;
1477
1478 /* Adjust the new item pointers */
1479 newItem->upsibling = upSiblingHandle;
1480 newItem->sibling = siblingHandle;
1481
1482 /* Adjust the sibling pointer */
1483 if ( sibling != NULL )
1484 sibling->upsibling = newItem->hItem;
1485 /*
1486 else
1487 newItem is the last of the level, nothing else to do
1488 */
1489 }
1490 else /* Insert as first child of this parent */
1491 if (parent)
1492 parent->firstChild = newItem->hItem;
1493 }
1494
1495 /***************************************************************************
1496 * Forward the DPA local callback to the treeview owner callback
1497 */
1498 static INT WINAPI TREEVIEW_CallBackCompare(
1499 LPVOID first,
1500 LPVOID second,
1501 LPARAM tvInfoPtr)
1502 {
1503 /* Forward the call to the client define callback */
1504 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr((HWND)tvInfoPtr);
1505 return (infoPtr->pCallBackSort->lpfnCompare)(
1506 ((TREEVIEW_ITEM*)first)->lParam,
1507 ((TREEVIEW_ITEM*)second)->lParam,
1508 infoPtr->pCallBackSort->lParam);
1509 }
1510
1511 /***************************************************************************
1512 * Treeview native sort routine: sort on item text.
1513 */
1514 static INT WINAPI TREEVIEW_SortOnName (
1515 LPVOID first,
1516 LPVOID second,
1517 LPARAM tvInfoPtr)
1518 {
1519 HWND hwnd=(HWND) tvInfoPtr;
1520 char *txt1, *txt2;
1521 TREEVIEW_ITEM *item;
1522
1523
1524 item=(TREEVIEW_ITEM *) first;
1525 if (item->pszText==LPSTR_TEXTCALLBACKA) {
1526 TREEVIEW_SendDispInfoNotify (hwnd, item, TVN_GETDISPINFOA, TVIF_TEXT);
1527 }
1528 txt1=item->pszText;
1529
1530 item=(TREEVIEW_ITEM *) second;
1531 if (item->pszText==LPSTR_TEXTCALLBACKA) {
1532 TREEVIEW_SendDispInfoNotify (hwnd, item, TVN_GETDISPINFOA, TVIF_TEXT);
1533 }
1534 txt2=item->pszText;
1535
1536 return -strcmp (txt1,txt2);
1537 }
1538
1539 /***************************************************************************
1540 * Setup the treeview structure with regards of the sort method
1541 * and sort the children of the TV item specified in lParam
1542 * fRecurse: currently unused. Should be zero.
1543 * parent: if pSort!=NULL, should equal pSort->hParent.
1544 * otherwise, item which child items are to be sorted.
1545 * pSort: sort method info. if NULL, sort on item text.
1546 * if non-NULL, sort on item's lParam content, and let the
1547 * application decide what that means. See also TVM_SORTCHILDRENCB.
1548 */
1549
1550 static LRESULT WINAPI TREEVIEW_Sort (
1551 HWND hwnd,
1552 BOOL fRecurse,
1553 HTREEITEM parent,
1554 LPTVSORTCB pSort
1555 )
1556 {
1557 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
1558 TREEVIEW_ITEM *sortMe = NULL; /* Node for which we sort the children */
1559
1560 /* Obtain the TVSORTBC struct */
1561 infoPtr->pCallBackSort = pSort;
1562
1563 /* undocumented feature: TVI_ROOT means `sort the whole tree' */
1564
1565 if (parent==TVI_ROOT)
1566 parent=infoPtr->TopRootItem;
1567
1568 /* Check for a valid handle to the parent item */
1569 if (!TREEVIEW_ValidItem(infoPtr, parent))
1570 {
1571 ERR ("invalid item hParent=%x\n", (INT)parent);
1572 return FALSE;
1573 }
1574
1575 /* Obtain the parent node to sort */
1576 sortMe = &infoPtr->items[ (INT)parent ];
1577
1578 /* Make sure there is something to sort */
1579 if ( sortMe->cChildren > 1 )
1580 {
1581 /* pointer organization */
1582 HDPA sortList = DPA_Create(sortMe->cChildren);
1583 HTREEITEM itemHandle = sortMe->firstChild;
1584 TREEVIEW_ITEM *itemPtr = & infoPtr->items[ (INT)itemHandle ];
1585
1586 /* TREEVIEW_ITEM rechaining */
1587 INT count = 0;
1588 VOID *item = 0;
1589 VOID *nextItem = 0;
1590 VOID *prevItem = 0;
1591
1592 /* Build the list of item to sort */
1593 do
1594 {
1595 DPA_InsertPtr(
1596 sortList, /* the list */
1597 sortMe->cChildren+1, /* force the insertion to be an append */
1598 itemPtr); /* the ptr to store */
1599
1600 /* Get the next sibling */
1601 itemHandle = itemPtr->sibling;
1602 itemPtr = & infoPtr->items[ (INT)itemHandle ];
1603 } while ( itemHandle != NULL );
1604
1605 /* let DPA perform the sort activity */
1606 if (pSort)
1607 DPA_Sort(
1608 sortList, /* what */
1609 TREEVIEW_CallBackCompare, /* how */
1610 hwnd); /* owner */
1611 else
1612 DPA_Sort (
1613 sortList, /* what */
1614 TREEVIEW_SortOnName, /* how */
1615 hwnd); /* owner */
1616
1617 /*
1618 * Reorganized TREEVIEW_ITEM structures.
1619 * Note that we know we have at least two elements.
1620 */
1621
1622 /* Get the first item and get ready to start... */
1623 item = DPA_GetPtr(sortList, count++);
1624 while ( (nextItem = DPA_GetPtr(sortList, count++)) != NULL )
1625 {
1626 /* link the two current item toghether */
1627 ((TREEVIEW_ITEM*)item)->sibling = ((TREEVIEW_ITEM*)nextItem)->hItem;
1628 ((TREEVIEW_ITEM*)nextItem)->upsibling = ((TREEVIEW_ITEM*)item)->hItem;
1629
1630 if (prevItem == NULL) /* this is the first item, update the parent */
1631 {
1632 sortMe->firstChild = ((TREEVIEW_ITEM*)item)->hItem;
1633 ((TREEVIEW_ITEM*)item)->upsibling = NULL;
1634 }
1635 else /* fix the back chaining */
1636 {
1637 ((TREEVIEW_ITEM*)item)->upsibling = ((TREEVIEW_ITEM*)prevItem)->hItem;
1638 }
1639
1640 /* get ready for the next one */
1641 prevItem = item;
1642 item = nextItem;
1643 }
1644
1645 /* the last item is pointed to by item and never has a sibling */
1646 ((TREEVIEW_ITEM*)item)->sibling = NULL;
1647
1648 DPA_Destroy(sortList);
1649
1650 return TRUE;
1651 }
1652 return FALSE;
1653 }
1654
1655
1656 /***************************************************************************
1657 * Setup the treeview structure with regards of the sort method
1658 * and sort the children of the TV item specified in lParam
1659 */
1660 static LRESULT WINAPI TREEVIEW_SortChildrenCB(
1661 HWND hwnd,
1662 WPARAM wParam,
1663 LPARAM lParam
1664 )
1665 {
1666 LPTVSORTCB pSort=(LPTVSORTCB) lParam;
1667
1668 return TREEVIEW_Sort (hwnd, wParam, pSort->hParent, pSort);
1669 }
1670
1671
1672 /***************************************************************************
1673 * Sort the children of the TV item specified in lParam.
1674 */
1675 static LRESULT WINAPI TREEVIEW_SortChildren (
1676 HWND hwnd,
1677 WPARAM wParam,
1678 LPARAM lParam)
1679 {
1680 return TREEVIEW_Sort (hwnd, (BOOL) wParam, (HTREEITEM) lParam, NULL);
1681 }
1682
1683
1684
1685 /* the method used below isn't the most memory-friendly, but it avoids
1686 a lot of memory reallocations */
1687
1688 /* BTW: we waste handle 0; 0 is not an allowed handle. */
1689
1690 static LRESULT
1691 TREEVIEW_InsertItemA (HWND hwnd, WPARAM wParam, LPARAM lParam)
1692
1693 {
1694 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
1695 TVINSERTSTRUCTA *ptdi;
1696 TVITEMEXA *tvItem;
1697 TREEVIEW_ITEM *wineItem, *parentItem, *prevsib, *sibItem;
1698 INT iItem,listItems,i,len;
1699
1700 /* Item to insert */
1701 ptdi = (LPTVINSERTSTRUCTA) lParam;
1702
1703 /* check if memory is available */
1704
1705 if (infoPtr->uNumPtrsAlloced==0) {
1706 infoPtr->items = COMCTL32_Alloc (TVITEM_ALLOC*sizeof (TREEVIEW_ITEM));
1707 infoPtr->freeList= COMCTL32_Alloc ((1+(TVITEM_ALLOC>>5)) * sizeof (INT));
1708 infoPtr->uNumPtrsAlloced=TVITEM_ALLOC;
1709 infoPtr->TopRootItem=(HTREEITEM)1;
1710 }
1711
1712 /*
1713 * Reallocate contiguous space for items
1714 */
1715 if (infoPtr->uNumItems == (infoPtr->uNumPtrsAlloced-1) ) {
1716 TREEVIEW_ITEM *oldItems = infoPtr->items;
1717 INT *oldfreeList = infoPtr->freeList;
1718
1719 infoPtr->uNumPtrsAlloced*=2;
1720 infoPtr->items = COMCTL32_Alloc (infoPtr->uNumPtrsAlloced*sizeof (TREEVIEW_ITEM));
1721 infoPtr->freeList= COMCTL32_Alloc ((1+(infoPtr->uNumPtrsAlloced>>5))*sizeof (INT));
1722
1723 memcpy (&infoPtr->items[0], &oldItems[0],
1724 infoPtr->uNumPtrsAlloced/2 * sizeof(TREEVIEW_ITEM));
1725 memcpy (&infoPtr->freeList[0], &oldfreeList[0],
1726 (infoPtr->uNumPtrsAlloced>>6) * sizeof(INT));
1727
1728 COMCTL32_Free (oldItems);
1729 COMCTL32_Free (oldfreeList);
1730 }
1731
1732 /*
1733 * Reset infoPtr structure with new stat according to current TV picture
1734 */
1735 iItem=0;
1736 infoPtr->uNumItems++;
1737 if ((INT)infoPtr->uMaxHandle==(infoPtr->uNumItems-1)) {
1738 iItem=infoPtr->uNumItems;
1739 infoPtr->uMaxHandle = (HTREEITEM)((INT)infoPtr->uMaxHandle + 1);
1740 } else { /* check freelist */
1741 for (i=0; i<=infoPtr->uNumPtrsAlloced>>5; i++) {
1742 if (infoPtr->freeList[i]) {
1743 iItem=ffs (infoPtr->freeList[i])-1;
1744 tv_clear_bit(iItem,&infoPtr->freeList[i]);
1745 iItem+=i<<5;
1746 break;
1747 }
1748 }
1749 }
1750
1751 if (TRACE_ON(treeview)) {
1752 for (i=0; i<=infoPtr->uNumPtrsAlloced>>5; i++)
1753 TRACE("%8x\n",infoPtr->freeList[i]);
1754 }
1755
1756 if (!iItem) ERR("Argh -- can't find free item.\n");
1757
1758 /*
1759 * Find the parent item of the new item
1760 */
1761 tvItem= & ptdi->DUMMYUNIONNAME.itemex;
1762 wineItem=& infoPtr->items[iItem];
1763
1764 if ((ptdi->hParent==TVI_ROOT) || (ptdi->hParent==0)) {
1765 parentItem = NULL;
1766 wineItem->parent = 0;
1767 sibItem = &infoPtr->items [(INT)infoPtr->TopRootItem];
1768 listItems = infoPtr->uNumItems;
1769 }
1770 else {
1771 parentItem = &infoPtr->items[(INT)ptdi->hParent];
1772
1773 /* Do the insertion here it if it's the only item of this parent */
1774 if (!parentItem->firstChild)
1775 parentItem->firstChild=(HTREEITEM)iItem;
1776
1777 wineItem->parent = ptdi->hParent;
1778 sibItem = &infoPtr->items [(INT)parentItem->firstChild];
1779 listItems = parentItem->cChildren;
1780 parentItem->cChildren++;
1781 }
1782
1783
1784 /* NOTE: I am moving some setup of the wineItem object that was initialy
1785 * done at the end of the function since some of the values are
1786 * required by the Callback sorting
1787 */
1788
1789 if (tvItem->mask & TVIF_TEXT)
1790 {
1791 /*
1792 * Setup the item text stuff here since it's required by the Sort method
1793 * when the insertion are ordered
1794 */
1795 if (tvItem->pszText!=LPSTR_TEXTCALLBACKA)
1796 {
1797 TRACE("(%p,%s)\n", &tvItem->pszText, tvItem->pszText);
1798 len = lstrlenA (tvItem->pszText)+1;
1799 wineItem->pszText= COMCTL32_Alloc (len+1);
1800 lstrcpyA (wineItem->pszText, tvItem->pszText);
1801 wineItem->cchTextMax=len;
1802 }
1803 else
1804 {
1805 TRACE("LPSTR_TEXTCALLBACK\n");
1806 wineItem->pszText = LPSTR_TEXTCALLBACKA;
1807 wineItem->cchTextMax = 0;
1808 }
1809 }
1810
1811 if (tvItem->mask & TVIF_PARAM)
1812 wineItem->lParam=tvItem->lParam;
1813
1814
1815 wineItem->upsibling=0; /* needed in case we're the first item in a list */
1816 wineItem->sibling=0;
1817 wineItem->firstChild=0;
1818 wineItem->hItem=(HTREEITEM)iItem;
1819
1820 if (listItems!=0) {
1821 prevsib=NULL;
1822
1823 switch ((DWORD) ptdi->hInsertAfter) {
1824 case (DWORD) TVI_FIRST:
1825 if (sibItem==wineItem) break;
1826 if (wineItem->parent) {
1827 wineItem->sibling=parentItem->firstChild;
1828 parentItem->firstChild=(HTREEITEM)iItem;
1829 } else {
1830 wineItem->sibling=infoPtr->TopRootItem;
1831 infoPtr->TopRootItem=(HTREEITEM)iItem;
1832 }
1833 sibItem->upsibling=(HTREEITEM)iItem;
1834 break;
1835
1836 case (DWORD) TVI_SORT:
1837 if (sibItem==wineItem)
1838 /*
1839 * This item is the first child of the level and it
1840 * has already been inserted
1841 */
1842 break;
1843 else
1844 {
1845 TREEVIEW_ITEM *aChild;
1846
1847
1848 TREEVIEW_ITEM *previousChild = NULL;
1849 BOOL bItemInserted = FALSE;
1850
1851 if (parentItem)
1852 aChild = &infoPtr->items[(INT)parentItem->firstChild];
1853 else
1854 aChild = &infoPtr->items[(INT)infoPtr->TopRootItem];
1855
1856 /* lookup the text if using LPSTR_TEXTCALLBACKs */
1857 if (wineItem->pszText==LPSTR_TEXTCALLBACKA) {
1858 TREEVIEW_SendDispInfoNotify (hwnd, wineItem, TVN_GETDISPINFOA, TVIF_TEXT);
1859 }
1860
1861 /* Iterate the parent children to see where we fit in */
1862 while ( aChild != NULL )
1863 {
1864 INT comp;
1865
1866 /* lookup the text if using LPSTR_TEXTCALLBACKs */
1867 if (aChild->pszText==LPSTR_TEXTCALLBACKA) {
1868 TREEVIEW_SendDispInfoNotify (hwnd, aChild, TVN_GETDISPINFOA, TVIF_TEXT);
1869 }
1870
1871 comp = strcmp(wineItem->pszText, aChild->pszText);
1872 if ( comp < 0 ) /* we are smaller than the current one */
1873 {
1874 TREEVIEW_InsertBefore(infoPtr, wineItem, aChild, parentItem);
1875 bItemInserted = TRUE;
1876 break;
1877 }
1878 else if ( comp > 0 ) /* we are bigger than the current one */
1879 {
1880 previousChild = aChild;
1881 aChild = (aChild->sibling == 0) /* This will help us to exit */
1882 ? NULL /* if there is no more sibling */
1883 : &infoPtr->items[(INT)aChild->sibling];
1884
1885 /* Look at the next item */
1886 continue;
1887 }
1888 else if ( comp == 0 )
1889 {
1890 /*
1891 * An item with this name is already existing, therefore,
1892 * we add after the one we found
1893 */
1894 TREEVIEW_InsertAfter(infoPtr, wineItem, aChild, parentItem);
1895 bItemInserted = TRUE;
1896 break;
1897 }
1898 }
1899
1900 /*
1901 * we reach the end of the child list and the item as not
1902 * yet been inserted, therefore, insert it after the last child.
1903 */
1904 if ( (! bItemInserted ) && (aChild == NULL) )
1905 TREEVIEW_InsertAfter(infoPtr, wineItem, previousChild, parentItem);
1906
1907 break;
1908 }
1909
1910
1911 case (DWORD) TVI_LAST:
1912 if (sibItem==wineItem) break;
1913 while (sibItem->sibling) {
1914 prevsib=sibItem;
1915 sibItem=&infoPtr->items [(INT)sibItem->sibling];
1916 }
1917 sibItem->sibling=(HTREEITEM)iItem;
1918 wineItem->upsibling=sibItem->hItem;
1919 break;
1920 default:
1921 while ((sibItem->sibling) && (sibItem->hItem!=ptdi->hInsertAfter))
1922 {
1923 prevsib=sibItem;
1924 sibItem=&infoPtr->items [(INT)sibItem->sibling];
1925 }
1926 if (sibItem->hItem!=ptdi->hInsertAfter) {
1927 ERR("tried to insert item after nonexisting handle %d.\n",
1928 (INT) ptdi->hInsertAfter);
1929 break;
1930 }
1931 prevsib=sibItem;
1932 if (sibItem->sibling) {
1933 sibItem=&infoPtr->items [(INT)sibItem->sibling];
1934 sibItem->upsibling=(HTREEITEM)iItem;
1935 wineItem->sibling=sibItem->hItem;
1936 }
1937 prevsib->sibling=(HTREEITEM)iItem;
1938 wineItem->upsibling=prevsib->hItem;
1939 break;
1940 }
1941 }
1942
1943
1944 /* Fill in info structure */
1945
1946 TRACE("new item %d; parent %d, mask %x\n", iItem,
1947 (INT)wineItem->parent,tvItem->mask);
1948
1949 wineItem->mask=tvItem->mask;
1950 wineItem->iIntegral=1;
1951
1952 if (tvItem->mask & TVIF_CHILDREN) {
1953 wineItem->cChildren=tvItem->cChildren;
1954 if (tvItem->cChildren==I_CHILDRENCALLBACK)
1955 FIXME(" I_CHILDRENCALLBACK not supported\n");
1956 }
1957
1958 wineItem->expandBox.left = 0; /* Initialize the expandBox */
1959 wineItem->expandBox.top = 0;
1960 wineItem->expandBox.right = 0;
1961 wineItem->expandBox.bottom = 0;
1962
1963 if (tvItem->mask & TVIF_IMAGE)
1964 wineItem->iImage=tvItem->iImage;
1965
1966 /* If the application sets TVIF_INTEGRAL without
1967 supplying a TVITEMEX structure, it's toast */
1968
1969 if (tvItem->mask & TVIF_INTEGRAL)
1970 wineItem->iIntegral=tvItem->iIntegral;
1971
1972 if (tvItem->mask & TVIF_SELECTEDIMAGE)
1973 wineItem->iSelectedImage=tvItem->iSelectedImage;
1974
1975 if (tvItem->mask & TVIF_STATE) {
1976 TRACE("item state: %x ->%x\n", wineItem->state, tvItem->state);
1977 TRACE("statemask: %x ->%x\n", wineItem->stateMask, tvItem->stateMask);
1978 wineItem->state=tvItem->state;
1979 wineItem->stateMask=tvItem->stateMask;
1980 }
1981
1982 TREEVIEW_QueueRefresh (hwnd);
1983
1984 return (LRESULT) iItem;
1985 }
1986
1987
1988 static LRESULT
1989 TREEVIEW_InsertItemW(HWND hwnd, WPARAM wParam, LPARAM lParam)
1990 {
1991 TVINSERTSTRUCTW *tvisW;
1992 TVINSERTSTRUCTA tvisA;
1993 LRESULT lRes;
1994
1995 tvisW = (LPTVINSERTSTRUCTW)lParam;
1996
1997 tvisA.hParent = tvisW->hParent;
1998 tvisA.hInsertAfter = tvisW->hInsertAfter;
1999
2000 tvisA.DUMMYUNIONNAME.item.mask = tvisW->DUMMYUNIONNAME.item.mask;
2001 tvisA.DUMMYUNIONNAME.item.hItem = tvisW->DUMMYUNIONNAME.item.hItem;
2002 tvisA.DUMMYUNIONNAME.item.state = tvisW->DUMMYUNIONNAME.item.state;
2003 tvisA.DUMMYUNIONNAME.item.stateMask = tvisW->DUMMYUNIONNAME.item.stateMask;
2004 tvisA.DUMMYUNIONNAME.item.cchTextMax = tvisW->DUMMYUNIONNAME.item.cchTextMax;
2005
2006 if(tvisW->DUMMYUNIONNAME.item.pszText)
2007 {
2008 if (tvisW->DUMMYUNIONNAME.item.pszText!=LPSTR_TEXTCALLBACKW)
2009 {
2010 int len = lstrlenW (tvisW->DUMMYUNIONNAME.item.pszText)+1;
2011 tvisA.DUMMYUNIONNAME.item.pszText = COMCTL32_Alloc (len);
2012 lstrcpyWtoA (tvisA.DUMMYUNIONNAME.item.pszText,
2013 tvisW->DUMMYUNIONNAME.item.pszText );
2014 }
2015 else
2016 {
2017 tvisA.DUMMYUNIONNAME.item.pszText = LPSTR_TEXTCALLBACKA;
2018 tvisA.DUMMYUNIONNAME.item.cchTextMax = 0;
2019 }
2020 }
2021
2022 tvisA.DUMMYUNIONNAME.item.iImage = tvisW->DUMMYUNIONNAME.item.iImage;
2023 tvisA.DUMMYUNIONNAME.item.iSelectedImage = tvisW->DUMMYUNIONNAME.item.iSelectedImage;
2024 tvisA.DUMMYUNIONNAME.item.cChildren = tvisW->DUMMYUNIONNAME.item.cChildren;
2025 tvisA.DUMMYUNIONNAME.item.lParam = tvisW->DUMMYUNIONNAME.item.lParam;
2026
2027 lRes = TREEVIEW_InsertItemA(hwnd,wParam,(LPARAM)&tvisA);
2028
2029 if (tvisA.DUMMYUNIONNAME.item.pszText!=LPSTR_TEXTCALLBACKA)
2030 {
2031 COMCTL32_Free(tvisA.DUMMYUNIONNAME.item.pszText);
2032 }
2033
2034 return lRes;
2035
2036 }
2037
2038
2039 static LRESULT
2040 TREEVIEW_DeleteItem (HWND hwnd, WPARAM wParam, LPARAM lParam)
2041 {
2042 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
2043 INT iItem;
2044 TREEVIEW_ITEM *wineItem;
2045
2046 TRACE("item = %08lx\n", lParam);
2047
2048 if (lParam == (INT)TVI_ROOT) {
2049 TREEVIEW_RemoveTree (hwnd);
2050 } else {
2051 iItem= (INT) lParam;
2052 wineItem = TREEVIEW_ValidItem (infoPtr, (HTREEITEM)iItem);
2053 if (!wineItem) return FALSE;
2054
2055 if (wineItem->pszText==LPSTR_TEXTCALLBACKA)
2056 TRACE("LPSTR_TEXTCALLBACK\n");
2057 else
2058 TRACE("%s\n",wineItem->pszText);
2059 TREEVIEW_RemoveItem (hwnd, wineItem);
2060 }
2061
2062 TREEVIEW_QueueRefresh (hwnd);
2063
2064 return TRUE;
2065 }
2066
2067
2068
2069 static LRESULT
2070 TREEVIEW_GetIndent (HWND hwnd)
2071 {
2072 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
2073
2074 TRACE("\n");
2075 return infoPtr->uIndent;
2076 }
2077
2078 static LRESULT
2079 TREEVIEW_SetIndent (HWND hwnd, WPARAM wParam)
2080 {
2081 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
2082 INT newIndent;
2083
2084 TRACE("\n");
2085 newIndent=(INT) wParam;
2086 if (newIndent < MINIMUM_INDENT) newIndent=MINIMUM_INDENT;
2087 infoPtr->uIndent=newIndent;
2088
2089 return 0;
2090 }
2091
2092 static LRESULT
2093 TREEVIEW_GetToolTips (HWND hwnd)
2094
2095 {
2096 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
2097
2098 TRACE("\n");
2099 return infoPtr->hwndToolTip;
2100 }
2101
2102
2103 static LRESULT
2104 TREEVIEW_SetToolTips (HWND hwnd, WPARAM wParam)
2105
2106 {
2107 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
2108 HWND prevToolTip;
2109
2110 TRACE("\n");
2111 prevToolTip=infoPtr->hwndToolTip;
2112 infoPtr->hwndToolTip= (HWND) wParam;
2113
2114 return prevToolTip;
2115 }
2116
2117
2118 static LRESULT CALLBACK
2119 TREEVIEW_GetEditControl (HWND hwnd)
2120
2121 {
2122 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
2123
2124 return infoPtr->hwndEdit;
2125 }
2126
2127 LRESULT CALLBACK
2128 TREEVIEW_Edit_SubclassProc (HWND hwnd, UINT uMsg, WPARAM wParam,
2129 LPARAM lParam)
2130 {
2131 switch (uMsg)
2132 {
2133 case WM_ERASEBKGND:
2134 {
2135 RECT rc;
2136 HDC hdc = (HDC) wParam;
2137 GetClientRect (hwnd, &rc);
2138 Rectangle (hdc, rc.left, rc.top, rc.right, rc.bottom);
2139 return -1;
2140 }
2141
2142 case WM_GETDLGCODE:
2143 {
2144 return DLGC_WANTARROWS | DLGC_WANTALLKEYS;
2145 }
2146
2147 default:
2148 {
2149 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(GetParent(hwnd));
2150 if (infoPtr!=NULL)
2151 return CallWindowProcA (infoPtr->wpEditOrig, hwnd, uMsg, wParam, lParam);
2152 else
2153 break;
2154
2155 }
2156 }
2157
2158 return 0;
2159 }
2160
2161
2162 /* should handle edit control messages here */
2163
2164 static LRESULT
2165 TREEVIEW_Command (HWND hwnd, WPARAM wParam, LPARAM lParam)
2166
2167 {
2168 TRACE("%x %ld\n",wParam, lParam);
2169
2170 switch (HIWORD(wParam))
2171 {
2172 case EN_UPDATE:
2173 {
2174 /*
2175 * Adjust the edit window size
2176 */
2177 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
2178 TREEVIEW_ITEM *editItem = TREEVIEW_ValidItem(infoPtr, infoPtr->editItem);
2179 INT iLength = GetWindowTextLengthA(infoPtr->hwndEdit);
2180 HDC hdc = GetDC(infoPtr->hwndEdit);
2181 TEXTMETRICA tm;
2182
2183 if ( GetTextMetricsA(hdc, &tm) )
2184 {
2185 LONG newWidth = (iLength * tm.tmAveCharWidth) + 15;
2186
2187 SetWindowPos (
2188 infoPtr->hwndEdit,
2189 HWND_TOP,
2190 editItem->text.left - 2,
2191 editItem->text.top - 1,
2192 newWidth,
2193 editItem->text.bottom - editItem->text.top + 3,
2194 SWP_DRAWFRAME );
2195 }
2196 ReleaseDC(hwnd, hdc);
2197
2198 break;
2199 }
2200
2201 case EN_KILLFOCUS:
2202 /* TREEVIEW_EndEditLabelNow(hwnd, (WPARAM)FALSE, 0);
2203 */
2204 break;
2205
2206 default:
2207 return SendMessageA (GetParent (hwnd), WM_COMMAND, wParam, lParam);
2208 }
2209
2210 return 0;
2211 }
2212
2213 static LRESULT
2214 TREEVIEW_Size (HWND hwnd, WPARAM wParam, LPARAM lParam)
2215
2216 {
2217 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
2218
2219 if (infoPtr->bAutoSize)
2220 {
2221 infoPtr->bAutoSize = FALSE;
2222 return 0;
2223 }
2224 infoPtr->bAutoSize = TRUE;
2225
2226 if (wParam == SIZE_RESTORED)
2227 {
2228 infoPtr->uTotalWidth = LOWORD (lParam);
2229 infoPtr->uTotalHeight = HIWORD (lParam);
2230 } else {
2231 FIXME("WM_SIZE flag %x %lx not handled\n", wParam, lParam);
2232 }
2233
2234 TREEVIEW_QueueRefresh (hwnd);
2235 return 0;
2236 }
2237
2238
2239
2240 static LRESULT
2241 TREEVIEW_StyleChanged (HWND hwnd, WPARAM wParam, LPARAM lParam)
2242 {
2243 HDC hdc;
2244
2245 TRACE("(%x %lx)\n",wParam,lParam);
2246 hdc = GetDC (hwnd);
2247 TREEVIEW_Refresh (hwnd, hdc);
2248 ReleaseDC(hwnd,hdc);
2249
2250 return 0;
2251 }
2252
2253 static LRESULT
2254 TREEVIEW_Create (HWND hwnd, WPARAM wParam, LPARAM lParam)
2255 {
2256 TREEVIEW_INFO *infoPtr;
2257 DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
2258 LOGFONTA logFont;
2259 TEXTMETRICA tm;
2260 HDC hdc;
2261
2262 TRACE("wnd %x, style %lx\n",hwnd,dwStyle);
2263 /* allocate memory for info structure */
2264 infoPtr = (TREEVIEW_INFO *) COMCTL32_Alloc (sizeof(TREEVIEW_INFO));
2265
2266 SetWindowLongA( hwnd, 0, (DWORD)infoPtr);
2267
2268 if (infoPtr == NULL) {
2269 ERR("could not allocate info memory!\n");
2270 return 0;
2271 }
2272
2273 if ((TREEVIEW_INFO*) GetWindowLongA( hwnd, 0) != infoPtr) {
2274 ERR("pointer assignment error!\n");
2275 return 0;
2276 }
2277
2278 hdc=GetDC (hwnd);
2279
2280 /* set default settings */
2281 infoPtr->uInternalStatus=0;
2282 infoPtr->uNumItems=0;
2283 infoPtr->clrBk = GetSysColor (COLOR_WINDOW);
2284 infoPtr->clrText = GetSysColor (COLOR_WINDOWTEXT);
2285 infoPtr->clrLine = GetSysColor (COLOR_WINDOWTEXT);
2286 infoPtr->clrInsertMark = GetSysColor (COLOR_BTNTEXT);
2287 infoPtr->cy = 0;
2288 infoPtr->cx = 0;
2289 infoPtr->uIndent = 15;
2290 infoPtr->himlNormal = NULL;
2291 infoPtr->himlState = NULL;
2292 infoPtr->uItemHeight = -1;
2293 GetTextMetricsA (hdc, &tm);
2294 infoPtr->hFont = GetStockObject (DEFAULT_GUI_FONT);
2295 GetObjectA (infoPtr->hFont, sizeof (LOGFONTA), &logFont);
2296 logFont.lfWeight=FW_BOLD;
2297 infoPtr->hBoldFont = CreateFontIndirectA (&logFont);
2298
2299 infoPtr->items = NULL;
2300 infoPtr->selectedItem=0;
2301 infoPtr->clrText=-1; /* use system color */
2302 infoPtr->dropItem=0;
2303 infoPtr->insertMarkItem=0;
2304 infoPtr->insertBeforeorAfter=0;
2305 infoPtr->pCallBackSort=NULL;
2306 infoPtr->uScrollTime = 300; /* milliseconds */
2307 infoPtr->wpEditOrig = NULL; /* we haven't subclassed anything yet */
2308
2309 infoPtr->hwndToolTip=0;
2310 if (!(dwStyle & TVS_NOTOOLTIPS)) { /* Create tooltip control */
2311 TTTOOLINFOA ti;
2312
2313 infoPtr->hwndToolTip =
2314 CreateWindowExA (0, TOOLTIPS_CLASSA, NULL, 0,
2315 CW_USEDEFAULT, CW_USEDEFAULT,
2316 CW_USEDEFAULT, CW_USEDEFAULT,
2317 hwnd, 0, 0, 0);
2318
2319 /* Send NM_TOOLTIPSCREATED notification */
2320 if (infoPtr->hwndToolTip) {
2321 NMTOOLTIPSCREATED nmttc;
2322
2323 nmttc.hdr.hwndFrom = hwnd;
2324 nmttc.hdr.idFrom = GetWindowLongA( hwnd, GWL_ID);
2325 nmttc.hdr.code = NM_TOOLTIPSCREATED;
2326 nmttc.hwndToolTips = infoPtr->hwndToolTip;
2327
2328 SendMessageA (GetParent (hwnd), WM_NOTIFY,
2329 (WPARAM) GetWindowLongA( hwnd, GWL_ID), (LPARAM)&nmttc);
2330 }
2331
2332 ZeroMemory (&ti, sizeof(TTTOOLINFOA));
2333 ti.cbSize = sizeof(TTTOOLINFOA);
2334 ti.uFlags = TTF_IDISHWND | TTF_TRACK | TTF_TRANSPARENT ;
2335 ti.hwnd = hwnd;
2336 ti.uId = 0;
2337 ti.lpszText = "Test"; /* LPSTR_TEXTCALLBACK; */
2338 SetRectEmpty (&ti.rect);
2339
2340 SendMessageA (infoPtr->hwndToolTip, TTM_ADDTOOLA, 0, (LPARAM)&ti);
2341 }
2342
2343 infoPtr->hwndEdit = CreateWindowExA (
2344 WS_EX_LEFT,
2345 "EDIT",
2346 0,
2347 WS_CHILD | WS_BORDER | ES_AUTOHSCROLL |
2348 ES_WANTRETURN | ES_LEFT,
2349 0, 0, 0, 0,
2350 hwnd,
2351 0,0,0); /* FIXME: (HMENU)IDTVEDIT,pcs->hInstance,0);*/
2352
2353 SendMessageA ( infoPtr->hwndEdit, WM_SETFONT, infoPtr->hFont, FALSE);
2354 infoPtr->wpEditOrig = (WNDPROC)SetWindowLongA (
2355 infoPtr->hwndEdit,
2356 GWL_WNDPROC,
2357 (LONG) TREEVIEW_Edit_SubclassProc);
2358
2359 if (dwStyle & TVS_CHECKBOXES) {
2360 HBITMAP hbmLoad;
2361 int nIndex;
2362
2363 infoPtr->himlState =
2364 ImageList_Create (16, 16,ILC_COLOR|ILC_MASK, 15, 1);
2365
2366 hbmLoad = LoadBitmapA (COMCTL32_hModule, MAKEINTRESOURCEA(IDT_CHECK));
2367 TRACE ("%x\n",hbmLoad);
2368 nIndex = ImageList_AddMasked (infoPtr->himlState, hbmLoad, CLR_DEFAULT);
2369 TRACE ("%d\n",nIndex);
2370 DeleteObject (hbmLoad);
2371 }
2372 ReleaseDC (hwnd, hdc);
2373 return 0;
2374 }
2375
2376
2377
2378 static LRESULT
2379 TREEVIEW_Destroy (HWND hwnd)
2380 {
2381 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
2382
2383 TRACE("\n");
2384 TREEVIEW_RemoveTree (hwnd);
2385 SetWindowLongA (hwnd, 0, (DWORD)NULL);
2386
2387 if (infoPtr->Timer & TV_REFRESH_TIMER_SET)
2388 KillTimer (hwnd, TV_REFRESH_TIMER);
2389 if (infoPtr->hwndToolTip)
2390 DestroyWindow (infoPtr->hwndToolTip);
2391
2392 COMCTL32_Free (infoPtr);
2393 return 0;
2394 }
2395
2396
2397 static LRESULT
2398 TREEVIEW_Paint (HWND hwnd, WPARAM wParam, LPARAM lParam)
2399 {
2400 HDC hdc;
2401 PAINTSTRUCT ps;
2402
2403 TRACE("\n");
2404 hdc = wParam==0 ? BeginPaint (hwnd, &ps) : (HDC)wParam;
2405 TREEVIEW_Refresh (hwnd, hdc);
2406 if(!wParam) EndPaint (hwnd, &ps);
2407 TRACE("done\n");
2408
2409 return DefWindowProcA (hwnd, WM_PAINT, wParam, lParam);
2410 }
2411
2412 static LRESULT
2413 TREEVIEW_SetFocus (HWND hwnd, WPARAM wParam, LPARAM lParam)
2414 {
2415 TREEVIEW_SendSimpleNotify (hwnd, NM_SETFOCUS);
2416 InvalidateRect(hwnd, NULL, FALSE);
2417 return 0;
2418 }
2419
2420 static LRESULT
2421 TREEVIEW_KillFocus (HWND hwnd, WPARAM wParam, LPARAM lParam)
2422 {
2423 TREEVIEW_SendSimpleNotify (hwnd, NM_KILLFOCUS);
2424 InvalidateRect(hwnd, NULL, FALSE);
2425 return 0;
2426 }
2427
2428 static LRESULT
2429 TREEVIEW_EraseBackground (HWND hwnd, WPARAM wParam, LPARAM lParam)
2430 {
2431 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
2432 HBRUSH hBrush = CreateSolidBrush (infoPtr->clrBk);
2433 RECT rect;
2434
2435 TRACE("\n");
2436 GetClientRect (hwnd, &rect);
2437 FillRect ((HDC)wParam, &rect, hBrush);
2438 DeleteObject (hBrush);
2439 return TRUE;
2440 }
2441
2442
2443
2444
2445
2446
2447 /* Notifications */
2448
2449
2450
2451
2452
2453 static BOOL
2454 TREEVIEW_SendSimpleNotify (HWND hwnd, UINT code)
2455 {
2456 NMHDR nmhdr;
2457
2458 TRACE("%x\n",code);
2459 nmhdr.hwndFrom = hwnd;
2460 nmhdr.idFrom = GetWindowLongA( hwnd, GWL_ID);
2461 nmhdr.code = code;
2462
2463 return (BOOL) SendMessageA (GetParent (hwnd), WM_NOTIFY,
2464 (WPARAM)nmhdr.idFrom, (LPARAM)&nmhdr);
2465 }
2466
2467
2468
2469 static BOOL
2470 TREEVIEW_SendTreeviewNotify (HWND hwnd, UINT code, UINT action,
2471 HTREEITEM oldItem, HTREEITEM newItem)
2472
2473 {
2474 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
2475 NMTREEVIEWA nmhdr;
2476 TREEVIEW_ITEM *wineItem;
2477
2478 TRACE("code:%x action:%x olditem:%x newitem:%x\n",
2479 code,action,(INT)oldItem,(INT)newItem);
2480 nmhdr.hdr.hwndFrom = hwnd;
2481 nmhdr.hdr.idFrom = GetWindowLongA( hwnd, GWL_ID);
2482 nmhdr.hdr.code = code;
2483 nmhdr.action = action;
2484 if (oldItem) {
2485 wineItem=& infoPtr->items[(INT)oldItem];
2486 nmhdr.itemOld.mask = wineItem->mask;
2487 nmhdr.itemOld.hItem = wineItem->hItem;
2488 nmhdr.itemOld.state = wineItem->state;
2489 nmhdr.itemOld.stateMask = wineItem->stateMask;
2490 nmhdr.itemOld.iImage = wineItem->iImage;
2491 nmhdr.itemOld.pszText = wineItem->pszText;
2492 nmhdr.itemOld.cchTextMax= wineItem->cchTextMax;
2493 nmhdr.itemOld.iImage = wineItem->iImage;
2494 nmhdr.itemOld.iSelectedImage = wineItem->iSelectedImage;
2495 nmhdr.itemOld.cChildren = wineItem->cChildren;
2496 nmhdr.itemOld.lParam = wineItem->lParam;
2497 }
2498
2499 if (newItem) {
2500 wineItem=& infoPtr->items[(INT)newItem];
2501 nmhdr.itemNew.mask = wineItem->mask;
2502 nmhdr.itemNew.hItem = wineItem->hItem;
2503 nmhdr.itemNew.state = wineItem->state;
2504 nmhdr.itemNew.stateMask = wineItem->stateMask;
2505 nmhdr.itemNew.iImage = wineItem->iImage;
2506 nmhdr.itemNew.pszText = wineItem->pszText;
2507 nmhdr.itemNew.cchTextMax= wineItem->cchTextMax;
2508 nmhdr.itemNew.iImage = wineItem->iImage;
2509 nmhdr.itemNew.iSelectedImage = wineItem->iSelectedImage;
2510 nmhdr.itemNew.cChildren = wineItem->cChildren;
2511 nmhdr.itemNew.lParam = wineItem->lParam;
2512 }
2513
2514 nmhdr.ptDrag.x = 0;
2515 nmhdr.ptDrag.y = 0;
2516
2517 return (BOOL)SendMessageA (GetParent (hwnd), WM_NOTIFY,
2518 (WPARAM) GetWindowLongA( hwnd, GWL_ID), (LPARAM)&nmhdr);
2519
2520 }
2521
2522 static BOOL
2523 TREEVIEW_SendTreeviewDnDNotify (HWND hwnd, UINT code, HTREEITEM dragItem,
2524 POINT pt)
2525 {
2526 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
2527 NMTREEVIEWA nmhdr;
2528 TREEVIEW_ITEM *wineItem;
2529
2530 TRACE("code:%x dragitem:%x\n", code,(INT)dragItem);
2531
2532 nmhdr.hdr.hwndFrom = hwnd;
2533 nmhdr.hdr.idFrom = GetWindowLongA( hwnd, GWL_ID);
2534 nmhdr.hdr.code = code;
2535 nmhdr.action = 0;
2536 wineItem=& infoPtr->items[(INT)dragItem];
2537 nmhdr.itemNew.mask = wineItem->mask;
2538 nmhdr.itemNew.hItem = wineItem->hItem;
2539 nmhdr.itemNew.state = wineItem->state;
2540 nmhdr.itemNew.lParam = wineItem->lParam;
2541
2542 nmhdr.ptDrag.x = pt.x;
2543 nmhdr.ptDrag.y = pt.y;
2544
2545 return (BOOL)SendMessageA (GetParent (hwnd), WM_NOTIFY,
2546 (WPARAM) GetWindowLongA( hwnd, GWL_ID), (LPARAM)&nmhdr);
2547
2548 }
2549
2550
2551
2552 static BOOL
2553 TREEVIEW_SendDispInfoNotify (HWND hwnd, TREEVIEW_ITEM *wineItem,
2554 UINT code, UINT what)
2555 {
2556 NMTVDISPINFOA tvdi;
2557 BOOL retval;
2558 char *buf;
2559
2560 TRACE("item %d, action %x, state %d\n",
2561 (INT)wineItem->hItem,
2562 what,
2563 (INT)wineItem->state);
2564
2565 tvdi.hdr.hwndFrom = hwnd;
2566 tvdi.hdr.idFrom = GetWindowLongA( hwnd, GWL_ID);
2567 tvdi.hdr.code = code;
2568 tvdi.item.mask = what;
2569 tvdi.item.hItem = wineItem->hItem;
2570 tvdi.item.state = wineItem->state;
2571 tvdi.item.lParam = wineItem->lParam;
2572 tvdi.item.pszText = COMCTL32_Alloc (128*sizeof(char));
2573 tvdi.item.cchTextMax = 128;
2574 buf = tvdi.item.pszText;
2575
2576 retval=(BOOL)SendMessageA (
2577 GetParent(hwnd),
2578 WM_NOTIFY,
2579 (WPARAM)tvdi.hdr.idFrom,
2580 (LPARAM)&tvdi);
2581
2582 if (what & TVIF_TEXT) {
2583 wineItem->pszText = tvdi.item.pszText;
2584 if (buf==tvdi.item.pszText) {
2585 wineItem->cchTextMax = 128;
2586 } else {
2587 TRACE("user-supplied buffer\n");
2588 COMCTL32_Free (buf);
2589 wineItem->cchTextMax = 0;
2590 }
2591 }
2592 if (what & TVIF_SELECTEDIMAGE)
2593 wineItem->iSelectedImage = tvdi.item.iSelectedImage;
2594 if (what & TVIF_IMAGE)
2595 wineItem->iImage = tvdi.item.iImage;
2596 if (what & TVIF_CHILDREN)
2597 wineItem->cChildren = tvdi.item.cChildren;
2598
2599 return retval;
2600 }
2601
2602
2603
2604 static BOOL
2605 TREEVIEW_SendCustomDrawNotify (HWND hwnd, DWORD dwDrawStage, HDC hdc,
2606 RECT rc)
2607 {
2608 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
2609 NMTVCUSTOMDRAW nmcdhdr;
2610 LPNMCUSTOMDRAW nmcd;
2611
2612 TRACE("drawstage:%lx hdc:%x\n", dwDrawStage, hdc);
2613
2614 nmcd= & nmcdhdr.nmcd;
2615 nmcd->hdr.hwndFrom = hwnd;
2616 nmcd->hdr.idFrom = GetWindowLongA( hwnd, GWL_ID);
2617 nmcd->hdr.code = NM_CUSTOMDRAW;
2618 nmcd->dwDrawStage= dwDrawStage;
2619 nmcd->hdc = hdc;
2620 nmcd->rc.left = rc.left;
2621 nmcd->rc.right = rc.right;
2622 nmcd->rc.bottom = rc.bottom;
2623 nmcd->rc.top = rc.top;
2624 nmcd->dwItemSpec = 0;
2625 nmcd->uItemState = 0;
2626 nmcd->lItemlParam= 0;
2627 nmcdhdr.clrText = infoPtr->clrText;
2628 nmcdhdr.clrTextBk= infoPtr->clrBk;
2629 nmcdhdr.iLevel = 0;
2630
2631 return (BOOL)SendMessageA (GetParent (hwnd), WM_NOTIFY,
2632 (WPARAM) GetWindowLongA( hwnd, GWL_ID), (LPARAM)&nmcdhdr);
2633
2634 }
2635
2636
2637
2638 /* FIXME: need to find out when the flags in uItemState need to be set */
2639
2640 static BOOL
2641 TREEVIEW_SendCustomDrawItemNotify (HWND hwnd, HDC hdc,
2642 TREEVIEW_ITEM *wineItem, UINT uItemDrawState)
2643 {
2644 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
2645 NMTVCUSTOMDRAW nmcdhdr;
2646 LPNMCUSTOMDRAW nmcd;
2647 DWORD dwDrawStage,dwItemSpec;
2648 UINT uItemState;
2649 INT retval;
2650
2651 dwDrawStage=CDDS_ITEM | uItemDrawState;
2652 dwItemSpec=(DWORD)wineItem->hItem;
2653 uItemState=0;
2654 if (wineItem->hItem==infoPtr->selectedItem) uItemState|=CDIS_SELECTED;
2655 if (wineItem->hItem==infoPtr->focusItem) uItemState|=CDIS_FOCUS;
2656 if (wineItem->hItem==infoPtr->hotItem) uItemState|=CDIS_HOT;
2657
2658 nmcd= & nmcdhdr.nmcd;
2659 nmcd->hdr.hwndFrom = hwnd;
2660 nmcd->hdr.idFrom = GetWindowLongA( hwnd, GWL_ID);
2661 nmcd->hdr.code = NM_CUSTOMDRAW;
2662 nmcd->dwDrawStage= dwDrawStage;
2663 nmcd->hdc = hdc;
2664 nmcd->rc.left = wineItem->rect.left;
2665 nmcd->rc.right = wineItem->rect.right;
2666 nmcd->rc.bottom = wineItem->rect.bottom;
2667 nmcd->rc.top = wineItem->rect.top;
2668 nmcd->dwItemSpec = dwItemSpec;
2669 nmcd->uItemState = uItemState;
2670 nmcd->lItemlParam= wineItem->lParam;
2671 nmcdhdr.clrText = infoPtr->clrText;
2672 nmcdhdr.clrTextBk= infoPtr->clrBk;
2673 nmcdhdr.iLevel = wineItem->iLevel;
2674
2675 TRACE("drawstage:%lx hdc:%x item:%lx, itemstate:%x, lItemlParam:%lx\n",
2676 nmcd->dwDrawStage, nmcd->hdc, nmcd->dwItemSpec,
2677 nmcd->uItemState, nmcd->lItemlParam);
2678
2679 retval=SendMessageA (GetParent (hwnd), WM_NOTIFY,
2680 (WPARAM) GetWindowLongA( hwnd, GWL_ID), (LPARAM)&nmcdhdr);
2681
2682 infoPtr->clrText=nmcdhdr.clrText;
2683 infoPtr->clrBk =nmcdhdr.clrTextBk;
2684 return (BOOL) retval;
2685 }
2686
2687
2688
2689 /* Note:If the specified item is the child of a collapsed parent item,
2690 the parent's list of child items is (recursively) expanded to reveal the
2691 specified item. This is mentioned for TREEVIEW_SelectItem; don't
2692 know if it also applies here.
2693 */
2694
2695 static LRESULT
2696 TREEVIEW_Expand (HWND hwnd, WPARAM wParam, LPARAM lParam)
2697 {
2698 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
2699 TREEVIEW_ITEM *wineItem;
2700 UINT flag;
2701 INT expand;
2702
2703 flag = (UINT) wParam;
2704 expand = (INT) lParam;
2705
2706 wineItem = TREEVIEW_ValidItem (infoPtr, (HTREEITEM)expand);
2707
2708 if (!wineItem)
2709 return 0;
2710 if (!wineItem->cChildren)
2711 return 0;
2712
2713 if (wineItem->pszText==LPSTR_TEXTCALLBACKA)
2714 TRACE ("For item %d, flags %d, state %d\n",
2715 expand, flag, wineItem->state);
2716 else
2717 TRACE("For (%s) item:%d, flags %x, state:%d\n",
2718 wineItem->pszText, flag, expand, wineItem->state);
2719
2720 if (wineItem->cChildren==I_CHILDRENCALLBACK) {
2721 FIXME("we don't handle I_CHILDRENCALLBACK yet\n");
2722 return 0;
2723 }
2724
2725 if (flag == TVE_TOGGLE) { /* FIXME: check exact behaviour here */
2726 flag &= ~TVE_TOGGLE; /* ie: bitwise ops or 'case' ops */
2727 if (wineItem->state & TVIS_EXPANDED)
2728 flag |= TVE_COLLAPSE;
2729 else
2730 flag |= TVE_EXPAND;
2731 }
2732
2733 switch (flag)
2734 {
2735 case TVE_COLLAPSERESET:
2736 TRACE(" case TVE_COLLAPSERESET\n");
2737 if (!wineItem->state & TVIS_EXPANDED)
2738 return 0;
2739
2740 wineItem->state &= ~(TVIS_EXPANDEDONCE | TVIS_EXPANDED);
2741 TREEVIEW_RemoveAllChildren (hwnd, wineItem);
2742 break;
2743
2744 case TVE_COLLAPSE:
2745 TRACE(" case TVE_COLLAPSE\n");
2746 if (!wineItem->state & TVIS_EXPANDED)
2747 return 0;
2748
2749 wineItem->state &= ~TVIS_EXPANDED;
2750 break;
2751
2752 case TVE_EXPAND:
2753 TRACE(" case TVE_EXPAND\n");
2754 if (wineItem->state & TVIS_EXPANDED)
2755 return 0;
2756
2757 TRACE(" is not expanded...\n");
2758
2759 if (!(wineItem->state & TVIS_EXPANDEDONCE))
2760 {
2761 TRACE(" and has never been expanded...\n");
2762 wineItem->state |= TVIS_EXPANDED;
2763
2764 /* this item has never been expanded */
2765 if (TREEVIEW_SendTreeviewNotify (
2766 hwnd,
2767 TVN_ITEMEXPANDINGA,
2768 TVE_EXPAND,
2769 0,
2770 (HTREEITEM)expand))
2771 {
2772 TRACE(" TVN_ITEMEXPANDINGA returned TRUE, exiting...\n");
2773 return FALSE;
2774 }
2775
2776 /* FIXME
2777 * Since the TVN_ITEMEXPANDINGA message may has caused the parent to
2778 * insert new items which in turn may have cause items placeholder
2779 * reallocation, I reassign the current item pointer so we have
2780 * something valid to work with...
2781 * However, this should not be necessary,
2782 * investigation required in TREEVIEW_InsertItemA
2783 */
2784 wineItem = TREEVIEW_ValidItem (infoPtr, (HTREEITEM)expand);
2785 if (! wineItem)
2786 {
2787 ERR(
2788 "Catastropic situation, cannot retreive item #%d\n",
2789 expand);
2790 return FALSE;
2791 }
2792
2793 wineItem->state |= TVIS_EXPANDEDONCE;
2794 TRACE(" TVN_ITEMEXPANDINGA sent...\n");
2795
2796 TREEVIEW_SendTreeviewNotify (
2797 hwnd,
2798 TVN_ITEMEXPANDEDA,
2799 TVE_EXPAND,
2800 0,
2801 (HTREEITEM)expand);
2802
2803 TRACE(" TVN_ITEMEXPANDEDA sent...\n");
2804
2805 }
2806 else
2807 {
2808 /* this item has already been expanded */
2809 wineItem->state |= TVIS_EXPANDED;
2810 }
2811 break;
2812
2813 case TVE_EXPANDPARTIAL:
2814 TRACE(" case TVE_EXPANDPARTIAL\n");
2815 FIXME("TVE_EXPANDPARTIAL not implemented\n");
2816 wineItem->state ^=TVIS_EXPANDED;
2817 wineItem->state |=TVIS_EXPANDEDONCE;
2818 break;
2819 }
2820
2821 TRACE("Exiting, Item %d state is now %d...\n",
2822 expand,
2823 wineItem->state);
2824
2825 TREEVIEW_QueueRefresh (hwnd);
2826 return TRUE;
2827 }
2828
2829
2830
2831 static TREEVIEW_ITEM *
2832 TREEVIEW_HitTestPoint (HWND hwnd, POINT pt)
2833 {
2834 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
2835 TREEVIEW_ITEM *wineItem;
2836 RECT rect;
2837
2838 GetClientRect (hwnd, &rect);
2839
2840 if (!infoPtr->firstVisible) return NULL;
2841
2842 wineItem=&infoPtr->items [(INT)infoPtr->firstVisible];
2843
2844 while ((wineItem!=NULL) && (pt.y > wineItem->rect.bottom))
2845 wineItem=TREEVIEW_GetNextListItem (infoPtr,wineItem);
2846
2847 if (!wineItem)
2848 return NULL;
2849
2850 return wineItem;
2851 }
2852
2853
2854
2855
2856 static LRESULT
2857 TREEVIEW_HitTest (HWND hwnd, LPARAM lParam)
2858 {
2859 LPTVHITTESTINFO lpht=(LPTVHITTESTINFO) lParam;
2860 TREEVIEW_ITEM *wineItem;
2861 RECT rect;
2862 UINT status,x,y;
2863
2864 GetClientRect (hwnd, &rect);
2865 status=0;
2866 x=lpht->pt.x;
2867 y=lpht->pt.y;
2868 if (x < rect.left) status|=TVHT_TOLEFT;
2869 if (x > rect.right) status|=TVHT_TORIGHT;
2870 if (y < rect.top ) status|=TVHT_ABOVE;
2871 if (y > rect.bottom) status|=TVHT_BELOW;
2872
2873 if (status) {
2874 lpht->flags=status;
2875 return 0;
2876 }
2877
2878 wineItem=TREEVIEW_HitTestPoint (hwnd, lpht->pt);
2879 if (!wineItem) {
2880 lpht->flags=TVHT_NOWHERE;
2881 return 0;
2882 }
2883
2884 lpht->flags=0;
2885
2886 if (x < wineItem->expandBox.left) {
2887 lpht->flags |= TVHT_ONITEMINDENT;
2888 goto done;
2889 }
2890 if ( PtInRect ( &wineItem->expandBox, lpht->pt)) {
2891 lpht->flags |= TVHT_ONITEMBUTTON;
2892 goto done;
2893 }
2894 if ( PtInRect ( &wineItem->bitmap, lpht->pt)) {
2895 lpht->flags |= TVHT_ONITEMICON;
2896 goto done;
2897 }
2898 if ( PtInRect ( &wineItem->statebitmap, lpht->pt)) {
2899 lpht->flags |= TVHT_ONITEMSTATEICON;
2900 goto done;
2901 }
2902 if ( PtInRect ( &wineItem->text, lpht->pt)) {
2903 lpht->flags |= TVHT_ONITEMLABEL;
2904 goto done;
2905 }
2906
2907 lpht->flags|=TVHT_ONITEMRIGHT;
2908
2909
2910 done:
2911 lpht->hItem=wineItem->hItem;
2912 TRACE ("(%ld,%ld):result %x\n",lpht->pt.x,lpht->pt.y,lpht->flags);
2913
2914 return (LRESULT) wineItem->hItem;
2915 }
2916
2917 LRESULT WINAPI
2918 TREEVIEW_EndEditLabelNow (HWND hwnd, WPARAM wParam, LPARAM lParam)
2919 {
2920 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
2921 TREEVIEW_ITEM *editedItem = TREEVIEW_ValidItem (infoPtr, infoPtr->editItem);
2922 BOOL bRevert = (BOOL)wParam;
2923 BOOL bReturn = ! bRevert;
2924
2925 if ( ! (BOOL)wParam ) /* wParam is set to true to cancel the edition */
2926 {
2927 if ( TREEVIEW_SendDispInfoNotify( /* return true to cancel edition */
2928 hwnd,
2929 editedItem,
2930 TVN_ENDLABELEDITA,
2931 0))
2932 {
2933 bRevert = TRUE;
2934 bReturn = FALSE;
2935 }
2936 }
2937
2938 if (bRevert == FALSE) /* Apply the changes */
2939 {
2940 char tmpText[1024];
2941 int iLength = GetWindowTextA(infoPtr->hwndEdit, tmpText, 1023);
2942 bReturn = FALSE;
2943
2944 if (iLength == 0)
2945 {
2946 ERR("Problem retreiving new item label.");
2947 }
2948 else if (iLength >= 1023)
2949 {
2950 ERR(
2951 "Insuficient space to retrieve new item label, new label ignored.");
2952 }
2953 else
2954 {
2955 if (strcmp( tmpText, editedItem->pszText ) == 0)
2956 /* Do nothing if the label has not changed */
2957 bReturn = TRUE;
2958 else
2959 {
2960 LPSTR tmpLabel = COMCTL32_Alloc( iLength+1 );
2961
2962 if ( tmpLabel == NULL )
2963 ERR(
2964 "OutOfMemory, cannot allocate space for label");
2965 else
2966 {
2967 COMCTL32_Free(editedItem->pszText);
2968 editedItem->pszText = tmpLabel;
2969 lstrcpyA( editedItem->pszText, tmpText);
2970 bReturn = TRUE;
2971 }
2972 }
2973 }
2974
2975 ShowWindow(infoPtr->hwndEdit, SW_HIDE);
2976 EnableWindow(infoPtr->hwndEdit, FALSE);
2977 infoPtr->editItem = 0;
2978 }
2979
2980 return bReturn;
2981 }
2982
2983
2984
2985 static LRESULT
2986 TREEVIEW_LButtonDoubleClick (HWND hwnd, WPARAM wParam, LPARAM lParam)
2987 {
2988 TREEVIEW_ITEM *wineItem;
2989 POINT pt;
2990
2991 TRACE("\n");
2992 pt.x = (INT)LOWORD(lParam);
2993 pt.y = (INT)HIWORD(lParam);
2994 SetFocus (hwnd);
2995
2996 wineItem=TREEVIEW_HitTestPoint (hwnd, pt);
2997 if (!wineItem) return 0;
2998 TRACE("item %d \n",(INT)wineItem->hItem);
2999
3000 if (TREEVIEW_SendSimpleNotify (hwnd, NM_DBLCLK)!=TRUE) { /* FIXME!*/
3001 TREEVIEW_Expand (hwnd, (WPARAM) TVE_TOGGLE, (LPARAM) wineItem->hItem);
3002 }
3003 return TRUE;
3004 }
3005
3006
3007 static LRESULT
3008 TREEVIEW_LButtonDown (HWND hwnd, WPARAM wParam, LPARAM lParam)
3009 {
3010 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
3011 INT iItem;
3012 TVHITTESTINFO ht;
3013
3014 ht.pt.x = (INT)LOWORD(lParam);
3015 ht.pt.y = (INT)HIWORD(lParam);
3016
3017 SetFocus (hwnd);
3018 iItem=TREEVIEW_HitTest (hwnd, (LPARAM) &ht);
3019 TRACE("item %d \n",iItem);
3020
3021 if (ht.flags & TVHT_ONITEMBUTTON) {
3022 TREEVIEW_Expand (hwnd, (WPARAM) TVE_TOGGLE, (LPARAM) iItem);
3023 }
3024 else
3025 {
3026 infoPtr->uInternalStatus|=TV_LDRAG;
3027 }
3028
3029 return 0;
3030 }
3031
3032 static LRESULT
3033 TREEVIEW_LButtonUp (HWND hwnd, WPARAM wParam, LPARAM lParam)
3034 {
3035 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
3036 INT iItem;
3037 TREEVIEW_ITEM *wineItem;
3038 TVHITTESTINFO ht;
3039
3040 ht.pt.x = (INT)LOWORD(lParam);
3041 ht.pt.y = (INT)HIWORD(lParam);
3042
3043 TRACE("\n");
3044
3045 /* Return true to cancel default behaviour */
3046 if ( TREEVIEW_SendSimpleNotify (hwnd, NM_CLICK) )
3047 return 0;
3048
3049 /* Get the item */
3050 iItem = TREEVIEW_HitTest (hwnd, (LPARAM) &ht);
3051 TRACE ("%d\n",iItem);
3052 if (!iItem)
3053 return 0;
3054
3055 wineItem = TREEVIEW_ValidItem(infoPtr, (HTREEITEM)iItem);
3056
3057 infoPtr->uInternalStatus &= ~(TV_LDRAG | TV_LDRAGGING);
3058
3059 /*
3060 * If the style allow editing and the node is already selected
3061 * and the click occured on the item label...
3062 */
3063 if ( ( GetWindowLongA( hwnd, GWL_STYLE) & TVS_EDITLABELS ) &&
3064 ( wineItem->state & TVIS_SELECTED ) &&
3065 ( ht.flags & TVHT_ONITEMLABEL ))
3066 {
3067 if ( infoPtr->editItem == 0 ) /* If we are not curently editing */
3068 {
3069 if ( TREEVIEW_SendDispInfoNotify( /* Return true to cancel edition */
3070 hwnd,
3071 wineItem,
3072 TVN_BEGINLABELEDITA,
3073 0))
3074 {
3075 return 0;
3076 }
3077
3078 TRACE("Edit started for %s.\n", wineItem->pszText);
3079 infoPtr->editItem = wineItem->hItem;
3080
3081 SetWindowPos (
3082 infoPtr->hwndEdit,
3083 HWND_TOP,
3084 wineItem->text.left - 2,
3085 wineItem->text.top - 1,
3086 wineItem->text.right - wineItem->text.left + 20 ,
3087 wineItem->text.bottom - wineItem->text.top + 3,
3088 SWP_DRAWFRAME );
3089
3090 SetWindowTextA( infoPtr->hwndEdit, wineItem->pszText );
3091 SendMessageA ( infoPtr->hwndEdit, EM_SETSEL, 0, -1 );
3092 SetFocus ( infoPtr->hwndEdit);
3093 ShowWindow ( infoPtr->hwndEdit, SW_SHOW);
3094 }
3095 }
3096 else if ( infoPtr->editItem != 0 ) /* If we are curently editing */
3097 {
3098 TREEVIEW_EndEditLabelNow(hwnd, (WPARAM)FALSE, 0);
3099 }
3100 else if ( ht.flags & (TVHT_ONITEMLABEL | TVHT_ONITEMICON))
3101 {
3102 TREEVIEW_DoSelectItem ( hwnd, TVGN_CARET, (HTREEITEM)iItem, TVC_BYMOUSE);
3103 }
3104
3105 if (ht.flags & TVHT_ONITEMSTATEICON) {
3106 DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
3107
3108
3109 if (dwStyle & TVS_CHECKBOXES) { /* TVS_CHECKBOXES requires _us_ */
3110 int state; /* to toggle the current state */
3111 state=1-(wineItem->state>>12);
3112 TRACE ("state:%x\n", state);
3113 wineItem->state&= ~TVIS_STATEIMAGEMASK;
3114 wineItem->state|=state<<12;
3115 TRACE ("state:%x\n", wineItem->state);
3116 TREEVIEW_QueueRefresh (hwnd);
3117 }
3118 }
3119 return 0;
3120 }
3121
3122
3123 static LRESULT
3124 TREEVIEW_RButtonDown (HWND hwnd, WPARAM wParam, LPARAM lParam)
3125 {
3126 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
3127
3128 TRACE("\n");
3129 infoPtr->uInternalStatus|=TV_RDRAG;
3130 return 0;
3131 }
3132
3133 static LRESULT
3134 TREEVIEW_RButtonUp (HWND hwnd, WPARAM wParam, LPARAM lParam)
3135 {
3136 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
3137
3138 TRACE("\n");
3139 if (TREEVIEW_SendSimpleNotify (hwnd, NM_RCLICK)) return 0;
3140 infoPtr->uInternalStatus&= ~(TV_RDRAG | TV_RDRAGGING);
3141 return 0;
3142 }
3143
3144
3145 static LRESULT
3146 TREEVIEW_MouseMove (HWND hwnd, WPARAM wParam, LPARAM lParam)
3147 {
3148 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
3149 TREEVIEW_ITEM *hotItem;
3150 POINT pt;
3151
3152 pt.x=(INT) LOWORD (lParam);
3153 pt.y=(INT) HIWORD (lParam);
3154 hotItem=TREEVIEW_HitTestPoint (hwnd, pt);
3155 if (!hotItem) return 0;
3156 infoPtr->focusItem=hotItem->hItem;
3157
3158 if ( GetWindowLongA( hwnd, GWL_STYLE) & TVS_DISABLEDRAGDROP) return 0;
3159
3160 if (infoPtr->uInternalStatus & TV_LDRAG) {
3161 TREEVIEW_SendTreeviewDnDNotify (hwnd, TVN_BEGINDRAGA, hotItem->hItem, pt);
3162 infoPtr->uInternalStatus &= ~TV_LDRAG;
3163 infoPtr->uInternalStatus |= TV_LDRAGGING;
3164 infoPtr->dropItem=hotItem->hItem;
3165 return 0;
3166 }
3167
3168 if (infoPtr->uInternalStatus & TV_RDRAG) {
3169 TREEVIEW_SendTreeviewDnDNotify (hwnd, TVN_BEGINRDRAGA, hotItem->hItem, pt);
3170 infoPtr->uInternalStatus &= ~TV_RDRAG;
3171 infoPtr->uInternalStatus |= TV_RDRAGGING;
3172 infoPtr->dropItem=hotItem->hItem;
3173 return 0;
3174 }
3175
3176 return 0;
3177 }
3178
3179
3180 static LRESULT
3181 TREEVIEW_CreateDragImage (HWND hwnd, WPARAM wParam, LPARAM lParam)
3182 {
3183 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
3184 TREEVIEW_ITEM *dragItem;
3185 INT cx,cy;
3186 HDC hdc,htopdc;
3187 HWND hwtop;
3188 HBITMAP hbmp,hOldbmp;
3189 SIZE size;
3190 RECT rc;
3191 HFONT hOldFont;
3192 char *itemtxt;
3193
3194 TRACE("\n");
3195 if (!(infoPtr->himlNormal)) return 0;
3196 dragItem=TREEVIEW_ValidItem (infoPtr, (HTREEITEM) lParam);
3197
3198 if (!dragItem) return 0;
3199
3200 if (dragItem->pszText==LPSTR_TEXTCALLBACKA) {
3201 TREEVIEW_SendDispInfoNotify (hwnd, dragItem, TVN_GETDISPINFOA, TVIF_TEXT);
3202 }
3203 itemtxt=dragItem->pszText;
3204
3205 hwtop=GetDesktopWindow ();
3206 htopdc= GetDC (hwtop);
3207 hdc=CreateCompatibleDC (htopdc);
3208
3209 hOldFont=SelectObject (hdc, infoPtr->hFont);
3210 GetTextExtentPoint32A (hdc, itemtxt, lstrlenA (itemtxt), &size);
3211 TRACE("%d %d %s %d\n",size.cx,size.cy,itemtxt,lstrlenA(itemtxt));
3212 hbmp=CreateCompatibleBitmap (htopdc, size.cx, size.cy);
3213 hOldbmp=SelectObject (hdc, hbmp);
3214
3215 ImageList_GetIconSize (infoPtr->himlNormal, &cx, &cy);
3216 size.cx+=cx;
3217 if (cy>size.cy) size.cy=cy;
3218
3219 infoPtr->dragList=ImageList_Create (size.cx, size.cy, ILC_COLOR, 10, 10);
3220 ImageList_Draw (infoPtr->himlNormal, dragItem->iImage, hdc, 0, 0, ILD_NORMAL);
3221
3222 /*
3223 ImageList_GetImageInfo (infoPtr->himlNormal, dragItem->hItem, &iminfo);
3224 ImageList_AddMasked (infoPtr->dragList, iminfo.hbmImage, CLR_DEFAULT);
3225 */
3226
3227 /* draw item text */
3228
3229 SetRect (&rc, cx, 0, size.cx,size.cy);
3230 DrawTextA (hdc, itemtxt, lstrlenA (itemtxt), &rc, DT_LEFT);
3231 SelectObject (hdc, hOldFont);
3232 SelectObject (hdc, hOldbmp);
3233
3234 ImageList_Add (infoPtr->dragList, hbmp, 0);
3235
3236 DeleteDC (hdc);
3237 DeleteObject (hbmp);
3238 ReleaseDC (hwtop, htopdc);
3239
3240 return (LRESULT)infoPtr->dragList;
3241 }
3242
3243
3244 static LRESULT
3245 TREEVIEW_DoSelectItem (HWND hwnd, INT action, HTREEITEM newSelect, INT cause)
3246
3247 {
3248 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
3249 TREEVIEW_ITEM *prevItem,*wineItem;
3250 INT prevSelect;
3251
3252 wineItem = TREEVIEW_ValidItem (infoPtr, (HTREEITEM)newSelect);
3253
3254 TRACE("Entering item %d, flag %x, cause %x, state %d\n",
3255 (INT)newSelect,
3256 action,
3257 cause,
3258 wineItem->state);
3259
3260 if ( (wineItem) && (wineItem->parent))
3261 {
3262 /*
3263 * If the item has a collapse parent expand the parent so he
3264 * can expose the item
3265 */
3266 TREEVIEW_ITEM *parentItem = TREEVIEW_ValidItem (infoPtr, wineItem->parent);
3267 if ( !(parentItem->state & TVIS_EXPANDED))
3268 TREEVIEW_Expand (hwnd, TVE_EXPAND, (LPARAM) wineItem->parent);
3269 }
3270
3271 switch (action)
3272 {
3273 case TVGN_CARET:
3274 prevSelect=(INT)infoPtr->selectedItem;
3275
3276 if ((HTREEITEM)prevSelect==newSelect)
3277 return FALSE;
3278
3279 prevItem= TREEVIEW_ValidItem (infoPtr, (HTREEITEM)prevSelect);
3280
3281 if (newSelect)
3282 if (TREEVIEW_SendTreeviewNotify(
3283 hwnd,
3284 TVN_SELCHANGINGA,
3285 cause,
3286 (HTREEITEM)prevSelect,
3287 (HTREEITEM)newSelect))
3288 return FALSE; /* FIXME: OK? */
3289
3290 if (prevItem)
3291 prevItem->state &= ~TVIS_SELECTED;
3292 if (wineItem)
3293 wineItem->state |= TVIS_SELECTED;
3294
3295 infoPtr->selectedItem=(HTREEITEM)newSelect;
3296
3297 TREEVIEW_SendTreeviewNotify(
3298 hwnd,
3299 TVN_SELCHANGEDA,
3300 cause,
3301 (HTREEITEM)prevSelect,
3302 (HTREEITEM)newSelect);
3303
3304 break;
3305
3306 case TVGN_DROPHILITE:
3307 prevItem= TREEVIEW_ValidItem (infoPtr, infoPtr->dropItem);
3308
3309 if (prevItem)
3310 prevItem->state &= ~TVIS_DROPHILITED;
3311
3312 infoPtr->dropItem=(HTREEITEM)newSelect;
3313
3314 if (wineItem)
3315 wineItem->state |=TVIS_DROPHILITED;
3316
3317 break;
3318
3319 case TVGN_FIRSTVISIBLE:
3320 FIXME("FIRSTVISIBLE not implemented\n");
3321 break;
3322 }
3323
3324 TREEVIEW_QueueRefresh (hwnd);
3325
3326 TRACE("Leaving state %d\n", wineItem->state);
3327 return TRUE;
3328 }
3329
3330 /* FIXME: handle NM_KILLFocus etc */
3331 static LRESULT
3332 TREEVIEW_SelectItem (HWND hwnd, WPARAM wParam, LPARAM lParam)
3333
3334 {
3335 return TREEVIEW_DoSelectItem (hwnd, wParam, (HTREEITEM) lParam, TVC_UNKNOWN);
3336 }
3337
3338
3339
3340
3341 static LRESULT
3342 TREEVIEW_GetFont (HWND hwnd, WPARAM wParam, LPARAM lParam)
3343
3344 {
3345 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
3346
3347 TRACE("%x\n",infoPtr->hFont);
3348 return infoPtr->hFont;
3349 }
3350
3351 static LRESULT
3352 TREEVIEW_SetFont (HWND hwnd, WPARAM wParam, LPARAM lParam)
3353
3354 {
3355 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
3356 TEXTMETRICA tm;
3357 LOGFONTA logFont;
3358 HFONT hFont, hOldFont;
3359 INT height;
3360 HDC hdc;
3361
3362 TRACE("%x %lx\n",wParam, lParam);
3363
3364 infoPtr->hFont = (HFONT)wParam;
3365
3366 hFont = infoPtr->hFont ? infoPtr->hFont : GetStockObject (SYSTEM_FONT);
3367
3368 GetObjectA (infoPtr->hFont, sizeof (LOGFONTA), &logFont);
3369 logFont.lfWeight=FW_BOLD;
3370 infoPtr->hBoldFont = CreateFontIndirectA (&logFont);
3371
3372 hdc = GetDC (0);
3373 hOldFont = SelectObject (hdc, hFont);
3374 GetTextMetricsA (hdc, &tm);
3375 height= tm.tmHeight + tm.tmExternalLeading;
3376 if (height>infoPtr->uRealItemHeight)
3377 infoPtr->uRealItemHeight=height;
3378 SelectObject (hdc, hOldFont);
3379 ReleaseDC (0, hdc);
3380
3381 if (lParam)
3382 TREEVIEW_QueueRefresh (hwnd);
3383
3384 return 0;
3385 }
3386
3387
3388
3389 static LRESULT
3390 TREEVIEW_VScroll (HWND hwnd, WPARAM wParam, LPARAM lParam)
3391
3392 {
3393 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
3394 int maxHeight;
3395
3396 TRACE("wp %x, lp %lx\n", wParam, lParam);
3397 if (!infoPtr->uInternalStatus & TV_VSCROLL) return FALSE;
3398
3399 switch (LOWORD (wParam)) {
3400 case SB_LINEUP:
3401 if (!infoPtr->cy) return FALSE;
3402 infoPtr->cy -= infoPtr->uRealItemHeight;
3403 if (infoPtr->cy < 0) infoPtr->cy=0;
3404 break;
3405 case SB_LINEDOWN:
3406 maxHeight=infoPtr->uTotalHeight-infoPtr->uVisibleHeight;
3407 if (infoPtr->cy == maxHeight) return FALSE;
3408 infoPtr->cy += infoPtr->uRealItemHeight;
3409 if (infoPtr->cy > maxHeight)
3410 infoPtr->cy = maxHeight;
3411 break;
3412 case SB_PAGEUP:
3413 if (!infoPtr->cy) return FALSE;
3414 infoPtr->cy -= infoPtr->uVisibleHeight;
3415 if (infoPtr->cy < 0) infoPtr->cy=0;
3416 break;
3417 case SB_PAGEDOWN:
3418 maxHeight=infoPtr->uTotalHeight-infoPtr->uVisibleHeight;
3419 if (infoPtr->cy == maxHeight) return FALSE;
3420 infoPtr->cy += infoPtr->uVisibleHeight;
3421 if (infoPtr->cy > maxHeight)
3422 infoPtr->cy = maxHeight;
3423 break;
3424 case SB_THUMBTRACK:
3425 infoPtr->cy = HIWORD (wParam);
3426 break;
3427
3428 }
3429
3430 TREEVIEW_QueueRefresh (hwnd);
3431 return TRUE;
3432 }
3433
3434 static LRESULT
3435 TREEVIEW_HScroll (HWND hwnd, WPARAM wParam, LPARAM lParam)
3436 {
3437 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
3438 int maxWidth;
3439
3440 TRACE("wp %lx, lp %x\n", lParam, wParam);
3441
3442 if (!infoPtr->uInternalStatus & TV_HSCROLL) return FALSE;
3443
3444 switch (LOWORD (wParam)) {
3445 case SB_LINEUP:
3446 if (!infoPtr->cx) return FALSE;
3447 infoPtr->cx -= infoPtr->uRealItemHeight;
3448 if (infoPtr->cx < 0) infoPtr->cx=0;
3449 break;
3450 case SB_LINEDOWN:
3451 maxWidth=infoPtr->uTotalWidth-infoPtr->uVisibleWidth;
3452 if (infoPtr->cx == maxWidth) return FALSE;
3453 infoPtr->cx += infoPtr->uRealItemHeight; /*FIXME */
3454 if (infoPtr->cx > maxWidth)
3455 infoPtr->cx = maxWidth;
3456 break;
3457 case SB_PAGEUP:
3458 if (!infoPtr->cx) return FALSE;
3459 infoPtr->cx -= infoPtr->uVisibleWidth;
3460 if (infoPtr->cx < 0) infoPtr->cx=0;
3461 break;
3462 case SB_PAGEDOWN:
3463 maxWidth=infoPtr->uTotalWidth-infoPtr->uVisibleWidth;
3464 if (infoPtr->cx == maxWidth) return FALSE;
3465 infoPtr->cx += infoPtr->uVisibleWidth;
3466 if (infoPtr->cx > maxWidth)
3467 infoPtr->cx = maxWidth;
3468 break;
3469 case SB_THUMBTRACK:
3470 infoPtr->cx = HIWORD (wParam);
3471 break;
3472
3473 }
3474
3475 TREEVIEW_QueueRefresh (hwnd);
3476 return TRUE;
3477 }
3478
3479 static LRESULT TREEVIEW_MouseWheel (HWND hwnd, WPARAM wParam, LPARAM lParam)
3480 {
3481
3482 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
3483 short gcWheelDelta = 0;
3484 UINT pulScrollLines = 3;
3485
3486 SystemParametersInfoW(SPI_GETWHEELSCROLLLINES,0, &pulScrollLines, 0);
3487
3488 gcWheelDelta -= (short) HIWORD(wParam);
3489 pulScrollLines *= (gcWheelDelta / WHEEL_DELTA);
3490
3491 if (abs(gcWheelDelta) >= WHEEL_DELTA && pulScrollLines)
3492 {
3493 int wheelDy = pulScrollLines * infoPtr->uRealItemHeight;
3494 int newDy = infoPtr->cy + wheelDy;
3495 int maxDy = infoPtr->uTotalHeight - infoPtr->uVisibleHeight;
3496
3497 if (newDy > maxDy) newDy = maxDy;
3498 if (newDy < 0) newDy = 0;
3499
3500 if (newDy == infoPtr->cy) return TRUE;
3501
3502 TREEVIEW_VScroll(hwnd, MAKEWPARAM(SB_THUMBTRACK,newDy),0);
3503 }
3504 return TRUE;
3505 }
3506
3507 static LRESULT
3508 TREEVIEW_KeyDown (HWND hwnd, WPARAM wParam, LPARAM lParam)
3509 {
3510 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
3511 HTREEITEM hNewSelection = 0;
3512 INT scrollNeeds = -1;
3513 INT cyChangeNeeds = -1;
3514 INT prevSelect = (INT)infoPtr->selectedItem;
3515
3516 TREEVIEW_ITEM *prevItem =
3517 (prevSelect != 0 ) ?
3518 TREEVIEW_ValidItem (infoPtr, (HTREEITEM)prevSelect) :
3519 NULL;
3520
3521 TREEVIEW_ITEM *newItem = NULL;
3522
3523 TRACE("%x %lx\n",wParam, lParam);
3524
3525 if (prevSelect == 0)
3526 return FALSE;
3527
3528 switch (wParam) {
3529 case VK_UP:
3530 newItem=TREEVIEW_GetPrevListItem (infoPtr, prevItem);
3531
3532 if (!newItem)
3533 newItem=& infoPtr->items[(INT)infoPtr->TopRootItem];
3534
3535 hNewSelection = newItem->hItem;
3536
3537 if (! newItem->visible)
3538 scrollNeeds = SB_LINEUP;
3539 break;
3540
3541 case VK_DOWN:
3542 newItem=TREEVIEW_GetNextListItem (infoPtr, prevItem);
3543
3544 if (!newItem)
3545 newItem=prevItem;
3546
3547 hNewSelection = newItem->hItem;
3548
3549 if (! newItem->visible)
3550 scrollNeeds = SB_LINEDOWN;
3551
3552 break;
3553
3554 case VK_HOME:
3555 newItem = &infoPtr->items[(INT)infoPtr->TopRootItem];
3556 hNewSelection = newItem->hItem;
3557 cyChangeNeeds = 0;
3558 break;
3559
3560 case VK_END:
3561 newItem = &infoPtr->items[(INT)infoPtr->TopRootItem];
3562 newItem = TREEVIEW_GetLastListItem (infoPtr, newItem);
3563 hNewSelection = newItem->hItem;
3564
3565 if (! newItem->visible)
3566 cyChangeNeeds = infoPtr->uTotalHeight-infoPtr->uVisibleHeight;
3567
3568 break;
3569
3570 case VK_LEFT:
3571 if ( (prevItem->cChildren > 0) && (prevItem->state & TVIS_EXPANDED) )
3572 {
3573 TREEVIEW_Expand(hwnd, TVE_COLLAPSE, prevSelect );
3574 }
3575 else if ((INT)prevItem->parent)
3576 {
3577 newItem = (& infoPtr->items[(INT)prevItem->parent]);
3578 if (! newItem->visible)
3579 /* FIXME find a way to make this item the first visible... */
3580 newItem = NULL;
3581
3582 hNewSelection = newItem->hItem;
3583 }
3584
3585 break;
3586
3587 case VK_RIGHT:
3588 if ( ( prevItem->cChildren > 0) ||
3589 ( prevItem->cChildren == I_CHILDRENCALLBACK))
3590 {
3591 if (! (prevItem->state & TVIS_EXPANDED))
3592 TREEVIEW_Expand(hwnd, TVE_EXPAND, prevSelect );
3593 else
3594 {
3595 newItem = (& infoPtr->items[(INT)prevItem->firstChild]);
3596 hNewSelection = newItem->hItem;
3597 }
3598 }
3599
3600 break;
3601
3602 case VK_ADD:
3603 if (! (prevItem->state & TVIS_EXPANDED))
3604 TREEVIEW_Expand(hwnd, TVE_EXPAND, prevSelect );
3605 break;
3606
3607 case VK_SUBTRACT:
3608 if (prevItem->state & TVIS_EXPANDED)
3609 TREEVIEW_Expand(hwnd, TVE_COLLAPSE, prevSelect );
3610 break;
3611
3612 case VK_PRIOR:
3613
3614 newItem=TREEVIEW_GetListItem(
3615 infoPtr,
3616 prevItem,
3617 -1*(TREEVIEW_GetVisibleCount(hwnd,0,0)-3));
3618 if (!newItem)
3619 newItem=prevItem;
3620
3621 hNewSelection = newItem->hItem;
3622
3623 if (! newItem->visible)
3624 scrollNeeds = SB_PAGEUP;
3625
3626 break;
3627
3628 case VK_NEXT:
3629 newItem=TREEVIEW_GetListItem(
3630 infoPtr,
3631 prevItem,
3632 TREEVIEW_GetVisibleCount(hwnd,0,0)-3);
3633
3634 if (!newItem)
3635 newItem=prevItem;
3636
3637 hNewSelection = newItem->hItem;
3638
3639 if (! newItem->visible)
3640 scrollNeeds = SB_PAGEDOWN;
3641
3642 break;
3643
3644 case VK_BACK:
3645
3646 case VK_RETURN:
3647
3648 default:
3649 FIXME("%x not implemented\n", wParam);
3650 break;
3651 }
3652
3653 if (hNewSelection)
3654 {
3655 /*
3656 This works but does not send notification...
3657
3658 prevItem->state &= ~TVIS_SELECTED;
3659 newItem->state |= TVIS_SELECTED;
3660 infoPtr->selectedItem = hNewSelection;
3661 TREEVIEW_QueueRefresh (hwnd);
3662 */
3663
3664 if ( TREEVIEW_DoSelectItem(
3665 hwnd,
3666 TVGN_CARET,
3667 (HTREEITEM)hNewSelection,
3668 TVC_BYKEYBOARD))
3669 {
3670 /* If selection change is allowed for the new item, perform scrolling */
3671 if (scrollNeeds != -1)
3672 TREEVIEW_VScroll(hwnd, scrollNeeds, 0);
3673
3674 if (cyChangeNeeds != -1)
3675 infoPtr->cy = cyChangeNeeds;
3676
3677 /* FIXME: Something happen in the load the in the two weeks before
3678 april 1st 1999 which makes this SetFocus mandatory otherwise, the focus
3679 is lost... However the SetFocus should not be required...*/
3680
3681 SetFocus(hwnd);
3682 }
3683 }
3684
3685 return FALSE;
3686 }
3687
3688
3689 static LRESULT
3690 TREEVIEW_GetScrollTime (HWND hwnd)
3691 {
3692 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
3693
3694 return infoPtr->uScrollTime;
3695 }
3696
3697
3698 static LRESULT
3699 TREEVIEW_SetScrollTime (HWND hwnd, UINT uScrollTime)
3700 {
3701 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
3702 UINT uOldScrollTime = infoPtr->uScrollTime;
3703
3704 infoPtr->uScrollTime = min (uScrollTime, 100);
3705
3706 return uOldScrollTime;
3707 }
3708
3709
3710 static LRESULT WINAPI
3711 TREEVIEW_WindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
3712 {
3713 if (uMsg==WM_CREATE)
3714 return TREEVIEW_Create (hwnd, wParam, lParam);
3715
3716 if (!TREEVIEW_GetInfoPtr(hwnd))
3717 return DefWindowProcA (hwnd, uMsg, wParam, lParam);
3718
3719 switch (uMsg) {
3720
3721 case TVM_INSERTITEMA:
3722 return TREEVIEW_InsertItemA (hwnd, wParam, lParam);
3723
3724 case TVM_INSERTITEMW:
3725 return TREEVIEW_InsertItemW(hwnd,wParam,lParam);;
3726
3727 case TVM_DELETEITEM:
3728 return TREEVIEW_DeleteItem (hwnd, wParam, lParam);
3729
3730 case TVM_EXPAND:
3731 return TREEVIEW_Expand (hwnd, wParam, lParam);
3732
3733 case TVM_GETITEMRECT:
3734 return TREEVIEW_GetItemRect (hwnd, wParam, lParam);
3735
3736 case TVM_GETCOUNT:
3737 return TREEVIEW_GetCount (hwnd, wParam, lParam);
3738
3739 case TVM_GETINDENT:
3740 return TREEVIEW_GetIndent (hwnd);
3741
3742 case TVM_SETINDENT:
3743 return TREEVIEW_SetIndent (hwnd, wParam);
3744
3745 case TVM_GETIMAGELIST:
3746 return TREEVIEW_GetImageList (hwnd, wParam, lParam);
3747
3748 case TVM_SETIMAGELIST:
3749 return TREEVIEW_SetImageList (hwnd, wParam, lParam);
3750
3751 case TVM_GETNEXTITEM:
3752 return TREEVIEW_GetNextItem (hwnd, wParam, lParam);
3753
3754 case TVM_SELECTITEM:
3755 return TREEVIEW_SelectItem (hwnd, wParam, lParam);
3756
3757 case TVM_GETITEMA:
3758 return TREEVIEW_GetItemA (hwnd, wParam, lParam);
3759
3760 case TVM_GETITEMW:
3761 FIXME("Unimplemented msg TVM_GETITEMW\n");
3762 return 0;
3763
3764 case TVM_SETITEMA:
3765 return TREEVIEW_SetItemA (hwnd, wParam, lParam);
3766
3767 case TVM_SETITEMW:
3768 FIXME("Unimplemented msg TVM_SETITEMW\n");
3769 return 0;
3770
3771 case TVM_EDITLABELA:
3772 FIXME("Unimplemented msg TVM_EDITLABELA \n");
3773 return 0;
3774
3775 case TVM_EDITLABELW:
3776 FIXME("Unimplemented msg TVM_EDITLABELW \n");
3777 return 0;
3778
3779 case TVM_GETEDITCONTROL:
3780 return TREEVIEW_GetEditControl (hwnd);
3781
3782 case TVM_GETVISIBLECOUNT:
3783 return TREEVIEW_GetVisibleCount (hwnd, wParam, lParam);
3784
3785 case TVM_HITTEST:
3786 return TREEVIEW_HitTest (hwnd, lParam);
3787
3788 case TVM_CREATEDRAGIMAGE:
3789 return TREEVIEW_CreateDragImage (hwnd, wParam, lParam);
3790
3791 case TVM_SORTCHILDREN:
3792 return TREEVIEW_SortChildren (hwnd, wParam, lParam);
3793
3794 case TVM_ENSUREVISIBLE:
3795 FIXME("Unimplemented msg TVM_ENSUREVISIBLE\n");
3796 return 0;
3797
3798 case TVM_SORTCHILDRENCB:
3799 return TREEVIEW_SortChildrenCB(hwnd, wParam, lParam);
3800
3801 case TVM_ENDEDITLABELNOW:
3802 return TREEVIEW_EndEditLabelNow (hwnd, wParam, lParam);
3803
3804 case TVM_GETISEARCHSTRINGA:
3805 FIXME("Unimplemented msg TVM_GETISEARCHSTRINGA\n");
3806 return 0;
3807
3808 case TVM_GETISEARCHSTRINGW:
3809 FIXME("Unimplemented msg TVM_GETISEARCHSTRINGW\n");
3810 return 0;
3811
3812 case TVM_GETTOOLTIPS:
3813 return TREEVIEW_GetToolTips (hwnd);
3814
3815 case TVM_SETTOOLTIPS:
3816 return TREEVIEW_SetToolTips (hwnd, wParam);
3817
3818 case TVM_SETINSERTMARK:
3819 return TREEVIEW_SetInsertMark (hwnd,wParam, lParam);
3820
3821 case TVM_SETITEMHEIGHT:
3822 return TREEVIEW_SetItemHeight (hwnd, wParam);
3823
3824 case TVM_GETITEMHEIGHT:
3825 return TREEVIEW_GetItemHeight (hwnd);
3826
3827 case TVM_SETBKCOLOR:
3828 return TREEVIEW_SetBkColor (hwnd, wParam, lParam);
3829
3830 case TVM_SETTEXTCOLOR:
3831 return TREEVIEW_SetTextColor (hwnd, wParam, lParam);
3832
3833 case TVM_GETBKCOLOR:
3834 return TREEVIEW_GetBkColor (hwnd);
3835
3836 case TVM_GETTEXTCOLOR:
3837 return TREEVIEW_GetTextColor (hwnd);
3838
3839 case TVM_SETSCROLLTIME:
3840 return TREEVIEW_SetScrollTime (hwnd, (UINT)wParam);
3841
3842 case TVM_GETSCROLLTIME:
3843 return TREEVIEW_GetScrollTime (hwnd);
3844
3845 case TVM_GETITEMSTATE:
3846 return TREEVIEW_GetItemState (hwnd,wParam, lParam);
3847
3848 case TVM_GETLINECOLOR:
3849 return TREEVIEW_GetLineColor (hwnd,wParam, lParam);
3850
3851 case TVM_SETLINECOLOR:
3852 return TREEVIEW_SetLineColor (hwnd,wParam, lParam);
3853
3854 case TVM_SETINSERTMARKCOLOR:
3855 return TREEVIEW_SetInsertMarkColor (hwnd,wParam, lParam);
3856
3857 case TVM_GETINSERTMARKCOLOR:
3858 return TREEVIEW_GetInsertMarkColor (hwnd,wParam, lParam);
3859
3860 case TVM_SETUNICODEFORMAT:
3861 FIXME("Unimplemented msg TVM_SETUNICODEFORMAT\n");
3862 return 0;
3863
3864 case TVM_GETUNICODEFORMAT:
3865 FIXME("Unimplemented msg TVM_GETUNICODEFORMAT\n");
3866 return 0;
3867
3868 case WM_COMMAND:
3869 return TREEVIEW_Command (hwnd, wParam, lParam);
3870
3871 case WM_DESTROY:
3872 return TREEVIEW_Destroy (hwnd);
3873
3874 /* case WM_ENABLE: */
3875
3876 case WM_ERASEBKGND:
3877 return TREEVIEW_EraseBackground (hwnd, wParam, lParam);
3878
3879 case WM_GETDLGCODE:
3880 return DLGC_WANTARROWS | DLGC_WANTCHARS;
3881
3882 case WM_PAINT:
3883 return TREEVIEW_Paint (hwnd, wParam, lParam);
3884
3885 case WM_GETFONT:
3886 return TREEVIEW_GetFont (hwnd, wParam, lParam);
3887
3888 case WM_SETFONT:
3889 return TREEVIEW_SetFont (hwnd, wParam, lParam);
3890
3891 case WM_KEYDOWN:
3892 return TREEVIEW_KeyDown (hwnd, wParam, lParam);
3893
3894 case WM_SETFOCUS:
3895 return TREEVIEW_SetFocus (hwnd, wParam, lParam);
3896
3897 case WM_KILLFOCUS:
3898 return TREEVIEW_KillFocus (hwnd, wParam, lParam);
3899
3900 case WM_LBUTTONDOWN:
3901 return TREEVIEW_LButtonDown (hwnd, wParam, lParam);
3902
3903 case WM_LBUTTONUP:
3904 return TREEVIEW_LButtonUp (hwnd, wParam, lParam);
3905
3906 case WM_LBUTTONDBLCLK:
3907 return TREEVIEW_LButtonDoubleClick (hwnd, wParam, lParam);
3908
3909 case WM_RBUTTONDOWN:
3910 return TREEVIEW_RButtonDown (hwnd, wParam, lParam);
3911
3912 case WM_RBUTTONUP:
3913 return TREEVIEW_RButtonUp (hwnd, wParam, lParam);
3914
3915 case WM_MOUSEMOVE:
3916 return TREEVIEW_MouseMove (hwnd, wParam, lParam);
3917
3918 case WM_STYLECHANGED:
3919 return TREEVIEW_StyleChanged (hwnd, wParam, lParam);
3920
3921 /* case WM_SYSCOLORCHANGE: */
3922 /* case WM_SETREDRAW: */
3923
3924 case WM_TIMER:
3925 return TREEVIEW_HandleTimer (hwnd, wParam, lParam);
3926
3927 case WM_SIZE:
3928 return TREEVIEW_Size (hwnd, wParam,lParam);
3929
3930 case WM_HSCROLL:
3931 return TREEVIEW_HScroll (hwnd, wParam, lParam);
3932 case WM_VSCROLL:
3933 return TREEVIEW_VScroll (hwnd, wParam, lParam);
3934
3935 case WM_MOUSEWHEEL:
3936 if (wParam & (MK_SHIFT | MK_CONTROL))
3937 return DefWindowProcA( hwnd, uMsg, wParam, lParam );
3938 return TREEVIEW_MouseWheel (hwnd, wParam, lParam);
3939
3940 case WM_DRAWITEM:
3941 TRACE ("drawItem\n");
3942 return DefWindowProcA (hwnd, uMsg, wParam, lParam);
3943
3944 default:
3945 if (uMsg >= WM_USER)
3946 FIXME("Unknown msg %04x wp=%08x lp=%08lx\n",
3947 uMsg, wParam, lParam);
3948 return DefWindowProcA (hwnd, uMsg, wParam, lParam);
3949 }
3950 return 0;
3951 }
3952
3953
3954 VOID
3955 TREEVIEW_Register (void)
3956 {
3957 WNDCLASSA wndClass;
3958
3959 TRACE("\n");
3960
3961 ZeroMemory (&wndClass, sizeof(WNDCLASSA));
3962 wndClass.style = CS_GLOBALCLASS | CS_DBLCLKS;
3963 wndClass.lpfnWndProc = (WNDPROC)TREEVIEW_WindowProc;
3964 wndClass.cbClsExtra = 0;
3965 wndClass.cbWndExtra = sizeof(TREEVIEW_INFO *);
3966 wndClass.hCursor = LoadCursorA (0, IDC_ARROWA);
3967 wndClass.hbrBackground = 0;
3968 wndClass.lpszClassName = WC_TREEVIEWA;
3969
3970 RegisterClassA (&wndClass);
3971 }
3972
3973
3974 VOID
3975 TREEVIEW_Unregister (void)
3976 {
3977 UnregisterClassA (WC_TREEVIEWA, (HINSTANCE)NULL);
3978 }
3979
3980
3981
Maarten's multimedia branch