- added version messages
[wine] / dlls / comctl32 / rebar.c
1 /*
2  * Rebar control
3  *
4  * Copyright 1998, 1999 Eric Kohl
5  *
6  * NOTES
7  *   An author is needed! Any volunteers?
8  *   I will only improve this control once in a while.
9  *     Eric <ekohl@abo.rhein-zeitung.de>
10  *
11  * TODO:
12  *   - vertical placement
13  *   - ComboBox and ComboBoxEx placement
14  *   - center image 
15  *   - Layout code.
16  *   - Display code.
17  *   - Some messages.
18  *   - All notifications.
19  */
20
21 #include <string.h>
22
23 #include "winbase.h"
24 #include "wingdi.h"
25 #include "commctrl.h"
26 #include "rebar.h"
27 #include "debugtools.h"
28
29 DEFAULT_DEBUG_CHANNEL(rebar)
30
31
32 /* fDraw flags */
33 #define DRAW_GRIPPER    1
34 #define DRAW_IMAGE      2
35 #define DRAW_TEXT       4
36 #define DRAW_CHILD      8
37
38 #define GRIPPER_WIDTH   13
39
40
41 #define REBAR_GetInfoPtr(wndPtr) ((REBAR_INFO *)GetWindowLongA (hwnd, 0))
42
43
44 static VOID
45 REBAR_DrawBand (HDC hdc, REBAR_INFO *infoPtr, REBAR_BAND *lpBand)
46 {
47
48     DrawEdge (hdc, &lpBand->rcBand, BDR_RAISEDINNER, BF_MIDDLE);
49
50     /* draw background */
51
52     /* draw gripper */
53     if (lpBand->fDraw & DRAW_GRIPPER)
54         DrawEdge (hdc, &lpBand->rcGripper, BDR_RAISEDINNER, BF_RECT | BF_MIDDLE);
55
56     /* draw caption image */
57     if (lpBand->fDraw & DRAW_IMAGE) {
58         /* FIXME: center image */
59         POINT pt;
60
61         pt.y = (lpBand->rcCapImage.bottom + lpBand->rcCapImage.top - infoPtr->imageSize.cy)/2;
62         pt.x = (lpBand->rcCapImage.right + lpBand->rcCapImage.left - infoPtr->imageSize.cx)/2;
63
64         ImageList_Draw (infoPtr->himl, lpBand->iImage, hdc,
65 /*                      lpBand->rcCapImage.left, lpBand->rcCapImage.top, */
66                         pt.x, pt.y,
67                         ILD_TRANSPARENT);
68     }
69
70     /* draw caption text */
71     if (lpBand->fDraw & DRAW_TEXT) {
72         HFONT hOldFont = SelectObject (hdc, infoPtr->hFont);
73         INT oldBkMode = SetBkMode (hdc, TRANSPARENT);
74         DrawTextW (hdc, lpBand->lpText, -1, &lpBand->rcCapText,
75                      DT_CENTER | DT_VCENTER | DT_SINGLELINE);
76         if (oldBkMode != TRANSPARENT)
77             SetBkMode (hdc, oldBkMode);
78         SelectObject (hdc, hOldFont);
79     }
80 }
81
82
83 static VOID
84 REBAR_Refresh (HWND hwnd, HDC hdc)
85 {
86     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
87     REBAR_BAND *lpBand;
88     UINT i;
89
90     for (i = 0; i < infoPtr->uNumBands; i++) {
91         lpBand = &infoPtr->bands[i];
92
93         if ((lpBand->fStyle & RBBS_HIDDEN) || 
94             ((GetWindowLongA (hwnd, GWL_STYLE) & CCS_VERT) &&
95              (lpBand->fStyle & RBBS_NOVERT)))
96             continue;
97
98         REBAR_DrawBand (hdc, infoPtr, lpBand);
99
100     }
101 }
102
103
104 static VOID
105 REBAR_CalcHorzBand (REBAR_INFO *infoPtr, REBAR_BAND *lpBand)
106 {
107     lpBand->fDraw = 0;
108
109     /* set initial caption image rectangle */
110     SetRect (&lpBand->rcCapImage, 0, 0, 0, 0);
111
112     /* image is visible */
113     if ((lpBand->iImage > -1) && (infoPtr->himl)) {
114         lpBand->fDraw |= DRAW_IMAGE;
115
116         lpBand->rcCapImage.right  = lpBand->rcCapImage.left + infoPtr->imageSize.cx;
117         lpBand->rcCapImage.bottom = lpBand->rcCapImage.top + infoPtr->imageSize.cy;
118
119         /* update band height */
120         if (lpBand->uMinHeight < infoPtr->imageSize.cy + 2) {
121             lpBand->uMinHeight = infoPtr->imageSize.cy + 2;
122             lpBand->rcBand.bottom = lpBand->rcBand.top + lpBand->uMinHeight;
123         }
124     }
125
126     /* set initial caption text rectangle */
127     lpBand->rcCapText.left   = lpBand->rcCapImage.right;
128     lpBand->rcCapText.top    = lpBand->rcBand.top + 1;
129     lpBand->rcCapText.right  = lpBand->rcCapText.left;
130     lpBand->rcCapText.bottom = lpBand->rcBand.bottom - 1;
131
132     /* text is visible */
133     if (lpBand->lpText) {
134         HDC hdc = GetDC (0);
135         HFONT hOldFont = SelectObject (hdc, infoPtr->hFont);
136         SIZE size;
137
138         lpBand->fDraw |= DRAW_TEXT;
139         GetTextExtentPoint32W (hdc, lpBand->lpText,
140                                lstrlenW (lpBand->lpText), &size);
141         lpBand->rcCapText.right += size.cx;
142
143         SelectObject (hdc, hOldFont);
144         ReleaseDC (0, hdc);
145     }
146
147     /* set initial child window rectangle */
148     if (lpBand->fStyle & RBBS_FIXEDSIZE) {
149         lpBand->rcChild.left   = lpBand->rcCapText.right;
150         lpBand->rcChild.top    = lpBand->rcBand.top;
151         lpBand->rcChild.right  = lpBand->rcBand.right;
152         lpBand->rcChild.bottom = lpBand->rcBand.bottom;
153     }
154     else {
155         lpBand->rcChild.left   = lpBand->rcCapText.right + 4;
156         lpBand->rcChild.top    = lpBand->rcBand.top + 2;
157         lpBand->rcChild.right  = lpBand->rcBand.right - 4;
158         lpBand->rcChild.bottom = lpBand->rcBand.bottom - 2;
159     }
160
161     /* calculate gripper rectangle */
162     if ((!(lpBand->fStyle & RBBS_NOGRIPPER)) &&
163         (!(lpBand->fStyle & RBBS_FIXEDSIZE)) &&
164         ((lpBand->fStyle & RBBS_GRIPPERALWAYS) || 
165          (infoPtr->uNumBands > 1))) {
166         lpBand->fDraw |= DRAW_GRIPPER;
167         lpBand->rcGripper.left   = lpBand->rcBand.left + 3;
168         lpBand->rcGripper.right  = lpBand->rcGripper.left + 3;
169         lpBand->rcGripper.top    = lpBand->rcBand.top + 3;
170         lpBand->rcGripper.bottom = lpBand->rcBand.bottom - 3;
171
172         /* move caption rectangles */
173         OffsetRect (&lpBand->rcCapImage, GRIPPER_WIDTH, 0);
174         OffsetRect (&lpBand->rcCapText, GRIPPER_WIDTH, 0);
175
176         /* adjust child rectangle */
177         lpBand->rcChild.left += GRIPPER_WIDTH;
178     }
179
180
181 }
182
183
184 static VOID
185 REBAR_CalcVertBand (HWND hwnd, REBAR_INFO *infoPtr, REBAR_BAND *lpBand)
186 {
187     lpBand->fDraw = 0;
188
189     /* set initial caption image rectangle */
190     SetRect (&lpBand->rcCapImage, 0, 0, 0, 0);
191
192     /* image is visible */
193     if ((lpBand->iImage > -1) && (infoPtr->himl)) {
194         lpBand->fDraw |= DRAW_IMAGE;
195
196         lpBand->rcCapImage.right  = lpBand->rcCapImage.left + infoPtr->imageSize.cx;
197         lpBand->rcCapImage.bottom = lpBand->rcCapImage.top + infoPtr->imageSize.cy;
198
199         /* update band width */
200         if (lpBand->uMinHeight < infoPtr->imageSize.cx + 2) {
201             lpBand->uMinHeight = infoPtr->imageSize.cx + 2;
202             lpBand->rcBand.right = lpBand->rcBand.left + lpBand->uMinHeight;
203         }
204     }
205
206     /* set initial caption text rectangle */
207     lpBand->rcCapText.left   = lpBand->rcBand.left + 1;
208     lpBand->rcCapText.top    = lpBand->rcCapImage.bottom;
209     lpBand->rcCapText.right  = lpBand->rcBand.right - 1;
210     lpBand->rcCapText.bottom = lpBand->rcCapText.top;
211
212     /* text is visible */
213     if (lpBand->lpText) {
214         HDC hdc = GetDC (0);
215         HFONT hOldFont = SelectObject (hdc, infoPtr->hFont);
216         SIZE size;
217
218         lpBand->fDraw |= DRAW_TEXT;
219         GetTextExtentPoint32W (hdc, lpBand->lpText,
220                                lstrlenW (lpBand->lpText), &size);
221 /*      lpBand->rcCapText.right += size.cx; */
222         lpBand->rcCapText.bottom += size.cy;
223
224         SelectObject (hdc, hOldFont);
225         ReleaseDC (0, hdc);
226     }
227
228     /* set initial child window rectangle */
229     if (lpBand->fStyle & RBBS_FIXEDSIZE) {
230         lpBand->rcChild.left   = lpBand->rcBand.left;
231         lpBand->rcChild.top    = lpBand->rcCapText.bottom;
232         lpBand->rcChild.right  = lpBand->rcBand.right;
233         lpBand->rcChild.bottom = lpBand->rcBand.bottom;
234     }
235     else {
236         lpBand->rcChild.left   = lpBand->rcBand.left + 2;
237         lpBand->rcChild.top    = lpBand->rcCapText.bottom + 4;
238         lpBand->rcChild.right  = lpBand->rcBand.right - 2;
239         lpBand->rcChild.bottom = lpBand->rcBand.bottom - 4;
240     }
241
242     /* calculate gripper rectangle */
243     if ((!(lpBand->fStyle & RBBS_NOGRIPPER)) &&
244         (!(lpBand->fStyle & RBBS_FIXEDSIZE)) &&
245         ((lpBand->fStyle & RBBS_GRIPPERALWAYS) || 
246          (infoPtr->uNumBands > 1))) {
247         lpBand->fDraw |= DRAW_GRIPPER;
248
249         if (GetWindowLongA (hwnd, GWL_STYLE) & RBS_VERTICALGRIPPER) {
250             /* adjust band width */
251             lpBand->rcBand.right += GRIPPER_WIDTH;
252             lpBand->uMinHeight += GRIPPER_WIDTH;
253
254             lpBand->rcGripper.left   = lpBand->rcBand.left + 3;
255             lpBand->rcGripper.right  = lpBand->rcGripper.left + 3;
256             lpBand->rcGripper.top    = lpBand->rcBand.top + 3;
257             lpBand->rcGripper.bottom = lpBand->rcBand.bottom - 3;
258
259             /* move caption rectangles */
260             OffsetRect (&lpBand->rcCapImage, GRIPPER_WIDTH, 0);
261             OffsetRect (&lpBand->rcCapText, GRIPPER_WIDTH, 0);
262  
263             /* adjust child rectangle */
264             lpBand->rcChild.left += GRIPPER_WIDTH;
265         }
266         else {
267             lpBand->rcGripper.left   = lpBand->rcBand.left + 3;
268             lpBand->rcGripper.right  = lpBand->rcBand.right - 3;
269             lpBand->rcGripper.top    = lpBand->rcBand.top + 3;
270             lpBand->rcGripper.bottom = lpBand->rcGripper.top + 3;
271
272             /* move caption rectangles */
273             OffsetRect (&lpBand->rcCapImage, 0, GRIPPER_WIDTH);
274             OffsetRect (&lpBand->rcCapText, 0, GRIPPER_WIDTH);
275  
276             /* adjust child rectangle */
277             lpBand->rcChild.top += GRIPPER_WIDTH;
278         }
279     }
280 }
281
282
283 static VOID
284 REBAR_Layout (HWND hwnd, LPRECT lpRect)
285 {
286     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
287     DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
288     REBAR_BAND *lpBand;
289     RECT rcClient;
290     INT x, y, cx, cy;
291     UINT i;
292
293     if (lpRect)
294         rcClient = *lpRect;
295     else
296         GetClientRect (hwnd, &rcClient);
297
298     x = 0;
299     y = 0;
300
301     if (dwStyle & CCS_VERT) {
302         cx = 20;    /* FIXME: fixed height */
303         cy = rcClient.bottom - rcClient.top;
304     }
305     else {
306         cx = rcClient.right - rcClient.left;
307         cy = 20;    /* FIXME: fixed height */
308     }
309
310     for (i = 0; i < infoPtr->uNumBands; i++) {
311         lpBand = &infoPtr->bands[i];
312
313         if ((lpBand->fStyle & RBBS_HIDDEN) || 
314             ((dwStyle & CCS_VERT) && (lpBand->fStyle & RBBS_NOVERT)))
315             continue;
316
317
318         if (dwStyle & CCS_VERT) {
319             if (lpBand->fStyle & RBBS_VARIABLEHEIGHT)
320                 cx = lpBand->cyMaxChild;
321             else if (lpBand->fStyle & RBBIM_CHILDSIZE)
322                 cx = lpBand->cyMinChild;
323             else
324                 cx = 20; /* FIXME */
325
326             lpBand->rcBand.left   = x;
327             lpBand->rcBand.right  = x + cx;
328             lpBand->rcBand.top    = y;
329             lpBand->rcBand.bottom = y + cy;
330             lpBand->uMinHeight = cx;
331         }
332         else {
333             if (lpBand->fStyle & RBBS_VARIABLEHEIGHT)
334                 cy = lpBand->cyMaxChild;
335             else if (lpBand->fStyle & RBBIM_CHILDSIZE)
336                 cy = lpBand->cyMinChild;
337             else
338                 cy = 20; /* FIXME */
339
340             lpBand->rcBand.left   = x;
341             lpBand->rcBand.right  = x + cx;
342             lpBand->rcBand.top    = y;
343             lpBand->rcBand.bottom = y + cy;
344             lpBand->uMinHeight = cy;
345         }
346
347         if (dwStyle & CCS_VERT) {
348             REBAR_CalcVertBand (hwnd, infoPtr, lpBand);
349             x += lpBand->uMinHeight;
350         }
351         else {
352             REBAR_CalcHorzBand (infoPtr, lpBand);
353             y += lpBand->uMinHeight;
354         }
355     }
356
357     if (dwStyle & CCS_VERT) {
358         infoPtr->calcSize.cx = x;
359         infoPtr->calcSize.cy = rcClient.bottom - rcClient.top;
360     }
361     else {
362         infoPtr->calcSize.cx = rcClient.right - rcClient.left;
363         infoPtr->calcSize.cy = y;
364     }
365 }
366
367
368 static VOID
369 REBAR_ForceResize (HWND hwnd)
370 {
371     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
372     RECT rc;
373
374     TRACE(" to [%d x %d]!\n",
375            infoPtr->calcSize.cx, infoPtr->calcSize.cy);
376
377     infoPtr->bAutoResize = TRUE;
378
379     rc.left = 0;
380     rc.top = 0;
381     rc.right  = infoPtr->calcSize.cx;
382     rc.bottom = infoPtr->calcSize.cy;
383
384     if (GetWindowLongA (hwnd, GWL_STYLE) & WS_BORDER) {
385         InflateRect (&rc, GetSystemMetrics(SM_CXEDGE), GetSystemMetrics(SM_CYEDGE));
386     }
387
388     SetWindowPos (hwnd, 0, 0, 0,
389                     rc.right - rc.left, rc.bottom - rc.top,
390                     SWP_NOMOVE | SWP_NOZORDER | SWP_SHOWWINDOW);
391 }
392
393
394 static VOID
395 REBAR_MoveChildWindows (HWND hwnd)
396 {
397     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
398     REBAR_BAND *lpBand;
399     CHAR szClassName[40];
400     UINT i;
401
402     for (i = 0; i < infoPtr->uNumBands; i++) {
403         lpBand = &infoPtr->bands[i];
404
405         if (lpBand->fStyle & RBBS_HIDDEN)
406             continue;
407         if (lpBand->hwndChild) {
408             TRACE("hwndChild = %x\n", lpBand->hwndChild);
409
410             GetClassNameA (lpBand->hwndChild, szClassName, 40);
411             if (!lstrcmpA (szClassName, "ComboBox")) {
412                 INT nEditHeight, yPos;
413                 RECT rc;
414
415                 /* special placement code for combo box */
416
417
418                 /* get size of edit line */
419                 GetWindowRect (lpBand->hwndChild, &rc);
420                 nEditHeight = rc.bottom - rc.top;
421                 yPos = (lpBand->rcChild.bottom + lpBand->rcChild.top - nEditHeight)/2;
422
423                 /* center combo box inside child area */
424                 SetWindowPos (lpBand->hwndChild, HWND_TOP,
425                             lpBand->rcChild.left, /*lpBand->rcChild.top*/ yPos,
426                             lpBand->rcChild.right - lpBand->rcChild.left,
427                             nEditHeight,
428                             SWP_SHOWWINDOW);
429             }
430 #if 0
431             else if (!lstrcmpA (szClassName, WC_COMBOBOXEXA)) {
432                 INT nEditHeight, yPos;
433                 RECT rc;
434                 HWND hwndEdit;
435
436                 /* special placement code for extended combo box */
437
438                 /* get size of edit line */
439                 hwndEdit = SendMessageA (lpBand->hwndChild, CBEM_GETEDITCONTROL, 0, 0);
440                 GetWindowRect (hwndEdit, &rc);
441                 nEditHeight = rc.bottom - rc.top;
442                 yPos = (lpBand->rcChild.bottom + lpBand->rcChild.top - nEditHeight)/2;
443
444                 /* center combo box inside child area */
445                 SetWindowPos (lpBand->hwndChild, HWND_TOP,
446                             lpBand->rcChild.left, /*lpBand->rcChild.top*/ yPos,
447                             lpBand->rcChild.right - lpBand->rcChild.left,
448                             nEditHeight,
449                             SWP_SHOWWINDOW);
450
451             }
452 #endif
453             else {
454                 SetWindowPos (lpBand->hwndChild, HWND_TOP,
455                             lpBand->rcChild.left, lpBand->rcChild.top,
456                             lpBand->rcChild.right - lpBand->rcChild.left,
457                             lpBand->rcChild.bottom - lpBand->rcChild.top,
458                             SWP_SHOWWINDOW);
459             }
460         }
461     }
462 }
463
464
465 static void
466 REBAR_InternalHitTest (HWND hwnd, LPPOINT lpPt, UINT *pFlags, INT *pBand)
467 {
468     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
469     REBAR_BAND *lpBand;
470     RECT rect;
471     INT  iCount;
472
473     GetClientRect (hwnd, &rect);
474
475     *pFlags = RBHT_NOWHERE;
476     if (PtInRect (&rect, *lpPt))
477     {
478         if (infoPtr->uNumBands == 0) {
479             *pFlags = RBHT_NOWHERE;
480             if (pBand)
481                 *pBand = -1;
482             TRACE("NOWHERE\n");
483             return;
484         }
485         else {
486             /* somewhere inside */
487             for (iCount = 0; iCount < infoPtr->uNumBands; iCount++) {
488                 lpBand = &infoPtr->bands[iCount];
489                 if (PtInRect (&lpBand->rcBand, *lpPt)) {
490                     if (pBand)
491                         *pBand = iCount;
492                     if (PtInRect (&lpBand->rcGripper, *lpPt)) {
493                         *pFlags = RBHT_GRABBER;
494                         TRACE("ON GRABBER %d\n", iCount);
495                         return;
496                     }
497                     else if (PtInRect (&lpBand->rcCapImage, *lpPt)) {
498                         *pFlags = RBHT_CAPTION;
499                         TRACE("ON CAPTION %d\n", iCount);
500                         return;
501                     }
502                     else if (PtInRect (&lpBand->rcCapText, *lpPt)) {
503                         *pFlags = RBHT_CAPTION;
504                         TRACE("ON CAPTION %d\n", iCount);
505                         return;
506                     }
507                     else if (PtInRect (&lpBand->rcChild, *lpPt)) {
508                         *pFlags = RBHT_CLIENT;
509                         TRACE("ON CLIENT %d\n", iCount);
510                         return;
511                     }
512                     else {
513                         *pFlags = RBHT_NOWHERE;
514                         TRACE("NOWHERE %d\n", iCount);
515                         return;
516                     }
517                 }
518             }
519
520             *pFlags = RBHT_NOWHERE;
521             if (pBand)
522                 *pBand = -1;
523
524             TRACE("NOWHERE\n");
525             return;
526         }
527     }
528     else {
529         *pFlags = RBHT_NOWHERE;
530         if (pBand)
531             *pBand = -1;
532         TRACE("NOWHERE\n");
533         return;
534     }
535
536     TRACE("flags=0x%X\n", *pFlags);
537     return;
538 }
539
540
541
542 /* << REBAR_BeginDrag >> */
543
544
545 static LRESULT
546 REBAR_DeleteBand (HWND hwnd, WPARAM wParam, LPARAM lParam)
547 {
548     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
549     UINT uBand = (UINT)wParam;
550
551     if (uBand >= infoPtr->uNumBands)
552         return FALSE;
553
554     TRACE("deleting band %u!\n", uBand);
555
556     if (infoPtr->uNumBands == 1) {
557         TRACE(" simple delete!\n");
558         COMCTL32_Free (infoPtr->bands);
559         infoPtr->bands = NULL;
560         infoPtr->uNumBands = 0;
561     }
562     else {
563         REBAR_BAND *oldBands = infoPtr->bands;
564         TRACE("complex delete! [uBand=%u]\n", uBand);
565
566         infoPtr->uNumBands--;
567         infoPtr->bands = COMCTL32_Alloc (sizeof (REBAR_BAND) * infoPtr->uNumBands);
568         if (uBand > 0) {
569             memcpy (&infoPtr->bands[0], &oldBands[0],
570                     uBand * sizeof(REBAR_BAND));
571         }
572
573         if (uBand < infoPtr->uNumBands) {
574             memcpy (&infoPtr->bands[uBand], &oldBands[uBand+1],
575                     (infoPtr->uNumBands - uBand) * sizeof(REBAR_BAND));
576         }
577
578         COMCTL32_Free (oldBands);
579     }
580
581     REBAR_Layout (hwnd, NULL);
582     REBAR_ForceResize (hwnd);
583     REBAR_MoveChildWindows (hwnd);
584
585     return TRUE;
586 }
587
588
589 /* << REBAR_DragMove >> */
590 /* << REBAR_EndDrag >> */
591
592
593 static LRESULT
594 REBAR_GetBandBorders (HWND hwnd, WPARAM wParam, LPARAM lParam)
595 {
596     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
597     /* LPRECT32 lpRect = (LPRECT32)lParam; */
598     REBAR_BAND *lpBand;
599
600     if (!lParam)
601         return 0;
602     if ((UINT)wParam >= infoPtr->uNumBands)
603         return 0;
604
605     lpBand = &infoPtr->bands[(UINT)wParam];
606     if (GetWindowLongA (hwnd, GWL_STYLE) & RBS_BANDBORDERS) {
607
608     }
609     else {
610
611     }
612
613     return 0;
614 }
615
616
617 inline static LRESULT
618 REBAR_GetBandCount (HWND hwnd)
619 {
620     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
621
622     TRACE("band count %u!\n", infoPtr->uNumBands);
623
624     return infoPtr->uNumBands;
625 }
626
627
628 static LRESULT
629 REBAR_GetBandInfoA (HWND hwnd, WPARAM wParam, LPARAM lParam)
630 {
631     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
632     LPREBARBANDINFOA lprbbi = (LPREBARBANDINFOA)lParam;
633     REBAR_BAND *lpBand;
634
635     if (lprbbi == NULL)
636         return FALSE;
637     if (lprbbi->cbSize < REBARBANDINFO_V3_SIZEA)
638         return FALSE;
639     if ((UINT)wParam >= infoPtr->uNumBands)
640         return FALSE;
641
642     TRACE("index %u\n", (UINT)wParam);
643
644     /* copy band information */
645     lpBand = &infoPtr->bands[(UINT)wParam];
646
647     if (lprbbi->fMask & RBBIM_STYLE)
648         lprbbi->fStyle = lpBand->fStyle;
649
650     if (lprbbi->fMask & RBBIM_COLORS) {
651         lprbbi->clrFore = lpBand->clrFore;
652         lprbbi->clrBack = lpBand->clrBack;
653     }
654
655     if ((lprbbi->fMask & RBBIM_TEXT) && 
656         (lprbbi->lpText) && (lpBand->lpText)) {
657             lstrcpynWtoA (lprbbi->lpText, lpBand->lpText, lprbbi->cch);
658     }
659
660     if (lprbbi->fMask & RBBIM_IMAGE)
661         lprbbi->iImage = lpBand->iImage;
662
663     if (lprbbi->fMask & RBBIM_CHILD)
664         lprbbi->hwndChild = lpBand->hwndChild;
665
666     if (lprbbi->fMask & RBBIM_CHILDSIZE) {
667         lprbbi->cxMinChild = lpBand->cxMinChild;
668         lprbbi->cyMinChild = lpBand->cyMinChild;
669         lprbbi->cyMaxChild = lpBand->cyMaxChild;
670         lprbbi->cyChild    = lpBand->cyChild;
671         lprbbi->cyIntegral = lpBand->cyIntegral;
672     }
673
674     if (lprbbi->fMask & RBBIM_SIZE)
675         lprbbi->cx = lpBand->cx;
676
677     if (lprbbi->fMask & RBBIM_BACKGROUND)
678         lprbbi->hbmBack = lpBand->hbmBack;
679
680     if (lprbbi->fMask & RBBIM_ID)
681         lprbbi->wID = lpBand->wID;
682
683     /* check for additional data */
684     if (lprbbi->cbSize >= sizeof (REBARBANDINFOA)) {
685         if (lprbbi->fMask & RBBIM_IDEALSIZE)
686             lprbbi->cxIdeal = lpBand->cxIdeal;
687
688         if (lprbbi->fMask & RBBIM_LPARAM)
689             lprbbi->lParam = lpBand->lParam;
690
691         if (lprbbi->fMask & RBBIM_HEADERSIZE)
692             lprbbi->cxHeader = lpBand->cxHeader;
693     }
694
695     return TRUE;
696 }
697
698
699 static LRESULT
700 REBAR_GetBandInfoW (HWND hwnd, WPARAM wParam, LPARAM lParam)
701 {
702     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
703     LPREBARBANDINFOW lprbbi = (LPREBARBANDINFOW)lParam;
704     REBAR_BAND *lpBand;
705
706     if (lprbbi == NULL)
707         return FALSE;
708     if (lprbbi->cbSize < REBARBANDINFO_V3_SIZEW)
709         return FALSE;
710     if ((UINT)wParam >= infoPtr->uNumBands)
711         return FALSE;
712
713     TRACE("index %u\n", (UINT)wParam);
714
715     /* copy band information */
716     lpBand = &infoPtr->bands[(UINT)wParam];
717
718     if (lprbbi->fMask & RBBIM_STYLE)
719         lprbbi->fStyle = lpBand->fStyle;
720
721     if (lprbbi->fMask & RBBIM_COLORS) {
722         lprbbi->clrFore = lpBand->clrFore;
723         lprbbi->clrBack = lpBand->clrBack;
724     }
725
726     if ((lprbbi->fMask & RBBIM_TEXT) && 
727         (lprbbi->lpText) && (lpBand->lpText)) {
728             lstrcpynW (lprbbi->lpText, lpBand->lpText, lprbbi->cch);
729     }
730
731     if (lprbbi->fMask & RBBIM_IMAGE)
732         lprbbi->iImage = lpBand->iImage;
733
734     if (lprbbi->fMask & RBBIM_CHILD)
735         lprbbi->hwndChild = lpBand->hwndChild;
736
737     if (lprbbi->fMask & RBBIM_CHILDSIZE) {
738         lprbbi->cxMinChild = lpBand->cxMinChild;
739         lprbbi->cyMinChild = lpBand->cyMinChild;
740         lprbbi->cyMaxChild = lpBand->cyMaxChild;
741         lprbbi->cyChild    = lpBand->cyChild;
742         lprbbi->cyIntegral = lpBand->cyIntegral;
743     }
744
745     if (lprbbi->fMask & RBBIM_SIZE)
746         lprbbi->cx = lpBand->cx;
747
748     if (lprbbi->fMask & RBBIM_BACKGROUND)
749         lprbbi->hbmBack = lpBand->hbmBack;
750
751     if (lprbbi->fMask & RBBIM_ID)
752         lprbbi->wID = lpBand->wID;
753
754     /* check for additional data */
755     if (lprbbi->cbSize >= sizeof (REBARBANDINFOA)) {
756         if (lprbbi->fMask & RBBIM_IDEALSIZE)
757             lprbbi->cxIdeal = lpBand->cxIdeal;
758
759         if (lprbbi->fMask & RBBIM_LPARAM)
760             lprbbi->lParam = lpBand->lParam;
761
762         if (lprbbi->fMask & RBBIM_HEADERSIZE)
763             lprbbi->cxHeader = lpBand->cxHeader;
764     }
765
766     return TRUE;
767 }
768
769
770 static LRESULT
771 REBAR_GetBarHeight (HWND hwnd, WPARAM wParam, LPARAM lParam)
772 {
773     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
774     INT nHeight;
775
776     REBAR_Layout (hwnd, NULL);
777     nHeight = infoPtr->calcSize.cy;
778
779     if (GetWindowLongA (hwnd, GWL_STYLE) & WS_BORDER)
780         nHeight += (2 * GetSystemMetrics(SM_CYEDGE));
781
782
783     FIXME("height = %d\n", nHeight);
784
785     return nHeight;
786 }
787
788
789 static LRESULT
790 REBAR_GetBarInfo (HWND hwnd, WPARAM wParam, LPARAM lParam)
791 {
792     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
793     LPREBARINFO lpInfo = (LPREBARINFO)lParam;
794
795     if (lpInfo == NULL)
796         return FALSE;
797
798     if (lpInfo->cbSize < sizeof (REBARINFO))
799         return FALSE;
800
801     TRACE("getting bar info!\n");
802
803     if (infoPtr->himl) {
804         lpInfo->himl = infoPtr->himl;
805         lpInfo->fMask |= RBIM_IMAGELIST;
806     }
807
808     return TRUE;
809 }
810
811
812 inline static LRESULT
813 REBAR_GetBkColor (HWND hwnd)
814 {
815     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
816
817     TRACE("background color 0x%06lx!\n", infoPtr->clrBk);
818
819     return infoPtr->clrBk;
820 }
821
822
823 /* << REBAR_GetColorScheme >> */
824 /* << REBAR_GetDropTarget >> */
825
826
827 static LRESULT
828 REBAR_GetPalette (HWND hwnd, WPARAM wParam, LPARAM lParam)
829 {
830     FIXME("empty stub!\n");
831
832     return 0;
833 }
834
835
836 static LRESULT
837 REBAR_GetRect (HWND hwnd, WPARAM wParam, LPARAM lParam)
838 {
839     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
840     INT iBand = (INT)wParam;
841     LPRECT lprc = (LPRECT)lParam;
842     REBAR_BAND *lpBand;
843
844     if ((iBand < 0) && ((UINT)iBand >= infoPtr->uNumBands))
845         return FALSE;
846     if (!lprc)
847         return FALSE;
848
849     TRACE("band %d\n", iBand);
850
851     lpBand = &infoPtr->bands[iBand];
852     CopyRect (lprc, &lpBand->rcBand);
853 /*
854     lprc->left   = lpBand->rcBand.left;
855     lprc->top    = lpBand->rcBand.top;
856     lprc->right  = lpBand->rcBand.right;
857     lprc->bottom = lpBand->rcBand.bottom;
858 */
859
860     return TRUE;
861 }
862
863
864 inline static LRESULT
865 REBAR_GetRowCount (HWND hwnd)
866 {
867     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
868
869     FIXME("%u : semi stub!\n", infoPtr->uNumBands);
870
871     return infoPtr->uNumBands;
872 }
873
874
875 static LRESULT
876 REBAR_GetRowHeight (HWND hwnd, WPARAM wParam, LPARAM lParam)
877 {
878 /*    REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd); */
879
880     FIXME("-- height = 20: semi stub!\n");
881
882     return 20;
883 }
884
885
886 inline static LRESULT
887 REBAR_GetTextColor (HWND hwnd)
888 {
889     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
890
891     TRACE("text color 0x%06lx!\n", infoPtr->clrText);
892
893     return infoPtr->clrText;
894 }
895
896
897 inline static LRESULT
898 REBAR_GetToolTips (HWND hwnd)
899 {
900     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
901     return infoPtr->hwndToolTip;
902 }
903
904
905 inline static LRESULT
906 REBAR_GetUnicodeFormat (HWND hwnd)
907 {
908     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
909     return infoPtr->bUnicode;
910 }
911
912
913 inline static LRESULT
914 REBAR_GetVersion (HWND hwnd)
915 {
916     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
917     return infoPtr->iVersion;
918 }
919
920
921 static LRESULT
922 REBAR_HitTest (HWND hwnd, WPARAM wParam, LPARAM lParam)
923 {
924     /* REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd); */
925     LPRBHITTESTINFO lprbht = (LPRBHITTESTINFO)lParam; 
926
927     if (!lprbht)
928         return -1;
929
930     REBAR_InternalHitTest (hwnd, &lprbht->pt, &lprbht->flags, &lprbht->iBand);
931
932     return lprbht->iBand;
933 }
934
935
936 static LRESULT
937 REBAR_IdToIndex (HWND hwnd, WPARAM wParam, LPARAM lParam)
938 {
939     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
940     UINT i;
941
942     if (infoPtr == NULL)
943         return -1;
944
945     if (infoPtr->uNumBands < 1)
946         return -1;
947
948     TRACE("id %u\n", (UINT)wParam);
949
950     for (i = 0; i < infoPtr->uNumBands; i++) {
951         if (infoPtr->bands[i].wID == (UINT)wParam) {
952             TRACE("band %u found!\n", i);
953             return i;
954         }
955     }
956
957     TRACE("no band found!\n");
958     return -1;
959 }
960
961
962 static LRESULT
963 REBAR_InsertBandA (HWND hwnd, WPARAM wParam, LPARAM lParam)
964 {
965     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
966     LPREBARBANDINFOA lprbbi = (LPREBARBANDINFOA)lParam;
967     UINT uIndex = (UINT)wParam;
968     REBAR_BAND *lpBand;
969
970     if (infoPtr == NULL)
971         return FALSE;
972     if (lprbbi == NULL)
973         return FALSE;
974     if (lprbbi->cbSize < REBARBANDINFO_V3_SIZEA)
975         return FALSE;
976
977     TRACE("insert band at %u!\n", uIndex);
978
979     if (infoPtr->uNumBands == 0) {
980         infoPtr->bands = (REBAR_BAND *)COMCTL32_Alloc (sizeof (REBAR_BAND));
981         uIndex = 0;
982     }
983     else {
984         REBAR_BAND *oldBands = infoPtr->bands;
985         infoPtr->bands =
986             (REBAR_BAND *)COMCTL32_Alloc ((infoPtr->uNumBands+1)*sizeof(REBAR_BAND));
987         if (((INT)uIndex == -1) || (uIndex > infoPtr->uNumBands))
988             uIndex = infoPtr->uNumBands;
989
990         /* pre insert copy */
991         if (uIndex > 0) {
992             memcpy (&infoPtr->bands[0], &oldBands[0],
993                     uIndex * sizeof(REBAR_BAND));
994         }
995
996         /* post copy */
997         if (uIndex < infoPtr->uNumBands - 1) {
998             memcpy (&infoPtr->bands[uIndex+1], &oldBands[uIndex],
999                     (infoPtr->uNumBands - uIndex - 1) * sizeof(REBAR_BAND));
1000         }
1001
1002         COMCTL32_Free (oldBands);
1003     }
1004
1005     infoPtr->uNumBands++;
1006
1007     TRACE("index %u!\n", uIndex);
1008
1009     /* initialize band (infoPtr->bands[uIndex])*/
1010     lpBand = &infoPtr->bands[uIndex];
1011
1012     if (lprbbi->fMask & RBBIM_STYLE)
1013         lpBand->fStyle = lprbbi->fStyle;
1014
1015     if (lprbbi->fMask & RBBIM_COLORS) {
1016         lpBand->clrFore = lprbbi->clrFore;
1017         lpBand->clrBack = lprbbi->clrBack;
1018     }
1019     else {
1020         lpBand->clrFore = CLR_NONE;
1021         lpBand->clrBack = CLR_NONE;
1022     }
1023
1024     if ((lprbbi->fMask & RBBIM_TEXT) && (lprbbi->lpText)) {
1025         INT len = lstrlenA (lprbbi->lpText);
1026         if (len > 0) {
1027             lpBand->lpText = (LPWSTR)COMCTL32_Alloc ((len + 1)*sizeof(WCHAR));
1028             lstrcpyAtoW (lpBand->lpText, lprbbi->lpText);
1029         }
1030     }
1031
1032     if (lprbbi->fMask & RBBIM_IMAGE)
1033         lpBand->iImage = lprbbi->iImage;
1034     else
1035         lpBand->iImage = -1;
1036
1037     if (lprbbi->fMask & RBBIM_CHILD) {
1038         TRACE("hwndChild = %x\n", lprbbi->hwndChild);
1039         lpBand->hwndChild = lprbbi->hwndChild;
1040         lpBand->hwndPrevParent =
1041             SetParent (lpBand->hwndChild, hwnd);
1042     }
1043
1044     if (lprbbi->fMask & RBBIM_CHILDSIZE) {
1045         lpBand->cxMinChild = lprbbi->cxMinChild;
1046         lpBand->cyMinChild = lprbbi->cyMinChild;
1047         lpBand->cyMaxChild = lprbbi->cyMaxChild;
1048         lpBand->cyChild    = lprbbi->cyChild;
1049         lpBand->cyIntegral = lprbbi->cyIntegral;
1050     }
1051     else {
1052         lpBand->cxMinChild = -1;
1053         lpBand->cyMinChild = -1;
1054         lpBand->cyMaxChild = -1;
1055         lpBand->cyChild    = -1;
1056         lpBand->cyIntegral = -1;
1057     }
1058
1059     if (lprbbi->fMask & RBBIM_SIZE)
1060         lpBand->cx = lprbbi->cx;
1061     else
1062         lpBand->cx = -1;
1063
1064     if (lprbbi->fMask & RBBIM_BACKGROUND)
1065         lpBand->hbmBack = lprbbi->hbmBack;
1066
1067     if (lprbbi->fMask & RBBIM_ID)
1068         lpBand->wID = lprbbi->wID;
1069
1070     /* check for additional data */
1071     if (lprbbi->cbSize >= sizeof (REBARBANDINFOA)) {
1072         if (lprbbi->fMask & RBBIM_IDEALSIZE)
1073             lpBand->cxIdeal = lprbbi->cxIdeal;
1074
1075         if (lprbbi->fMask & RBBIM_LPARAM)
1076             lpBand->lParam = lprbbi->lParam;
1077
1078         if (lprbbi->fMask & RBBIM_HEADERSIZE)
1079             lpBand->cxHeader = lprbbi->cxHeader;
1080     }
1081
1082
1083     REBAR_Layout (hwnd, NULL);
1084     REBAR_ForceResize (hwnd);
1085     REBAR_MoveChildWindows (hwnd);
1086
1087     return TRUE;
1088 }
1089
1090
1091 static LRESULT
1092 REBAR_InsertBandW (HWND hwnd, WPARAM wParam, LPARAM lParam)
1093 {
1094     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
1095     LPREBARBANDINFOW lprbbi = (LPREBARBANDINFOW)lParam;
1096     UINT uIndex = (UINT)wParam;
1097     REBAR_BAND *lpBand;
1098
1099     if (infoPtr == NULL)
1100         return FALSE;
1101     if (lprbbi == NULL)
1102         return FALSE;
1103     if (lprbbi->cbSize < REBARBANDINFO_V3_SIZEW)
1104         return FALSE;
1105
1106     TRACE("insert band at %u!\n", uIndex);
1107
1108     if (infoPtr->uNumBands == 0) {
1109         infoPtr->bands = (REBAR_BAND *)COMCTL32_Alloc (sizeof (REBAR_BAND));
1110         uIndex = 0;
1111     }
1112     else {
1113         REBAR_BAND *oldBands = infoPtr->bands;
1114         infoPtr->bands =
1115             (REBAR_BAND *)COMCTL32_Alloc ((infoPtr->uNumBands+1)*sizeof(REBAR_BAND));
1116         if (((INT)uIndex == -1) || (uIndex > infoPtr->uNumBands))
1117             uIndex = infoPtr->uNumBands;
1118
1119         /* pre insert copy */
1120         if (uIndex > 0) {
1121             memcpy (&infoPtr->bands[0], &oldBands[0],
1122                     uIndex * sizeof(REBAR_BAND));
1123         }
1124
1125         /* post copy */
1126         if (uIndex < infoPtr->uNumBands - 1) {
1127             memcpy (&infoPtr->bands[uIndex+1], &oldBands[uIndex],
1128                     (infoPtr->uNumBands - uIndex - 1) * sizeof(REBAR_BAND));
1129         }
1130
1131         COMCTL32_Free (oldBands);
1132     }
1133
1134     infoPtr->uNumBands++;
1135
1136     TRACE("index %u!\n", uIndex);
1137
1138     /* initialize band (infoPtr->bands[uIndex])*/
1139     lpBand = &infoPtr->bands[uIndex];
1140
1141     if (lprbbi->fMask & RBBIM_STYLE)
1142         lpBand->fStyle = lprbbi->fStyle;
1143
1144     if (lprbbi->fMask & RBBIM_COLORS) {
1145         lpBand->clrFore = lprbbi->clrFore;
1146         lpBand->clrBack = lprbbi->clrBack;
1147     }
1148     else {
1149         lpBand->clrFore = CLR_NONE;
1150         lpBand->clrBack = CLR_NONE;
1151     }
1152
1153     if ((lprbbi->fMask & RBBIM_TEXT) && (lprbbi->lpText)) {
1154         INT len = lstrlenW (lprbbi->lpText);
1155         if (len > 0) {
1156             lpBand->lpText = (LPWSTR)COMCTL32_Alloc ((len + 1)*sizeof(WCHAR));
1157             lstrcpyW (lpBand->lpText, lprbbi->lpText);
1158         }
1159     }
1160
1161     if (lprbbi->fMask & RBBIM_IMAGE)
1162         lpBand->iImage = lprbbi->iImage;
1163     else
1164         lpBand->iImage = -1;
1165
1166     if (lprbbi->fMask & RBBIM_CHILD) {
1167         TRACE("hwndChild = %x\n", lprbbi->hwndChild);
1168         lpBand->hwndChild = lprbbi->hwndChild;
1169         lpBand->hwndPrevParent =
1170             SetParent (lpBand->hwndChild, hwnd);
1171     }
1172
1173     if (lprbbi->fMask & RBBIM_CHILDSIZE) {
1174         lpBand->cxMinChild = lprbbi->cxMinChild;
1175         lpBand->cyMinChild = lprbbi->cyMinChild;
1176         lpBand->cyMaxChild = lprbbi->cyMaxChild;
1177         lpBand->cyChild    = lprbbi->cyChild;
1178         lpBand->cyIntegral = lprbbi->cyIntegral;
1179     }
1180     else {
1181         lpBand->cxMinChild = -1;
1182         lpBand->cyMinChild = -1;
1183         lpBand->cyMaxChild = -1;
1184         lpBand->cyChild    = -1;
1185         lpBand->cyIntegral = -1;
1186     }
1187
1188     if (lprbbi->fMask & RBBIM_SIZE)
1189         lpBand->cx = lprbbi->cx;
1190     else
1191         lpBand->cx = -1;
1192
1193     if (lprbbi->fMask & RBBIM_BACKGROUND)
1194         lpBand->hbmBack = lprbbi->hbmBack;
1195
1196     if (lprbbi->fMask & RBBIM_ID)
1197         lpBand->wID = lprbbi->wID;
1198
1199     /* check for additional data */
1200     if (lprbbi->cbSize >= sizeof (REBARBANDINFOW)) {
1201         if (lprbbi->fMask & RBBIM_IDEALSIZE)
1202             lpBand->cxIdeal = lprbbi->cxIdeal;
1203
1204         if (lprbbi->fMask & RBBIM_LPARAM)
1205             lpBand->lParam = lprbbi->lParam;
1206
1207         if (lprbbi->fMask & RBBIM_HEADERSIZE)
1208             lpBand->cxHeader = lprbbi->cxHeader;
1209     }
1210
1211
1212     REBAR_Layout (hwnd, NULL);
1213     REBAR_ForceResize (hwnd);
1214     REBAR_MoveChildWindows (hwnd);
1215
1216     return TRUE;
1217 }
1218
1219
1220 static LRESULT
1221 REBAR_MaximizeBand (HWND hwnd, WPARAM wParam, LPARAM lParam)
1222 {
1223 /*    REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd); */
1224
1225     FIXME("(uBand = %u fIdeal = %s)\n",
1226            (UINT)wParam, lParam ? "TRUE" : "FALSE");
1227
1228  
1229     return 0;
1230 }
1231
1232
1233 static LRESULT
1234 REBAR_MinimizeBand (HWND hwnd, WPARAM wParam, LPARAM lParam)
1235 {
1236 /*    REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd); */
1237
1238     FIXME("(uBand = %u)\n", (UINT)wParam);
1239
1240  
1241     return 0;
1242 }
1243
1244
1245 static LRESULT
1246 REBAR_MoveBand (HWND hwnd, WPARAM wParam, LPARAM lParam)
1247 {
1248 /*    REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd); */
1249
1250     FIXME("(iFrom = %u iTof = %u)\n",
1251            (UINT)wParam, (UINT)lParam);
1252
1253  
1254     return FALSE;
1255 }
1256
1257
1258 static LRESULT
1259 REBAR_SetBandInfoA (HWND hwnd, WPARAM wParam, LPARAM lParam)
1260 {
1261     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
1262     LPREBARBANDINFOA lprbbi = (LPREBARBANDINFOA)lParam;
1263     REBAR_BAND *lpBand;
1264
1265     if (lprbbi == NULL)
1266         return FALSE;
1267     if (lprbbi->cbSize < REBARBANDINFO_V3_SIZEA)
1268         return FALSE;
1269     if ((UINT)wParam >= infoPtr->uNumBands)
1270         return FALSE;
1271
1272     TRACE("index %u\n", (UINT)wParam);
1273
1274     /* set band information */
1275     lpBand = &infoPtr->bands[(UINT)wParam];
1276
1277     if (lprbbi->fMask & RBBIM_STYLE)
1278         lpBand->fStyle = lprbbi->fStyle;
1279
1280     if (lprbbi->fMask & RBBIM_COLORS) {
1281         lpBand->clrFore = lprbbi->clrFore;
1282         lpBand->clrBack = lprbbi->clrBack;
1283     }
1284
1285     if (lprbbi->fMask & RBBIM_TEXT) {
1286         if (lpBand->lpText) {
1287             COMCTL32_Free (lpBand->lpText);
1288             lpBand->lpText = NULL;
1289         }
1290         if (lprbbi->lpText) {
1291             INT len = lstrlenA (lprbbi->lpText);
1292             lpBand->lpText = (LPWSTR)COMCTL32_Alloc ((len + 1)*sizeof(WCHAR));
1293             lstrcpyAtoW (lpBand->lpText, lprbbi->lpText);
1294         }
1295     }
1296
1297     if (lprbbi->fMask & RBBIM_IMAGE)
1298         lpBand->iImage = lprbbi->iImage;
1299
1300     if (lprbbi->fMask & RBBIM_CHILD) {
1301         if (lprbbi->hwndChild) {
1302             lpBand->hwndChild = lprbbi->hwndChild;
1303             lpBand->hwndPrevParent =
1304                 SetParent (lpBand->hwndChild, hwnd);
1305         }
1306         else {
1307             TRACE("child: 0x%x  prev parent: 0x%x\n",
1308                    lpBand->hwndChild, lpBand->hwndPrevParent);
1309             lpBand->hwndChild = 0;
1310             lpBand->hwndPrevParent = 0;
1311         }
1312     }
1313
1314     if (lprbbi->fMask & RBBIM_CHILDSIZE) {
1315         lpBand->cxMinChild = lprbbi->cxMinChild;
1316         lpBand->cyMinChild = lprbbi->cyMinChild;
1317         lpBand->cyMaxChild = lprbbi->cyMaxChild;
1318         lpBand->cyChild    = lprbbi->cyChild;
1319         lpBand->cyIntegral = lprbbi->cyIntegral;
1320     }
1321
1322     if (lprbbi->fMask & RBBIM_SIZE)
1323         lpBand->cx = lprbbi->cx;
1324
1325     if (lprbbi->fMask & RBBIM_BACKGROUND)
1326         lpBand->hbmBack = lprbbi->hbmBack;
1327
1328     if (lprbbi->fMask & RBBIM_ID)
1329         lpBand->wID = lprbbi->wID;
1330
1331     /* check for additional data */
1332     if (lprbbi->cbSize >= sizeof (REBARBANDINFOA)) {
1333         if (lprbbi->fMask & RBBIM_IDEALSIZE)
1334             lpBand->cxIdeal = lprbbi->cxIdeal;
1335
1336         if (lprbbi->fMask & RBBIM_LPARAM)
1337             lpBand->lParam = lprbbi->lParam;
1338
1339         if (lprbbi->fMask & RBBIM_HEADERSIZE)
1340             lpBand->cxHeader = lprbbi->cxHeader;
1341     }
1342
1343     REBAR_Layout (hwnd, NULL);
1344     REBAR_ForceResize (hwnd);
1345     REBAR_MoveChildWindows (hwnd);
1346
1347     return TRUE;
1348 }
1349
1350
1351 static LRESULT
1352 REBAR_SetBandInfoW (HWND hwnd, WPARAM wParam, LPARAM lParam)
1353 {
1354     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
1355     LPREBARBANDINFOW lprbbi = (LPREBARBANDINFOW)lParam;
1356     REBAR_BAND *lpBand;
1357
1358     if (lprbbi == NULL)
1359         return FALSE;
1360     if (lprbbi->cbSize < REBARBANDINFO_V3_SIZEW)
1361         return FALSE;
1362     if ((UINT)wParam >= infoPtr->uNumBands)
1363         return FALSE;
1364
1365     TRACE("index %u\n", (UINT)wParam);
1366
1367     /* set band information */
1368     lpBand = &infoPtr->bands[(UINT)wParam];
1369
1370     if (lprbbi->fMask & RBBIM_STYLE)
1371         lpBand->fStyle = lprbbi->fStyle;
1372
1373     if (lprbbi->fMask & RBBIM_COLORS) {
1374         lpBand->clrFore = lprbbi->clrFore;
1375         lpBand->clrBack = lprbbi->clrBack;
1376     }
1377
1378     if (lprbbi->fMask & RBBIM_TEXT) {
1379         if (lpBand->lpText) {
1380             COMCTL32_Free (lpBand->lpText);
1381             lpBand->lpText = NULL;
1382         }
1383         if (lprbbi->lpText) {
1384             INT len = lstrlenW (lprbbi->lpText);
1385             lpBand->lpText = (LPWSTR)COMCTL32_Alloc ((len + 1)*sizeof(WCHAR));
1386             lstrcpyW (lpBand->lpText, lprbbi->lpText);
1387         }
1388     }
1389
1390     if (lprbbi->fMask & RBBIM_IMAGE)
1391         lpBand->iImage = lprbbi->iImage;
1392
1393     if (lprbbi->fMask & RBBIM_CHILD) {
1394         if (lprbbi->hwndChild) {
1395             lpBand->hwndChild = lprbbi->hwndChild;
1396             lpBand->hwndPrevParent =
1397                 SetParent (lpBand->hwndChild, hwnd);
1398         }
1399         else {
1400             TRACE("child: 0x%x  prev parent: 0x%x\n",
1401                    lpBand->hwndChild, lpBand->hwndPrevParent);
1402             lpBand->hwndChild = 0;
1403             lpBand->hwndPrevParent = 0;
1404         }
1405     }
1406
1407     if (lprbbi->fMask & RBBIM_CHILDSIZE) {
1408         lpBand->cxMinChild = lprbbi->cxMinChild;
1409         lpBand->cyMinChild = lprbbi->cyMinChild;
1410         lpBand->cyMaxChild = lprbbi->cyMaxChild;
1411         lpBand->cyChild    = lprbbi->cyChild;
1412         lpBand->cyIntegral = lprbbi->cyIntegral;
1413     }
1414
1415     if (lprbbi->fMask & RBBIM_SIZE)
1416         lpBand->cx = lprbbi->cx;
1417
1418     if (lprbbi->fMask & RBBIM_BACKGROUND)
1419         lpBand->hbmBack = lprbbi->hbmBack;
1420
1421     if (lprbbi->fMask & RBBIM_ID)
1422         lpBand->wID = lprbbi->wID;
1423
1424     /* check for additional data */
1425     if (lprbbi->cbSize >= sizeof (REBARBANDINFOW)) {
1426         if (lprbbi->fMask & RBBIM_IDEALSIZE)
1427             lpBand->cxIdeal = lprbbi->cxIdeal;
1428
1429         if (lprbbi->fMask & RBBIM_LPARAM)
1430             lpBand->lParam = lprbbi->lParam;
1431
1432         if (lprbbi->fMask & RBBIM_HEADERSIZE)
1433             lpBand->cxHeader = lprbbi->cxHeader;
1434     }
1435
1436     REBAR_Layout (hwnd, NULL);
1437     REBAR_ForceResize (hwnd);
1438     REBAR_MoveChildWindows (hwnd);
1439
1440     return TRUE;
1441 }
1442
1443
1444 static LRESULT
1445 REBAR_SetBarInfo (HWND hwnd, WPARAM wParam, LPARAM lParam)
1446 {
1447     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
1448     LPREBARINFO lpInfo = (LPREBARINFO)lParam;
1449
1450     if (lpInfo == NULL)
1451         return FALSE;
1452
1453     if (lpInfo->cbSize < sizeof (REBARINFO))
1454         return FALSE;
1455
1456     TRACE("setting bar info!\n");
1457
1458     if (lpInfo->fMask & RBIM_IMAGELIST) {
1459         infoPtr->himl = lpInfo->himl;
1460         if (infoPtr->himl) {
1461             ImageList_GetIconSize (infoPtr->himl, &infoPtr->imageSize.cx,
1462                                    &infoPtr->imageSize.cy);
1463         }
1464         else {
1465             infoPtr->imageSize.cx = 0;
1466             infoPtr->imageSize.cy = 0;
1467         }
1468     }
1469
1470     return TRUE;
1471 }
1472
1473
1474 static LRESULT
1475 REBAR_SetBkColor (HWND hwnd, WPARAM wParam, LPARAM lParam)
1476 {
1477     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
1478     COLORREF clrTemp;
1479
1480     clrTemp = infoPtr->clrBk;
1481     infoPtr->clrBk = (COLORREF)lParam;
1482
1483     TRACE("background color 0x%06lx!\n", infoPtr->clrBk);
1484
1485     return clrTemp;
1486 }
1487
1488
1489 /* << REBAR_SetColorScheme >> */
1490 /* << REBAR_SetPalette >> */
1491
1492
1493 static LRESULT
1494 REBAR_SetParent (HWND hwnd, WPARAM wParam, LPARAM lParam)
1495 {
1496     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
1497     HWND hwndTemp = infoPtr->hwndNotify;
1498
1499     infoPtr->hwndNotify = (HWND)wParam;
1500
1501     return (LRESULT)hwndTemp;
1502 }
1503
1504
1505 static LRESULT
1506 REBAR_SetTextColor (HWND hwnd, WPARAM wParam, LPARAM lParam)
1507 {
1508     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
1509     COLORREF clrTemp;
1510
1511     clrTemp = infoPtr->clrText;
1512     infoPtr->clrText = (COLORREF)lParam;
1513
1514     TRACE("text color 0x%06lx!\n", infoPtr->clrText);
1515
1516     return clrTemp;
1517 }
1518
1519
1520 /* << REBAR_SetTooltips >> */
1521
1522
1523 inline static LRESULT
1524 REBAR_SetUnicodeFormat (HWND hwnd, WPARAM wParam)
1525 {
1526     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
1527     BOOL bTemp = infoPtr->bUnicode;
1528     infoPtr->bUnicode = (BOOL)wParam;
1529     return bTemp;
1530 }
1531
1532
1533 static LRESULT
1534 REBAR_SetVersion (HWND hwnd, INT iVersion)
1535 {
1536     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
1537     INT iOldVersion = infoPtr->iVersion;
1538
1539     if (iVersion > COMCTL32_VERSION)
1540         return -1;
1541
1542     infoPtr->iVersion = iVersion;
1543
1544     return iOldVersion;
1545 }
1546
1547
1548 static LRESULT
1549 REBAR_ShowBand (HWND hwnd, WPARAM wParam, LPARAM lParam)
1550 {
1551     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
1552     REBAR_BAND *lpBand;
1553
1554     if (((INT)wParam < 0) || ((INT)wParam > infoPtr->uNumBands))
1555         return FALSE;
1556
1557     lpBand = &infoPtr->bands[(INT)wParam];
1558
1559     if ((BOOL)lParam) {
1560         TRACE("show band %d\n", (INT)wParam);
1561         lpBand->fStyle = lpBand->fStyle & ~RBBS_HIDDEN;
1562         if (IsWindow (lpBand->hwndChild))
1563             ShowWindow (lpBand->hwndChild, SW_SHOW);
1564     }
1565     else {
1566         TRACE("hide band %d\n", (INT)wParam);
1567         lpBand->fStyle = lpBand->fStyle | RBBS_HIDDEN;
1568         if (IsWindow (lpBand->hwndChild))
1569             ShowWindow (lpBand->hwndChild, SW_SHOW);
1570     }
1571
1572     REBAR_Layout (hwnd, NULL);
1573     REBAR_ForceResize (hwnd);
1574     REBAR_MoveChildWindows (hwnd);
1575
1576     return TRUE;
1577 }
1578
1579
1580 static LRESULT
1581 REBAR_SizeToRect (HWND hwnd, WPARAM wParam, LPARAM lParam)
1582 {
1583     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
1584     LPRECT lpRect = (LPRECT)lParam;
1585
1586     if (lpRect == NULL)
1587         return FALSE;
1588
1589     FIXME("layout change not implemented!\n");
1590     FIXME("[%d %d %d %d]\n",
1591            lpRect->left, lpRect->top, lpRect->right, lpRect->bottom);
1592
1593 #if 0
1594     SetWindowPos (hwnd, 0, lpRect->left, lpRect->top,
1595                     lpRect->right - lpRect->left, lpRect->bottom - lpRect->top,
1596                     SWP_NOZORDER);
1597 #endif
1598
1599     infoPtr->calcSize.cx = lpRect->right - lpRect->left;
1600     infoPtr->calcSize.cy = lpRect->bottom - lpRect->top;
1601
1602     REBAR_ForceResize (hwnd);
1603     return TRUE;
1604 }
1605
1606
1607
1608 static LRESULT
1609 REBAR_Create (HWND hwnd, WPARAM wParam, LPARAM lParam)
1610 {
1611     REBAR_INFO *infoPtr;
1612
1613     /* allocate memory for info structure */
1614     infoPtr = (REBAR_INFO *)COMCTL32_Alloc (sizeof(REBAR_INFO));
1615     SetWindowLongA (hwnd, 0, (DWORD)infoPtr);
1616
1617     /* initialize info structure */
1618     infoPtr->iVersion = 0;
1619     infoPtr->clrBk = CLR_NONE;
1620     infoPtr->clrText = RGB(0, 0, 0);
1621
1622     infoPtr->bAutoResize = FALSE;
1623     infoPtr->hcurArrow = LoadCursorA (0, IDC_ARROWA);
1624     infoPtr->hcurHorz  = LoadCursorA (0, IDC_SIZEWEA);
1625     infoPtr->hcurVert  = LoadCursorA (0, IDC_SIZENSA);
1626     infoPtr->hcurDrag  = LoadCursorA (0, IDC_SIZEA);
1627
1628     infoPtr->bUnicode = IsWindowUnicode (hwnd);
1629
1630     if (GetWindowLongA (hwnd, GWL_STYLE) & RBS_AUTOSIZE)
1631         FIXME("style RBS_AUTOSIZE set!\n");
1632
1633 #if 0
1634     SendMessageA (hwnd, WM_NOTIFYFORMAT, (WPARAM)hwnd, NF_QUERY);
1635 #endif
1636
1637     TRACE("created!\n");
1638     return 0;
1639 }
1640
1641
1642 static LRESULT
1643 REBAR_Destroy (HWND hwnd, WPARAM wParam, LPARAM lParam)
1644 {
1645     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
1646     REBAR_BAND *lpBand;
1647     INT i;
1648
1649
1650     /* free rebar bands */
1651     if ((infoPtr->uNumBands > 0) && infoPtr->bands) {
1652         /* clean up each band */
1653         for (i = 0; i < infoPtr->uNumBands; i++) {
1654             lpBand = &infoPtr->bands[i];
1655
1656             /* delete text strings */
1657             if (lpBand->lpText) {
1658                 COMCTL32_Free (lpBand->lpText);
1659                 lpBand->lpText = NULL;
1660             }
1661             /* destroy child window */
1662             DestroyWindow (lpBand->hwndChild);
1663         }
1664
1665         /* free band array */
1666         COMCTL32_Free (infoPtr->bands);
1667         infoPtr->bands = NULL;
1668     }
1669
1670
1671
1672
1673     DeleteObject (infoPtr->hcurArrow);
1674     DeleteObject (infoPtr->hcurHorz);
1675     DeleteObject (infoPtr->hcurVert);
1676     DeleteObject (infoPtr->hcurDrag);
1677
1678
1679
1680
1681     /* free rebar info data */
1682     COMCTL32_Free (infoPtr);
1683
1684     TRACE("destroyed!\n");
1685     return 0;
1686 }
1687
1688
1689 static LRESULT
1690 REBAR_GetFont (HWND hwnd, WPARAM wParam, LPARAM lParam)
1691 {
1692     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
1693
1694     return (LRESULT)infoPtr->hFont;
1695 }
1696
1697
1698 #if 0
1699 static LRESULT
1700 REBAR_MouseMove (HWND hwnd, WPARAM wParam, LPARAM lParam)
1701 {
1702     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
1703
1704     return 0;
1705 }
1706 #endif
1707
1708
1709 inline static LRESULT
1710 REBAR_NCCalcSize (HWND hwnd, WPARAM wParam, LPARAM lParam)
1711 {
1712     if (GetWindowLongA (hwnd, GWL_STYLE) & WS_BORDER) {
1713         ((LPRECT)lParam)->left   += GetSystemMetrics(SM_CXEDGE);
1714         ((LPRECT)lParam)->top    += GetSystemMetrics(SM_CYEDGE);
1715         ((LPRECT)lParam)->right  -= GetSystemMetrics(SM_CXEDGE);
1716         ((LPRECT)lParam)->bottom -= GetSystemMetrics(SM_CYEDGE);
1717     }
1718
1719     return 0;
1720 }
1721
1722
1723 static LRESULT
1724 REBAR_NCPaint (HWND hwnd, WPARAM wParam, LPARAM lParam)
1725 {
1726     DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
1727     RECT rcWindow;
1728     HDC hdc;
1729
1730     if (dwStyle & WS_MINIMIZE)
1731         return 0; /* Nothing to do */
1732
1733     DefWindowProcA (hwnd, WM_NCPAINT, wParam, lParam);
1734
1735     if (!(hdc = GetDCEx( hwnd, 0, DCX_USESTYLE | DCX_WINDOW )))
1736         return 0;
1737
1738     if (dwStyle & WS_BORDER) {
1739         GetWindowRect (hwnd, &rcWindow);
1740         OffsetRect (&rcWindow, -rcWindow.left, -rcWindow.top);
1741         DrawEdge (hdc, &rcWindow, EDGE_ETCHED, BF_RECT);
1742     }
1743
1744     ReleaseDC( hwnd, hdc );
1745
1746     return 0;
1747 }
1748
1749
1750 static LRESULT
1751 REBAR_Paint (HWND hwnd, WPARAM wParam)
1752 {
1753     HDC hdc;
1754     PAINTSTRUCT ps;
1755
1756     hdc = wParam==0 ? BeginPaint (hwnd, &ps) : (HDC)wParam;
1757     REBAR_Refresh (hwnd, hdc);
1758     if (!wParam)
1759         EndPaint (hwnd, &ps);
1760     return 0;
1761 }
1762
1763
1764 static LRESULT
1765 REBAR_SetCursor (HWND hwnd, WPARAM wParam, LPARAM lParam)
1766 {
1767     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
1768     DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
1769     POINT pt;
1770     UINT  flags;
1771
1772     TRACE("code=0x%X  id=0x%X\n", LOWORD(lParam), HIWORD(lParam));
1773
1774     GetCursorPos (&pt);
1775     ScreenToClient (hwnd, &pt);
1776
1777     REBAR_InternalHitTest (hwnd, &pt, &flags, NULL);
1778
1779     if (flags == RBHT_GRABBER) {
1780         if ((dwStyle & CCS_VERT) &&
1781             !(dwStyle & RBS_VERTICALGRIPPER))
1782             SetCursor (infoPtr->hcurVert);
1783         else
1784             SetCursor (infoPtr->hcurHorz);
1785     }
1786     else if (flags != RBHT_CLIENT)
1787         SetCursor (infoPtr->hcurArrow);
1788
1789     return 0;
1790 }
1791
1792
1793 static LRESULT
1794 REBAR_SetFont (HWND hwnd, WPARAM wParam, LPARAM lParam)
1795 {
1796     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
1797     
1798     /* TEXTMETRIC32A tm; */
1799     HFONT hFont /*, hOldFont */;
1800     /* HDC32 hdc; */
1801
1802     infoPtr->hFont = (HFONT)wParam;
1803
1804     hFont = infoPtr->hFont ? infoPtr->hFont : GetStockObject (SYSTEM_FONT);
1805 /*
1806     hdc = GetDC32 (0);
1807     hOldFont = SelectObject32 (hdc, hFont);
1808     GetTextMetrics32A (hdc, &tm);
1809     infoPtr->nHeight = tm.tmHeight + VERT_BORDER;
1810     SelectObject32 (hdc, hOldFont);
1811     ReleaseDC32 (0, hdc);
1812 */
1813     if (lParam) {
1814 /*
1815         REBAR_Layout (hwnd);
1816         hdc = GetDC32 (hwnd);
1817         REBAR_Refresh (hwnd, hdc);
1818         ReleaseDC32 (hwnd, hdc);
1819 */
1820     }
1821
1822     return 0;
1823 }
1824
1825 static LRESULT
1826 REBAR_Size (HWND hwnd, WPARAM wParam, LPARAM lParam)
1827 {
1828     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
1829     /* DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE); */
1830     RECT rcParent;
1831     /* INT32 x, y, cx, cy; */
1832
1833     /* auto resize deadlock check */
1834     if (infoPtr->bAutoResize) {
1835         infoPtr->bAutoResize = FALSE;
1836         return 0;
1837     }
1838
1839     TRACE("sizing rebar!\n");
1840
1841     /* get parent rectangle */
1842     GetClientRect (GetParent (hwnd), &rcParent);
1843 /*
1844     REBAR_Layout (hwnd, &rcParent);
1845
1846     if (dwStyle & CCS_VERT) {
1847         if (dwStyle & CCS_LEFT == CCS_LEFT) {
1848             x = rcParent.left;
1849             y = rcParent.top;
1850             cx = infoPtr->calcSize.cx;
1851             cy = infoPtr->calcSize.cy;
1852         }
1853         else {
1854             x = rcParent.right - infoPtr->calcSize.cx;
1855             y = rcParent.top;
1856             cx = infoPtr->calcSize.cx;
1857             cy = infoPtr->calcSize.cy;
1858         }
1859     }
1860     else {
1861         if (dwStyle & CCS_TOP) {
1862             x = rcParent.left;
1863             y = rcParent.top;
1864             cx = infoPtr->calcSize.cx;
1865             cy = infoPtr->calcSize.cy;
1866         }
1867         else {
1868             x = rcParent.left;
1869             y = rcParent.bottom - infoPtr->calcSize.cy;
1870             cx = infoPtr->calcSize.cx;
1871             cy = infoPtr->calcSize.cy;
1872         }
1873     }
1874
1875     SetWindowPos32 (hwnd, 0, x, y, cx, cy,
1876                     SWP_NOZORDER | SWP_SHOWWINDOW);
1877 */
1878     REBAR_Layout (hwnd, NULL);
1879     REBAR_ForceResize (hwnd);
1880     REBAR_MoveChildWindows (hwnd);
1881
1882     return 0;
1883 }
1884
1885
1886 static LRESULT WINAPI
1887 REBAR_WindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
1888 {
1889     switch (uMsg)
1890     {
1891 /*      case RB_BEGINDRAG: */
1892
1893         case RB_DELETEBAND:
1894             return REBAR_DeleteBand (hwnd, wParam, lParam);
1895
1896 /*      case RB_DRAGMOVE: */
1897 /*      case RB_ENDDRAG: */
1898
1899         case RB_GETBANDBORDERS:
1900             return REBAR_GetBandBorders (hwnd, wParam, lParam);
1901
1902         case RB_GETBANDCOUNT:
1903             return REBAR_GetBandCount (hwnd);
1904
1905 /*      case RB_GETBANDINFO32:  */ /* outdated, just for compatibility */
1906
1907         case RB_GETBANDINFOA:
1908             return REBAR_GetBandInfoA (hwnd, wParam, lParam);
1909
1910         case RB_GETBANDINFOW:
1911             return REBAR_GetBandInfoW (hwnd, wParam, lParam);
1912
1913         case RB_GETBARHEIGHT:
1914             return REBAR_GetBarHeight (hwnd, wParam, lParam);
1915
1916         case RB_GETBARINFO:
1917             return REBAR_GetBarInfo (hwnd, wParam, lParam);
1918
1919         case RB_GETBKCOLOR:
1920             return REBAR_GetBkColor (hwnd);
1921
1922 /*      case RB_GETCOLORSCHEME: */
1923 /*      case RB_GETDROPTARGET: */
1924
1925         case RB_GETPALETTE:
1926             return REBAR_GetPalette (hwnd, wParam, lParam);
1927
1928         case RB_GETRECT:
1929             return REBAR_GetRect (hwnd, wParam, lParam);
1930
1931         case RB_GETROWCOUNT:
1932             return REBAR_GetRowCount (hwnd);
1933
1934         case RB_GETROWHEIGHT:
1935             return REBAR_GetRowHeight (hwnd, wParam, lParam);
1936
1937         case RB_GETTEXTCOLOR:
1938             return REBAR_GetTextColor (hwnd);
1939
1940         case RB_GETTOOLTIPS:
1941             return REBAR_GetToolTips (hwnd);
1942
1943         case RB_GETUNICODEFORMAT:
1944             return REBAR_GetUnicodeFormat (hwnd);
1945
1946         case CCM_GETVERSION:
1947             return REBAR_GetVersion (hwnd);
1948
1949         case RB_HITTEST:
1950             return REBAR_HitTest (hwnd, wParam, lParam);
1951
1952         case RB_IDTOINDEX:
1953             return REBAR_IdToIndex (hwnd, wParam, lParam);
1954
1955         case RB_INSERTBANDA:
1956             return REBAR_InsertBandA (hwnd, wParam, lParam);
1957
1958         case RB_INSERTBANDW:
1959             return REBAR_InsertBandW (hwnd, wParam, lParam);
1960
1961         case RB_MAXIMIZEBAND:
1962             return REBAR_MaximizeBand (hwnd, wParam, lParam);
1963
1964         case RB_MINIMIZEBAND:
1965             return REBAR_MinimizeBand (hwnd, wParam, lParam);
1966
1967         case RB_MOVEBAND:
1968             return REBAR_MoveBand (hwnd, wParam, lParam);
1969
1970         case RB_SETBANDINFOA:
1971             return REBAR_SetBandInfoA (hwnd, wParam, lParam);
1972
1973         case RB_SETBANDINFOW:
1974             return REBAR_SetBandInfoW (hwnd, wParam, lParam);
1975
1976         case RB_SETBARINFO:
1977             return REBAR_SetBarInfo (hwnd, wParam, lParam);
1978
1979         case RB_SETBKCOLOR:
1980             return REBAR_SetBkColor (hwnd, wParam, lParam);
1981
1982 /*      case RB_SETCOLORSCHEME: */
1983 /*      case RB_SETPALETTE: */
1984 /*          return REBAR_GetPalette (hwnd, wParam, lParam); */
1985
1986         case RB_SETPARENT:
1987             return REBAR_SetParent (hwnd, wParam, lParam);
1988
1989         case RB_SETTEXTCOLOR:
1990             return REBAR_SetTextColor (hwnd, wParam, lParam);
1991
1992 /*      case RB_SETTOOLTIPS: */
1993
1994         case RB_SETUNICODEFORMAT:
1995             return REBAR_SetUnicodeFormat (hwnd, wParam);
1996
1997         case CCM_SETVERSION:
1998             return REBAR_SetVersion (hwnd, (INT)wParam);
1999
2000         case RB_SHOWBAND:
2001             return REBAR_ShowBand (hwnd, wParam, lParam);
2002
2003         case RB_SIZETORECT:
2004             return REBAR_SizeToRect (hwnd, wParam, lParam);
2005
2006
2007         case WM_COMMAND:
2008             return SendMessageA (GetParent (hwnd), uMsg, wParam, lParam);
2009
2010         case WM_CREATE:
2011             return REBAR_Create (hwnd, wParam, lParam);
2012
2013         case WM_DESTROY:
2014             return REBAR_Destroy (hwnd, wParam, lParam);
2015
2016         case WM_GETFONT:
2017             return REBAR_GetFont (hwnd, wParam, lParam);
2018
2019 /*      case WM_MOUSEMOVE: */
2020 /*          return REBAR_MouseMove (hwnd, wParam, lParam); */
2021
2022         case WM_NCCALCSIZE:
2023             return REBAR_NCCalcSize (hwnd, wParam, lParam);
2024
2025         case WM_NCPAINT:
2026             return REBAR_NCPaint (hwnd, wParam, lParam);
2027
2028         case WM_NOTIFY:
2029             return SendMessageA (GetParent (hwnd), uMsg, wParam, lParam);
2030
2031         case WM_PAINT:
2032             return REBAR_Paint (hwnd, wParam);
2033
2034         case WM_SETCURSOR:
2035             return REBAR_SetCursor (hwnd, wParam, lParam);
2036
2037         case WM_SETFONT:
2038             return REBAR_SetFont (hwnd, wParam, lParam);
2039
2040         case WM_SIZE:
2041             return REBAR_Size (hwnd, wParam, lParam);
2042
2043 /*      case WM_TIMER: */
2044
2045 /*      case WM_WININICHANGE: */
2046
2047         default:
2048             if (uMsg >= WM_USER)
2049                 ERR("unknown msg %04x wp=%08x lp=%08lx\n",
2050                      uMsg, wParam, lParam);
2051             return DefWindowProcA (hwnd, uMsg, wParam, lParam);
2052     }
2053     return 0;
2054 }
2055
2056
2057 VOID
2058 REBAR_Register (void)
2059 {
2060     WNDCLASSA wndClass;
2061
2062     if (GlobalFindAtomA (REBARCLASSNAMEA)) return;
2063
2064     ZeroMemory (&wndClass, sizeof(WNDCLASSA));
2065     wndClass.style         = CS_GLOBALCLASS | CS_DBLCLKS;
2066     wndClass.lpfnWndProc   = (WNDPROC)REBAR_WindowProc;
2067     wndClass.cbClsExtra    = 0;
2068     wndClass.cbWndExtra    = sizeof(REBAR_INFO *);
2069     wndClass.hCursor       = 0;
2070     wndClass.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
2071     wndClass.lpszClassName = REBARCLASSNAMEA;
2072  
2073     RegisterClassA (&wndClass);
2074 }
2075
2076
2077 VOID
2078 REBAR_Unregister (void)
2079 {
2080     if (GlobalFindAtomA (REBARCLASSNAMEA))
2081         UnregisterClassA (REBARCLASSNAMEA, (HINSTANCE)NULL);
2082 }
2083