?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Added add_queue/remove_queue to server object operations.
[wine/testsucceed.git] / dlls / comctl32 / treeview.c
blobafd848711f7aa5ac9af7713636cc1fb61a8708b7
1 /* Treeview control
2 *
3 * Copyright 1998 Eric Kohl <ekohl@abo.rhein-zeitung.de>
4 * Copyright 1998 Alex Priem <alexp@sci.kun.nl>
5 *
6 *
7 * TODO:
8 * - Nearly all notifications.
9 *
10 * list-handling stuff: sort, sorted insertitem.
11 *
12 * refreshtreeview:
13 -small array containing info about positions.
14 -better implementation of DrawItem (connecting lines).
15 -implement partial drawing?
16 * Expand: -ctlmacro expands twice ->toggle.
17 * -drag&drop.
18 * -scrollbars.
19 * -Unicode messages
20 * -TVITEMEX
21 *
22 * FIXMEs:
23 -GetNextItem: add flags for traversing child lists.
24 (DESCEND_ALWAYS, DESCEND_NEVER, DESCEND_VISIBLE)
25 -DblClick: ctlmacro.exe's NM_DBLCLK seems to go wrong (returns FALSE).
26
27 */
28
29 #include <string.h>
30 #include "windows.h"
31 #include "commctrl.h"
32 #include "treeview.h"
33 #include "heap.h"
34 #include "win.h"
35 #include "debug.h"
36
37 /* ffs should be in <string.h>. */
38
39 /* Defines, since they do not need to return previous state, and nr
40 * has no side effects in this file.
41 */
42 #define tv_test_bit(nr,bf) (((LPBYTE)bf)[nr>>3]&(1<<(nr&7)))
43 #define tv_set_bit(nr,bf) ((LPBYTE)bf)[nr>>3]|=(1<<(nr&7))
44 #define tv_clear_bit(nr,bf) ((LPBYTE)bf)[nr>>3]&=~(1<<(nr&7))
45
46
47 #define TREEVIEW_GetInfoPtr(wndPtr) ((TREEVIEW_INFO *)wndPtr->wExtra[0])
48
49 static BOOL32
50 TREEVIEW_SendSimpleNotify (WND *wndPtr, UINT32 code);
51 static BOOL32
52 TREEVIEW_SendTreeviewNotify (WND *wndPtr, UINT32 code, UINT32 action,
53 INT32 oldItem, INT32 newItem, POINT32 pt);
54 static LRESULT
55 TREEVIEW_SelectItem (WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
56 static void
57 TREEVIEW_Refresh (WND *wndPtr);
58
59
60
61
62
63 /* helper functions. Work with the assumption that validity of operands
64 is checked beforehand */
65
66 /* FIXME: MS documentation says `GetNextVisibleItem' returns NULL
67 if not succesfull'. Probably means derefencing, and not whether
68 there is a next `visible' child. */
69
70
71 static TREEVIEW_ITEM *
72 TREEVIEW_ValidItem (TREEVIEW_INFO *infoPtr,int handle)
73 {
74
75 if ((!handle) || (handle>infoPtr->uMaxHandle)) return NULL;
76 if (tv_test_bit (handle, infoPtr->freeList)) return NULL;
77
78 return & infoPtr->items[handle];
79 }
80
81
82
83 static TREEVIEW_ITEM *TREEVIEW_GetPrevListItem (TREEVIEW_INFO *infoPtr,
84 TREEVIEW_ITEM *tvItem)
85
86 {
87 TREEVIEW_ITEM *wineItem;
88
89 if (tvItem->upsibling) {
90 wineItem=& infoPtr->items[tvItem->upsibling];
91 if ((wineItem->firstChild) && (wineItem->state & TVIS_EXPANDED)) {
92 wineItem=& infoPtr->items[wineItem->firstChild];
93 while (wineItem->sibling)
94 wineItem= & infoPtr->items[wineItem->sibling];
95 }
96 return wineItem;
97 }
98
99 wineItem=tvItem;
100 while (wineItem->parent) {
101 wineItem=& infoPtr->items[wineItem->parent];
102 if (wineItem->upsibling)
103 return (& infoPtr->items[wineItem->upsibling]);
104 }
105
106 return wineItem;
107 }
108
109
110 static TREEVIEW_ITEM *TREEVIEW_GetNextListItem (TREEVIEW_INFO *infoPtr,
111 TREEVIEW_ITEM *tvItem)
112
113 {
114 TREEVIEW_ITEM *wineItem;
115
116 if ((tvItem->firstChild) && (tvItem->state & TVIS_EXPANDED))
117 return (& infoPtr->items[tvItem->firstChild]);
118
119 if (tvItem->sibling)
120 return (& infoPtr->items[tvItem->sibling]);
121
122 wineItem=tvItem;
123 while (wineItem->parent) {
124 wineItem=& infoPtr->items [wineItem->parent];
125 if (wineItem->sibling)
126 return (& infoPtr->items [wineItem->sibling]);
127 }
128
129 return wineItem;
130 }
131
132 static TREEVIEW_ITEM *TREEVIEW_GetLastListItem (TREEVIEW_INFO *infoPtr)
133
134 {
135 TREEVIEW_ITEM *wineItem;
136
137 wineItem=NULL;
138 if (infoPtr->TopRootItem)
139 wineItem=& infoPtr->items [infoPtr->TopRootItem];
140 while (wineItem->sibling)
141 wineItem=& infoPtr->items [wineItem->sibling];
142
143 return wineItem;
144 }
145
146
147
148
149 static void
150 TREEVIEW_RemoveItem (TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *wineItem)
151
152 {
153 TREEVIEW_ITEM *parentItem, *upsiblingItem, *siblingItem;
154 INT32 iItem;
155
156 iItem=wineItem->hItem;
157 tv_set_bit(iItem,infoPtr->freeList);
158 infoPtr->uNumItems--;
159 parentItem=NULL;
160 if (wineItem->pszText!=LPSTR_TEXTCALLBACK32A)
161 COMCTL32_Free (wineItem->pszText);
162
163 if (wineItem->parent) {
164 parentItem=& infoPtr->items[ wineItem->parent];
165 if (parentItem->cChildren==1) {
166 parentItem->cChildren=0;
167 parentItem->firstChild=0;
168 return;
169 } else {
170 parentItem->cChildren--;
171 if (parentItem->firstChild==iItem)
172 parentItem->firstChild=wineItem->sibling;
173 }
174 }
175
176 if (iItem==infoPtr->TopRootItem)
177 infoPtr->TopRootItem=wineItem->sibling;
178 if (wineItem->upsibling) {
179 upsiblingItem=& infoPtr->items [wineItem->upsibling];
180 upsiblingItem->sibling=wineItem->sibling;
181 }
182 if (wineItem->sibling) {
183 siblingItem=& infoPtr->items [wineItem->sibling];
184 siblingItem->upsibling=wineItem->upsibling;
185 }
186 }
187
188
189
190 static void TREEVIEW_RemoveAllChildren (TREEVIEW_INFO *infoPtr,
191 TREEVIEW_ITEM *parentItem)
192
193 {
194 TREEVIEW_ITEM *killItem;
195 INT32 kill;
196
197 kill=parentItem->firstChild;
198 while (kill) {
199 tv_set_bit ( kill, infoPtr->freeList);
200 killItem=& infoPtr->items[kill];
201 if (killItem->pszText!=LPSTR_TEXTCALLBACK32A)
202 COMCTL32_Free (killItem->pszText);
203 kill=killItem->sibling;
204 }
205 infoPtr->uNumItems -= parentItem->cChildren;
206 parentItem->firstChild = 0;
207 parentItem->cChildren = 0;
208 }
209
210
211 /* Note:TREEVIEW_RemoveTree doesn't remove infoPtr itself */
212
213 static void TREEVIEW_RemoveTree (TREEVIEW_INFO *infoPtr)
214
215
216 {
217 TREEVIEW_ITEM *killItem;
218 int i;
219
220 for (i=1; i<=infoPtr->uMaxHandle; i++)
221 if (!tv_test_bit (i, infoPtr->freeList)) {
222 killItem=& infoPtr->items [i];
223 if (killItem->pszText!=LPSTR_TEXTCALLBACK32A)
224 COMCTL32_Free (killItem->pszText);
225 }
226
227 if (infoPtr->uNumPtrsAlloced) {
228 COMCTL32_Free (infoPtr->items);
229 COMCTL32_Free (infoPtr->freeList);
230 infoPtr->uNumItems=0;
231 infoPtr->uNumPtrsAlloced=0;
232 infoPtr->uMaxHandle=0;
233 }
234 }
235
236
237
238
239
240
241
242
243
244
245 static LRESULT
246 TREEVIEW_GetImageList (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
247 {
248 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
249
250 TRACE (treeview,"\n");
251 if (infoPtr==NULL) return 0;
252
253 if ((INT32)wParam == TVSIL_NORMAL)
254 return (LRESULT) infoPtr->himlNormal;
255 if ((INT32)wParam == TVSIL_STATE)
256 return (LRESULT) infoPtr->himlState;
257
258 return 0;
259 }
260
261
262
263
264 static LRESULT
265 TREEVIEW_SetImageList (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
266 {
267 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
268 HIMAGELIST himlTemp;
269
270 TRACE (treeview,"\n");
271 switch ((INT32)wParam) {
272 case TVSIL_NORMAL:
273 himlTemp = infoPtr->himlNormal;
274 infoPtr->himlNormal = (HIMAGELIST)lParam;
275 return (LRESULT)himlTemp;
276
277 case TVSIL_STATE:
278 himlTemp = infoPtr->himlState;
279 infoPtr->himlState = (HIMAGELIST)lParam;
280 return (LRESULT)himlTemp;
281 }
282
283 return (LRESULT)NULL;
284 }
285
286
287
288 static LRESULT
289 TREEVIEW_SetItemHeight (WND *wndPtr, WPARAM32 wParam)
290 {
291 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
292 INT32 prevHeight=infoPtr->uItemHeight;
293 HDC32 hdc;
294 TEXTMETRIC32A tm;
295
296 TRACE (treeview,"\n");
297 if (wParam==-1) {
298 hdc=GetDC32 (wndPtr->hwndSelf);
299 infoPtr->uItemHeight=-1;
300 GetTextMetrics32A (hdc, &tm);
301 infoPtr->uRealItemHeight= tm.tmHeight + tm.tmExternalLeading;
302 ReleaseDC32 (wndPtr->hwndSelf, hdc);
303 return prevHeight;
304 }
305
306 /* FIXME: check wParam > imagelist height */
307
308 if (!(wndPtr->dwStyle & TVS_NONEVENHEIGHT))
309 infoPtr->uItemHeight = (INT32) wParam & 0xfffffffe;
310 return prevHeight;
311 }
312
313 static LRESULT
314 TREEVIEW_GetItemHeight (WND *wndPtr)
315 {
316 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
317
318 TRACE (treeview,"\n");
319 return infoPtr->uItemHeight;
320 }
321
322 static LRESULT
323 TREEVIEW_SetTextColor (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
324 {
325 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
326 COLORREF prevColor=infoPtr->clrText;
327
328 TRACE (treeview,"\n");
329 infoPtr->clrText=(COLORREF) lParam;
330 return (LRESULT) prevColor;
331 }
332
333 static LRESULT
334 TREEVIEW_GetTextColor (WND *wndPtr)
335 {
336 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
337
338 TRACE (treeview,"\n");
339 return (LRESULT) infoPtr->clrText;
340 }
341
342
343 static INT32
344 TREEVIEW_DrawItem (WND *wndPtr, HDC32 hdc, TREEVIEW_ITEM *wineItem,
345 TREEVIEW_ITEM *upperItem, int indent)
346 {
347 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
348 INT32 oldBkMode,center,xpos;
349 COLORREF oldBkColor;
350 UINT32 uTextJustify = DT_LEFT;
351 HPEN32 hOldPen, hnewPen,hRootPen;
352 RECT32 r,upper;
353
354 hnewPen = CreatePen32(PS_DOT, 0, GetSysColor32(COLOR_WINDOWTEXT) );
355 hOldPen = SelectObject32( hdc, hnewPen );
356
357 r=wineItem->rect;
358 if (upperItem)
359 upper=upperItem->rect;
360 else {
361 upper.top=0;
362 upper.left=8;
363 }
364 center=(r.top+r.bottom)/2;
365 xpos=r.left+8;
366
367 if (wndPtr->dwStyle & TVS_HASLINES) {
368 POINT32 points[3];
369 if ((wndPtr->dwStyle & TVS_LINESATROOT) && (indent==0)) {
370 points[0].y=points[1].y=center;
371 points[2].y=upper.top;
372 points[1].x=points[2].x=upper.left;
373 points[0].x=upper.left+12;
374 points[2].y+=5;
375
376 Polyline32 (hdc,points,3);
377 }
378 else {
379 points[0].y=points[1].y=center;
380 points[2].y=upper.top;
381 points[1].x=points[2].x=upper.left+13;
382 points[0].x=upper.left+25;
383 points[2].y+=5;
384 Polyline32 (hdc,points,3);
385 }
386 }
387
388 DeleteObject32(hnewPen);
389 SelectObject32(hdc, hOldPen);
390
391 if ((wndPtr->dwStyle & TVS_HASBUTTONS) && (wineItem->cChildren)) {
392 /*
393 hRootPen = CreatePen32(PS_SOLID, 0, GetSysColor32(COLOR_WINDOW) );
394 SelectObject32( hdc, hRootPen );
395 */
396
397 Rectangle32 (hdc, xpos-4, center-4, xpos+5, center+5);
398 MoveToEx32 (hdc, xpos-2, center, NULL);
399 LineTo32 (hdc, xpos+3, center);
400 if (!(wineItem->state & TVIS_EXPANDED)) {
401 MoveToEx32 (hdc, xpos, center-2, NULL);
402 LineTo32 (hdc, xpos, center+3);
403 }
404 /* DeleteObject32(hRootPen); */
405 }
406
407
408 xpos+=13;
409
410 if (wineItem->mask & TVIF_IMAGE) {
411 if (wineItem->iImage!=I_IMAGECALLBACK) {
412 if (infoPtr->himlNormal) {
413 ImageList_Draw (infoPtr->himlNormal,wineItem->iImage, hdc,
414 xpos-2, r.top+1, ILD_NORMAL);
415 xpos+=15;
416 }
417 }
418 }
419
420 r.left=xpos;
421 if ((wineItem->mask & TVIF_TEXT) && (wineItem->pszText)) {
422 if (wineItem->state & TVIS_SELECTED) {
423 oldBkMode = SetBkMode32(hdc, OPAQUE);
424 oldBkColor= SetBkColor32 (hdc, GetSysColor32( COLOR_HIGHLIGHT));
425 SetTextColor32 (hdc, GetSysColor32(COLOR_HIGHLIGHTTEXT));
426 } else {
427 oldBkMode = SetBkMode32(hdc, TRANSPARENT);
428 }
429 r.left += 3;
430 r.right -= 3;
431 if (infoPtr->clrText==-1)
432 SetTextColor32 (hdc, COLOR_BTNTEXT);
433 else
434 SetTextColor32 (hdc, infoPtr->clrText); /* FIXME: retval */
435 if (wineItem->pszText!= LPSTR_TEXTCALLBACK32A)
436 DrawText32A (hdc, wineItem->pszText, lstrlen32A(wineItem->pszText),
437 &r, uTextJustify|DT_VCENTER|DT_SINGLELINE);
438 else {
439 /* send TVN_GETDISPINFO notification */
440 TRACE (treeview,"LPSTR_TEXTCALLBACK\n");
441 }
442 if (oldBkMode != TRANSPARENT)
443 SetBkMode32(hdc, oldBkMode);
444 if (wineItem->state & TVIS_SELECTED)
445 SetBkColor32 (hdc, oldBkColor);
446 }
447
448 return wineItem->rect.right;
449 }
450
451
452
453
454
455
456
457 static LRESULT
458 TREEVIEW_GetItemRect (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
459 {
460 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
461 TREEVIEW_ITEM *wineItem;
462 INT32 iItem;
463 LPRECT32 lpRect;
464
465 TRACE (treeview,"\n");
466 if (infoPtr==NULL) return FALSE;
467
468 iItem = (INT32)lParam;
469 wineItem = TREEVIEW_ValidItem (infoPtr, iItem);
470 if (!wineItem) return FALSE;
471
472 wineItem=& infoPtr->items[ iItem ];
473 if (!wineItem->visible) return FALSE;
474
475 lpRect = (LPRECT32)lParam;
476 if (lpRect == NULL) return FALSE;
477
478 if ((INT32) wParam) {
479 lpRect->left = wineItem->text.left;
480 lpRect->right = wineItem->text.right;
481 lpRect->bottom = wineItem->text.bottom;
482 lpRect->top = wineItem->text.top;
483 } else {
484 lpRect->left = wineItem->rect.left;
485 lpRect->right = wineItem->rect.right;
486 lpRect->bottom = wineItem->rect.bottom;
487 lpRect->top = wineItem->rect.top;
488 }
489
490 return TRUE;
491 }
492
493
494
495 static LRESULT
496 TREEVIEW_GetVisibleCount (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
497
498 {
499 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
500
501 TRACE (treeview,"\n");
502 return (LRESULT) infoPtr->uVisibleHeight / infoPtr->uRealItemHeight;
503 }
504
505
506
507 static LRESULT
508 TREEVIEW_SetItem (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
509 {
510 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
511 TREEVIEW_ITEM *wineItem;
512 TV_ITEM *tvItem;
513 INT32 iItem,len;
514
515 tvItem=(LPTVITEM) lParam;
516 iItem=tvItem->hItem;
517 TRACE (treeview,"item %d,mask %x\n",iItem,tvItem->mask);
518
519 wineItem = TREEVIEW_ValidItem (infoPtr, iItem);
520 if (!wineItem) return FALSE;
521
522 if (tvItem->mask & TVIF_CHILDREN) {
523 wineItem->cChildren=tvItem->cChildren;
524 }
525
526 if (tvItem->mask & TVIF_IMAGE) {
527 wineItem->iImage=tvItem->iImage;
528 }
529
530 if (tvItem->mask & TVIF_INTEGRAL) {
531 /* wineItem->iIntegral=tvItem->iIntegral; */
532 }
533
534 if (tvItem->mask & TVIF_PARAM) {
535 wineItem->lParam=tvItem->lParam;
536 }
537
538 if (tvItem->mask & TVIF_SELECTEDIMAGE) {
539 wineItem->iSelectedImage=tvItem->iSelectedImage;
540 }
541
542 if (tvItem->mask & TVIF_STATE) {
543 wineItem->state=tvItem->state & tvItem->stateMask;
544 }
545
546 if (tvItem->mask & TVIF_TEXT) {
547 len=lstrlen32A (tvItem->pszText);
548 if (len>wineItem->cchTextMax)
549 wineItem->pszText= COMCTL32_ReAlloc (wineItem->pszText, len+1);
550 lstrcpyn32A (wineItem->pszText, tvItem->pszText,len);
551 }
552
553 return TRUE;
554 }
555
556
557
558
559
560 static void
561 TREEVIEW_Refresh (WND *wndPtr)
562
563 {
564 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
565 HFONT32 hFont, hOldFont;
566 RECT32 rect;
567 HBRUSH32 hbrBk;
568 HDC32 hdc;
569 INT32 iItem, indent, x, y, height;
570 INT32 viewtop,viewbottom,viewleft,viewright;
571 TREEVIEW_ITEM *wineItem, *prevItem;
572
573 TRACE (treeview,"\n");
574
575 hdc=GetDC32 (wndPtr->hwndSelf);
576
577 if (infoPtr->Timer & TV_REFRESH_TIMER_SET) {
578 KillTimer32 (wndPtr->hwndSelf, TV_REFRESH_TIMER);
579 infoPtr->Timer &= ~TV_REFRESH_TIMER_SET;
580 }
581
582
583 GetClientRect32 (wndPtr->hwndSelf, &rect);
584 if ((rect.left-rect.right ==0) || (rect.top-rect.bottom==0)) return;
585 viewtop=infoPtr->cy;
586 viewbottom=infoPtr->cy + rect.bottom-rect.top;
587 viewleft=infoPtr->cx;
588 viewright=infoPtr->cx + rect.right-rect.left;
589
590 infoPtr->uVisibleHeight=viewbottom - viewtop;
591
592 hFont = infoPtr->hFont;
593 hOldFont = SelectObject32 (hdc, hFont);
594
595 /* draw background */
596 hbrBk = GetSysColorBrush32(COLOR_WINDOW);
597 FillRect32(hdc, &rect, hbrBk);
598
599
600 iItem=infoPtr->TopRootItem;
601 infoPtr->firstVisible=0;
602 wineItem=NULL;
603 indent=0;
604 x=y=0;
605 TRACE (treeview, "[%d %d %d %d]\n",viewtop,viewbottom,viewleft,viewright);
606
607 while (iItem) {
608 prevItem=wineItem;
609 wineItem= & infoPtr->items[iItem];
610
611 TRACE (treeview, "%d %d [%d %d %d %d] (%s)\n",y,x,
612 wineItem->rect.top, wineItem->rect.bottom,
613 wineItem->rect.left, wineItem->rect.right,
614 wineItem->pszText);
615
616 height=infoPtr->uRealItemHeight * wineItem->iIntegral;
617 if ((y >= viewtop) && (y <= viewbottom) &&
618 (x >= viewleft ) && (x <= viewright)) {
619 wineItem->rect.top = y - infoPtr->cy + rect.top;
620 wineItem->rect.bottom = wineItem->rect.top + height ;
621 wineItem->rect.left = x - infoPtr->cx + rect.left;
622 wineItem->rect.right = rect.right;
623 if (!infoPtr->firstVisible)
624 infoPtr->firstVisible=wineItem->hItem;
625 TREEVIEW_DrawItem (wndPtr, hdc, wineItem, prevItem, indent);
626 }
627 else {
628 wineItem->rect.top = wineItem->rect.bottom = -1;
629 wineItem->rect.left = wineItem->rect.right = -1;
630 }
631
632 /* look up next item */
633
634 if ((wineItem->firstChild) && (wineItem->state & TVIS_EXPANDED)) {
635 iItem=wineItem->firstChild;
636 indent++;
637 x+=infoPtr->uIndent;
638 }
639 else {
640 iItem=wineItem->sibling;
641 while ((!iItem) && (indent>0)) {
642 indent--;
643 x-=infoPtr->uIndent;
644 prevItem=wineItem;
645 wineItem=&infoPtr->items[wineItem->parent];
646 iItem=wineItem->sibling;
647 }
648 }
649 y +=height;
650 } /* while */
651
652 infoPtr->uTotalHeight=y;
653 if (y >= (viewbottom-viewtop)) {
654 if (!(infoPtr->uInternalStatus & TV_VSCROLL))
655 ShowScrollBar32 (wndPtr->hwndSelf, SB_VERT, TRUE);
656 infoPtr->uInternalStatus |=TV_VSCROLL;
657 SetScrollRange32 (wndPtr->hwndSelf, SB_VERT, 0,
658 y - infoPtr->uVisibleHeight, FALSE);
659 SetScrollPos32 (wndPtr->hwndSelf, SB_VERT, infoPtr->cy, TRUE);
660 }
661 else {
662 if (infoPtr->uInternalStatus & TV_VSCROLL)
663 ShowScrollBar32 (wndPtr->hwndSelf, SB_VERT, FALSE);
664 infoPtr->uInternalStatus &= ~TV_VSCROLL;
665 }
666
667
668 SelectObject32 (hdc, hOldFont);
669 ReleaseDC32 (wndPtr->hwndSelf, hdc);
670 }
671
672
673 static LRESULT
674 TREEVIEW_HandleTimer ( WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
675 {
676 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
677
678 TRACE (treeview, " %d\n",wParam);
679 if (!infoPtr) return FALSE;
680
681 switch (wParam) {
682 case TV_REFRESH_TIMER:
683 KillTimer32 (wndPtr->hwndSelf, TV_REFRESH_TIMER);
684 infoPtr->Timer &= ~TV_REFRESH_TIMER_SET;
685 TREEVIEW_Refresh (wndPtr);
686 return 0;
687 case TV_EDIT_TIMER:
688 KillTimer32 (wndPtr->hwndSelf, TV_EDIT_TIMER);
689 infoPtr->Timer &= ~TV_EDIT_TIMER_SET;
690 return 0;
691 }
692
693 return 1;
694 }
695
696
697 static void
698 TREEVIEW_QueueRefresh (WND *wndPtr)
699
700 {
701 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
702
703 TRACE (treeview,"\n");
704 if (infoPtr->Timer & TV_REFRESH_TIMER_SET) {
705 KillTimer32 (wndPtr->hwndSelf, TV_REFRESH_TIMER);
706 }
707
708 SetTimer32 (wndPtr->hwndSelf, TV_REFRESH_TIMER, TV_REFRESH_DELAY, 0);
709 infoPtr->Timer|=TV_REFRESH_TIMER_SET;
710 }
711
712
713
714 static LRESULT
715 TREEVIEW_GetItem (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
716 {
717 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
718 LPTVITEM tvItem;
719 TREEVIEW_ITEM *wineItem;
720 INT32 iItem;
721
722 TRACE (treeview,"\n");
723 tvItem=(LPTVITEM) lParam;
724 iItem=tvItem->hItem;
725
726 wineItem = TREEVIEW_ValidItem (infoPtr, iItem);
727 if (!wineItem) return FALSE;
728
729
730 if (tvItem->mask & TVIF_CHILDREN) {
731 tvItem->cChildren=wineItem->cChildren;
732 }
733
734 if (tvItem->mask & TVIF_HANDLE) {
735 tvItem->hItem=wineItem->hItem;
736 }
737
738 if (tvItem->mask & TVIF_IMAGE) {
739 tvItem->iImage=wineItem->iImage;
740 }
741
742 if (tvItem->mask & TVIF_INTEGRAL) {
743 /* tvItem->iIntegral=wineItem->iIntegral; */
744 }
745
746 if (tvItem->mask & TVIF_PARAM) {
747 tvItem->lParam=wineItem->lParam;
748 }
749
750 if (tvItem->mask & TVIF_SELECTEDIMAGE) {
751 tvItem->iSelectedImage=wineItem->iSelectedImage;
752 }
753
754 if (tvItem->mask & TVIF_STATE) {
755 tvItem->state=wineItem->state & tvItem->stateMask;
756 }
757
758 if (tvItem->mask & TVIF_TEXT) {
759 if (wineItem->pszText == LPSTR_TEXTCALLBACK32A) {
760 tvItem->pszText = LPSTR_TEXTCALLBACK32A;
761 }
762 else if (wineItem->pszText) {
763 lstrcpyn32A (tvItem->pszText, wineItem->pszText, tvItem->cchTextMax);
764 }
765 }
766
767 return TRUE;
768 }
769
770
771
772 /* FIXME: check implementation of TVGN_NEXT/TVGN_NEXTVISIBLE */
773
774
775 static LRESULT
776 TREEVIEW_GetNextItem32 (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
777
778 {
779 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
780 TREEVIEW_ITEM *wineItem;
781 INT32 iItem, flag;
782
783
784 TRACE (treeview,"item:%lu, flags:%x\n", lParam, wParam);
785 if (!infoPtr) return FALSE;
786
787 flag= (INT32) wParam;
788 switch (flag) {
789 case TVGN_ROOT: return (LRESULT) infoPtr->TopRootItem;
790 case TVGN_CARET: return (LRESULT) infoPtr->selectedItem;
791 case TVGN_FIRSTVISIBLE:
792 TREEVIEW_Refresh (wndPtr);
793 return (LRESULT) infoPtr->firstVisible;
794 case TVGN_DROPHILITE:
795 return (LRESULT) infoPtr->dropItem;
796 }
797
798 iItem= (INT32) lParam;
799 wineItem = TREEVIEW_ValidItem (infoPtr, iItem);
800 if (!wineItem) return FALSE;
801
802 switch (flag) {
803 case TVGN_NEXT: return (LRESULT) wineItem->sibling;
804 case TVGN_PREVIOUS: return (LRESULT) wineItem->upsibling;
805 case TVGN_PARENT: return (LRESULT) wineItem->parent;
806 case TVGN_CHILD: return (LRESULT) wineItem->firstChild;
807 case TVGN_LASTVISIBLE:
808 wineItem=TREEVIEW_GetLastListItem (infoPtr);
809 break;
810 case TVGN_NEXTVISIBLE:
811 wineItem=TREEVIEW_GetNextListItem (infoPtr,wineItem);
812 TRACE (treeview,"(%s)\n",wineItem->pszText);
813 break;
814 case TVGN_PREVIOUSVISIBLE:
815 wineItem=TREEVIEW_GetPrevListItem (infoPtr, wineItem);
816 TRACE (treeview,"(%s)\n",wineItem->pszText);
817 break;
818 default: FIXME (treeview,"Unknown msg %x,item %x\n", flag,iItem);
819 break;
820 }
821
822 if (wineItem) return (LRESULT) wineItem->hItem;
823
824 FIXME (treeview, "returning 0\n");
825 return 0;
826 }
827
828
829 static LRESULT
830 TREEVIEW_GetCount (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
831 {
832 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
833
834 TRACE (treeview,"\n");
835 return (LRESULT) infoPtr->uNumItems;
836 }
837
838
839
840
841 /* the method used below isn't the most memory-friendly, but it avoids
842 a lot of memory reallocations */
843
844 /* BTW: we waste handle 0; 0 is not an allowed handle. Fix this by
845 decreasing infoptr->items with 1, and increasing it by 1 if
846 it is referenced in mm-handling stuff? */
847
848 static LRESULT
849 TREEVIEW_InsertItem32A (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
850
851 {
852 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
853 TVINSERTSTRUCT *ptdi;
854 TV_ITEM *tvItem;
855 TREEVIEW_ITEM *wineItem, *parentItem, *prevsib, *sibItem;
856 INT32 iItem,listItems,i,len;
857
858 TRACE (treeview,"\n");
859 ptdi = (TVINSERTSTRUCT *) lParam;
860
861 /* check if memory is available */
862
863 if (infoPtr->uNumPtrsAlloced==0) {
864 infoPtr->items = COMCTL32_Alloc (TVITEM_ALLOC*sizeof (TREEVIEW_ITEM));
865 infoPtr->freeList= COMCTL32_Alloc ((1+(TVITEM_ALLOC>>5)) * sizeof (INT32));
866 infoPtr->uNumPtrsAlloced=TVITEM_ALLOC;
867 infoPtr->TopRootItem=1;
868 }
869
870 if (infoPtr->uNumItems == (infoPtr->uNumPtrsAlloced-1) ) {
871 TREEVIEW_ITEM *oldItems = infoPtr->items;
872 INT32 *oldfreeList = infoPtr->freeList;
873
874 infoPtr->uNumPtrsAlloced*=2;
875 infoPtr->items = COMCTL32_Alloc ( infoPtr->uNumPtrsAlloced * sizeof (TREEVIEW_ITEM));
876 infoPtr->freeList= COMCTL32_Alloc ((1+(infoPtr->uNumPtrsAlloced>>5))*sizeof (INT32));
877
878 memcpy (&infoPtr->items[0], &oldItems[0],
879 infoPtr->uNumPtrsAlloced/2 * sizeof(TREEVIEW_ITEM));
880 memcpy (&infoPtr->freeList[0], &oldfreeList[0],
881 infoPtr->uNumPtrsAlloced>>6 * sizeof(INT32));
882
883 COMCTL32_Free (oldItems);
884 COMCTL32_Free (oldfreeList);
885 }
886
887 iItem=0;
888 infoPtr->uNumItems++;
889
890 if (infoPtr->uMaxHandle==(infoPtr->uNumItems-1)) {
891 iItem=infoPtr->uNumItems;
892 infoPtr->uMaxHandle++;
893 }
894 else { /* check freelist */
895 for (i=0; i<infoPtr->uNumPtrsAlloced>>5; i++) {
896 if (infoPtr->freeList[i]) {
897 iItem=ffs (infoPtr->freeList[i]);
898 tv_clear_bit(iItem,&infoPtr->freeList[i]);
899 break;
900 }
901 }
902 }
903 if (!iItem) ERR (treeview, "Argh -- can't find free item.\n");
904
905 tvItem= & ptdi->item;
906 wineItem=& infoPtr->items[iItem];
907
908
909
910 if ((ptdi->hParent==TVI_ROOT) || (ptdi->hParent==0)) {
911 parentItem=NULL;
912 wineItem->parent=0;
913 sibItem=&infoPtr->items [infoPtr->TopRootItem];
914 listItems=infoPtr->uNumItems;
915 }
916 else {
917 parentItem= &infoPtr->items[ptdi->hParent];
918 if (!parentItem->firstChild)
919 parentItem->firstChild=iItem;
920 wineItem->parent=ptdi->hParent;
921 sibItem=&infoPtr->items [parentItem->firstChild];
922 parentItem->cChildren++;
923 listItems=parentItem->cChildren;
924 }
925
926 wineItem->upsibling=0; /* needed in case we're the first item in a list */
927 wineItem->sibling=0;
928 wineItem->firstChild=0;
929
930 if (listItems>1) {
931 prevsib=NULL;
932 switch (ptdi->hInsertAfter) {
933 case TVI_FIRST: wineItem->sibling=infoPtr->TopRootItem;
934 infoPtr->TopRootItem=iItem;
935 break;
936 case TVI_LAST:
937 while (sibItem->sibling) {
938 prevsib=sibItem;
939 sibItem=&infoPtr->items [sibItem->sibling];
940 }
941 sibItem->sibling=iItem;
942 if (prevsib!=NULL)
943 wineItem->upsibling=prevsib->hItem;
944 else
945 wineItem->sibling=0; /* terminate list */
946 break;
947 case TVI_SORT:
948 FIXME (treeview, "Sorted insert not implemented yet\n");
949 break;
950 default:
951 while ((sibItem->sibling) && (sibItem->sibling!=iItem)) {
952 prevsib=sibItem;
953 sibItem=&infoPtr->items [sibItem->sibling];
954 }
955 if (sibItem->sibling)
956 WARN (treeview, "Buggy program tried to insert item after nonexisting handle.");
957 sibItem->upsibling=iItem;
958 wineItem->sibling=sibItem->hItem;
959 if (prevsib!=NULL)
960 wineItem->upsibling=prevsib->hItem;
961 break;
962 }
963 }
964
965
966 /* Fill in info structure */
967
968 TRACE (treeview,"item %d, mask %x\n",iItem, tvItem->mask);
969 wineItem->mask=tvItem->mask;
970 wineItem->hItem=iItem;
971 wineItem->iIntegral=1;
972
973 if (tvItem->mask & TVIF_CHILDREN)
974 wineItem->cChildren=tvItem->cChildren;
975
976 if (tvItem->mask & TVIF_IMAGE)
977 wineItem->iImage=tvItem->iImage;
978
979 /* if (tvItem->mask & TVIF_INTEGRAL)
980 wineItem->iIntegral=tvItem->iIntegral; */
981
982
983 if (tvItem->mask & TVIF_PARAM)
984 wineItem->lParam=tvItem->lParam;
985
986 if (tvItem->mask & TVIF_SELECTEDIMAGE)
987 wineItem->iSelectedImage=tvItem->iSelectedImage;
988
989 if (tvItem->mask & TVIF_STATE) {
990 wineItem->state=tvItem->state;
991 wineItem->stateMask=tvItem->stateMask;
992 }
993
994 if (tvItem->mask & TVIF_TEXT) {
995 TRACE (treeview,"(%s)\n", tvItem->pszText);
996 if (tvItem->pszText!=LPSTR_TEXTCALLBACK32A) {
997 len = lstrlen32A (tvItem->pszText)+1;
998 wineItem->pszText= COMCTL32_Alloc (len+1);
999 lstrcpy32A (wineItem->pszText, tvItem->pszText);
1000 wineItem->cchTextMax=len;
1001 }
1002 else {
1003 wineItem->pszText = LPSTR_TEXTCALLBACK32A;
1004 TRACE (treeview,"LPSTR_TEXTCALLBACK\n");
1005 wineItem->cchTextMax = 0;
1006 }
1007 }
1008
1009 TREEVIEW_QueueRefresh (wndPtr);
1010
1011 return (LRESULT) iItem;
1012 }
1013
1014
1015
1016 static LRESULT
1017 TREEVIEW_DeleteItem (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1018 {
1019 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
1020 INT32 iItem;
1021 POINT32 pt;
1022 TREEVIEW_ITEM *wineItem;
1023
1024 TRACE (treeview,"\n");
1025 if (!infoPtr) return FALSE;
1026
1027 if ((INT32) lParam == TVI_ROOT) {
1028 TREEVIEW_RemoveTree (infoPtr);
1029 } else {
1030 iItem= (INT32) lParam;
1031 wineItem = TREEVIEW_ValidItem (infoPtr, iItem);
1032 if (!wineItem) return FALSE;
1033 TREEVIEW_SendTreeviewNotify (wndPtr, TVN_DELETEITEM, 0, iItem, 0, pt);
1034 TREEVIEW_RemoveItem (infoPtr, wineItem);
1035 }
1036
1037 TREEVIEW_QueueRefresh (wndPtr);
1038
1039 return TRUE;
1040 }
1041
1042
1043 static LRESULT
1044 TREEVIEW_GetIndent (WND *wndPtr)
1045 {
1046 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
1047
1048 TRACE (treeview,"\n");
1049 return infoPtr->uIndent;
1050 }
1051
1052 static LRESULT
1053 TREEVIEW_SetIndent (WND *wndPtr, WPARAM32 wParam)
1054 {
1055 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
1056 INT32 newIndent;
1057
1058 TRACE (treeview,"\n");
1059 newIndent=(INT32) wParam;
1060 if (newIndent < MINIMUM_INDENT) newIndent=MINIMUM_INDENT;
1061 infoPtr->uIndent=newIndent;
1062
1063 return 0;
1064 }
1065
1066 static LRESULT
1067 TREEVIEW_GetToolTips (WND *wndPtr)
1068
1069 {
1070 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
1071
1072 TRACE (treeview,"\n");
1073 return infoPtr->hwndToolTip;
1074 }
1075
1076
1077 static LRESULT
1078 TREEVIEW_SetToolTips (WND *wndPtr, WPARAM32 wParam)
1079
1080 {
1081 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
1082 HWND32 prevToolTip;
1083
1084 TRACE (treeview,"\n");
1085 prevToolTip=infoPtr->hwndToolTip;
1086 infoPtr->hwndToolTip= (HWND32) wParam;
1087
1088 return prevToolTip;
1089 }
1090
1091
1092
1093
1094
1095
1096 static LRESULT
1097 TREEVIEW_Create (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1098 {
1099 TREEVIEW_INFO *infoPtr;
1100 HDC32 hdc;
1101 TEXTMETRIC32A tm;
1102
1103 TRACE (treeview,"\n");
1104 /* allocate memory for info structure */
1105 infoPtr = (TREEVIEW_INFO *) COMCTL32_Alloc (sizeof(TREEVIEW_INFO));
1106
1107 wndPtr->wExtra[0] = (DWORD)infoPtr;
1108
1109 if (infoPtr == NULL) {
1110 ERR (treeview, "could not allocate info memory!\n");
1111 return 0;
1112 }
1113
1114 if ((TREEVIEW_INFO*)wndPtr->wExtra[0] != infoPtr) {
1115 ERR (treeview, "pointer assignment error!\n");
1116 return 0;
1117 }
1118
1119 hdc=GetDC32 (wndPtr->hwndSelf);
1120
1121 /* set default settings */
1122 infoPtr->uInternalStatus=0;
1123 infoPtr->uNumItems=0;
1124 infoPtr->clrBk = GetSysColor32 (COLOR_WINDOW);
1125 infoPtr->clrText = GetSysColor32 (COLOR_BTNTEXT);
1126 infoPtr->cy = 0;
1127 infoPtr->cx = 0;
1128 infoPtr->uIndent = 15;
1129 infoPtr->himlNormal = NULL;
1130 infoPtr->himlState = NULL;
1131 infoPtr->uItemHeight = -1;
1132 GetTextMetrics32A (hdc, &tm);
1133 infoPtr->hFont = GetStockObject32 (DEFAULT_GUI_FONT);
1134 infoPtr->uRealItemHeight= tm.tmHeight + tm.tmExternalLeading;
1135
1136 infoPtr->items = NULL;
1137 infoPtr->selectedItem=0;
1138 infoPtr->clrText=-1; /* use system color */
1139 infoPtr->dropItem=0;
1140
1141 /*
1142 infoPtr->hwndNotify = GetParent32 (wndPtr->hwndSelf);
1143 infoPtr->bTransparent = (wndPtr->dwStyle & TBSTYLE_FLAT);
1144 */
1145
1146 infoPtr->hwndToolTip=0;
1147 if (!(wndPtr->dwStyle & TVS_NOTOOLTIPS)) { /* Create tooltip control */
1148 TTTOOLINFO32A ti;
1149
1150 infoPtr->hwndToolTip =
1151 CreateWindowEx32A (0, TOOLTIPS_CLASS32A, NULL, 0,
1152 CW_USEDEFAULT32, CW_USEDEFAULT32,
1153 CW_USEDEFAULT32, CW_USEDEFAULT32,
1154 wndPtr->hwndSelf, 0, 0, 0);
1155
1156 /* Send NM_TOOLTIPSCREATED notification */
1157 if (infoPtr->hwndToolTip) {
1158 NMTOOLTIPSCREATED nmttc;
1159
1160 nmttc.hdr.hwndFrom = wndPtr->hwndSelf;
1161 nmttc.hdr.idFrom = wndPtr->wIDmenu;
1162 nmttc.hdr.code = NM_TOOLTIPSCREATED;
1163 nmttc.hwndToolTips = infoPtr->hwndToolTip;
1164
1165 SendMessage32A (GetParent32 (wndPtr->hwndSelf), WM_NOTIFY,
1166 (WPARAM32)wndPtr->wIDmenu, (LPARAM)&nmttc);
1167 }
1168
1169 ZeroMemory (&ti, sizeof(TTTOOLINFO32A));
1170 ti.cbSize = sizeof(TTTOOLINFO32A);
1171 ti.uFlags = TTF_IDISHWND | TTF_TRACK | TTF_TRANSPARENT ;
1172 ti.hwnd = wndPtr->hwndSelf;
1173 ti.uId = 0;
1174 ti.lpszText = "Test"; /* LPSTR_TEXTCALLBACK; */
1175 SetRectEmpty32 (&ti.rect);
1176
1177 SendMessage32A (infoPtr->hwndToolTip, TTM_ADDTOOL32A, 0, (LPARAM)&ti);
1178
1179 }
1180 ReleaseDC32 (wndPtr->hwndSelf, hdc);
1181
1182 return 0;
1183 }
1184
1185
1186
1187 static LRESULT
1188 TREEVIEW_Destroy (WND *wndPtr)
1189 {
1190 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
1191
1192 TRACE (treeview,"\n");
1193 TREEVIEW_RemoveTree (infoPtr);
1194 if (infoPtr->Timer & TV_REFRESH_TIMER_SET)
1195 KillTimer32 (wndPtr->hwndSelf, TV_REFRESH_TIMER);
1196 if (infoPtr->hwndToolTip)
1197 DestroyWindow32 (infoPtr->hwndToolTip);
1198
1199 COMCTL32_Free (infoPtr);
1200 return 0;
1201 }
1202
1203
1204 static LRESULT
1205 TREEVIEW_Paint (WND *wndPtr, WPARAM32 wParam)
1206 {
1207 HDC32 hdc;
1208 PAINTSTRUCT32 ps;
1209
1210 TRACE (treeview,"\n");
1211 hdc = wParam==0 ? BeginPaint32 (wndPtr->hwndSelf, &ps) : (HDC32)wParam;
1212 TREEVIEW_QueueRefresh (wndPtr);
1213 if(!wParam)
1214 EndPaint32 (wndPtr->hwndSelf, &ps);
1215 return 0;
1216 }
1217
1218
1219
1220 static LRESULT
1221 TREEVIEW_EraseBackground (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1222 {
1223 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
1224 HBRUSH32 hBrush = CreateSolidBrush32 (infoPtr->clrBk);
1225 RECT32 rect;
1226
1227 TRACE (treeview,"\n");
1228 GetClientRect32 (wndPtr->hwndSelf, &rect);
1229 FillRect32 ((HDC32)wParam, &rect, hBrush);
1230 DeleteObject32 (hBrush);
1231 return TRUE;
1232 }
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242 static BOOL32
1243 TREEVIEW_SendSimpleNotify (WND *wndPtr, UINT32 code)
1244 {
1245 NMHDR nmhdr;
1246
1247 TRACE (treeview, "%x\n",code);
1248 nmhdr.hwndFrom = wndPtr->hwndSelf;
1249 nmhdr.idFrom = wndPtr->wIDmenu;
1250 nmhdr.code = code;
1251
1252 return (BOOL32) SendMessage32A (GetParent32 (wndPtr->hwndSelf), WM_NOTIFY,
1253 (WPARAM32)nmhdr.idFrom, (LPARAM)&nmhdr);
1254 }
1255
1256
1257
1258
1259 static BOOL32
1260 TREEVIEW_SendTreeviewNotify (WND *wndPtr, UINT32 code, UINT32 action,
1261 INT32 oldItem, INT32 newItem, POINT32 pt)
1262 {
1263 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
1264 NMTREEVIEW nmhdr;
1265 TREEVIEW_ITEM *wineItem;
1266
1267 TRACE (treeview,"code:%x action:%x olditem:%x newitem:%x\n",
1268 code,action,oldItem,newItem);
1269 nmhdr.hdr.hwndFrom = wndPtr->hwndSelf;
1270 nmhdr.hdr.idFrom = wndPtr->wIDmenu;
1271 nmhdr.hdr.code = code;
1272 nmhdr.action = action;
1273 if (oldItem) {
1274 wineItem=& infoPtr->items[oldItem];
1275 nmhdr.itemOld.mask = wineItem->mask;
1276 nmhdr.itemOld.hItem = wineItem->hItem;
1277 nmhdr.itemOld.state = wineItem->state;
1278 nmhdr.itemOld.stateMask = wineItem->stateMask;
1279 nmhdr.itemOld.iImage = wineItem->iImage;
1280 nmhdr.itemOld.pszText = wineItem->pszText;
1281 nmhdr.itemOld.cchTextMax = wineItem->cchTextMax;
1282 nmhdr.itemOld.iImage = wineItem->iImage;
1283 nmhdr.itemOld.iSelectedImage = wineItem->iSelectedImage;
1284 nmhdr.itemOld.cChildren = wineItem->cChildren;
1285 nmhdr.itemOld.lParam = wineItem->lParam;
1286 }
1287
1288 if (newItem) {
1289 wineItem=& infoPtr->items[newItem];
1290 nmhdr.itemNew.mask = wineItem->mask;
1291 nmhdr.itemNew.hItem = wineItem->hItem;
1292 nmhdr.itemNew.state = wineItem->state;
1293 nmhdr.itemNew.stateMask = wineItem->stateMask;
1294 nmhdr.itemNew.iImage = wineItem->iImage;
1295 nmhdr.itemNew.pszText = wineItem->pszText;
1296 nmhdr.itemNew.cchTextMax = wineItem->cchTextMax;
1297 nmhdr.itemNew.iImage = wineItem->iImage;
1298 nmhdr.itemNew.iSelectedImage = wineItem->iSelectedImage;
1299 nmhdr.itemNew.cChildren = wineItem->cChildren;
1300 nmhdr.itemNew.lParam = wineItem->lParam;
1301 }
1302
1303 nmhdr.ptDrag.x = pt.x;
1304 nmhdr.ptDrag.y = pt.y;
1305
1306 return (BOOL32)SendMessage32A (GetParent32 (wndPtr->hwndSelf), WM_NOTIFY,
1307 (WPARAM32)wndPtr->wIDmenu, (LPARAM)&nmhdr);
1308
1309 }
1310
1311
1312
1313
1314 static LRESULT
1315 TREEVIEW_Expand (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1316 {
1317 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
1318 TREEVIEW_ITEM *wineItem;
1319 UINT32 flag;
1320 INT32 expandItem;
1321 POINT32 pt;
1322
1323 flag= (UINT32) wParam;
1324 expandItem= (INT32) lParam;
1325 TRACE (treeview,"flags:%x item:%x\n", expandItem, wParam);
1326 wineItem = TREEVIEW_ValidItem (infoPtr, expandItem);
1327 if (!wineItem) return 0;
1328 if (!wineItem->cChildren) return 0;
1329
1330 if (flag & TVE_TOGGLE) { /* FIXME: check exact behaviour here */
1331 flag &= ~TVE_TOGGLE; /* ie: bitwise ops or 'case' ops */
1332 if (wineItem->state & TVIS_EXPANDED)
1333 flag |= TVE_COLLAPSE;
1334 else
1335 flag |= TVE_EXPAND;
1336 }
1337
1338 switch (flag) {
1339 case TVE_COLLAPSERESET:
1340 if (!wineItem->state & TVIS_EXPANDED) return 0;
1341 wineItem->state &= ~(TVIS_EXPANDEDONCE | TVIS_EXPANDED);
1342 TREEVIEW_RemoveAllChildren (infoPtr, wineItem);
1343 break;
1344
1345 case TVE_COLLAPSE:
1346 if (!wineItem->state & TVIS_EXPANDED) return 0;
1347 wineItem->state &= ~TVIS_EXPANDED;
1348 break;
1349
1350 case TVE_EXPAND:
1351 if (wineItem->state & TVIS_EXPANDED) return 0;
1352 if (!(wineItem->state & TVIS_EXPANDEDONCE)) {
1353 if (TREEVIEW_SendTreeviewNotify (wndPtr, TVN_ITEMEXPANDING,
1354 0, 0, expandItem, pt))
1355 return FALSE; /* FIXME: OK? */
1356 wineItem->state |= TVIS_EXPANDED | TVIS_EXPANDEDONCE;
1357 TREEVIEW_SendTreeviewNotify (wndPtr, TVN_ITEMEXPANDED,
1358 0, 0, expandItem, pt);
1359 }
1360 wineItem->state |= TVIS_EXPANDED;
1361 break;
1362 case TVE_EXPANDPARTIAL:
1363 FIXME (treeview, "TVE_EXPANDPARTIAL not implemented\n");
1364 wineItem->state ^=TVIS_EXPANDED;
1365 wineItem->state |=TVIS_EXPANDEDONCE;
1366 break;
1367 }
1368
1369 TREEVIEW_QueueRefresh (wndPtr);
1370
1371 return TRUE;
1372 }
1373
1374
1375
1376 static HTREEITEM
1377 TREEVIEW_HitTest (WND *wndPtr, LPTVHITTESTINFO lpht)
1378 {
1379 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
1380 TREEVIEW_ITEM *wineItem;
1381 RECT32 rect;
1382 UINT32 status,x,y;
1383
1384
1385
1386 GetClientRect32 (wndPtr->hwndSelf, &rect);
1387 TRACE (treeview,"(%d,%d)\n",lpht->pt.x, lpht->pt.y);
1388
1389 status=0;
1390 x=lpht->pt.x;
1391 y=lpht->pt.y;
1392 if (x < rect.left) status|=TVHT_TOLEFT;
1393 if (x > rect.right) status|=TVHT_TORIGHT;
1394 if (y < rect.top ) status|=TVHT_ABOVE;
1395 if (y > rect.bottom) status|=TVHT_BELOW;
1396 if (status) {
1397 lpht->flags=status;
1398 return 0;
1399 }
1400
1401 if (!infoPtr->firstVisible) WARN (treeview,"Can't fetch first visible item");
1402 wineItem=&infoPtr->items [infoPtr->firstVisible];
1403
1404 while ((wineItem!=NULL) && (y > wineItem->rect.bottom))
1405 wineItem=TREEVIEW_GetNextListItem (infoPtr,wineItem);
1406
1407 if (wineItem==NULL) {
1408 lpht->flags=TVHT_NOWHERE;
1409 return 0;
1410 }
1411
1412 if (x>wineItem->rect.right) {
1413 lpht->flags|=TVHT_ONITEMRIGHT;
1414 return wineItem->hItem;
1415 }
1416
1417
1418 if (x<wineItem->rect.left+10) lpht->flags|=TVHT_ONITEMBUTTON;
1419
1420 lpht->flags=TVHT_ONITEMLABEL; /* FIXME: implement other flags */
1421
1422
1423 lpht->hItem=wineItem->hItem;
1424 return wineItem->hItem;
1425 }
1426
1427
1428 static LRESULT
1429 TREEVIEW_HitTest32 (WND *wndPtr, LPARAM lParam)
1430 {
1431
1432 return (LRESULT) TREEVIEW_HitTest (wndPtr, (LPTVHITTESTINFO) lParam);
1433 }
1434
1435
1436
1437
1438 LRESULT
1439 TREEVIEW_LButtonDoubleClick (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1440 {
1441 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
1442 TREEVIEW_ITEM *wineItem;
1443 INT32 iItem;
1444 TVHITTESTINFO ht;
1445
1446 TRACE (treeview,"\n");
1447 ht.pt.x = (INT32)LOWORD(lParam);
1448 ht.pt.y = (INT32)HIWORD(lParam);
1449 SetFocus32 (wndPtr->hwndSelf);
1450
1451 iItem=TREEVIEW_HitTest (wndPtr, &ht);
1452 TRACE (treeview,"item %d \n",iItem);
1453 wineItem=TREEVIEW_ValidItem (infoPtr, iItem);
1454 if (!wineItem) return 0;
1455
1456 if (TREEVIEW_SendSimpleNotify (wndPtr, NM_DBLCLK)!=TRUE) { /* FIXME!*/
1457 wineItem->state &= ~TVIS_EXPANDEDONCE;
1458 TREEVIEW_Expand (wndPtr, (WPARAM32) TVE_TOGGLE, (LPARAM) iItem);
1459 }
1460 return TRUE;
1461 }
1462
1463
1464
1465 static LRESULT
1466 TREEVIEW_LButtonDown (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1467 {
1468 INT32 iItem;
1469 TVHITTESTINFO ht;
1470
1471 TRACE (treeview,"\n");
1472 ht.pt.x = (INT32)LOWORD(lParam);
1473 ht.pt.y = (INT32)HIWORD(lParam);
1474
1475 SetFocus32 (wndPtr->hwndSelf);
1476 iItem=TREEVIEW_HitTest (wndPtr, &ht);
1477 TRACE (treeview,"item %d \n",iItem);
1478 if (ht.flags & TVHT_ONITEMBUTTON) {
1479 TREEVIEW_Expand (wndPtr, (WPARAM32) TVE_TOGGLE, (LPARAM) iItem);
1480 }
1481
1482 if (TREEVIEW_SelectItem (wndPtr, (WPARAM32) TVGN_CARET, (LPARAM) iItem))
1483 return 0;
1484
1485
1486 return 0;
1487 }
1488
1489
1490 static LRESULT
1491 TREEVIEW_RButtonDown (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1492 {
1493
1494 TRACE (treeview,"\n");
1495 return 0;
1496 }
1497
1498
1499
1500
1501 /* FIXME: If the specified item is the child of a collapsed parent item,
1502 expand parent's list of child items to reveal the specified item.
1503 */
1504
1505 static LRESULT
1506 TREEVIEW_SelectItem (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1507 {
1508 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
1509 TREEVIEW_ITEM *prevItem,*wineItem;
1510 INT32 action,prevSelect, newSelect;
1511 POINT32 dummy;
1512
1513 TRACE (treeview,"item %lx, flag %x\n", lParam, wParam);
1514 newSelect= (INT32) lParam;
1515 wineItem = TREEVIEW_ValidItem (infoPtr, newSelect);
1516 if (!wineItem) return FALSE;
1517 prevSelect=infoPtr->selectedItem;
1518 prevItem= TREEVIEW_ValidItem (infoPtr, prevSelect);
1519 dummy.x=0;
1520 dummy.y=0;
1521
1522 action= (INT32) wParam;
1523
1524 switch (action) {
1525 case TVGN_CARET:
1526 if (TREEVIEW_SendTreeviewNotify (wndPtr, TVN_SELCHANGING, TVC_BYMOUSE,
1527 prevSelect, newSelect,dummy))
1528 return FALSE; /* FIXME: OK? */
1529
1530 if (prevItem) prevItem->state &= ~TVIS_SELECTED;
1531 infoPtr->selectedItem=newSelect;
1532 wineItem->state |=TVIS_SELECTED;
1533 TREEVIEW_SendTreeviewNotify (wndPtr, TVN_SELCHANGED,
1534 TVC_BYMOUSE, prevSelect, newSelect, dummy);
1535 break;
1536 case TVGN_DROPHILITE:
1537 FIXME (treeview, "DROPHILITE not implemented");
1538 break;
1539 case TVGN_FIRSTVISIBLE:
1540 FIXME (treeview, "FIRSTVISIBLE not implemented");
1541 break;
1542 }
1543
1544 TREEVIEW_QueueRefresh (wndPtr);
1545
1546 return TRUE;
1547 }
1548
1549
1550
1551
1552 static LRESULT
1553 TREEVIEW_GetFont (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1554
1555 {
1556 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
1557
1558 TRACE (treeview,"%x\n",infoPtr->hFont);
1559 return infoPtr->hFont;
1560 }
1561
1562 static LRESULT
1563 TREEVIEW_SetFont (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1564
1565 {
1566 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
1567 TEXTMETRIC32A tm;
1568 HFONT32 hFont, hOldFont;
1569 HDC32 hdc;
1570
1571 TRACE (treeview,"%x %lx\n",wParam, lParam);
1572
1573 infoPtr->hFont = (HFONT32)wParam;
1574
1575 hFont = infoPtr->hFont ? infoPtr->hFont : GetStockObject32 (SYSTEM_FONT);
1576
1577 hdc = GetDC32 (0);
1578 hOldFont = SelectObject32 (hdc, hFont);
1579 GetTextMetrics32A (hdc, &tm);
1580 infoPtr->uRealItemHeight= tm.tmHeight + tm.tmExternalLeading;
1581 SelectObject32 (hdc, hOldFont);
1582 ReleaseDC32 (0, hdc);
1583
1584 if (lParam)
1585 TREEVIEW_QueueRefresh (wndPtr);
1586
1587 return 0;
1588 }
1589
1590
1591 /* FIXME: does KEYDOWN also send notifications?? If so, use
1592 TREEVIEW_SelectItem.
1593 */
1594
1595
1596 static LRESULT
1597 TREEVIEW_KeyDown (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1598 {
1599 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
1600 TREEVIEW_ITEM *prevItem,*newItem;
1601 int prevSelect;
1602
1603
1604 TRACE (treeview,"%x %lx\n",wParam, lParam);
1605 prevSelect=infoPtr->selectedItem;
1606 if (!prevSelect) return FALSE;
1607
1608 prevItem= TREEVIEW_ValidItem (infoPtr, prevSelect);
1609
1610 newItem=NULL;
1611 switch (wParam) {
1612 case VK_UP:
1613 newItem=TREEVIEW_GetPrevListItem (infoPtr, prevItem);
1614 if (!newItem)
1615 newItem=& infoPtr->items[infoPtr->TopRootItem];
1616 break;
1617 case VK_DOWN:
1618 newItem=TREEVIEW_GetNextListItem (infoPtr, prevItem);
1619 if (!newItem) newItem=prevItem;
1620 break;
1621 case VK_HOME:
1622 newItem=& infoPtr->items[infoPtr->TopRootItem];
1623 break;
1624 case VK_END:
1625 newItem=TREEVIEW_GetLastListItem (infoPtr);
1626 break;
1627 case VK_PRIOR:
1628 case VK_NEXT:
1629 case VK_BACK:
1630 case VK_RETURN:
1631 FIXME (treeview, "%x not implemented\n", wParam);
1632 break;
1633 }
1634
1635 if (!newItem) return FALSE;
1636
1637 if (prevItem!=newItem) {
1638 prevItem->state &= ~TVIS_SELECTED;
1639 newItem->state |= TVIS_SELECTED;
1640 infoPtr->selectedItem=newItem->hItem;
1641 TREEVIEW_QueueRefresh (wndPtr);
1642 return TRUE;
1643 }
1644
1645 return FALSE;
1646 }
1647
1648
1649
1650 static LRESULT
1651 TREEVIEW_VScroll (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1652
1653 {
1654 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
1655 int maxHeight;
1656
1657 TRACE (treeview,"wp %x, lp %lx\n", wParam, lParam);
1658 if (!infoPtr->uInternalStatus & TV_VSCROLL) return FALSE;
1659
1660 switch (LOWORD (wParam)) {
1661 case SB_LINEUP:
1662 if (!infoPtr->cy) return FALSE;
1663 infoPtr->cy -= infoPtr->uRealItemHeight;
1664 if (infoPtr->cy < 0) infoPtr->cy=0;
1665 break;
1666 case SB_LINEDOWN:
1667 maxHeight=infoPtr->uTotalHeight-infoPtr->uVisibleHeight;
1668 if (infoPtr->cy == maxHeight) return FALSE;
1669 infoPtr->cy += infoPtr->uRealItemHeight;
1670 if (infoPtr->cy > maxHeight)
1671 infoPtr->cy = maxHeight;
1672 break;
1673 case SB_PAGEUP:
1674 if (!infoPtr->cy) return FALSE;
1675 infoPtr->cy -= infoPtr->uVisibleHeight;
1676 if (infoPtr->cy < 0) infoPtr->cy=0;
1677 break;
1678 case SB_PAGEDOWN:
1679 maxHeight=infoPtr->uTotalHeight-infoPtr->uVisibleHeight;
1680 if (infoPtr->cy == maxHeight) return FALSE;
1681 infoPtr->cy += infoPtr->uVisibleHeight;
1682 if (infoPtr->cy > maxHeight)
1683 infoPtr->cy = maxHeight;
1684 break;
1685 case SB_THUMBTRACK:
1686 infoPtr->cy = HIWORD (wParam);
1687 break;
1688
1689 }
1690
1691 TREEVIEW_QueueRefresh (wndPtr);
1692 return TRUE;
1693 }
1694
1695 static LRESULT
1696 TREEVIEW_HScroll (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1697 {
1698 TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
1699
1700 TRACE (treeview,"wp %lx, lp %x\n", lParam, wParam);
1701
1702 if (!infoPtr->uInternalStatus & TV_HSCROLL) return FALSE;
1703 return TRUE;
1704 }
1705
1706
1707
1708
1709 LRESULT WINAPI
1710 TREEVIEW_WindowProc (HWND32 hwnd, UINT32 uMsg, WPARAM32 wParam, LPARAM lParam)
1711 {
1712 WND *wndPtr = WIN_FindWndPtr(hwnd);
1713
1714
1715 switch (uMsg) {
1716 case TVM_INSERTITEM32A:
1717 return TREEVIEW_InsertItem32A (wndPtr, wParam, lParam);
1718
1719 case TVM_INSERTITEM32W:
1720 FIXME (treeview, "Unimplemented msg TVM_INSERTITEM32W\n");
1721 return 0;
1722
1723 case TVM_DELETEITEM:
1724 return TREEVIEW_DeleteItem (wndPtr, wParam, lParam);
1725
1726 case TVM_EXPAND:
1727 return TREEVIEW_Expand (wndPtr, wParam, lParam);
1728
1729 case TVM_GETITEMRECT:
1730 return TREEVIEW_GetItemRect (wndPtr, wParam, lParam);
1731
1732 case TVM_GETCOUNT:
1733 return TREEVIEW_GetCount (wndPtr, wParam, lParam);
1734
1735 case TVM_GETINDENT:
1736 return TREEVIEW_GetIndent (wndPtr);
1737
1738 case TVM_SETINDENT:
1739 return TREEVIEW_SetIndent (wndPtr, wParam);
1740
1741 case TVM_GETIMAGELIST:
1742 return TREEVIEW_GetImageList (wndPtr, wParam, lParam);
1743
1744 case TVM_SETIMAGELIST:
1745 return TREEVIEW_SetImageList (wndPtr, wParam, lParam);
1746
1747 case TVM_GETNEXTITEM:
1748 return TREEVIEW_GetNextItem32 (wndPtr, wParam, lParam);
1749
1750 case TVM_SELECTITEM:
1751 return TREEVIEW_SelectItem (wndPtr, wParam, lParam);
1752
1753 case TVM_GETITEM32A:
1754 return TREEVIEW_GetItem (wndPtr, wParam, lParam);
1755
1756 case TVM_GETITEM32W:
1757 FIXME (treeview, "Unimplemented msg TVM_GETITEM32W\n");
1758 return 0;
1759
1760 case TVM_SETITEM32A:
1761 return TREEVIEW_SetItem (wndPtr, wParam, lParam);
1762
1763 case TVM_SETITEM32W:
1764 FIXME (treeview, "Unimplemented msg TVM_SETITEMW\n");
1765 return 0;
1766
1767 case TVM_EDITLABEL32A:
1768 FIXME (treeview, "Unimplemented msg TVM_EDITLABEL32A \n");
1769 return 0;
1770
1771 case TVM_EDITLABEL32W:
1772 FIXME (treeview, "Unimplemented msg TVM_EDITLABEL32W \n");
1773 return 0;
1774
1775 case TVM_GETEDITCONTROL:
1776 FIXME (treeview, "Unimplemented msg TVM_GETEDITCONTROL\n");
1777 return 0;
1778
1779 case TVM_GETVISIBLECOUNT:
1780 return TREEVIEW_GetVisibleCount (wndPtr, wParam, lParam);
1781
1782 case TVM_HITTEST:
1783 return TREEVIEW_HitTest32 (wndPtr, lParam);
1784
1785 case TVM_CREATEDRAGIMAGE:
1786 FIXME (treeview, "Unimplemented msg TVM_CREATEDRAGIMAGE\n");
1787 return 0;
1788
1789 case TVM_SORTCHILDREN:
1790 FIXME (treeview, "Unimplemented msg TVM_SORTCHILDREN\n");
1791 return 0;
1792
1793 case TVM_ENSUREVISIBLE:
1794 FIXME (treeview, "Unimplemented msg TVM_ENSUREVISIBLE\n");
1795 return 0;
1796
1797 case TVM_SORTCHILDRENCB:
1798 FIXME (treeview, "Unimplemented msg TVM_SORTCHILDRENCB\n");
1799 return 0;
1800
1801 case TVM_ENDEDITLABELNOW:
1802 FIXME (treeview, "Unimplemented msg TVM_ENDEDITLABELNOW\n");
1803 return 0;
1804
1805 case TVM_GETISEARCHSTRING32A:
1806 FIXME (treeview, "Unimplemented msg TVM_GETISEARCHSTRING32A\n");
1807 return 0;
1808
1809 case TVM_GETISEARCHSTRING32W:
1810 FIXME (treeview, "Unimplemented msg TVM_GETISEARCHSTRING32W\n");
1811 return 0;
1812
1813 case TVM_GETTOOLTIPS:
1814 return TREEVIEW_GetToolTips (wndPtr);
1815
1816 case TVM_SETTOOLTIPS:
1817 return TREEVIEW_SetToolTips (wndPtr, wParam);
1818
1819 case TVM_SETINSERTMARK:
1820 FIXME (treeview, "Unimplemented msg TVM_SETINSERTMARK\n");
1821 return 0;
1822
1823 case TVM_SETITEMHEIGHT:
1824 return TREEVIEW_SetItemHeight (wndPtr, wParam);
1825
1826 case TVM_GETITEMHEIGHT:
1827 return TREEVIEW_GetItemHeight (wndPtr);
1828
1829 case TVM_SETBKCOLOR:
1830 FIXME (treeview, "Unimplemented msg TVM_SETBKCOLOR\n");
1831 return 0;
1832
1833 case TVM_SETTEXTCOLOR:
1834 return TREEVIEW_SetTextColor (wndPtr, wParam, lParam);
1835
1836 case TVM_GETBKCOLOR:
1837 FIXME (treeview, "Unimplemented msg TVM_GETBKCOLOR\n");
1838 return 0;
1839
1840 case TVM_GETTEXTCOLOR:
1841 return TREEVIEW_GetTextColor (wndPtr);
1842
1843 case TVM_SETSCROLLTIME:
1844 FIXME (treeview, "Unimplemented msg TVM_SETSCROLLTIME\n");
1845 return 0;
1846
1847 case TVM_GETSCROLLTIME:
1848 FIXME (treeview, "Unimplemented msg TVM_GETSCROLLTIME\n");
1849 return 0;
1850
1851 case TVM_SETINSERTMARKCOLOR:
1852 FIXME (treeview, "Unimplemented msg TVM_SETINSERTMARKCOLOR\n");
1853 return 0;
1854
1855 case TVM_SETUNICODEFORMAT:
1856 FIXME (treeview, "Unimplemented msg TVM_SETUNICODEFORMAT\n");
1857 return 0;
1858
1859 case TVM_GETUNICODEFORMAT:
1860 FIXME (treeview, "Unimplemented msg TVM_GETUNICODEFORMAT\n");
1861 return 0;
1862
1863 /* case WM_COMMAND: */
1864
1865 case WM_CREATE:
1866 return TREEVIEW_Create (wndPtr, wParam, lParam);
1867
1868 case WM_DESTROY:
1869 return TREEVIEW_Destroy (wndPtr);
1870
1871 /* case WM_ENABLE: */
1872
1873 case WM_ERASEBKGND:
1874 return TREEVIEW_EraseBackground (wndPtr, wParam, lParam);
1875
1876 case WM_GETDLGCODE:
1877 return DLGC_WANTARROWS | DLGC_WANTCHARS;
1878
1879 case WM_PAINT:
1880 return TREEVIEW_Paint (wndPtr, wParam);
1881
1882 case WM_GETFONT:
1883 return TREEVIEW_GetFont (wndPtr, wParam, lParam);
1884
1885 case WM_SETFONT:
1886 return TREEVIEW_SetFont (wndPtr, wParam, lParam);
1887
1888 case WM_KEYDOWN:
1889 return TREEVIEW_KeyDown (wndPtr, wParam, lParam);
1890
1891
1892 /* case WM_KILLFOCUS: */
1893 /* case WM_SETFOCUS: */
1894
1895
1896 case WM_LBUTTONDOWN:
1897 return TREEVIEW_LButtonDown (wndPtr, wParam, lParam);
1898
1899 case WM_LBUTTONDBLCLK:
1900 return TREEVIEW_LButtonDoubleClick (wndPtr, wParam, lParam);
1901
1902 case WM_RBUTTONDOWN:
1903 return TREEVIEW_RButtonDown (wndPtr, wParam, lParam);
1904
1905
1906 /* case WM_SYSCOLORCHANGE: */
1907 /* case WM_STYLECHANGED: */
1908 /* case WM_SETREDRAW: */
1909
1910 case WM_TIMER:
1911 return TREEVIEW_HandleTimer (wndPtr, wParam, lParam);
1912
1913 /* case WM_SIZE: */
1914 case WM_HSCROLL:
1915 return TREEVIEW_HScroll (wndPtr, wParam, lParam);
1916 case WM_VSCROLL:
1917 return TREEVIEW_VScroll (wndPtr, wParam, lParam);
1918
1919 default:
1920 if (uMsg >= WM_USER)
1921 FIXME (treeview, "Unknown msg %04x wp=%08x lp=%08lx\n",
1922 uMsg, wParam, lParam);
1923 return DefWindowProc32A (hwnd, uMsg, wParam, lParam);
1924 }
1925 return 0;
1926 }
1927
1928
1929 VOID
1930 TREEVIEW_Register (VOID)
1931 {
1932 WNDCLASS32A wndClass;
1933
1934 TRACE (treeview,"\n");
1935
1936 if (GlobalFindAtom32A (WC_TREEVIEW32A)) return;
1937
1938 ZeroMemory (&wndClass, sizeof(WNDCLASS32A));
1939 wndClass.style = CS_GLOBALCLASS | CS_DBLCLKS;
1940 wndClass.lpfnWndProc = (WNDPROC32)TREEVIEW_WindowProc;
1941 wndClass.cbClsExtra = 0;
1942 wndClass.cbWndExtra = sizeof(TREEVIEW_INFO *);
1943 wndClass.hCursor = LoadCursor32A (0, IDC_ARROW32A);
1944 wndClass.hbrBackground = 0;
1945 wndClass.lpszClassName = WC_TREEVIEW32A;
1946
1947 RegisterClass32A (&wndClass);
1948 }
1949
1950
1951 VOID
1952 TREEVIEW_Unregister (VOID)
1953 {
1954 if (GlobalFindAtom32A (WC_TREEVIEW32A))
1955 UnregisterClass32A (WC_TREEVIEW32A, (HINSTANCE32)NULL);
1956 }
1957
Quick hack tree for wine patches julliard doesn't want to commit