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