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