2 * Testing: set to 1 to make background brush *always* green
8 * 2. At "FIXME: problem # 2" WinRAR:
9 * if "#if 1" then last band draws in separate row
10 * if "#if 0" then last band draws in previous row *** just like native ***
16 * 3. REBAR_MoveChildWindows should have a loop because more than
17 * one pass is made (together with the RBN_CHILDSIZEs) is made on
18 * at least RB_INSERTBAND
23 * Rebar control rev 8e
25 * Copyright 1998, 1999 Eric Kohl
27 * This library is free software; you can redistribute it and/or
28 * modify it under the terms of the GNU Lesser General Public
29 * License as published by the Free Software Foundation; either
30 * version 2.1 of the License, or (at your option) any later version.
32 * This library is distributed in the hope that it will be useful,
33 * but WITHOUT ANY WARRANTY; without even the implied warranty of
34 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
35 * Lesser General Public License for more details.
37 * You should have received a copy of the GNU Lesser General Public
38 * License along with this library; if not, write to the Free Software
39 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
42 * An author is needed! Any volunteers?
43 * I will only improve this control once in a while.
44 * Eric <ekohl@abo.rhein-zeitung.de>
47 * - vertical placement
48 * - ComboBox and ComboBoxEx placement
53 * - All notifications.
55 * Changes Guy Albertelli <galberte@neo.lrun.com>
57 * - Implement initial version of row grouping, row separators,
58 * text and background colors. Support additional messages.
59 * Support RBBS_BREAK. Implement ERASEBKGND and improve painting.
61 * - implement support for dragging Gripper left or right in a row. Supports
62 * WM_LBUTTONDOWN, WM_LBUTTONUP, and WM_MOUSEMOVE. Also support
65 * - Fix or implement notifications for RBN_HEIGHTCHANGE, RBN_CHILDSIZE.
66 * - Correct styles RBBS_NOGRIPPER, RBBS_GRIPPERALWAYS, and RBBS_FIXEDSIZE.
67 * - Fix algorithm for Layout and AdjustBand.
70 * - Fix algorithm for _Layout and _AdjustBand.
71 * - Fix or implement RBN_ENDDRAG, RB_MOVEBAND, WM_SETREDRAW,
72 * WM_STYLECHANGED, RB_MINIMIZEBAND, RBBS_VARIABLEHEIGHT, RBS_VARHEIGHT,
73 * RBBS_HIDDEN, WM_NOTIFYFORMAT, NM_NCHITTEST, WM_SETREDRAW, RBS_AUTOSIZE,
74 * WM_SETFONT, RBS_BORDERS
75 * - Create structures in WM_NCCREATE
76 * - Additional performance enhancements.
79 * 1. Create array of start and end band indexes by row and use.
80 * 2. Fix problem with REBAR_Layout Phase 2b to process only if only
82 * 3. Set the Caption Font (Regular) as default font for text.
83 * 4. Delete font handle on control distruction.
84 * 5. Add UpdateWindow call in _MoveChildWindows to match repainting done
86 * 6. Improve some traces.
87 * 7. Invalidate window rectangles after SetBandInfo, InsertBand, ShowBand
88 * so that repainting is correct.
89 * 8. Implement RB_MAXIMIZEBAND for the "ideal=TRUE" case.
90 * 9. Implement item custom draw notifications partially. Only done for
91 * ITEMPREPAINT and ITEMPOSTPAINT. (Used by IE4 for "Favorites" frame
92 * to draw the word "Favorites").
94 * 10. Handle CCS_NODIVIDER and fix WS_BORDER code.
95 * 11. Fix logic error in _AdjustBands where flag was set to valid band
96 * number (0) to indicate *no* band.
97 * 12. Fix CCS_VERT errors in _ForceResize, _NCCalcSize, and _NCPaint.
98 * 13. Support some special cases of CCS_TOP (and therefore CCS_LEFT),
99 * CCS_BOTTOM (and therefore CCS_RIGHT) and CCS_NOPARENTALIGN. Not
100 * at all sure whether this is all cases.
101 * 14. Handle returned value for the RBN_CHILDSIZE notify.
102 * 15. Implement RBBS_CHILDEDGE, and set each bands "offChild" at _Layout
104 * 16. Fix REBARSPACE. It should depend on CCS_NODIVIDER.
106 * 17. Fix determination of whether Gripper is needed in _ValidateBand.
107 * 18. Fix _AdjustBand processing of RBBS_FIXEDSIZE.
109 * 19. Fix problem in _Layout when all lengths are 0.
110 * 20. If CLR_NONE specified, we will use default BtnFace color when drawing.
111 * 21. Fix test in REBAR_Layout.
113 * 22. Add support for WM_WINDOWPOSCHANGED to save new origin of window.
114 * 23. Correct RBN_CHILDSIZE rect value for CCS_VERT rebar.
115 * 24. Do UpdateWindow only if doing redraws.
117 * 25. Adjust setting of offChild.cx based on RBBS_CHILDEDGE.
121 * 2. Following still not handled: RBBS_FIXEDBMP,
123 * CCS_NOMOVEX, CCS_NOMOVEY
124 * 3. Following are only partially handled:
125 * RBS_AUTOSIZE, RBBS_VARIABLEHEIGHT
126 * 5. Native uses (on each draw!!) SM_CYBORDER (or SM_CXBORDER for CCS_VERT)
127 * to set the size of the separator width (the value SEP_WIDTH_SIZE
128 * in here). Should be fixed!!
129 * 6. The following messages are not implemented:
130 * RB_BEGINDRAG, RB_DRAGMOVE, RB_ENDDRAG, RB_GETCOLORSCHEME,
131 * RB_GETDROPTARGET, RB_MAXIMIZEBAND,
132 * RB_SETCOLORSCHEME, RB_SETPALETTE, RB_SETTOOLTIPS
133 * WM_CHARTOITEM, WM_LBUTTONDBLCLK, WM_MEASUREITEM,
134 * WM_PALETTECHANGED, WM_PRINTCLIENT, WM_QUERYNEWPALETTE,
135 * WM_RBUTTONDOWN, WM_RBUTTONUP,
136 * WM_SYSCOLORCHANGE, WM_VKEYTOITEM, WM_WININICHANGE
137 * 7. The following notifications are not implemented:
138 * NM_CUSTOMDRAW, NM_RELEASEDCAPTURE
149 #include "wine/unicode.h"
152 #include "commctrl.h"
153 #include "comctl32.h"
154 #include "wine/debug.h"
156 WINE_DEFAULT_DEBUG_CHANNEL(rebar
);
166 UINT cxMinChild
; /* valid if _CHILDSIZE */
167 UINT cyMinChild
; /* valid if _CHILDSIZE */
168 UINT cx
; /* valid if _SIZE */
171 UINT cyChild
; /* valid if _CHILDSIZE */
172 UINT cyMaxChild
; /* valid if _CHILDSIZE */
173 UINT cyIntegral
; /* valid if _CHILDSIZE */
178 UINT lcx
; /* minimum cx for band */
179 UINT ccx
; /* current cx for band */
180 UINT hcx
; /* maximum cx for band */
181 UINT lcy
; /* minimum cy for band */
182 UINT ccy
; /* current cy for band */
183 UINT hcy
; /* maximum cy for band */
185 SIZE offChild
; /* x,y offset if child is not FIXEDSIZE */
187 INT iRow
; /* row this band assigned to */
188 UINT fStatus
; /* status flags, reset only by _Validate */
189 UINT fDraw
; /* drawing flags, reset only by _Layout */
190 UINT uCDret
; /* last return from NM_CUSTOMDRAW */
191 RECT rcoldBand
; /* previous calculated band rectangle */
192 RECT rcBand
; /* calculated band rectangle */
193 RECT rcGripper
; /* calculated gripper rectangle */
194 RECT rcCapImage
; /* calculated caption image rectangle */
195 RECT rcCapText
; /* calculated caption text rectangle */
196 RECT rcChild
; /* calculated child rectangle */
197 RECT rcChevron
; /* calculated chevron rectangle */
204 #define HAS_GRIPPER 0x00000001
205 #define HAS_IMAGE 0x00000002
206 #define HAS_TEXT 0x00000004
209 #define DRAW_GRIPPER 0x00000001
210 #define DRAW_IMAGE 0x00000002
211 #define DRAW_TEXT 0x00000004
212 #define DRAW_RIGHTSEP 0x00000010
213 #define DRAW_BOTTOMSEP 0x00000020
214 #define DRAW_CHEVRONHOT 0x00000040
215 #define DRAW_CHEVRONPUSHED 0x00000080
216 #define DRAW_LAST_IN_ROW 0x00000100
217 #define DRAW_FIRST_IN_ROW 0x00000200
218 #define NTF_INVALIDATE 0x01000000
222 COLORREF clrBk
; /* background color */
223 COLORREF clrText
; /* text color */
224 COLORREF clrBtnText
; /* system color for BTNTEXT */
225 COLORREF clrBtnFace
; /* system color for BTNFACE */
226 HIMAGELIST himl
; /* handle to imagelist */
227 UINT uNumBands
; /* # of bands in rebar (first=0, last=uNumBands-1 */
228 UINT uNumRows
; /* # of rows of bands (first=1, last=uNumRows */
229 HWND hwndSelf
; /* handle of REBAR window itself */
230 HWND hwndToolTip
; /* handle to the tool tip control */
231 HWND hwndNotify
; /* notification window (parent) */
233 HFONT hFont
; /* handle to the rebar's font */
234 SIZE imageSize
; /* image size (image list) */
235 DWORD dwStyle
; /* window style */
236 SIZE calcSize
; /* calculated rebar size */
237 SIZE oldSize
; /* previous calculated rebar size */
238 BOOL bUnicode
; /* TRUE if this window is W type */
239 BOOL NtfUnicode
; /* TRUE if parent wants notify in W format */
240 BOOL DoRedraw
; /* TRUE to acutally draw bands */
241 UINT fStatus
; /* Status flags (see below) */
242 HCURSOR hcurArrow
; /* handle to the arrow cursor */
243 HCURSOR hcurHorz
; /* handle to the EW cursor */
244 HCURSOR hcurVert
; /* handle to the NS cursor */
245 HCURSOR hcurDrag
; /* handle to the drag cursor */
246 INT iVersion
; /* version number */
247 POINTS dragStart
; /* x,y of button down */
248 POINTS dragNow
; /* x,y of this MouseMove */
249 INT iOldBand
; /* last band that had the mouse cursor over it */
250 INT ihitoffset
; /* offset of hotspot from gripper.left */
251 POINT origin
; /* left/upper corner of client */
252 INT ichevronhotBand
; /* last band that had a hot chevron */
253 INT iGrabbedBand
;/* band number of band whose gripper was grabbed */
255 REBAR_BAND
*bands
; /* pointer to the array of rebar bands */
259 #define BEGIN_DRAG_ISSUED 0x00000001
260 #define AUTO_RESIZE 0x00000002
261 #define RESIZE_ANYHOW 0x00000004
262 #define NTF_HGHTCHG 0x00000008
263 #define BAND_NEEDS_LAYOUT 0x00000010
264 #define BAND_NEEDS_REDRAW 0x00000020
265 #define CREATE_RUNNING 0x00000040
267 /* ---- REBAR layout constants. Mostly determined by ---- */
268 /* ---- experiment on WIN 98. ---- */
270 /* Width (or height) of separators between bands (either horz. or */
271 /* vert.). True only if RBS_BANDBORDERS is set */
272 #define SEP_WIDTH_SIZE 2
273 #define SEP_WIDTH ((infoPtr->dwStyle & RBS_BANDBORDERS) ? SEP_WIDTH_SIZE : 0)
275 /* Blank (background color) space between Gripper (if present) */
276 /* and next item (image, text, or window). Always present */
277 #define REBAR_ALWAYS_SPACE 4
279 /* Blank (background color) space after Image (if present). */
280 #define REBAR_POST_IMAGE 2
282 /* Blank (background color) space after Text (if present). */
283 #define REBAR_POST_TEXT 4
285 /* Height of vertical gripper in a CCS_VERT rebar. */
286 #define GRIPPER_HEIGHT 16
288 /* Blank (background color) space before Gripper (if present). */
289 #define REBAR_PRE_GRIPPER 2
291 /* Width (of normal vertical gripper) or height (of horz. gripper) */
293 #define GRIPPER_WIDTH 3
295 /* Width of the chevron button if present */
296 #define CHEVRON_WIDTH 10
298 /* Height of divider for Rebar if not disabled (CCS_NODIVIDER) */
299 /* either top or bottom */
300 #define REBAR_DIVIDER 2
302 /* This is the increment that is used over the band height */
303 #define REBARSPACE(a) ((a->fStyle & RBBS_CHILDEDGE) ? 2*REBAR_DIVIDER : 0)
305 /* ---- End of REBAR layout constants. ---- */
307 #define RB_GETBANDINFO_OLD (WM_USER+5) /* obsoleted after IE3, but we have to support it anyway */
309 /* The following 6 defines return the proper rcBand element */
310 /* depending on whether CCS_VERT was set. */
311 #define rcBlt(b) ((infoPtr->dwStyle & CCS_VERT) ? b->rcBand.top : b->rcBand.left)
312 #define rcBrb(b) ((infoPtr->dwStyle & CCS_VERT) ? b->rcBand.bottom : b->rcBand.right)
313 #define rcBw(b) ((infoPtr->dwStyle & CCS_VERT) ? (b->rcBand.bottom - b->rcBand.top) : \
314 (b->rcBand.right - b->rcBand.left))
315 #define ircBlt(b) ((infoPtr->dwStyle & CCS_VERT) ? b->rcBand.left : b->rcBand.top)
316 #define ircBrb(b) ((infoPtr->dwStyle & CCS_VERT) ? b->rcBand.right : b->rcBand.bottom)
317 #define ircBw(b) ((infoPtr->dwStyle & CCS_VERT) ? (b->rcBand.right - b->rcBand.left) : \
318 (b->rcBand.bottom - b->rcBand.top))
320 /* The following define determines if a given band is hidden */
321 #define HIDDENBAND(a) (((a)->fStyle & RBBS_HIDDEN) || \
322 ((infoPtr->dwStyle & CCS_VERT) && \
323 ((a)->fStyle & RBBS_NOVERT)))
325 /* The following defines adjust the right or left end of a rectangle */
326 #define READJ(b,i) do { if(infoPtr->dwStyle & CCS_VERT) b->rcBand.bottom+=(i); \
327 else b->rcBand.right += (i); } while(0)
328 #define LEADJ(b,i) do { if(infoPtr->dwStyle & CCS_VERT) b->rcBand.top+=(i); \
329 else b->rcBand.left += (i); } while(0)
332 #define REBAR_GetInfoPtr(wndPtr) ((REBAR_INFO *)GetWindowLongA (hwnd, 0))
335 /* "constant values" retrieved when DLL was initialized */
336 /* FIXME we do this when the classes are registered. */
337 static UINT mindragx
= 0;
338 static UINT mindragy
= 0;
340 static const char *band_stylename
[] = {
341 "RBBS_BREAK", /* 0001 */
342 "RBBS_FIXEDSIZE", /* 0002 */
343 "RBBS_CHILDEDGE", /* 0004 */
344 "RBBS_HIDDEN", /* 0008 */
345 "RBBS_NOVERT", /* 0010 */
346 "RBBS_FIXEDBMP", /* 0020 */
347 "RBBS_VARIABLEHEIGHT", /* 0040 */
348 "RBBS_GRIPPERALWAYS", /* 0080 */
349 "RBBS_NOGRIPPER", /* 0100 */
352 static const char *band_maskname
[] = {
353 "RBBIM_STYLE", /* 0x00000001 */
354 "RBBIM_COLORS", /* 0x00000002 */
355 "RBBIM_TEXT", /* 0x00000004 */
356 "RBBIM_IMAGE", /* 0x00000008 */
357 "RBBIM_CHILD", /* 0x00000010 */
358 "RBBIM_CHILDSIZE", /* 0x00000020 */
359 "RBBIM_SIZE", /* 0x00000040 */
360 "RBBIM_BACKGROUND", /* 0x00000080 */
361 "RBBIM_ID", /* 0x00000100 */
362 "RBBIM_IDEALSIZE", /* 0x00000200 */
363 "RBBIM_LPARAM", /* 0x00000400 */
364 "RBBIM_HEADERSIZE", /* 0x00000800 */
368 static CHAR line
[200];
372 REBAR_FmtStyle( UINT style
)
377 while (band_stylename
[i
]) {
378 if (style
& (1<<i
)) {
379 if (*line
!= 0) strcat(line
, " | ");
380 strcat(line
, band_stylename
[i
]);
389 REBAR_FmtMask( UINT mask
)
394 while (band_maskname
[i
]) {
396 if (*line
!= 0) strcat(line
, " | ");
397 strcat(line
, band_maskname
[i
]);
406 REBAR_DumpBandInfo( LPREBARBANDINFOA pB
)
408 if( !TRACE_ON(rebar
) ) return;
409 TRACE("band info: ID=%u, size=%u, child=%p, clrF=0x%06lx, clrB=0x%06lx\n",
410 pB
->wID
, pB
->cbSize
, pB
->hwndChild
, pB
->clrFore
, pB
->clrBack
);
411 TRACE("band info: mask=0x%08x (%s)\n", pB
->fMask
, REBAR_FmtMask(pB
->fMask
));
412 if (pB
->fMask
& RBBIM_STYLE
)
413 TRACE("band info: style=0x%08x (%s)\n", pB
->fStyle
, REBAR_FmtStyle(pB
->fStyle
));
414 if (pB
->fMask
& (RBBIM_SIZE
| RBBIM_IDEALSIZE
| RBBIM_HEADERSIZE
| RBBIM_LPARAM
)) {
416 if (pB
->fMask
& RBBIM_SIZE
)
417 TRACE(" cx=%u", pB
->cx
);
418 if (pB
->fMask
& RBBIM_IDEALSIZE
)
419 TRACE(" xIdeal=%u", pB
->cxIdeal
);
420 if (pB
->fMask
& RBBIM_HEADERSIZE
)
421 TRACE(" xHeader=%u", pB
->cxHeader
);
422 if (pB
->fMask
& RBBIM_LPARAM
)
423 TRACE(" lParam=0x%08lx", pB
->lParam
);
426 if (pB
->fMask
& RBBIM_CHILDSIZE
)
427 TRACE("band info: xMin=%u, yMin=%u, yChild=%u, yMax=%u, yIntgl=%u\n",
429 pB
->cyMinChild
, pB
->cyChild
, pB
->cyMaxChild
, pB
->cyIntegral
);
433 REBAR_DumpBand (REBAR_INFO
*iP
)
438 if(! TRACE_ON(rebar
) ) return;
440 TRACE("hwnd=%p: color=%08lx/%08lx, bands=%u, rows=%u, cSize=%ld,%ld\n",
441 iP
->hwndSelf
, iP
->clrText
, iP
->clrBk
, iP
->uNumBands
, iP
->uNumRows
,
442 iP
->calcSize
.cx
, iP
->calcSize
.cy
);
443 TRACE("hwnd=%p: flags=%08x, dragStart=%d,%d, dragNow=%d,%d, iGrabbedBand=%d\n",
444 iP
->hwndSelf
, iP
->fStatus
, iP
->dragStart
.x
, iP
->dragStart
.y
,
445 iP
->dragNow
.x
, iP
->dragNow
.y
,
447 TRACE("hwnd=%p: style=%08lx, I'm Unicode=%s, notify in Unicode=%s, redraw=%s\n",
448 iP
->hwndSelf
, iP
->dwStyle
, (iP
->bUnicode
)?"TRUE":"FALSE",
449 (iP
->NtfUnicode
)?"TRUE":"FALSE", (iP
->DoRedraw
)?"TRUE":"FALSE");
450 for (i
= 0; i
< iP
->uNumBands
; i
++) {
452 TRACE("band # %u: ID=%u, child=%p, row=%u, clrF=0x%06lx, clrB=0x%06lx\n",
453 i
, pB
->wID
, pB
->hwndChild
, pB
->iRow
, pB
->clrFore
, pB
->clrBack
);
454 TRACE("band # %u: mask=0x%08x (%s)\n", i
, pB
->fMask
, REBAR_FmtMask(pB
->fMask
));
455 if (pB
->fMask
& RBBIM_STYLE
)
456 TRACE("band # %u: style=0x%08x (%s)\n",
457 i
, pB
->fStyle
, REBAR_FmtStyle(pB
->fStyle
));
458 TRACE("band # %u: uMinH=%u xHeader=%u",
459 i
, pB
->uMinHeight
, pB
->cxHeader
);
460 if (pB
->fMask
& (RBBIM_SIZE
| RBBIM_IDEALSIZE
| RBBIM_LPARAM
)) {
461 if (pB
->fMask
& RBBIM_SIZE
)
462 TRACE(" cx=%u", pB
->cx
);
463 if (pB
->fMask
& RBBIM_IDEALSIZE
)
464 TRACE(" xIdeal=%u", pB
->cxIdeal
);
465 if (pB
->fMask
& RBBIM_LPARAM
)
466 TRACE(" lParam=0x%08lx", pB
->lParam
);
470 TRACE("band # %u: xMin=%u, yMin=%u, yChild=%u, yMax=%u, yIntgl=%u\n",
471 i
, pB
->cxMinChild
, pB
->cyMinChild
, pB
->cyChild
, pB
->cyMaxChild
, pB
->cyIntegral
);
472 if (pB
->fMask
& RBBIM_TEXT
)
473 TRACE("band # %u: text=%s\n",
474 i
, (pB
->lpText
) ? debugstr_w(pB
->lpText
) : "(null)");
475 TRACE("band # %u: lcx=%u, ccx=%u, hcx=%u, lcy=%u, ccy=%u, hcy=%u, offChild=%ld,%ld\n",
476 i
, pB
->lcx
, pB
->ccx
, pB
->hcx
, pB
->lcy
, pB
->ccy
, pB
->hcy
, pB
->offChild
.cx
, pB
->offChild
.cy
);
477 TRACE("band # %u: fStatus=%08x, fDraw=%08x, Band=(%ld,%ld)-(%ld,%ld), Grip=(%ld,%ld)-(%ld,%ld)\n",
478 i
, pB
->fStatus
, pB
->fDraw
,
479 pB
->rcBand
.left
, pB
->rcBand
.top
, pB
->rcBand
.right
, pB
->rcBand
.bottom
,
480 pB
->rcGripper
.left
, pB
->rcGripper
.top
, pB
->rcGripper
.right
, pB
->rcGripper
.bottom
);
481 TRACE("band # %u: Img=(%ld,%ld)-(%ld,%ld), Txt=(%ld,%ld)-(%ld,%ld), Child=(%ld,%ld)-(%ld,%ld)\n",
483 pB
->rcCapImage
.left
, pB
->rcCapImage
.top
, pB
->rcCapImage
.right
, pB
->rcCapImage
.bottom
,
484 pB
->rcCapText
.left
, pB
->rcCapText
.top
, pB
->rcCapText
.right
, pB
->rcCapText
.bottom
,
485 pB
->rcChild
.left
, pB
->rcChild
.top
, pB
->rcChild
.right
, pB
->rcChild
.bottom
);
491 REBAR_DrawChevron (HDC hdc
, INT left
, INT top
, INT colorRef
)
496 if (!(hPen
= CreatePen( PS_SOLID
, 1, GetSysColor( colorRef
)))) return;
497 hOldPen
= SelectObject ( hdc
, hPen
);
500 MoveToEx (hdc
, x
, y
, NULL
);
501 LineTo (hdc
, x
+5, y
++); x
++;
502 MoveToEx (hdc
, x
, y
, NULL
);
503 LineTo (hdc
, x
+3, y
++); x
++;
504 MoveToEx (hdc
, x
, y
, NULL
);
505 LineTo (hdc
, x
+1, y
++);
506 SelectObject( hdc
, hOldPen
);
507 DeleteObject( hPen
);
511 REBAR_GetNotifyParent (REBAR_INFO
*infoPtr
)
515 parent
= infoPtr
->hwndNotify
;
517 parent
= GetParent (infoPtr
->hwndSelf
);
518 owner
= GetWindow (infoPtr
->hwndSelf
, GW_OWNER
);
519 if (owner
) parent
= owner
;
526 REBAR_Notify (NMHDR
*nmhdr
, REBAR_INFO
*infoPtr
, UINT code
)
530 parent
= REBAR_GetNotifyParent (infoPtr
);
531 nmhdr
->idFrom
= GetDlgCtrlID (infoPtr
->hwndSelf
);
532 nmhdr
->hwndFrom
= infoPtr
->hwndSelf
;
535 TRACE("window %p, code=%08x, %s\n", parent
, code
,
536 (infoPtr
->NtfUnicode
) ? "via Unicode" : "via ANSI");
538 if (infoPtr
->NtfUnicode
)
539 return SendMessageW (parent
, WM_NOTIFY
, (WPARAM
) nmhdr
->idFrom
,
542 return SendMessageA (parent
, WM_NOTIFY
, (WPARAM
) nmhdr
->idFrom
,
547 REBAR_Notify_NMREBAR (REBAR_INFO
*infoPtr
, UINT uBand
, UINT code
)
549 NMREBAR notify_rebar
;
552 notify_rebar
.dwMask
= 0;
554 lpBand
= &infoPtr
->bands
[uBand
];
555 if (lpBand
->fMask
& RBBIM_ID
) {
556 notify_rebar
.dwMask
|= RBNM_ID
;
557 notify_rebar
.wID
= lpBand
->wID
;
559 if (lpBand
->fMask
& RBBIM_LPARAM
) {
560 notify_rebar
.dwMask
|= RBNM_LPARAM
;
561 notify_rebar
.lParam
= lpBand
->lParam
;
563 if (lpBand
->fMask
& RBBIM_STYLE
) {
564 notify_rebar
.dwMask
|= RBNM_STYLE
;
565 notify_rebar
.fStyle
= lpBand
->fStyle
;
568 notify_rebar
.uBand
= uBand
;
569 return REBAR_Notify ((NMHDR
*)¬ify_rebar
, infoPtr
, code
);
573 REBAR_DrawBand (HDC hdc
, REBAR_INFO
*infoPtr
, REBAR_BAND
*lpBand
)
579 if (lpBand
->fDraw
& DRAW_TEXT
) {
580 hOldFont
= SelectObject (hdc
, infoPtr
->hFont
);
581 oldBkMode
= SetBkMode (hdc
, TRANSPARENT
);
584 /* should test for CDRF_NOTIFYITEMDRAW here */
585 nmcd
.dwDrawStage
= CDDS_ITEMPREPAINT
;
587 nmcd
.rc
= lpBand
->rcBand
;
588 nmcd
.rc
.right
= lpBand
->rcCapText
.right
;
589 nmcd
.rc
.bottom
= lpBand
->rcCapText
.bottom
;
590 nmcd
.dwItemSpec
= lpBand
->wID
;
592 nmcd
.lItemlParam
= lpBand
->lParam
;
593 lpBand
->uCDret
= REBAR_Notify ((NMHDR
*)&nmcd
, infoPtr
, NM_CUSTOMDRAW
);
594 if (lpBand
->uCDret
== CDRF_SKIPDEFAULT
) {
595 if (oldBkMode
!= TRANSPARENT
)
596 SetBkMode (hdc
, oldBkMode
);
597 SelectObject (hdc
, hOldFont
);
602 if (lpBand
->fDraw
& DRAW_GRIPPER
)
603 DrawEdge (hdc
, &lpBand
->rcGripper
, BDR_RAISEDINNER
, BF_RECT
| BF_MIDDLE
);
605 /* draw caption image */
606 if (lpBand
->fDraw
& DRAW_IMAGE
) {
610 pt
.y
= (lpBand
->rcCapImage
.bottom
+ lpBand
->rcCapImage
.top
- infoPtr
->imageSize
.cy
)/2;
611 pt
.x
= (lpBand
->rcCapImage
.right
+ lpBand
->rcCapImage
.left
- infoPtr
->imageSize
.cx
)/2;
613 ImageList_Draw (infoPtr
->himl
, lpBand
->iImage
, hdc
,
618 /* draw caption text */
619 if (lpBand
->fDraw
& DRAW_TEXT
) {
620 /* need to handle CDRF_NEWFONT here */
621 INT oldBkMode
= SetBkMode (hdc
, TRANSPARENT
);
622 COLORREF oldcolor
= CLR_NONE
;
624 if (lpBand
->clrFore
!= CLR_NONE
) {
625 new = (lpBand
->clrFore
== CLR_DEFAULT
) ? infoPtr
->clrBtnText
:
627 oldcolor
= SetTextColor (hdc
, new);
629 DrawTextW (hdc
, lpBand
->lpText
, -1, &lpBand
->rcCapText
,
630 DT_CENTER
| DT_VCENTER
| DT_SINGLELINE
);
631 if (oldBkMode
!= TRANSPARENT
)
632 SetBkMode (hdc
, oldBkMode
);
633 if (lpBand
->clrFore
!= CLR_NONE
)
634 SetTextColor (hdc
, oldcolor
);
635 SelectObject (hdc
, hOldFont
);
638 if (!IsRectEmpty(&lpBand
->rcChevron
))
640 if (lpBand
->fDraw
& DRAW_CHEVRONPUSHED
)
642 DrawEdge(hdc
, &lpBand
->rcChevron
, BDR_SUNKENOUTER
, BF_RECT
| BF_MIDDLE
);
643 REBAR_DrawChevron(hdc
, lpBand
->rcChevron
.left
+1, lpBand
->rcChevron
.top
+ 11, COLOR_WINDOWFRAME
);
645 else if (lpBand
->fDraw
& DRAW_CHEVRONHOT
)
647 DrawEdge(hdc
, &lpBand
->rcChevron
, BDR_RAISEDINNER
, BF_RECT
| BF_MIDDLE
);
648 REBAR_DrawChevron(hdc
, lpBand
->rcChevron
.left
, lpBand
->rcChevron
.top
+ 10, COLOR_WINDOWFRAME
);
651 REBAR_DrawChevron(hdc
, lpBand
->rcChevron
.left
, lpBand
->rcChevron
.top
+ 10, COLOR_WINDOWFRAME
);
654 if (lpBand
->uCDret
== (CDRF_NOTIFYPOSTPAINT
| CDRF_NOTIFYITEMDRAW
)) {
655 nmcd
.dwDrawStage
= CDDS_ITEMPOSTPAINT
;
657 nmcd
.rc
= lpBand
->rcBand
;
658 nmcd
.rc
.right
= lpBand
->rcCapText
.right
;
659 nmcd
.rc
.bottom
= lpBand
->rcCapText
.bottom
;
660 nmcd
.dwItemSpec
= lpBand
->wID
;
662 nmcd
.lItemlParam
= lpBand
->lParam
;
663 lpBand
->uCDret
= REBAR_Notify ((NMHDR
*)&nmcd
, infoPtr
, NM_CUSTOMDRAW
);
669 REBAR_Refresh (REBAR_INFO
*infoPtr
, HDC hdc
)
674 if (!infoPtr
->DoRedraw
) return;
676 for (i
= 0; i
< infoPtr
->uNumBands
; i
++) {
677 lpBand
= &infoPtr
->bands
[i
];
679 if (HIDDENBAND(lpBand
)) continue;
681 /* now draw the band */
682 TRACE("[%p] drawing band %i, flags=%08x\n",
683 infoPtr
->hwndSelf
, i
, lpBand
->fDraw
);
684 REBAR_DrawBand (hdc
, infoPtr
, lpBand
);
691 REBAR_FixVert (REBAR_INFO
*infoPtr
, UINT rowstart
, UINT rowend
,
694 /* Cycle through bands in row and fix height of each band. */
695 /* Also determine whether each band has changed. */
697 /* all bands at desired size. */
698 /* start and end bands are *not* hidden */
703 for (i
= (INT
)rowstart
; i
<=(INT
)rowend
; i
++) {
704 lpBand
= &infoPtr
->bands
[i
];
705 if (HIDDENBAND(lpBand
)) continue;
707 /* adjust height of bands in row to "mcy" value */
708 if (infoPtr
->dwStyle
& CCS_VERT
) {
709 if (lpBand
->rcBand
.right
!= lpBand
->rcBand
.left
+ mcy
)
710 lpBand
->rcBand
.right
= lpBand
->rcBand
.left
+ mcy
;
713 if (lpBand
->rcBand
.bottom
!= lpBand
->rcBand
.top
+ mcy
)
714 lpBand
->rcBand
.bottom
= lpBand
->rcBand
.top
+ mcy
;
718 /* mark whether we need to invalidate this band and trace */
719 if ((lpBand
->rcoldBand
.left
!=lpBand
->rcBand
.left
) ||
720 (lpBand
->rcoldBand
.top
!=lpBand
->rcBand
.top
) ||
721 (lpBand
->rcoldBand
.right
!=lpBand
->rcBand
.right
) ||
722 (lpBand
->rcoldBand
.bottom
!=lpBand
->rcBand
.bottom
)) {
723 lpBand
->fDraw
|= NTF_INVALIDATE
;
724 TRACE("band %d row=%d: changed to (%ld,%ld)-(%ld,%ld) from (%ld,%ld)-(%ld,%ld)\n",
726 lpBand
->rcBand
.left
, lpBand
->rcBand
.top
,
727 lpBand
->rcBand
.right
, lpBand
->rcBand
.bottom
,
728 lpBand
->rcoldBand
.left
, lpBand
->rcoldBand
.top
,
729 lpBand
->rcoldBand
.right
, lpBand
->rcoldBand
.bottom
);
732 TRACE("band %d row=%d: unchanged (%ld,%ld)-(%ld,%ld)\n",
734 lpBand
->rcBand
.left
, lpBand
->rcBand
.top
,
735 lpBand
->rcBand
.right
, lpBand
->rcBand
.bottom
);
741 REBAR_AdjustBands (REBAR_INFO
*infoPtr
, UINT rowstart
, UINT rowend
,
743 /* Function: This routine distributes the extra space in a row. */
744 /* See algorithm below. */
746 /* all bands @ ->cxHeader size */
747 /* start and end bands are *not* hidden */
750 UINT x
, xsep
, extra
, curwidth
, fudge
;
751 INT i
, last_adjusted
;
753 TRACE("start=%u, end=%u, max x=%d, max y=%d\n",
754 rowstart
, rowend
, maxx
, mcy
);
756 /* ******************* Phase 1 ************************ */
758 /* For each visible band with valid child */
759 /* a. inflate band till either all extra space used */
760 /* or band's ->ccx reached. */
761 /* If any band modified, add any space left to last band */
764 /* ****************************************************** */
765 lpBand
= &infoPtr
->bands
[rowend
];
766 extra
= maxx
- rcBrb(lpBand
);
769 for (i
=(INT
)rowstart
; i
<=(INT
)rowend
; i
++) {
770 lpBand
= &infoPtr
->bands
[i
];
771 if (HIDDENBAND(lpBand
)) continue;
772 xsep
= (x
== 0) ? 0 : SEP_WIDTH
;
773 curwidth
= rcBw(lpBand
);
775 /* set new left/top point */
776 if (infoPtr
->dwStyle
& CCS_VERT
)
777 lpBand
->rcBand
.top
= x
+ xsep
;
779 lpBand
->rcBand
.left
= x
+ xsep
;
781 /* compute new width */
782 if ((lpBand
->hwndChild
&& extra
) && !(lpBand
->fStyle
& RBBS_FIXEDSIZE
)) {
783 /* set to the "current" band size less the header */
786 if ((lpBand
->fMask
& RBBIM_SIZE
) && (lpBand
->cx
> 0) &&
787 (fudge
> curwidth
)) {
788 TRACE("adjusting band %d by %d, fudge=%d, curwidth=%d, extra=%d\n",
789 i
, fudge
-curwidth
, fudge
, curwidth
, extra
);
790 if ((fudge
- curwidth
) > extra
)
791 fudge
= curwidth
+ extra
;
792 extra
-= (fudge
- curwidth
);
796 TRACE("adjusting band %d by %d, fudge=%d, curwidth=%d\n",
797 i
, extra
, fudge
, curwidth
);
803 /* set new right/bottom point */
804 if (infoPtr
->dwStyle
& CCS_VERT
)
805 lpBand
->rcBand
.bottom
= lpBand
->rcBand
.top
+ curwidth
;
807 lpBand
->rcBand
.right
= lpBand
->rcBand
.left
+ curwidth
;
808 TRACE("Phase 1 band %d, (%ld,%ld)-(%ld,%ld), orig x=%d, xsep=%d\n",
809 i
, lpBand
->rcBand
.left
, lpBand
->rcBand
.top
,
810 lpBand
->rcBand
.right
, lpBand
->rcBand
.bottom
, x
, xsep
);
813 if ((x
>= maxx
) || (last_adjusted
!= -1)) {
815 ERR("Phase 1 failed, x=%d, maxx=%d, start=%u, end=%u\n",
816 x
, maxx
, rowstart
, rowend
);
818 /* done, so spread extra space */
821 TRACE("Need to spread %d on last adjusted band %d\n",
822 fudge
, last_adjusted
);
823 for (i
=(INT
)last_adjusted
; i
<=(INT
)rowend
; i
++) {
824 lpBand
= &infoPtr
->bands
[i
];
825 if (HIDDENBAND(lpBand
)) continue;
827 /* set right/bottom point */
828 if (i
!= last_adjusted
) {
829 if (infoPtr
->dwStyle
& CCS_VERT
)
830 lpBand
->rcBand
.top
+= fudge
;
832 lpBand
->rcBand
.left
+= fudge
;
835 /* set left/bottom point */
836 if (infoPtr
->dwStyle
& CCS_VERT
)
837 lpBand
->rcBand
.bottom
+= fudge
;
839 lpBand
->rcBand
.right
+= fudge
;
842 TRACE("Phase 1 succeeded, used x=%d\n", x
);
843 REBAR_FixVert (infoPtr
, rowstart
, rowend
, mcy
);
847 /* ******************* Phase 2 ************************ */
849 /* Find first visible band, put all */
850 /* extra space there. */
852 /* ****************************************************** */
855 for (i
=(INT
)rowstart
; i
<=(INT
)rowend
; i
++) {
856 lpBand
= &infoPtr
->bands
[i
];
857 if (HIDDENBAND(lpBand
)) continue;
858 xsep
= (x
== 0) ? 0 : SEP_WIDTH
;
859 curwidth
= rcBw(lpBand
);
861 /* set new left/top point */
862 if (infoPtr
->dwStyle
& CCS_VERT
)
863 lpBand
->rcBand
.top
= x
+ xsep
;
865 lpBand
->rcBand
.left
= x
+ xsep
;
867 /* compute new width */
873 /* set new right/bottom point */
874 if (infoPtr
->dwStyle
& CCS_VERT
)
875 lpBand
->rcBand
.bottom
= lpBand
->rcBand
.top
+ curwidth
;
877 lpBand
->rcBand
.right
= lpBand
->rcBand
.left
+ curwidth
;
878 TRACE("Phase 2 band %d, (%ld,%ld)-(%ld,%ld), orig x=%d, xsep=%d\n",
879 i
, lpBand
->rcBand
.left
, lpBand
->rcBand
.top
,
880 lpBand
->rcBand
.right
, lpBand
->rcBand
.bottom
, x
, xsep
);
885 ERR("Phase 2 failed, x=%d, maxx=%d, start=%u, end=%u\n",
886 x
, maxx
, rowstart
, rowend
);
888 /* done, so spread extra space */
889 TRACE("Phase 2 succeeded, used x=%d\n", x
);
890 REBAR_FixVert (infoPtr
, rowstart
, rowend
, mcy
);
894 /* ******************* Phase 3 ************************ */
895 /* at this point everything is back to ->cxHeader values */
896 /* and should not have gotten here. */
897 /* ****************************************************** */
899 lpBand
= &infoPtr
->bands
[rowstart
];
900 ERR("Serious problem adjusting row %d, start band %d, end band %d\n",
901 lpBand
->iRow
, rowstart
, rowend
);
902 REBAR_DumpBand (infoPtr
);
908 REBAR_CalcHorzBand (REBAR_INFO
*infoPtr
, UINT rstart
, UINT rend
, BOOL notify
)
909 /* Function: this routine initializes all the rectangles in */
910 /* each band in a row to fit in the adjusted rcBand rect. */
911 /* *** Supports only Horizontal bars. *** */
918 /* MS seems to use GetDlgCtrlID() for above GetWindowLong call */
919 parenthwnd
= GetParent (infoPtr
->hwndSelf
);
921 for(i
=rstart
; i
<rend
; i
++){
922 lpBand
= &infoPtr
->bands
[i
];
923 if (HIDDENBAND(lpBand
)) {
924 SetRect (&lpBand
->rcChild
,
925 lpBand
->rcBand
.right
, lpBand
->rcBand
.top
,
926 lpBand
->rcBand
.right
, lpBand
->rcBand
.bottom
);
930 oldChild
= lpBand
->rcChild
;
932 /* set initial gripper rectangle */
933 SetRect (&lpBand
->rcGripper
, lpBand
->rcBand
.left
, lpBand
->rcBand
.top
,
934 lpBand
->rcBand
.left
, lpBand
->rcBand
.bottom
);
936 /* calculate gripper rectangle */
937 if ( lpBand
->fStatus
& HAS_GRIPPER
) {
938 lpBand
->fDraw
|= DRAW_GRIPPER
;
939 lpBand
->rcGripper
.left
+= REBAR_PRE_GRIPPER
;
940 lpBand
->rcGripper
.right
= lpBand
->rcGripper
.left
+ GRIPPER_WIDTH
;
941 lpBand
->rcGripper
.top
+= 2;
942 lpBand
->rcGripper
.bottom
-= 2;
944 SetRect (&lpBand
->rcCapImage
,
945 lpBand
->rcGripper
.right
+REBAR_ALWAYS_SPACE
, lpBand
->rcBand
.top
,
946 lpBand
->rcGripper
.right
+REBAR_ALWAYS_SPACE
, lpBand
->rcBand
.bottom
);
948 else { /* no gripper will be drawn */
950 if (lpBand
->fStatus
& (HAS_IMAGE
| HAS_TEXT
))
951 /* if no gripper but either image or text, then leave space */
952 xoff
= REBAR_ALWAYS_SPACE
;
953 SetRect (&lpBand
->rcCapImage
,
954 lpBand
->rcBand
.left
+xoff
, lpBand
->rcBand
.top
,
955 lpBand
->rcBand
.left
+xoff
, lpBand
->rcBand
.bottom
);
958 /* image is visible */
959 if (lpBand
->fStatus
& HAS_IMAGE
) {
960 lpBand
->fDraw
|= DRAW_IMAGE
;
961 lpBand
->rcCapImage
.right
+= infoPtr
->imageSize
.cx
;
962 lpBand
->rcCapImage
.bottom
= lpBand
->rcCapImage
.top
+ infoPtr
->imageSize
.cy
;
964 /* set initial caption text rectangle */
965 SetRect (&lpBand
->rcCapText
,
966 lpBand
->rcCapImage
.right
+REBAR_POST_IMAGE
, lpBand
->rcBand
.top
+1,
967 lpBand
->rcBand
.left
+lpBand
->cxHeader
, lpBand
->rcBand
.bottom
-1);
968 /* update band height
969 if (lpBand->uMinHeight < infoPtr->imageSize.cy + 2) {
970 lpBand->uMinHeight = infoPtr->imageSize.cy + 2;
971 lpBand->rcBand.bottom = lpBand->rcBand.top + lpBand->uMinHeight;
975 /* set initial caption text rectangle */
976 SetRect (&lpBand
->rcCapText
, lpBand
->rcCapImage
.right
, lpBand
->rcBand
.top
+1,
977 lpBand
->rcBand
.left
+lpBand
->cxHeader
, lpBand
->rcBand
.bottom
-1);
980 /* text is visible */
981 if ((lpBand
->fStatus
& HAS_TEXT
) && !(lpBand
->fStyle
& RBBS_HIDETITLE
)) {
982 lpBand
->fDraw
|= DRAW_TEXT
;
983 lpBand
->rcCapText
.right
= max(lpBand
->rcCapText
.left
,
984 lpBand
->rcCapText
.right
-REBAR_POST_TEXT
);
987 /* set initial child window rectangle if there is a child */
988 if (lpBand
->fMask
& RBBIM_CHILD
) {
989 xoff
= lpBand
->offChild
.cx
;
990 yoff
= lpBand
->offChild
.cy
;
991 SetRect (&lpBand
->rcChild
,
992 lpBand
->rcBand
.left
+lpBand
->cxHeader
, lpBand
->rcBand
.top
+yoff
,
993 lpBand
->rcBand
.right
-xoff
, lpBand
->rcBand
.bottom
-yoff
);
994 if ((lpBand
->fStyle
& RBBS_USECHEVRON
) && (lpBand
->rcChild
.right
- lpBand
->rcChild
.left
< lpBand
->cxIdeal
))
996 lpBand
->rcChild
.right
-= CHEVRON_WIDTH
;
997 SetRect(&lpBand
->rcChevron
, lpBand
->rcChild
.right
,
998 lpBand
->rcChild
.top
, lpBand
->rcChild
.right
+ CHEVRON_WIDTH
,
999 lpBand
->rcChild
.bottom
);
1003 SetRect (&lpBand
->rcChild
,
1004 lpBand
->rcBand
.left
+lpBand
->cxHeader
, lpBand
->rcBand
.top
,
1005 lpBand
->rcBand
.right
, lpBand
->rcBand
.bottom
);
1008 /* flag if notify required and invalidate rectangle */
1010 ((oldChild
.right
-oldChild
.left
!= lpBand
->rcChild
.right
-lpBand
->rcChild
.left
) ||
1011 (oldChild
.bottom
-oldChild
.top
!= lpBand
->rcChild
.bottom
-lpBand
->rcChild
.top
))) {
1012 TRACE("Child rectangle changed for band %u\n", i
);
1013 TRACE(" from (%ld,%ld)-(%ld,%ld) to (%ld,%ld)-(%ld,%ld)\n",
1014 oldChild
.left
, oldChild
.top
,
1015 oldChild
.right
, oldChild
.bottom
,
1016 lpBand
->rcChild
.left
, lpBand
->rcChild
.top
,
1017 lpBand
->rcChild
.right
, lpBand
->rcChild
.bottom
);
1019 if (lpBand
->fDraw
& NTF_INVALIDATE
) {
1020 TRACE("invalidating (%ld,%ld)-(%ld,%ld)\n",
1021 lpBand
->rcBand
.left
,
1023 lpBand
->rcBand
.right
+ ((lpBand
->fDraw
& DRAW_RIGHTSEP
) ? SEP_WIDTH_SIZE
: 0),
1024 lpBand
->rcBand
.bottom
+ ((lpBand
->fDraw
& DRAW_BOTTOMSEP
) ? SEP_WIDTH_SIZE
: 0));
1025 lpBand
->fDraw
&= ~NTF_INVALIDATE
;
1026 work
= lpBand
->rcBand
;
1027 if (lpBand
->fDraw
& DRAW_RIGHTSEP
) work
.right
+= SEP_WIDTH_SIZE
;
1028 if (lpBand
->fDraw
& DRAW_BOTTOMSEP
) work
.bottom
+= SEP_WIDTH_SIZE
;
1029 InvalidateRect(infoPtr
->hwndSelf
, &work
, TRUE
);
1038 REBAR_CalcVertBand (REBAR_INFO
*infoPtr
, UINT rstart
, UINT rend
, BOOL notify
)
1039 /* Function: this routine initializes all the rectangles in */
1040 /* each band in a row to fit in the adjusted rcBand rect. */
1041 /* *** Supports only Vertical bars. *** */
1046 RECT oldChild
, work
;
1048 /* MS seems to use GetDlgCtrlID() for above GetWindowLong call */
1049 parenthwnd
= GetParent (infoPtr
->hwndSelf
);
1051 for(i
=rstart
; i
<rend
; i
++){
1052 lpBand
= &infoPtr
->bands
[i
];
1053 if (HIDDENBAND(lpBand
)) continue;
1054 oldChild
= lpBand
->rcChild
;
1056 /* set initial gripper rectangle */
1057 SetRect (&lpBand
->rcGripper
, lpBand
->rcBand
.left
, lpBand
->rcBand
.top
,
1058 lpBand
->rcBand
.right
, lpBand
->rcBand
.top
);
1060 /* calculate gripper rectangle */
1061 if (lpBand
->fStatus
& HAS_GRIPPER
) {
1062 lpBand
->fDraw
|= DRAW_GRIPPER
;
1064 if (infoPtr
->dwStyle
& RBS_VERTICALGRIPPER
) {
1065 /* vertical gripper */
1066 lpBand
->rcGripper
.left
+= 3;
1067 lpBand
->rcGripper
.right
= lpBand
->rcGripper
.left
+ GRIPPER_WIDTH
;
1068 lpBand
->rcGripper
.top
+= REBAR_PRE_GRIPPER
;
1069 lpBand
->rcGripper
.bottom
= lpBand
->rcGripper
.top
+ GRIPPER_HEIGHT
;
1071 /* initialize Caption image rectangle */
1072 SetRect (&lpBand
->rcCapImage
, lpBand
->rcBand
.left
,
1073 lpBand
->rcGripper
.bottom
+ REBAR_ALWAYS_SPACE
,
1074 lpBand
->rcBand
.right
,
1075 lpBand
->rcGripper
.bottom
+ REBAR_ALWAYS_SPACE
);
1078 /* horizontal gripper */
1079 lpBand
->rcGripper
.left
+= 2;
1080 lpBand
->rcGripper
.right
-= 2;
1081 lpBand
->rcGripper
.top
+= REBAR_PRE_GRIPPER
;
1082 lpBand
->rcGripper
.bottom
= lpBand
->rcGripper
.top
+ GRIPPER_WIDTH
;
1084 /* initialize Caption image rectangle */
1085 SetRect (&lpBand
->rcCapImage
, lpBand
->rcBand
.left
,
1086 lpBand
->rcGripper
.bottom
+ REBAR_ALWAYS_SPACE
,
1087 lpBand
->rcBand
.right
,
1088 lpBand
->rcGripper
.bottom
+ REBAR_ALWAYS_SPACE
);
1091 else { /* no gripper will be drawn */
1093 if (lpBand
->fStatus
& (HAS_IMAGE
| HAS_TEXT
))
1094 /* if no gripper but either image or text, then leave space */
1095 xoff
= REBAR_ALWAYS_SPACE
;
1096 /* initialize Caption image rectangle */
1097 SetRect (&lpBand
->rcCapImage
,
1098 lpBand
->rcBand
.left
, lpBand
->rcBand
.top
+xoff
,
1099 lpBand
->rcBand
.right
, lpBand
->rcBand
.top
+xoff
);
1102 /* image is visible */
1103 if (lpBand
->fStatus
& HAS_IMAGE
) {
1104 lpBand
->fDraw
|= DRAW_IMAGE
;
1106 lpBand
->rcCapImage
.right
= lpBand
->rcCapImage
.left
+ infoPtr
->imageSize
.cx
;
1107 lpBand
->rcCapImage
.bottom
+= infoPtr
->imageSize
.cy
;
1109 /* set initial caption text rectangle */
1110 SetRect (&lpBand
->rcCapText
,
1111 lpBand
->rcBand
.left
, lpBand
->rcCapImage
.bottom
+REBAR_POST_IMAGE
,
1112 lpBand
->rcBand
.right
, lpBand
->rcBand
.top
+lpBand
->cxHeader
);
1113 /* update band height *
1114 if (lpBand->uMinHeight < infoPtr->imageSize.cx + 2) {
1115 lpBand->uMinHeight = infoPtr->imageSize.cx + 2;
1116 lpBand->rcBand.right = lpBand->rcBand.left + lpBand->uMinHeight;
1120 /* set initial caption text rectangle */
1121 SetRect (&lpBand
->rcCapText
,
1122 lpBand
->rcBand
.left
, lpBand
->rcCapImage
.bottom
,
1123 lpBand
->rcBand
.right
, lpBand
->rcBand
.top
+lpBand
->cxHeader
);
1126 /* text is visible */
1127 if ((lpBand
->fStatus
& HAS_TEXT
) && !(lpBand
->fStyle
& RBBS_HIDETITLE
)) {
1128 lpBand
->fDraw
|= DRAW_TEXT
;
1129 lpBand
->rcCapText
.bottom
= max(lpBand
->rcCapText
.top
,
1130 lpBand
->rcCapText
.bottom
);
1133 /* set initial child window rectangle if there is a child */
1134 if (lpBand
->fMask
& RBBIM_CHILD
) {
1135 yoff
= lpBand
->offChild
.cx
;
1136 xoff
= lpBand
->offChild
.cy
;
1137 SetRect (&lpBand
->rcChild
,
1138 lpBand
->rcBand
.left
+xoff
, lpBand
->rcBand
.top
+lpBand
->cxHeader
,
1139 lpBand
->rcBand
.right
-xoff
, lpBand
->rcBand
.bottom
-yoff
);
1142 SetRect (&lpBand
->rcChild
,
1143 lpBand
->rcBand
.left
, lpBand
->rcBand
.top
+lpBand
->cxHeader
,
1144 lpBand
->rcBand
.right
, lpBand
->rcBand
.bottom
);
1147 /* flag if notify required and invalidate rectangle */
1149 ((oldChild
.right
-oldChild
.left
!= lpBand
->rcChild
.right
-lpBand
->rcChild
.left
) ||
1150 (oldChild
.bottom
-oldChild
.top
!= lpBand
->rcChild
.bottom
-lpBand
->rcChild
.top
))) {
1151 TRACE("Child rectangle changed for band %u\n", i
);
1152 TRACE(" from (%ld,%ld)-(%ld,%ld) to (%ld,%ld)-(%ld,%ld)\n",
1153 oldChild
.left
, oldChild
.top
,
1154 oldChild
.right
, oldChild
.bottom
,
1155 lpBand
->rcChild
.left
, lpBand
->rcChild
.top
,
1156 lpBand
->rcChild
.right
, lpBand
->rcChild
.bottom
);
1158 if (lpBand
->fDraw
& NTF_INVALIDATE
) {
1159 TRACE("invalidating (%ld,%ld)-(%ld,%ld)\n",
1160 lpBand
->rcBand
.left
,
1162 lpBand
->rcBand
.right
+ ((lpBand
->fDraw
& DRAW_BOTTOMSEP
) ? SEP_WIDTH_SIZE
: 0),
1163 lpBand
->rcBand
.bottom
+ ((lpBand
->fDraw
& DRAW_RIGHTSEP
) ? SEP_WIDTH_SIZE
: 0));
1164 lpBand
->fDraw
&= ~NTF_INVALIDATE
;
1165 work
= lpBand
->rcBand
;
1166 if (lpBand
->fDraw
& DRAW_RIGHTSEP
) work
.bottom
+= SEP_WIDTH_SIZE
;
1167 if (lpBand
->fDraw
& DRAW_BOTTOMSEP
) work
.right
+= SEP_WIDTH_SIZE
;
1168 InvalidateRect(infoPtr
->hwndSelf
, &work
, TRUE
);
1176 REBAR_ForceResize (REBAR_INFO
*infoPtr
)
1177 /* Function: This changes the size of the REBAR window to that */
1178 /* calculated by REBAR_Layout. */
1181 INT x
, y
, width
, height
;
1182 INT xedge
= GetSystemMetrics(SM_CXEDGE
);
1183 INT yedge
= GetSystemMetrics(SM_CYEDGE
);
1185 /* TEST TEST TEST */
1186 GetWindowRect (infoPtr
->hwndSelf
, &rc
);
1187 /* END TEST END TEST END TEST */
1190 GetClientRect (infoPtr
->hwndSelf
, &rc
);
1192 TRACE( " old [%ld x %ld], new [%ld x %ld], client [%ld x %ld]\n",
1193 infoPtr
->oldSize
.cx
, infoPtr
->oldSize
.cy
,
1194 infoPtr
->calcSize
.cx
, infoPtr
->calcSize
.cy
,
1195 rc
.right
, rc
.bottom
);
1197 /* If we need to shrink client, then skip size test */
1198 if ((infoPtr
->calcSize
.cy
>= rc
.bottom
) &&
1199 (infoPtr
->calcSize
.cx
>= rc
.right
)) {
1201 /* if size did not change then skip process */
1202 if ((infoPtr
->oldSize
.cx
== infoPtr
->calcSize
.cx
) &&
1203 (infoPtr
->oldSize
.cy
== infoPtr
->calcSize
.cy
) &&
1204 !(infoPtr
->fStatus
& RESIZE_ANYHOW
))
1206 TRACE("skipping reset\n");
1211 infoPtr
->fStatus
&= ~RESIZE_ANYHOW
;
1212 /* Set flag to ignore next WM_SIZE message */
1213 infoPtr
->fStatus
|= AUTO_RESIZE
;
1220 if (infoPtr
->dwStyle
& WS_BORDER
) {
1225 if (!(infoPtr
->dwStyle
& CCS_NOPARENTALIGN
)) {
1226 INT mode
= infoPtr
->dwStyle
& (CCS_VERT
| CCS_TOP
| CCS_BOTTOM
);
1229 GetClientRect(GetParent(infoPtr
->hwndSelf
), &rcPcl
);
1232 /* _TOP sets width to parents width */
1233 width
+= (rcPcl
.right
- rcPcl
.left
);
1234 height
+= infoPtr
->calcSize
.cy
;
1235 x
+= ((infoPtr
->dwStyle
& WS_BORDER
) ? -xedge
: 0);
1236 y
+= ((infoPtr
->dwStyle
& WS_BORDER
) ? -yedge
: 0);
1237 y
+= ((infoPtr
->dwStyle
& CCS_NODIVIDER
) ? 0 : REBAR_DIVIDER
);
1240 /* FIXME: wrong wrong wrong */
1241 /* _BOTTOM sets width to parents width */
1242 width
+= (rcPcl
.right
- rcPcl
.left
);
1243 height
+= infoPtr
->calcSize
.cy
;
1245 y
= rcPcl
.bottom
- height
+ 1;
1248 /* _LEFT sets height to parents height */
1249 width
+= infoPtr
->calcSize
.cx
;
1250 height
+= (rcPcl
.bottom
- rcPcl
.top
);
1251 x
+= ((infoPtr
->dwStyle
& WS_BORDER
) ? -xedge
: 0);
1252 x
+= ((infoPtr
->dwStyle
& CCS_NODIVIDER
) ? 0 : REBAR_DIVIDER
);
1253 y
+= ((infoPtr
->dwStyle
& WS_BORDER
) ? -yedge
: 0);
1256 /* FIXME: wrong wrong wrong */
1257 /* _RIGHT sets height to parents height */
1258 width
+= infoPtr
->calcSize
.cx
;
1259 height
+= (rcPcl
.bottom
- rcPcl
.top
);
1260 x
= rcPcl
.right
- width
+ 1;
1264 width
+= infoPtr
->calcSize
.cx
;
1265 height
+= infoPtr
->calcSize
.cy
;
1269 width
+= infoPtr
->calcSize
.cx
;
1270 height
+= infoPtr
->calcSize
.cy
;
1271 x
= infoPtr
->origin
.x
;
1272 y
= infoPtr
->origin
.y
;
1275 TRACE("hwnd %p, style=%08lx, setting at (%d,%d) for (%d,%d)\n",
1276 infoPtr
->hwndSelf
, infoPtr
->dwStyle
,
1277 x
, y
, width
, height
);
1278 SetWindowPos (infoPtr
->hwndSelf
, 0, x
, y
, width
, height
,
1284 REBAR_MoveChildWindows (REBAR_INFO
*infoPtr
, UINT start
, UINT endplus
)
1287 CHAR szClassName
[40];
1289 NMREBARCHILDSIZE rbcz
;
1293 if (!(deferpos
= BeginDeferWindowPos(infoPtr
->uNumBands
)))
1294 ERR("BeginDeferWindowPos returned NULL\n");
1296 for (i
= start
; i
< endplus
; i
++) {
1297 lpBand
= &infoPtr
->bands
[i
];
1299 if (HIDDENBAND(lpBand
)) continue;
1300 if (lpBand
->hwndChild
) {
1301 TRACE("hwndChild = %p\n", lpBand
->hwndChild
);
1303 /* Always geterate the RBN_CHILDSIZE even it child
1306 rbcz
.wID
= lpBand
->wID
;
1307 rbcz
.rcChild
= lpBand
->rcChild
;
1308 rbcz
.rcBand
= lpBand
->rcBand
;
1309 if (infoPtr
->dwStyle
& CCS_VERT
)
1310 rbcz
.rcBand
.top
+= lpBand
->cxHeader
;
1312 rbcz
.rcBand
.left
+= lpBand
->cxHeader
;
1313 REBAR_Notify ((NMHDR
*)&rbcz
, infoPtr
, RBN_CHILDSIZE
);
1314 if (!EqualRect (&lpBand
->rcChild
, &rbcz
.rcChild
)) {
1315 TRACE("Child rect changed by NOTIFY for band %u\n", i
);
1316 TRACE(" from (%ld,%ld)-(%ld,%ld) to (%ld,%ld)-(%ld,%ld)\n",
1317 lpBand
->rcChild
.left
, lpBand
->rcChild
.top
,
1318 lpBand
->rcChild
.right
, lpBand
->rcChild
.bottom
,
1319 rbcz
.rcChild
.left
, rbcz
.rcChild
.top
,
1320 rbcz
.rcChild
.right
, rbcz
.rcChild
.bottom
);
1321 lpBand
->rcChild
= rbcz
.rcChild
; /* *** ??? */
1324 /* native (IE4 in "Favorites" frame **1) does:
1325 * SetRect (&rc, -1, -1, -1, -1)
1326 * EqualRect (&rc,band->rc???)
1328 * CopyRect (band->rc????, &rc)
1329 * set flag outside of loop
1332 GetClassNameA (lpBand
->hwndChild
, szClassName
, 40);
1333 if (!lstrcmpA (szClassName
, "ComboBox") ||
1334 !lstrcmpA (szClassName
, WC_COMBOBOXEXA
)) {
1335 INT nEditHeight
, yPos
;
1338 /* special placement code for combo or comboex box */
1341 /* get size of edit line */
1342 GetWindowRect (lpBand
->hwndChild
, &rc
);
1343 nEditHeight
= rc
.bottom
- rc
.top
;
1344 yPos
= (lpBand
->rcChild
.bottom
+ lpBand
->rcChild
.top
- nEditHeight
)/2;
1346 /* center combo box inside child area */
1347 TRACE("moving child (Combo(Ex)) %p to (%ld,%d) for (%ld,%d)\n",
1349 lpBand
->rcChild
.left
, yPos
,
1350 lpBand
->rcChild
.right
- lpBand
->rcChild
.left
,
1352 deferpos
= DeferWindowPos (deferpos
, lpBand
->hwndChild
, HWND_TOP
,
1353 lpBand
->rcChild
.left
,
1354 /*lpBand->rcChild.top*/ yPos
,
1355 lpBand
->rcChild
.right
- lpBand
->rcChild
.left
,
1359 ERR("DeferWindowPos returned NULL\n");
1362 TRACE("moving child (Other) %p to (%ld,%ld) for (%ld,%ld)\n",
1364 lpBand
->rcChild
.left
, lpBand
->rcChild
.top
,
1365 lpBand
->rcChild
.right
- lpBand
->rcChild
.left
,
1366 lpBand
->rcChild
.bottom
- lpBand
->rcChild
.top
);
1367 deferpos
= DeferWindowPos (deferpos
, lpBand
->hwndChild
, HWND_TOP
,
1368 lpBand
->rcChild
.left
,
1369 lpBand
->rcChild
.top
,
1370 lpBand
->rcChild
.right
- lpBand
->rcChild
.left
,
1371 lpBand
->rcChild
.bottom
- lpBand
->rcChild
.top
,
1374 ERR("DeferWindowPos returned NULL\n");
1378 if (!EndDeferWindowPos(deferpos
))
1379 ERR("EndDeferWindowPos returned NULL\n");
1381 if (infoPtr
->DoRedraw
)
1382 UpdateWindow (infoPtr
->hwndSelf
);
1384 if (infoPtr
->fStatus
& NTF_HGHTCHG
) {
1385 infoPtr
->fStatus
&= ~NTF_HGHTCHG
;
1386 REBAR_Notify (&heightchange
, infoPtr
, RBN_HEIGHTCHANGE
);
1389 /* native (from **1 above) does:
1390 * UpdateWindow(rebar)
1392 * RBN_HEIGHTCHANGE if necessary
1393 * if ret from any EqualRect was 0
1394 * Goto "BeginDeferWindowPos"
1401 REBAR_Layout (REBAR_INFO
*infoPtr
, LPRECT lpRect
, BOOL notify
, BOOL resetclient
)
1402 /* Function: This routine is resposible for laying out all */
1403 /* the bands in a rebar. It assigns each band to a row and*/
1404 /* determines when to start a new row. */
1406 REBAR_BAND
*lpBand
, *prevBand
;
1407 RECT rcClient
, rcAdj
;
1408 INT initx
, inity
, x
, y
, cx
, cxsep
, mmcy
, mcy
, clientcx
, clientcy
;
1409 INT adjcx
, adjcy
, row
, rightx
, bottomy
, origheight
;
1410 UINT i
, j
, rowstart
, origrows
, cntonrow
;
1413 if (!(infoPtr
->fStatus
& BAND_NEEDS_LAYOUT
)) {
1414 TRACE("no layout done. No band changed.\n");
1415 REBAR_DumpBand (infoPtr
);
1418 infoPtr
->fStatus
&= ~BAND_NEEDS_LAYOUT
;
1419 if (!infoPtr
->DoRedraw
) infoPtr
->fStatus
|= BAND_NEEDS_REDRAW
;
1421 GetClientRect (infoPtr
->hwndSelf
, &rcClient
);
1422 TRACE("Client is (%ld,%ld)-(%ld,%ld)\n",
1423 rcClient
.left
, rcClient
.top
, rcClient
.right
, rcClient
.bottom
);
1427 TRACE("adjustment rect is (%ld,%ld)-(%ld,%ld)\n",
1428 rcAdj
.left
, rcAdj
.top
, rcAdj
.right
, rcAdj
.bottom
);
1431 CopyRect (&rcAdj
, &rcClient
);
1434 clientcx
= rcClient
.right
- rcClient
.left
;
1435 clientcy
= rcClient
.bottom
- rcClient
.top
;
1436 adjcx
= rcAdj
.right
- rcAdj
.left
;
1437 adjcy
= rcAdj
.bottom
- rcAdj
.top
;
1439 TRACE("window client rect will be set to adj rect\n");
1444 if (!infoPtr
->DoRedraw
&& (clientcx
== 0) && (clientcy
== 0)) {
1445 ERR("no redraw and client is zero, skip layout\n");
1446 infoPtr
->fStatus
|= BAND_NEEDS_LAYOUT
;
1450 /* save height of original control */
1451 if (infoPtr
->dwStyle
& CCS_VERT
)
1452 origheight
= infoPtr
->calcSize
.cx
;
1454 origheight
= infoPtr
->calcSize
.cy
;
1455 origrows
= infoPtr
->uNumRows
;
1460 /* ******* Start Phase 1 - all bands on row at minimum size ******* */
1462 TRACE("band loop constants, clientcx=%d, clientcy=%d, adjcx=%d, adjcy=%d\n",
1463 clientcx
, clientcy
, adjcx
, adjcy
);
1473 for (i
= 0; i
< infoPtr
->uNumBands
; i
++) {
1474 lpBand
= &infoPtr
->bands
[i
];
1478 SetRectEmpty(&lpBand
->rcChevron
);
1480 if (HIDDENBAND(lpBand
)) continue;
1482 lpBand
->rcoldBand
= lpBand
->rcBand
;
1484 /* Set the offset of the child window */
1485 if ((lpBand
->fMask
& RBBIM_CHILD
) &&
1486 !(lpBand
->fStyle
& RBBS_FIXEDSIZE
)) {
1487 lpBand
->offChild
.cx
= ((lpBand
->fStyle
& RBBS_CHILDEDGE
) ? 4 : 0);
1489 lpBand
->offChild
.cy
= ((lpBand
->fStyle
& RBBS_CHILDEDGE
) ? 2 : 0);
1491 /* separator from previous band */
1492 cxsep
= (cntonrow
== 0) ? 0 : SEP_WIDTH
;
1495 if (infoPtr
->dwStyle
& CCS_VERT
)
1496 dobreak
= (y
+ cx
+ cxsep
> adjcy
);
1498 dobreak
= (x
+ cx
+ cxsep
> adjcx
);
1500 /* This is the check for whether we need to start a new row */
1501 if ( ( (lpBand
->fStyle
& RBBS_BREAK
) && (i
!= 0) ) ||
1502 ( ((infoPtr
->dwStyle
& CCS_VERT
) ? (y
!= 0) : (x
!= 0)) && dobreak
)) {
1504 for (j
= rowstart
; j
< i
; j
++) {
1506 lpB
= &infoPtr
->bands
[j
];
1507 if (infoPtr
->dwStyle
& CCS_VERT
) {
1508 lpB
->rcBand
.right
= lpB
->rcBand
.left
+ mcy
;
1511 lpB
->rcBand
.bottom
= lpB
->rcBand
.top
+ mcy
;
1515 TRACE("P1 Spliting to new row %d on band %u\n", row
+1, i
);
1516 if (infoPtr
->dwStyle
& CCS_VERT
) {
1518 x
+= (mcy
+ SEP_WIDTH
);
1522 y
+= (mcy
+ SEP_WIDTH
);
1534 if (mcy
< lpBand
->lcy
+ REBARSPACE(lpBand
))
1535 mcy
= lpBand
->lcy
+ REBARSPACE(lpBand
);
1537 /* if boundary rect specified then limit mcy */
1539 if (infoPtr
->dwStyle
& CCS_VERT
) {
1540 if (x
+mcy
> adjcx
) {
1542 TRACE("P1 row %u limiting mcy=%d, adjcx=%d, x=%d\n",
1547 if (y
+mcy
> adjcy
) {
1549 TRACE("P1 row %u limiting mcy=%d, adjcy=%d, y=%d\n",
1555 TRACE("P1 band %u, row %d, x=%d, y=%d, cxsep=%d, cx=%d\n",
1558 if (infoPtr
->dwStyle
& CCS_VERT
) {
1559 /* bound the bottom side if we have a bounding rectangle */
1561 bottomy
= (lpRect
) ? min(clientcy
, y
+cxsep
+cx
) : y
+cxsep
+cx
;
1562 lpBand
->rcBand
.left
= x
;
1563 lpBand
->rcBand
.right
= x
+ min(mcy
,
1564 lpBand
->lcy
+REBARSPACE(lpBand
));
1565 lpBand
->rcBand
.top
= min(bottomy
, y
+ cxsep
);
1566 lpBand
->rcBand
.bottom
= bottomy
;
1567 lpBand
->uMinHeight
= lpBand
->lcy
;
1571 /* bound the right side if we have a bounding rectangle */
1572 rightx
= (lpRect
) ? min(clientcx
, x
+cxsep
+cx
) : x
+cxsep
+cx
;
1574 lpBand
->rcBand
.left
= min(rightx
, x
+ cxsep
);
1575 lpBand
->rcBand
.right
= rightx
;
1576 lpBand
->rcBand
.top
= y
;
1577 lpBand
->rcBand
.bottom
= y
+ min(mcy
,
1578 lpBand
->lcy
+REBARSPACE(lpBand
));
1579 lpBand
->uMinHeight
= lpBand
->lcy
;
1582 TRACE("P1 band %u, row %d, (%ld,%ld)-(%ld,%ld)\n",
1584 lpBand
->rcBand
.left
, lpBand
->rcBand
.top
,
1585 lpBand
->rcBand
.right
, lpBand
->rcBand
.bottom
);
1589 } /* for (i = 0; i < infoPtr->uNumBands... */
1591 if (infoPtr
->dwStyle
& CCS_VERT
)
1596 for (j
= rowstart
; j
< infoPtr
->uNumBands
; j
++) {
1597 lpBand
= &infoPtr
->bands
[j
];
1598 if (infoPtr
->dwStyle
& CCS_VERT
) {
1599 lpBand
->rcBand
.right
= lpBand
->rcBand
.left
+ mcy
;
1602 lpBand
->rcBand
.bottom
= lpBand
->rcBand
.top
+ mcy
;
1606 if (infoPtr
->uNumBands
)
1607 infoPtr
->uNumRows
= row
;
1609 /* ******* End Phase 1 - all bands on row at minimum size ******* */
1612 /* ******* Start Phase 1a - Adjust heights for RBS_VARHEIGHT off ******* */
1615 if (!(infoPtr
->dwStyle
& RBS_VARHEIGHT
)) {
1618 /* get the max height of all bands */
1619 for (i
=0; i
<infoPtr
->uNumBands
; i
++) {
1620 lpBand
= &infoPtr
->bands
[i
];
1621 if (HIDDENBAND(lpBand
)) continue;
1622 if (infoPtr
->dwStyle
& CCS_VERT
)
1623 mmcy
= max(mmcy
, lpBand
->rcBand
.right
- lpBand
->rcBand
.left
);
1625 mmcy
= max(mmcy
, lpBand
->rcBand
.bottom
- lpBand
->rcBand
.top
);
1628 /* now adjust all rectangles by using the height found above */
1631 for (i
=0; i
<infoPtr
->uNumBands
; i
++) {
1632 lpBand
= &infoPtr
->bands
[i
];
1633 if (HIDDENBAND(lpBand
)) continue;
1634 if (lpBand
->iRow
!= row
)
1635 xy
+= (mmcy
+ SEP_WIDTH
);
1636 if (infoPtr
->dwStyle
& CCS_VERT
) {
1637 lpBand
->rcBand
.left
= xy
;
1638 lpBand
->rcBand
.right
= xy
+ mmcy
;
1641 lpBand
->rcBand
.top
= xy
;
1642 lpBand
->rcBand
.bottom
= xy
+ mmcy
;
1646 /* set the x/y values to the correct maximum */
1647 if (infoPtr
->dwStyle
& CCS_VERT
)
1653 /* ******* End Phase 1a - Adjust heights for RBS_VARHEIGHT off ******* */
1656 /* ******* Start Phase 2 - split rows till adjustment height full ******* */
1658 /* assumes that the following variables contain: */
1659 /* y/x current height/width of all rows */
1661 INT i
, prev_rh
, new_rh
, adj_rh
, prev_idx
, current_idx
;
1662 REBAR_BAND
*prev
, *current
, *walk
;
1665 /* FIXME: problem # 2 */
1666 if (((infoPtr
->dwStyle
& CCS_VERT
) ?
1668 (x
< adjcx
) : (y
< adjcy
)
1670 (adjcx
- x
> 5) : (adjcy
- y
> 4)
1673 (infoPtr
->uNumBands
> 1)) {
1674 for (i
=(INT
)infoPtr
->uNumBands
-2; i
>=0; i
--) {
1675 TRACE("P2 adjcx=%d, adjcy=%d, x=%d, y=%d\n",
1676 adjcx
, adjcy
, x
, y
);
1678 /* find the current band (starts at i+1) */
1679 current
= &infoPtr
->bands
[i
+1];
1681 while (HIDDENBAND(current
)) {
1683 if (i
< 0) break; /* out of bands */
1684 current
= &infoPtr
->bands
[i
+1];
1687 if (i
< 0) break; /* out of bands */
1689 /* now find the prev band (starts at i) */
1690 prev
= &infoPtr
->bands
[i
];
1692 while (HIDDENBAND(prev
)) {
1694 if (i
< 0) break; /* out of bands */
1695 prev
= &infoPtr
->bands
[i
];
1698 if (i
< 0) break; /* out of bands */
1700 prev_rh
= ircBw(prev
);
1701 if (prev
->iRow
== current
->iRow
) {
1702 new_rh
= (infoPtr
->dwStyle
& RBS_VARHEIGHT
) ?
1703 current
->lcy
+ REBARSPACE(current
) :
1705 adj_rh
= new_rh
+ SEP_WIDTH
;
1706 infoPtr
->uNumRows
++;
1707 current
->fDraw
|= NTF_INVALIDATE
;
1709 if (infoPtr
->dwStyle
& CCS_VERT
) {
1710 current
->rcBand
.top
= inity
;
1711 current
->rcBand
.bottom
= clientcy
;
1712 current
->rcBand
.left
+= (prev_rh
+ SEP_WIDTH
);
1713 current
->rcBand
.right
= current
->rcBand
.left
+ new_rh
;
1717 current
->rcBand
.left
= initx
;
1718 current
->rcBand
.right
= clientcx
;
1719 current
->rcBand
.top
+= (prev_rh
+ SEP_WIDTH
);
1720 current
->rcBand
.bottom
= current
->rcBand
.top
+ new_rh
;
1723 TRACE("P2 moving band %d to own row at (%ld,%ld)-(%ld,%ld)\n",
1725 current
->rcBand
.left
, current
->rcBand
.top
,
1726 current
->rcBand
.right
, current
->rcBand
.bottom
);
1727 TRACE("P2 prev band %d at (%ld,%ld)-(%ld,%ld)\n",
1729 prev
->rcBand
.left
, prev
->rcBand
.top
,
1730 prev
->rcBand
.right
, prev
->rcBand
.bottom
);
1731 TRACE("P2 values: prev_rh=%d, new_rh=%d, adj_rh=%d\n",
1732 prev_rh
, new_rh
, adj_rh
);
1733 /* for bands below current adjust row # and top/bottom */
1734 for (j
= current_idx
+1; j
<infoPtr
->uNumBands
; j
++) {
1735 walk
= &infoPtr
->bands
[j
];
1736 if (HIDDENBAND(walk
)) continue;
1737 walk
->fDraw
|= NTF_INVALIDATE
;
1739 if (infoPtr
->dwStyle
& CCS_VERT
) {
1740 walk
->rcBand
.left
+= adj_rh
;
1741 walk
->rcBand
.right
+= adj_rh
;
1744 walk
->rcBand
.top
+= adj_rh
;
1745 walk
->rcBand
.bottom
+= adj_rh
;
1748 if ((infoPtr
->dwStyle
& CCS_VERT
) ? (x
>= adjcx
) : (y
>= adjcy
))
1749 break; /* all done */
1755 /* ******* End Phase 2 - split rows till adjustment height full ******* */
1758 /* ******* Start Phase 2a - mark first and last band in each ******* */
1761 for (i
= 0; i
< infoPtr
->uNumBands
; i
++) {
1762 lpBand
= &infoPtr
->bands
[i
];
1763 if (HIDDENBAND(lpBand
))
1766 lpBand
->fDraw
|= DRAW_FIRST_IN_ROW
;
1769 else if( prevBand
->iRow
== lpBand
->iRow
)
1772 prevBand
->fDraw
|= DRAW_LAST_IN_ROW
;
1773 lpBand
->fDraw
|= DRAW_FIRST_IN_ROW
;
1778 prevBand
->fDraw
|= DRAW_LAST_IN_ROW
;
1780 /* ******* End Phase 2a - mark first and last band in each ******* */
1783 /* ******* Start Phase 2b - adjust all bands for height full ******* */
1784 /* assumes that the following variables contain: */
1785 /* y/x current height/width of all rows */
1786 /* clientcy/clientcx height/width of client area */
1788 if (((infoPtr
->dwStyle
& CCS_VERT
) ? clientcx
> x
: clientcy
> y
) &&
1789 infoPtr
->uNumBands
) {
1793 diff
= (infoPtr
->dwStyle
& CCS_VERT
) ? clientcx
- x
: clientcy
- y
;
1795 /* iterate backwards thru the rows */
1796 for (i
= infoPtr
->uNumBands
-1; i
>=0; i
--) {
1797 lpBand
= &infoPtr
->bands
[i
];
1798 if(HIDDENBAND(lpBand
)) continue;
1800 /* if row has more than 1 band, ignore it */
1801 if( !(lpBand
->fDraw
&DRAW_FIRST_IN_ROW
) )
1803 if( !(lpBand
->fDraw
&DRAW_LAST_IN_ROW
) )
1806 if (lpBand
->fMask
& RBBS_VARIABLEHEIGHT
) continue;
1807 if (((INT
)lpBand
->cyMaxChild
< 1) ||
1808 ((INT
)lpBand
->cyIntegral
< 1)) {
1809 if (lpBand
->cyMaxChild
+ lpBand
->cyIntegral
== 0) continue;
1810 ERR("P2b band %u RBBS_VARIABLEHEIGHT set but cyMax=%d, cyInt=%d\n",
1811 i
, lpBand
->cyMaxChild
, lpBand
->cyIntegral
);
1814 /* j is now the maximum height/width in the client area */
1815 j
= ((diff
/ lpBand
->cyIntegral
) * lpBand
->cyIntegral
) +
1817 if (j
> lpBand
->cyMaxChild
+ REBARSPACE(lpBand
))
1818 j
= lpBand
->cyMaxChild
+ REBARSPACE(lpBand
);
1819 diff
-= (j
- ircBw(lpBand
));
1820 if (infoPtr
->dwStyle
& CCS_VERT
)
1821 lpBand
->rcBand
.right
= lpBand
->rcBand
.left
+ j
;
1823 lpBand
->rcBand
.bottom
= lpBand
->rcBand
.top
+ j
;
1824 TRACE("P2b band %d, row %d changed to (%ld,%ld)-(%ld,%ld)\n",
1826 lpBand
->rcBand
.left
, lpBand
->rcBand
.top
,
1827 lpBand
->rcBand
.right
, lpBand
->rcBand
.bottom
);
1828 if (diff
<= 0) break;
1831 ERR("P2b allocated more than available, diff=%d\n", diff
);
1834 if (infoPtr
->dwStyle
& CCS_VERT
)
1835 x
= clientcx
- diff
;
1837 y
= clientcy
- diff
;
1840 /* ******* End Phase 2b - adjust all bands for height full ******* */
1843 /* ******* Start Phase 3 - adjust all bands for width full ******* */
1845 if (infoPtr
->uNumBands
) {
1848 /* If RBS_BANDBORDERS set then indicate to draw bottom separator */
1849 /* on all bands in all rows but last row. */
1850 /* Also indicate to draw the right separator for each band in */
1851 /* each row but the rightmost band. */
1852 if (infoPtr
->dwStyle
& RBS_BANDBORDERS
) {
1854 for (i
=0; i
<infoPtr
->uNumBands
; i
++) {
1855 lpBand
= &infoPtr
->bands
[i
];
1856 if (HIDDENBAND(lpBand
))
1859 /* not righthand bands */
1860 if( !(lpBand
->fDraw
& DRAW_LAST_IN_ROW
) )
1861 lpBand
->fDraw
|= DRAW_RIGHTSEP
;
1863 /* not the last row */
1864 if( lpBand
->iRow
!= infoPtr
->uNumRows
)
1865 lpBand
->fDraw
|= DRAW_BOTTOMSEP
;
1869 /* Distribute the extra space on the horizontal and adjust */
1870 /* all bands in row to same height. */
1873 for (i
=0; i
<infoPtr
->uNumBands
; i
++) {
1875 lpBand
= &infoPtr
->bands
[i
];
1877 if( lpBand
->fDraw
& DRAW_FIRST_IN_ROW
)
1883 if ( (mcy
< ircBw(lpBand
)) && !HIDDENBAND(lpBand
) )
1884 mcy
= ircBw(lpBand
);
1886 if( lpBand
->fDraw
& DRAW_LAST_IN_ROW
)
1888 TRACE("P3 processing row %d, starting band %d, ending band %d\n",
1889 lpBand
->iRow
, startband
, i
);
1891 ERR("Last band %d with no first, row %d\n", i
, lpBand
->iRow
);
1893 REBAR_AdjustBands (infoPtr
, startband
, i
,
1894 (infoPtr
->dwStyle
& CCS_VERT
) ?
1895 clientcy
: clientcx
, mcy
);
1899 /* Calculate the other rectangles in each band */
1900 if (infoPtr
->dwStyle
& CCS_VERT
) {
1901 REBAR_CalcVertBand (infoPtr
, 0, infoPtr
->uNumBands
,
1905 REBAR_CalcHorzBand (infoPtr
, 0, infoPtr
->uNumBands
,
1910 /* ******* End Phase 3 - adjust all bands for width full ******* */
1912 /* now compute size of Rebar itself */
1913 infoPtr
->oldSize
= infoPtr
->calcSize
;
1914 if (infoPtr
->uNumBands
== 0) {
1915 /* we have no bands, so make size the size of client */
1919 if (infoPtr
->dwStyle
& CCS_VERT
) {
1920 infoPtr
->calcSize
.cx
= x
;
1921 infoPtr
->calcSize
.cy
= clientcy
;
1922 TRACE("vert, notify=%d, x=%d, origheight=%d\n",
1923 notify
, x
, origheight
);
1924 if (notify
&& (x
!= origheight
)) infoPtr
->fStatus
|= NTF_HGHTCHG
;
1927 infoPtr
->calcSize
.cx
= clientcx
;
1928 infoPtr
->calcSize
.cy
= y
;
1929 TRACE("horz, notify=%d, y=%d, origheight=%d\n",
1930 notify
, y
, origheight
);
1931 if (notify
&& (y
!= origheight
)) infoPtr
->fStatus
|= NTF_HGHTCHG
;
1934 REBAR_DumpBand (infoPtr
);
1936 REBAR_MoveChildWindows (infoPtr
, 0, infoPtr
->uNumBands
);
1938 REBAR_ForceResize (infoPtr
);
1943 REBAR_ValidateBand (REBAR_INFO
*infoPtr
, REBAR_BAND
*lpBand
)
1944 /* Function: This routine evaluates the band specs supplied */
1945 /* by the user and updates the following 5 fields in */
1946 /* the internal band structure: cxHeader, lcx, lcy, hcx, hcy*/
1953 lpBand
->fStatus
= 0;
1961 /* Data comming in from users into the cx... and cy... fields */
1962 /* may be bad, just garbage, because the user never clears */
1963 /* the fields. RB_{SET|INSERT}BAND{A|W} just passes the data */
1964 /* along if the fields exist in the input area. Here we must */
1965 /* determine if the data is valid. I have no idea how MS does */
1966 /* the validation, but it does because the RB_GETBANDINFO */
1967 /* returns a 0 when I know the sample program passed in an */
1968 /* address. Here I will use the algorithim that if the value */
1969 /* is greater than 65535 then it is bad and replace it with */
1970 /* a zero. Feel free to improve the algorithim. - GA 12/2000 */
1971 if (lpBand
->cxMinChild
> 65535) lpBand
->cxMinChild
= 0;
1972 if (lpBand
->cyMinChild
> 65535) lpBand
->cyMinChild
= 0;
1973 if (lpBand
->cx
> 65535) lpBand
->cx
= 0;
1974 if (lpBand
->cyChild
> 65535) lpBand
->cyChild
= 0;
1975 if (lpBand
->cyMaxChild
> 65535) lpBand
->cyMaxChild
= 0;
1976 if (lpBand
->cyIntegral
> 65535) lpBand
->cyIntegral
= 0;
1977 if (lpBand
->cxIdeal
> 65535) lpBand
->cxIdeal
= 0;
1978 if (lpBand
->cxHeader
> 65535) lpBand
->cxHeader
= 0;
1980 /* FIXME: probably should only set NEEDS_LAYOUT flag when */
1981 /* values change. Till then always set it. */
1982 TRACE("setting NEEDS_LAYOUT\n");
1983 infoPtr
->fStatus
|= BAND_NEEDS_LAYOUT
;
1985 /* Header is where the image, text and gripper exist */
1986 /* in the band and preceed the child window. */
1988 /* count number of non-FIXEDSIZE and non-Hidden bands */
1990 for (i
=0; i
<infoPtr
->uNumBands
; i
++){
1991 tBand
= &infoPtr
->bands
[i
];
1992 if (!HIDDENBAND(tBand
) && !(tBand
->fStyle
& RBBS_FIXEDSIZE
))
1996 /* calculate gripper rectangle */
1997 if ( (!(lpBand
->fStyle
& RBBS_NOGRIPPER
)) &&
1998 ( (lpBand
->fStyle
& RBBS_GRIPPERALWAYS
) ||
1999 ( !(lpBand
->fStyle
& RBBS_FIXEDSIZE
) && (nonfixed
> 1)))
2001 lpBand
->fStatus
|= HAS_GRIPPER
;
2002 if (infoPtr
->dwStyle
& CCS_VERT
)
2003 if (infoPtr
->dwStyle
& RBS_VERTICALGRIPPER
)
2004 header
+= (GRIPPER_HEIGHT
+ REBAR_PRE_GRIPPER
);
2006 header
+= (GRIPPER_WIDTH
+ REBAR_PRE_GRIPPER
);
2008 header
+= (REBAR_PRE_GRIPPER
+ GRIPPER_WIDTH
);
2009 /* Always have 4 pixels before anything else */
2010 header
+= REBAR_ALWAYS_SPACE
;
2013 /* image is visible */
2014 if ((lpBand
->fMask
& RBBIM_IMAGE
) && (infoPtr
->himl
)) {
2015 lpBand
->fStatus
|= HAS_IMAGE
;
2016 if (infoPtr
->dwStyle
& CCS_VERT
) {
2017 header
+= (infoPtr
->imageSize
.cy
+ REBAR_POST_IMAGE
);
2018 lpBand
->lcy
= infoPtr
->imageSize
.cx
+ 2;
2021 header
+= (infoPtr
->imageSize
.cx
+ REBAR_POST_IMAGE
);
2022 lpBand
->lcy
= infoPtr
->imageSize
.cy
+ 2;
2026 /* text is visible */
2027 if ((lpBand
->fMask
& RBBIM_TEXT
) && (lpBand
->lpText
) &&
2028 !(lpBand
->fStyle
& RBBS_HIDETITLE
)) {
2029 HDC hdc
= GetDC (0);
2030 HFONT hOldFont
= SelectObject (hdc
, infoPtr
->hFont
);
2033 lpBand
->fStatus
|= HAS_TEXT
;
2034 GetTextExtentPoint32W (hdc
, lpBand
->lpText
,
2035 lstrlenW (lpBand
->lpText
), &size
);
2036 header
+= ((infoPtr
->dwStyle
& CCS_VERT
) ? (size
.cy
+ REBAR_POST_TEXT
) : (size
.cx
+ REBAR_POST_TEXT
));
2037 textheight
= (infoPtr
->dwStyle
& CCS_VERT
) ? 0 : size
.cy
;
2039 SelectObject (hdc
, hOldFont
);
2043 /* if no gripper but either image or text, then leave space */
2044 if ((lpBand
->fStatus
& (HAS_IMAGE
| HAS_TEXT
)) &&
2045 !(lpBand
->fStatus
& HAS_GRIPPER
)) {
2046 header
+= REBAR_ALWAYS_SPACE
;
2049 /* check if user overrode the header value */
2050 if (!(lpBand
->fMask
& RBBIM_HEADERSIZE
))
2051 lpBand
->cxHeader
= header
;
2054 /* Now compute minimum size of child window */
2055 lpBand
->offChild
.cx
= 0;
2056 lpBand
->offChild
.cy
= 0;
2057 lpBand
->lcy
= textheight
;
2058 lpBand
->ccy
= lpBand
->lcy
;
2059 if (lpBand
->fMask
& RBBIM_CHILDSIZE
) {
2060 lpBand
->lcx
= lpBand
->cxMinChild
;
2062 /* Set the .cy values for CHILDSIZE case */
2063 lpBand
->lcy
= max(lpBand
->lcy
, lpBand
->cyMinChild
);
2064 lpBand
->ccy
= lpBand
->lcy
;
2065 lpBand
->hcy
= lpBand
->lcy
;
2066 if (lpBand
->cyMaxChild
!= 0xffffffff) {
2067 lpBand
->hcy
= lpBand
->cyMaxChild
;
2069 if (lpBand
->cyChild
!= 0xffffffff)
2070 lpBand
->ccy
= max (lpBand
->cyChild
, lpBand
->lcy
);
2072 TRACE("_CHILDSIZE\n");
2074 if (lpBand
->fMask
& RBBIM_SIZE
) {
2075 lpBand
->hcx
= max (lpBand
->cx
-lpBand
->cxHeader
, lpBand
->lcx
);
2079 lpBand
->hcx
= lpBand
->lcx
;
2080 lpBand
->ccx
= lpBand
->hcx
;
2082 /* make ->.cx include header size for _Layout */
2083 lpBand
->lcx
+= lpBand
->cxHeader
;
2084 lpBand
->ccx
+= lpBand
->cxHeader
;
2085 lpBand
->hcx
+= lpBand
->cxHeader
;
2090 REBAR_CommonSetupBand (HWND hwnd
, LPREBARBANDINFOA lprbbi
, REBAR_BAND
*lpBand
)
2091 /* Function: This routine copies the supplied values from */
2092 /* user input (lprbbi) to the internal band structure. */
2093 /* It returns true if something changed and false if not. */
2095 BOOL bChanged
= FALSE
;
2097 lpBand
->fMask
|= lprbbi
->fMask
;
2099 if( (lprbbi
->fMask
& RBBIM_STYLE
) &&
2100 (lpBand
->fStyle
!= lprbbi
->fStyle
) )
2102 lpBand
->fStyle
= lprbbi
->fStyle
;
2106 if( (lprbbi
->fMask
& RBBIM_COLORS
) &&
2107 ( ( lpBand
->clrFore
!= lprbbi
->clrFore
) ||
2108 ( lpBand
->clrBack
!= lprbbi
->clrBack
) ) )
2110 lpBand
->clrFore
= lprbbi
->clrFore
;
2111 lpBand
->clrBack
= lprbbi
->clrBack
;
2115 if( (lprbbi
->fMask
& RBBIM_IMAGE
) &&
2116 ( lpBand
->iImage
!= lprbbi
->iImage
) )
2118 lpBand
->iImage
= lprbbi
->iImage
;
2122 if( (lprbbi
->fMask
& RBBIM_CHILD
) &&
2123 (lprbbi
->hwndChild
!= lpBand
->hwndChild
) )
2125 if (lprbbi
->hwndChild
) {
2126 lpBand
->hwndChild
= lprbbi
->hwndChild
;
2127 lpBand
->hwndPrevParent
=
2128 SetParent (lpBand
->hwndChild
, hwnd
);
2129 /* below in trace fro WinRAR */
2130 ShowWindow(lpBand
->hwndChild
, SW_SHOWNOACTIVATE
| SW_SHOWNORMAL
);
2131 /* above in trace fro WinRAR */
2134 TRACE("child: %p prev parent: %p\n",
2135 lpBand
->hwndChild
, lpBand
->hwndPrevParent
);
2136 lpBand
->hwndChild
= 0;
2137 lpBand
->hwndPrevParent
= 0;
2142 if( (lprbbi
->fMask
& RBBIM_CHILDSIZE
) &&
2143 ( (lpBand
->cxMinChild
!= lprbbi
->cxMinChild
) ||
2144 (lpBand
->cyMinChild
!= lprbbi
->cyMinChild
) ||
2145 ( (lprbbi
->cbSize
>= sizeof (REBARBANDINFOA
)) &&
2146 ( (lpBand
->cyChild
!= lprbbi
->cyChild
) ||
2147 (lpBand
->cyMaxChild
!= lprbbi
->cyMaxChild
) ||
2148 (lpBand
->cyIntegral
!= lprbbi
->cyIntegral
) ) ) ||
2149 ( (lprbbi
->cbSize
< sizeof (REBARBANDINFOA
)) &&
2150 ( (lpBand
->cyChild
||
2151 lpBand
->cyMaxChild
||
2152 lpBand
->cyIntegral
) ) ) ) )
2154 lpBand
->cxMinChild
= lprbbi
->cxMinChild
;
2155 lpBand
->cyMinChild
= lprbbi
->cyMinChild
;
2156 if (lprbbi
->cbSize
>= sizeof (REBARBANDINFOA
)) {
2157 lpBand
->cyChild
= lprbbi
->cyChild
;
2158 lpBand
->cyMaxChild
= lprbbi
->cyMaxChild
;
2159 lpBand
->cyIntegral
= lprbbi
->cyIntegral
;
2161 else { /* special case - these should be zeroed out since */
2162 /* RBBIM_CHILDSIZE added these in WIN32_IE >= 0x0400 */
2163 lpBand
->cyChild
= 0;
2164 lpBand
->cyMaxChild
= 0;
2165 lpBand
->cyIntegral
= 0;
2170 if( (lprbbi
->fMask
& RBBIM_SIZE
) &&
2171 (lpBand
->cx
!= lprbbi
->cx
) )
2173 lpBand
->cx
= lprbbi
->cx
;
2177 if( (lprbbi
->fMask
& RBBIM_BACKGROUND
) &&
2178 ( lpBand
->hbmBack
!= lprbbi
->hbmBack
) )
2180 lpBand
->hbmBack
= lprbbi
->hbmBack
;
2184 if( (lprbbi
->fMask
& RBBIM_ID
) &&
2185 (lpBand
->wID
!= lprbbi
->wID
) )
2187 lpBand
->wID
= lprbbi
->wID
;
2191 /* check for additional data */
2192 if (lprbbi
->cbSize
>= sizeof (REBARBANDINFOA
)) {
2193 if( (lprbbi
->fMask
& RBBIM_IDEALSIZE
) &&
2194 ( lpBand
->cxIdeal
!= lprbbi
->cxIdeal
) )
2196 lpBand
->cxIdeal
= lprbbi
->cxIdeal
;
2200 if( (lprbbi
->fMask
& RBBIM_LPARAM
) &&
2201 (lpBand
->lParam
!= lprbbi
->lParam
) )
2203 lpBand
->lParam
= lprbbi
->lParam
;
2207 if( (lprbbi
->fMask
& RBBIM_HEADERSIZE
) &&
2208 (lpBand
->cxHeader
!= lprbbi
->cxHeader
) )
2210 lpBand
->cxHeader
= lprbbi
->cxHeader
;
2219 REBAR_InternalEraseBkGnd (REBAR_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
, RECT
*clip
)
2220 /* Function: This erases the background rectangle by drawing */
2221 /* each band with its background color (or the default) and */
2222 /* draws each bands right separator if necessary. The row */
2223 /* separators are drawn on the first band of the next row. */
2228 HDC hdc
= (HDC
)wParam
;
2230 COLORREF old
= CLR_NONE
, new;
2233 for(i
=0; i
<infoPtr
->uNumBands
; i
++) {
2234 lpBand
= &infoPtr
->bands
[i
];
2235 if (HIDDENBAND(lpBand
)) continue;
2237 /* draw band separator between rows */
2238 if (lpBand
->iRow
!= oldrow
) {
2239 oldrow
= lpBand
->iRow
;
2240 if (lpBand
->fDraw
& DRAW_BOTTOMSEP
) {
2242 rcRowSep
= lpBand
->rcBand
;
2243 if (infoPtr
->dwStyle
& CCS_VERT
) {
2244 rcRowSep
.right
+= SEP_WIDTH_SIZE
;
2245 rcRowSep
.bottom
= infoPtr
->calcSize
.cy
;
2246 DrawEdge (hdc
, &rcRowSep
, EDGE_ETCHED
, BF_RIGHT
);
2249 rcRowSep
.bottom
+= SEP_WIDTH_SIZE
;
2250 rcRowSep
.right
= infoPtr
->calcSize
.cx
;
2251 DrawEdge (hdc
, &rcRowSep
, EDGE_ETCHED
, BF_BOTTOM
);
2253 TRACE ("drawing band separator bottom (%ld,%ld)-(%ld,%ld)\n",
2254 rcRowSep
.left
, rcRowSep
.top
,
2255 rcRowSep
.right
, rcRowSep
.bottom
);
2259 /* draw band separator between bands in a row */
2260 if (lpBand
->fDraw
& DRAW_RIGHTSEP
) {
2262 rcSep
= lpBand
->rcBand
;
2263 if (infoPtr
->dwStyle
& CCS_VERT
) {
2264 rcSep
.bottom
+= SEP_WIDTH_SIZE
;
2265 DrawEdge (hdc
, &rcSep
, EDGE_ETCHED
, BF_BOTTOM
);
2268 rcSep
.right
+= SEP_WIDTH_SIZE
;
2269 DrawEdge (hdc
, &rcSep
, EDGE_ETCHED
, BF_RIGHT
);
2271 TRACE("drawing band separator right (%ld,%ld)-(%ld,%ld)\n",
2272 rcSep
.left
, rcSep
.top
, rcSep
.right
, rcSep
.bottom
);
2275 /* draw the actual background */
2276 if (lpBand
->clrBack
!= CLR_NONE
) {
2277 new = (lpBand
->clrBack
== CLR_DEFAULT
) ? infoPtr
->clrBtnFace
:
2280 /* testing only - make background green to see it */
2285 /* In the absence of documentation for Rebar vs. CLR_NONE,
2286 * we will use the default BtnFace color. Note documentation
2287 * exists for Listview and Imagelist.
2289 new = infoPtr
->clrBtnFace
;
2291 /* testing only - make background green to see it */
2295 old
= SetBkColor (hdc
, new);
2297 rect
= lpBand
->rcBand
;
2298 TRACE("%s background color=0x%06lx, band (%ld,%ld)-(%ld,%ld), clip (%ld,%ld)-(%ld,%ld)\n",
2299 (lpBand
->clrBack
== CLR_NONE
) ? "none" :
2300 ((lpBand
->clrBack
== CLR_DEFAULT
) ? "dft" : ""),
2302 lpBand
->rcBand
.left
,lpBand
->rcBand
.top
,
2303 lpBand
->rcBand
.right
,lpBand
->rcBand
.bottom
,
2304 clip
->left
, clip
->top
,
2305 clip
->right
, clip
->bottom
);
2306 ExtTextOutA (hdc
, 0, 0, ETO_OPAQUE
, &rect
, NULL
, 0, 0);
2307 if (lpBand
->clrBack
!= CLR_NONE
)
2308 SetBkColor (hdc
, old
);
2314 REBAR_InternalHitTest (REBAR_INFO
*infoPtr
, const LPPOINT lpPt
, UINT
*pFlags
, INT
*pBand
)
2320 GetClientRect (infoPtr
->hwndSelf
, &rect
);
2322 *pFlags
= RBHT_NOWHERE
;
2323 if (PtInRect (&rect
, *lpPt
))
2325 if (infoPtr
->uNumBands
== 0) {
2326 *pFlags
= RBHT_NOWHERE
;
2333 /* somewhere inside */
2334 for (iCount
= 0; iCount
< infoPtr
->uNumBands
; iCount
++) {
2335 lpBand
= &infoPtr
->bands
[iCount
];
2336 if (HIDDENBAND(lpBand
)) continue;
2337 if (PtInRect (&lpBand
->rcBand
, *lpPt
)) {
2340 if (PtInRect (&lpBand
->rcGripper
, *lpPt
)) {
2341 *pFlags
= RBHT_GRABBER
;
2342 TRACE("ON GRABBER %d\n", iCount
);
2345 else if (PtInRect (&lpBand
->rcCapImage
, *lpPt
)) {
2346 *pFlags
= RBHT_CAPTION
;
2347 TRACE("ON CAPTION %d\n", iCount
);
2350 else if (PtInRect (&lpBand
->rcCapText
, *lpPt
)) {
2351 *pFlags
= RBHT_CAPTION
;
2352 TRACE("ON CAPTION %d\n", iCount
);
2355 else if (PtInRect (&lpBand
->rcChild
, *lpPt
)) {
2356 *pFlags
= RBHT_CLIENT
;
2357 TRACE("ON CLIENT %d\n", iCount
);
2360 else if (PtInRect (&lpBand
->rcChevron
, *lpPt
)) {
2361 *pFlags
= RBHT_CHEVRON
;
2362 TRACE("ON CHEVRON %d\n", iCount
);
2366 *pFlags
= RBHT_NOWHERE
;
2367 TRACE("NOWHERE %d\n", iCount
);
2373 *pFlags
= RBHT_NOWHERE
;
2382 *pFlags
= RBHT_NOWHERE
;
2392 REBAR_Shrink (REBAR_INFO
*infoPtr
, REBAR_BAND
*band
, INT movement
, INT i
)
2393 /* Function: This attempts to shrink the given band by the */
2394 /* the amount in "movement". A shrink to the left is indi- */
2395 /* cated by "movement" being negative. "i" is merely the */
2396 /* band index for trace messages. */
2398 INT Leadjust
, Readjust
, avail
, ret
;
2400 /* Note: a left drag is indicated by "movement" being negative. */
2401 /* Similarly, a right drag is indicated by "movement" */
2402 /* being positive. "movement" should never be 0, but if */
2403 /* it is then the band does not move. */
2405 avail
= rcBw(band
) - band
->lcx
;
2407 /* now compute the Left End adjustment factor and Right End */
2408 /* adjustment factor. They may be different if shrinking. */
2410 /* if this band is not shrinkable, then just move it */
2411 Leadjust
= Readjust
= movement
;
2417 if (avail
<= abs(movement
)) {
2418 Readjust
= movement
;
2419 Leadjust
= movement
+ avail
;
2423 Readjust
= movement
;
2430 if (avail
<= abs(movement
)) {
2431 Leadjust
= movement
;
2432 Readjust
= movement
- avail
;
2436 Leadjust
= movement
;
2443 /* Reasonability Check */
2444 if (rcBlt(band
) + Leadjust
< 0) {
2445 ERR("adjustment will fail, band %d: left=%d, right=%d, move=%d, rtn=%d\n",
2446 i
, Leadjust
, Readjust
, movement
, ret
);
2449 LEADJ(band
, Leadjust
);
2450 READJ(band
, Readjust
);
2452 TRACE("band %d: left=%d, right=%d, move=%d, rtn=%d, rcBand=(%ld,%ld)-(%ld,%ld)\n",
2453 i
, Leadjust
, Readjust
, movement
, ret
,
2454 band
->rcBand
.left
, band
->rcBand
.top
,
2455 band
->rcBand
.right
, band
->rcBand
.bottom
);
2461 REBAR_HandleLRDrag (REBAR_INFO
*infoPtr
, POINTS
*ptsmove
)
2462 /* Function: This will implement the functionality of a */
2463 /* Gripper drag within a row. It will not implement "out- */
2464 /* of-row" drags. (They are detected and handled in */
2465 /* REBAR_MouseMove.) */
2466 /* **** FIXME Switching order of bands in a row not **** */
2467 /* **** yet implemented. **** */
2469 REBAR_BAND
*hitBand
, *band
, *mindBand
, *maxdBand
;
2471 INT imindBand
= -1, imaxdBand
, ihitBand
, i
, movement
;
2472 INT RHeaderSum
= 0, LHeaderSum
= 0;
2475 /* on first significant mouse movement, issue notify */
2477 if (!(infoPtr
->fStatus
& BEGIN_DRAG_ISSUED
)) {
2478 if (REBAR_Notify_NMREBAR (infoPtr
, -1, RBN_BEGINDRAG
)) {
2479 /* Notify returned TRUE - abort drag */
2480 infoPtr
->dragStart
.x
= 0;
2481 infoPtr
->dragStart
.y
= 0;
2482 infoPtr
->dragNow
= infoPtr
->dragStart
;
2483 infoPtr
->iGrabbedBand
= -1;
2487 infoPtr
->fStatus
|= BEGIN_DRAG_ISSUED
;
2490 ihitBand
= infoPtr
->iGrabbedBand
;
2491 hitBand
= &infoPtr
->bands
[ihitBand
];
2492 imaxdBand
= ihitBand
; /* to suppress warning message */
2494 /* find all the bands in the row of the one whose Gripper was seized */
2495 for (i
=0; i
<infoPtr
->uNumBands
; i
++) {
2496 band
= &infoPtr
->bands
[i
];
2497 if (HIDDENBAND(band
)) continue;
2498 if (band
->iRow
== hitBand
->iRow
) {
2500 if (imindBand
== -1) imindBand
= i
;
2501 /* minimum size of each band is size of header plus */
2502 /* size of minimum child plus offset of child from header plus */
2503 /* a one to separate each band. */
2505 LHeaderSum
+= (band
->lcx
+ SEP_WIDTH
);
2507 RHeaderSum
+= (band
->lcx
+ SEP_WIDTH
);
2511 if (RHeaderSum
) RHeaderSum
-= SEP_WIDTH
; /* no separator afterlast band */
2513 mindBand
= &infoPtr
->bands
[imindBand
];
2514 maxdBand
= &infoPtr
->bands
[imaxdBand
];
2516 if (imindBand
== imaxdBand
) return; /* nothing to drag agains */
2517 if (imindBand
== ihitBand
) return; /* first band in row, cant drag */
2519 /* limit movement to inside adjustable bands - Left */
2520 if ( (ptsmove
->x
< mindBand
->rcBand
.left
) ||
2521 (ptsmove
->x
> maxdBand
->rcBand
.right
) ||
2522 (ptsmove
->y
< mindBand
->rcBand
.top
) ||
2523 (ptsmove
->y
> maxdBand
->rcBand
.bottom
))
2524 return; /* should swap bands */
2526 if (infoPtr
->dwStyle
& CCS_VERT
)
2527 movement
= ptsmove
->y
- ((hitBand
->rcBand
.top
+REBAR_PRE_GRIPPER
) -
2528 infoPtr
->ihitoffset
);
2530 movement
= ptsmove
->x
- ((hitBand
->rcBand
.left
+REBAR_PRE_GRIPPER
) -
2531 infoPtr
->ihitoffset
);
2532 infoPtr
->dragNow
= *ptsmove
;
2534 TRACE("before: movement=%d (%d,%d), imindBand=%d, ihitBand=%d, imaxdBand=%d, LSum=%d, RSum=%d\n",
2535 movement
, ptsmove
->x
, ptsmove
->y
, imindBand
, ihitBand
,
2536 imaxdBand
, LHeaderSum
, RHeaderSum
);
2537 REBAR_DumpBand (infoPtr
);
2541 /* *** Drag left/up *** */
2542 compress
= rcBlt(hitBand
) - rcBlt(mindBand
) -
2544 if (compress
< abs(movement
)) {
2545 TRACE("limiting left drag, was %d changed to %d\n",
2546 movement
, -compress
);
2547 movement
= -compress
;
2550 for (i
=ihitBand
; i
>=imindBand
; i
--) {
2551 band
= &infoPtr
->bands
[i
];
2552 if (HIDDENBAND(band
)) continue;
2553 if (i
== ihitBand
) {
2554 LEADJ(band
, movement
);
2557 movement
= REBAR_Shrink (infoPtr
, band
, movement
, i
);
2558 band
->ccx
= rcBw(band
);
2564 /* *** Drag right/down *** */
2565 compress
= rcBrb(maxdBand
) - rcBlt(hitBand
) -
2567 if (compress
< abs(movement
)) {
2568 TRACE("limiting right drag, was %d changed to %d\n",
2569 movement
, compress
);
2570 movement
= compress
;
2572 for (i
=ihitBand
-1; i
<=imaxdBand
; i
++) {
2573 band
= &infoPtr
->bands
[i
];
2574 if (HIDDENBAND(band
)) continue;
2577 READJ(band
, movement
);
2580 movement
= REBAR_Shrink (infoPtr
, band
, movement
, i
);
2581 band
->ccx
= rcBw(band
);
2585 /* recompute all rectangles */
2586 if (infoPtr
->dwStyle
& CCS_VERT
) {
2587 REBAR_CalcVertBand (infoPtr
, imindBand
, imaxdBand
+1,
2591 REBAR_CalcHorzBand (infoPtr
, imindBand
, imaxdBand
+1,
2595 TRACE("bands after adjustment, see band # %d, %d\n",
2596 imindBand
, imaxdBand
);
2597 REBAR_DumpBand (infoPtr
);
2600 mindBand
->rcBand
.left
,
2601 mindBand
->rcBand
.top
,
2602 maxdBand
->rcBand
.right
,
2603 maxdBand
->rcBand
.bottom
);
2605 REBAR_MoveChildWindows (infoPtr
, imindBand
, imaxdBand
+1);
2607 InvalidateRect (infoPtr
->hwndSelf
, &newrect
, TRUE
);
2608 UpdateWindow (infoPtr
->hwndSelf
);
2614 /* << REBAR_BeginDrag >> */
2618 REBAR_DeleteBand (REBAR_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
2620 UINT uBand
= (UINT
)wParam
;
2624 if (uBand
>= infoPtr
->uNumBands
)
2627 TRACE("deleting band %u!\n", uBand
);
2628 lpBand
= &infoPtr
->bands
[uBand
];
2629 REBAR_Notify_NMREBAR (infoPtr
, uBand
, RBN_DELETINGBAND
);
2631 if (infoPtr
->uNumBands
== 1) {
2632 TRACE(" simple delete!\n");
2633 if ((lpBand
->fMask
& RBBIM_CHILD
) && lpBand
->hwndChild
)
2634 childhwnd
= lpBand
->hwndChild
;
2635 Free (infoPtr
->bands
);
2636 infoPtr
->bands
= NULL
;
2637 infoPtr
->uNumBands
= 0;
2640 REBAR_BAND
*oldBands
= infoPtr
->bands
;
2641 TRACE("complex delete! [uBand=%u]\n", uBand
);
2643 if ((lpBand
->fMask
& RBBIM_CHILD
) && lpBand
->hwndChild
)
2644 childhwnd
= lpBand
->hwndChild
;
2646 infoPtr
->uNumBands
--;
2647 infoPtr
->bands
= Alloc (sizeof (REBAR_BAND
) * infoPtr
->uNumBands
);
2649 memcpy (&infoPtr
->bands
[0], &oldBands
[0],
2650 uBand
* sizeof(REBAR_BAND
));
2653 if (uBand
< infoPtr
->uNumBands
) {
2654 memcpy (&infoPtr
->bands
[uBand
], &oldBands
[uBand
+1],
2655 (infoPtr
->uNumBands
- uBand
) * sizeof(REBAR_BAND
));
2662 ShowWindow (childhwnd
, SW_HIDE
);
2664 REBAR_Notify_NMREBAR (infoPtr
, -1, RBN_DELETEDBAND
);
2666 /* if only 1 band left the re-validate to possible eliminate gripper */
2667 if (infoPtr
->uNumBands
== 1)
2668 REBAR_ValidateBand (infoPtr
, &infoPtr
->bands
[0]);
2670 TRACE("setting NEEDS_LAYOUT\n");
2671 infoPtr
->fStatus
|= BAND_NEEDS_LAYOUT
;
2672 infoPtr
->fStatus
|= RESIZE_ANYHOW
;
2673 REBAR_Layout (infoPtr
, NULL
, TRUE
, FALSE
);
2679 /* << REBAR_DragMove >> */
2680 /* << REBAR_EndDrag >> */
2684 REBAR_GetBandBorders (REBAR_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
2686 LPRECT lpRect
= (LPRECT
)lParam
;
2691 if ((UINT
)wParam
>= infoPtr
->uNumBands
)
2694 lpBand
= &infoPtr
->bands
[(UINT
)wParam
];
2696 /* FIXME - the following values were determined by experimentation */
2697 /* with the REBAR Control Spy. I have guesses as to what the 4 and */
2698 /* 1 are, but I am not sure. There doesn't seem to be any actual */
2699 /* difference in size of the control area with and without the */
2701 if (infoPtr
->dwStyle
& RBS_BANDBORDERS
) {
2702 if (infoPtr
->dwStyle
& CCS_VERT
) {
2704 lpRect
->top
= lpBand
->cxHeader
+ 4;
2709 lpRect
->left
= lpBand
->cxHeader
+ 4;
2716 lpRect
->left
= lpBand
->cxHeader
;
2722 inline static LRESULT
2723 REBAR_GetBandCount (REBAR_INFO
*infoPtr
)
2725 TRACE("band count %u!\n", infoPtr
->uNumBands
);
2727 return infoPtr
->uNumBands
;
2732 REBAR_GetBandInfoA (REBAR_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
2734 LPREBARBANDINFOA lprbbi
= (LPREBARBANDINFOA
)lParam
;
2739 if (lprbbi
->cbSize
< REBARBANDINFOA_V3_SIZE
)
2741 if ((UINT
)wParam
>= infoPtr
->uNumBands
)
2744 TRACE("index %u\n", (UINT
)wParam
);
2746 /* copy band information */
2747 lpBand
= &infoPtr
->bands
[(UINT
)wParam
];
2749 if (lprbbi
->fMask
& RBBIM_STYLE
)
2750 lprbbi
->fStyle
= lpBand
->fStyle
;
2752 if (lprbbi
->fMask
& RBBIM_COLORS
) {
2753 lprbbi
->clrFore
= lpBand
->clrFore
;
2754 lprbbi
->clrBack
= lpBand
->clrBack
;
2755 if (lprbbi
->clrBack
== CLR_DEFAULT
)
2756 lprbbi
->clrBack
= infoPtr
->clrBtnFace
;
2759 if ((lprbbi
->fMask
& RBBIM_TEXT
) && (lprbbi
->lpText
)) {
2760 if (lpBand
->lpText
&& (lpBand
->fMask
& RBBIM_TEXT
))
2762 if (!WideCharToMultiByte( CP_ACP
, 0, lpBand
->lpText
, -1,
2763 lprbbi
->lpText
, lprbbi
->cch
, NULL
, NULL
))
2764 lprbbi
->lpText
[lprbbi
->cch
-1] = 0;
2767 *lprbbi
->lpText
= 0;
2770 if (lprbbi
->fMask
& RBBIM_IMAGE
) {
2771 if (lpBand
->fMask
& RBBIM_IMAGE
)
2772 lprbbi
->iImage
= lpBand
->iImage
;
2774 lprbbi
->iImage
= -1;
2777 if (lprbbi
->fMask
& RBBIM_CHILD
)
2778 lprbbi
->hwndChild
= lpBand
->hwndChild
;
2780 if (lprbbi
->fMask
& RBBIM_CHILDSIZE
) {
2781 lprbbi
->cxMinChild
= lpBand
->cxMinChild
;
2782 lprbbi
->cyMinChild
= lpBand
->cyMinChild
;
2783 if (lprbbi
->cbSize
>= sizeof (REBARBANDINFOA
)) {
2784 lprbbi
->cyChild
= lpBand
->cyChild
;
2785 lprbbi
->cyMaxChild
= lpBand
->cyMaxChild
;
2786 lprbbi
->cyIntegral
= lpBand
->cyIntegral
;
2790 if (lprbbi
->fMask
& RBBIM_SIZE
)
2791 lprbbi
->cx
= lpBand
->cx
;
2793 if (lprbbi
->fMask
& RBBIM_BACKGROUND
)
2794 lprbbi
->hbmBack
= lpBand
->hbmBack
;
2796 if (lprbbi
->fMask
& RBBIM_ID
)
2797 lprbbi
->wID
= lpBand
->wID
;
2799 /* check for additional data */
2800 if (lprbbi
->cbSize
>= sizeof (REBARBANDINFOA
)) {
2801 if (lprbbi
->fMask
& RBBIM_IDEALSIZE
)
2802 lprbbi
->cxIdeal
= lpBand
->cxIdeal
;
2804 if (lprbbi
->fMask
& RBBIM_LPARAM
)
2805 lprbbi
->lParam
= lpBand
->lParam
;
2807 if (lprbbi
->fMask
& RBBIM_HEADERSIZE
)
2808 lprbbi
->cxHeader
= lpBand
->cxHeader
;
2811 REBAR_DumpBandInfo (lprbbi
);
2818 REBAR_GetBandInfoW (REBAR_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
2820 LPREBARBANDINFOW lprbbi
= (LPREBARBANDINFOW
)lParam
;
2825 if (lprbbi
->cbSize
< REBARBANDINFOW_V3_SIZE
)
2827 if ((UINT
)wParam
>= infoPtr
->uNumBands
)
2830 TRACE("index %u\n", (UINT
)wParam
);
2832 /* copy band information */
2833 lpBand
= &infoPtr
->bands
[(UINT
)wParam
];
2835 if (lprbbi
->fMask
& RBBIM_STYLE
)
2836 lprbbi
->fStyle
= lpBand
->fStyle
;
2838 if (lprbbi
->fMask
& RBBIM_COLORS
) {
2839 lprbbi
->clrFore
= lpBand
->clrFore
;
2840 lprbbi
->clrBack
= lpBand
->clrBack
;
2841 if (lprbbi
->clrBack
== CLR_DEFAULT
)
2842 lprbbi
->clrBack
= infoPtr
->clrBtnFace
;
2845 if ((lprbbi
->fMask
& RBBIM_TEXT
) && (lprbbi
->lpText
)) {
2846 if (lpBand
->lpText
&& (lpBand
->fMask
& RBBIM_TEXT
))
2847 lstrcpynW (lprbbi
->lpText
, lpBand
->lpText
, lprbbi
->cch
);
2849 *lprbbi
->lpText
= 0;
2852 if (lprbbi
->fMask
& RBBIM_IMAGE
) {
2853 if (lpBand
->fMask
& RBBIM_IMAGE
)
2854 lprbbi
->iImage
= lpBand
->iImage
;
2856 lprbbi
->iImage
= -1;
2859 if (lprbbi
->fMask
& RBBIM_CHILD
)
2860 lprbbi
->hwndChild
= lpBand
->hwndChild
;
2862 if (lprbbi
->fMask
& RBBIM_CHILDSIZE
) {
2863 lprbbi
->cxMinChild
= lpBand
->cxMinChild
;
2864 lprbbi
->cyMinChild
= lpBand
->cyMinChild
;
2865 if (lprbbi
->cbSize
>= sizeof (REBARBANDINFOW
)) {
2866 lprbbi
->cyChild
= lpBand
->cyChild
;
2867 lprbbi
->cyMaxChild
= lpBand
->cyMaxChild
;
2868 lprbbi
->cyIntegral
= lpBand
->cyIntegral
;
2872 if (lprbbi
->fMask
& RBBIM_SIZE
)
2873 lprbbi
->cx
= lpBand
->cx
;
2875 if (lprbbi
->fMask
& RBBIM_BACKGROUND
)
2876 lprbbi
->hbmBack
= lpBand
->hbmBack
;
2878 if (lprbbi
->fMask
& RBBIM_ID
)
2879 lprbbi
->wID
= lpBand
->wID
;
2881 /* check for additional data */
2882 if (lprbbi
->cbSize
>= sizeof (REBARBANDINFOW
)) {
2883 if (lprbbi
->fMask
& RBBIM_IDEALSIZE
)
2884 lprbbi
->cxIdeal
= lpBand
->cxIdeal
;
2886 if (lprbbi
->fMask
& RBBIM_LPARAM
)
2887 lprbbi
->lParam
= lpBand
->lParam
;
2889 if (lprbbi
->fMask
& RBBIM_HEADERSIZE
)
2890 lprbbi
->cxHeader
= lpBand
->cxHeader
;
2893 REBAR_DumpBandInfo ((LPREBARBANDINFOA
)lprbbi
);
2900 REBAR_GetBarHeight (REBAR_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
2904 nHeight
= (infoPtr
->dwStyle
& CCS_VERT
) ? infoPtr
->calcSize
.cx
: infoPtr
->calcSize
.cy
;
2906 TRACE("height = %d\n", nHeight
);
2913 REBAR_GetBarInfo (REBAR_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
2915 LPREBARINFO lpInfo
= (LPREBARINFO
)lParam
;
2920 if (lpInfo
->cbSize
< sizeof (REBARINFO
))
2923 TRACE("getting bar info!\n");
2925 if (infoPtr
->himl
) {
2926 lpInfo
->himl
= infoPtr
->himl
;
2927 lpInfo
->fMask
|= RBIM_IMAGELIST
;
2934 inline static LRESULT
2935 REBAR_GetBkColor (REBAR_INFO
*infoPtr
)
2937 COLORREF clr
= infoPtr
->clrBk
;
2939 if (clr
== CLR_DEFAULT
)
2940 clr
= infoPtr
->clrBtnFace
;
2942 TRACE("background color 0x%06lx!\n", clr
);
2948 /* << REBAR_GetColorScheme >> */
2949 /* << REBAR_GetDropTarget >> */
2953 REBAR_GetPalette (REBAR_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
2955 FIXME("empty stub!\n");
2962 REBAR_GetRect (REBAR_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
2964 INT iBand
= (INT
)wParam
;
2965 LPRECT lprc
= (LPRECT
)lParam
;
2968 if ((iBand
< 0) && ((UINT
)iBand
>= infoPtr
->uNumBands
))
2973 lpBand
= &infoPtr
->bands
[iBand
];
2974 CopyRect (lprc
, &lpBand
->rcBand
);
2976 TRACE("band %d, (%ld,%ld)-(%ld,%ld)\n", iBand
,
2977 lprc
->left
, lprc
->top
, lprc
->right
, lprc
->bottom
);
2983 inline static LRESULT
2984 REBAR_GetRowCount (REBAR_INFO
*infoPtr
)
2986 TRACE("%u\n", infoPtr
->uNumRows
);
2988 return infoPtr
->uNumRows
;
2993 REBAR_GetRowHeight (REBAR_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
2995 INT iRow
= (INT
)wParam
;
3000 for (i
=0; i
<infoPtr
->uNumBands
; i
++) {
3001 lpBand
= &infoPtr
->bands
[i
];
3002 if (HIDDENBAND(lpBand
)) continue;
3003 if (lpBand
->iRow
!= iRow
) continue;
3004 if (infoPtr
->dwStyle
& CCS_VERT
)
3005 j
= lpBand
->rcBand
.right
- lpBand
->rcBand
.left
;
3007 j
= lpBand
->rcBand
.bottom
- lpBand
->rcBand
.top
;
3008 if (j
> ret
) ret
= j
;
3011 TRACE("row %d, height %d\n", iRow
, ret
);
3017 inline static LRESULT
3018 REBAR_GetTextColor (REBAR_INFO
*infoPtr
)
3020 TRACE("text color 0x%06lx!\n", infoPtr
->clrText
);
3022 return infoPtr
->clrText
;
3026 inline static LRESULT
3027 REBAR_GetToolTips (REBAR_INFO
*infoPtr
)
3029 return (LRESULT
)infoPtr
->hwndToolTip
;
3033 inline static LRESULT
3034 REBAR_GetUnicodeFormat (REBAR_INFO
*infoPtr
)
3036 TRACE("%s hwnd=%p\n",
3037 infoPtr
->bUnicode
? "TRUE" : "FALSE", infoPtr
->hwndSelf
);
3039 return infoPtr
->bUnicode
;
3043 inline static LRESULT
3044 REBAR_GetVersion (REBAR_INFO
*infoPtr
)
3046 TRACE("version %d\n", infoPtr
->iVersion
);
3047 return infoPtr
->iVersion
;
3052 REBAR_HitTest (REBAR_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
3054 LPRBHITTESTINFO lprbht
= (LPRBHITTESTINFO
)lParam
;
3059 REBAR_InternalHitTest (infoPtr
, &lprbht
->pt
, &lprbht
->flags
, &lprbht
->iBand
);
3061 return lprbht
->iBand
;
3066 REBAR_IdToIndex (REBAR_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
3070 if (infoPtr
== NULL
)
3073 if (infoPtr
->uNumBands
< 1)
3076 for (i
= 0; i
< infoPtr
->uNumBands
; i
++) {
3077 if (infoPtr
->bands
[i
].wID
== (UINT
)wParam
) {
3078 TRACE("id %u is band %u found!\n", (UINT
)wParam
, i
);
3083 TRACE("id %u is not found\n", (UINT
)wParam
);
3089 REBAR_InsertBandA (REBAR_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
3091 LPREBARBANDINFOA lprbbi
= (LPREBARBANDINFOA
)lParam
;
3092 UINT uIndex
= (UINT
)wParam
;
3095 if (infoPtr
== NULL
)
3099 if (lprbbi
->cbSize
< REBARBANDINFOA_V3_SIZE
)
3102 /* trace the index as signed to see the -1 */
3103 TRACE("insert band at %d!\n", (INT
)uIndex
);
3104 REBAR_DumpBandInfo (lprbbi
);
3106 if (infoPtr
->uNumBands
== 0) {
3107 infoPtr
->bands
= (REBAR_BAND
*)Alloc (sizeof (REBAR_BAND
));
3111 REBAR_BAND
*oldBands
= infoPtr
->bands
;
3113 (REBAR_BAND
*)Alloc ((infoPtr
->uNumBands
+1)*sizeof(REBAR_BAND
));
3114 if (((INT
)uIndex
== -1) || (uIndex
> infoPtr
->uNumBands
))
3115 uIndex
= infoPtr
->uNumBands
;
3117 /* pre insert copy */
3119 memcpy (&infoPtr
->bands
[0], &oldBands
[0],
3120 uIndex
* sizeof(REBAR_BAND
));
3124 if (uIndex
< infoPtr
->uNumBands
- 1) {
3125 memcpy (&infoPtr
->bands
[uIndex
+1], &oldBands
[uIndex
],
3126 (infoPtr
->uNumBands
- uIndex
- 1) * sizeof(REBAR_BAND
));
3132 infoPtr
->uNumBands
++;
3134 TRACE("index %u!\n", uIndex
);
3136 /* initialize band (infoPtr->bands[uIndex])*/
3137 lpBand
= &infoPtr
->bands
[uIndex
];
3139 lpBand
->fStatus
= 0;
3140 lpBand
->clrFore
= infoPtr
->clrText
;
3141 lpBand
->clrBack
= infoPtr
->clrBk
;
3142 lpBand
->hwndChild
= 0;
3143 lpBand
->hwndPrevParent
= 0;
3145 REBAR_CommonSetupBand (infoPtr
->hwndSelf
, lprbbi
, lpBand
);
3146 lpBand
->lpText
= NULL
;
3147 if ((lprbbi
->fMask
& RBBIM_TEXT
) && (lprbbi
->lpText
)) {
3148 INT len
= MultiByteToWideChar( CP_ACP
, 0, lprbbi
->lpText
, -1, NULL
, 0 );
3150 lpBand
->lpText
= (LPWSTR
)Alloc (len
*sizeof(WCHAR
));
3151 MultiByteToWideChar( CP_ACP
, 0, lprbbi
->lpText
, -1, lpBand
->lpText
, len
);
3155 REBAR_ValidateBand (infoPtr
, lpBand
);
3156 /* On insert of second band, revalidate band 1 to possible add gripper */
3157 if (infoPtr
->uNumBands
== 2)
3158 REBAR_ValidateBand (infoPtr
, &infoPtr
->bands
[0]);
3160 REBAR_DumpBand (infoPtr
);
3162 REBAR_Layout (infoPtr
, NULL
, TRUE
, FALSE
);
3163 InvalidateRect(infoPtr
->hwndSelf
, 0, 1);
3170 REBAR_InsertBandW (REBAR_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
3172 LPREBARBANDINFOW lprbbi
= (LPREBARBANDINFOW
)lParam
;
3173 UINT uIndex
= (UINT
)wParam
;
3176 if (infoPtr
== NULL
)
3180 if (lprbbi
->cbSize
< REBARBANDINFOW_V3_SIZE
)
3183 /* trace the index as signed to see the -1 */
3184 TRACE("insert band at %d!\n", (INT
)uIndex
);
3185 REBAR_DumpBandInfo ((LPREBARBANDINFOA
)lprbbi
);
3187 if (infoPtr
->uNumBands
== 0) {
3188 infoPtr
->bands
= (REBAR_BAND
*)Alloc (sizeof (REBAR_BAND
));
3192 REBAR_BAND
*oldBands
= infoPtr
->bands
;
3194 (REBAR_BAND
*)Alloc ((infoPtr
->uNumBands
+1)*sizeof(REBAR_BAND
));
3195 if (((INT
)uIndex
== -1) || (uIndex
> infoPtr
->uNumBands
))
3196 uIndex
= infoPtr
->uNumBands
;
3198 /* pre insert copy */
3200 memcpy (&infoPtr
->bands
[0], &oldBands
[0],
3201 uIndex
* sizeof(REBAR_BAND
));
3205 if (uIndex
<= infoPtr
->uNumBands
- 1) {
3206 memcpy (&infoPtr
->bands
[uIndex
+1], &oldBands
[uIndex
],
3207 (infoPtr
->uNumBands
- uIndex
) * sizeof(REBAR_BAND
));
3213 infoPtr
->uNumBands
++;
3215 TRACE("index %u!\n", uIndex
);
3217 /* initialize band (infoPtr->bands[uIndex])*/
3218 lpBand
= &infoPtr
->bands
[uIndex
];
3220 lpBand
->fStatus
= 0;
3221 lpBand
->clrFore
= infoPtr
->clrText
;
3222 lpBand
->clrBack
= infoPtr
->clrBk
;
3223 lpBand
->hwndChild
= 0;
3224 lpBand
->hwndPrevParent
= 0;
3226 REBAR_CommonSetupBand (infoPtr
->hwndSelf
, (LPREBARBANDINFOA
)lprbbi
, lpBand
);
3227 lpBand
->lpText
= NULL
;
3228 if ((lprbbi
->fMask
& RBBIM_TEXT
) && (lprbbi
->lpText
)) {
3229 INT len
= lstrlenW (lprbbi
->lpText
);
3231 lpBand
->lpText
= (LPWSTR
)Alloc ((len
+ 1)*sizeof(WCHAR
));
3232 strcpyW (lpBand
->lpText
, lprbbi
->lpText
);
3236 REBAR_ValidateBand (infoPtr
, lpBand
);
3237 /* On insert of second band, revalidate band 1 to possible add gripper */
3238 if (infoPtr
->uNumBands
== 2)
3239 REBAR_ValidateBand (infoPtr
, &infoPtr
->bands
[uIndex
? 0 : 1]);
3241 REBAR_DumpBand (infoPtr
);
3243 REBAR_Layout (infoPtr
, NULL
, TRUE
, FALSE
);
3244 InvalidateRect(infoPtr
->hwndSelf
, 0, 1);
3251 REBAR_MaximizeBand (REBAR_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
3254 UINT uBand
= (UINT
) wParam
;
3257 if ((infoPtr
->uNumBands
== 0) ||
3258 ((INT
)uBand
< 0) || (uBand
>= infoPtr
->uNumBands
)) {
3260 ERR("Illegal MaximizeBand, requested=%d, current band count=%d\n",
3261 (INT
)uBand
, infoPtr
->uNumBands
);
3265 lpBand
= &infoPtr
->bands
[uBand
];
3267 if (lParam
&& (lpBand
->fMask
& RBBIM_IDEALSIZE
)) {
3268 /* handle setting ideal size */
3269 lpBand
->ccx
= lpBand
->cxIdeal
;
3272 /* handle setting to max */
3273 FIXME("(uBand = %u fIdeal = %s) case not coded\n",
3274 (UINT
)wParam
, lParam
? "TRUE" : "FALSE");
3278 infoPtr
->fStatus
|= BAND_NEEDS_LAYOUT
;
3279 REBAR_Layout (infoPtr
, 0, TRUE
, TRUE
);
3280 InvalidateRect (infoPtr
->hwndSelf
, 0, TRUE
);
3288 REBAR_MinimizeBand (REBAR_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
3290 REBAR_BAND
*band
, *lpBand
;
3291 UINT uBand
= (UINT
) wParam
;
3293 INT imindBand
, imaxdBand
, iprevBand
, startBand
, endBand
;
3296 /* A "minimize" band is equivalent to "dragging" the gripper
3297 * of than band to the right till the band is only the size
3302 if ((infoPtr
->uNumBands
== 0) ||
3303 ((INT
)uBand
< 0) || (uBand
>= infoPtr
->uNumBands
)) {
3305 ERR("Illegal MinimizeBand, requested=%d, current band count=%d\n",
3306 (INT
)uBand
, infoPtr
->uNumBands
);
3310 /* compute amount of movement and validate */
3311 lpBand
= &infoPtr
->bands
[uBand
];
3313 if (infoPtr
->dwStyle
& CCS_VERT
)
3314 movement
= lpBand
->rcBand
.bottom
- lpBand
->rcBand
.top
-
3317 movement
= lpBand
->rcBand
.right
- lpBand
->rcBand
.left
-
3320 ERR("something is wrong, band=(%ld,%ld)-(%ld,%ld), cxheader=%d\n",
3321 lpBand
->rcBand
.left
, lpBand
->rcBand
.top
,
3322 lpBand
->rcBand
.right
, lpBand
->rcBand
.bottom
,
3329 iprevBand
= -1; /* to suppress warning message */
3331 /* find the first band in row of the one whose is being minimized */
3332 for (i
=0; i
<infoPtr
->uNumBands
; i
++) {
3333 band
= &infoPtr
->bands
[i
];
3334 if (HIDDENBAND(band
)) continue;
3335 if (band
->iRow
== lpBand
->iRow
) {
3337 if (imindBand
== -1) imindBand
= i
;
3341 /* if the selected band is first in row then need to expand */
3342 /* next visible band */
3343 if (imindBand
== uBand
) {
3345 movement
= -movement
;
3346 /* find the first visible band to the right of the selected band */
3347 for (i
=uBand
+1; i
<=imaxdBand
; i
++) {
3348 band
= &infoPtr
->bands
[i
];
3349 if (!HIDDENBAND(band
)) {
3351 LEADJ(band
, movement
);
3352 band
->ccx
= rcBw(band
);
3356 /* what case is this */
3357 if (iprevBand
== -1) {
3358 ERR("no previous visible band\n");
3362 endBand
= iprevBand
;
3364 lpBand
->rcBand
.left
,
3367 band
->rcBand
.bottom
);
3369 /* otherwise expand previous visible band */
3372 /* find the first visible band to the left of the selected band */
3373 for (i
=uBand
-1; i
>=imindBand
; i
--) {
3374 band
= &infoPtr
->bands
[i
];
3375 if (!HIDDENBAND(band
)) {
3377 READJ(band
, movement
);
3378 band
->ccx
= rcBw(band
);
3382 /* what case is this */
3383 if (iprevBand
== -1) {
3384 ERR("no previous visible band\n");
3387 startBand
= iprevBand
;
3392 lpBand
->rcBand
.right
,
3393 lpBand
->rcBand
.bottom
);
3396 REBAR_Shrink (infoPtr
, lpBand
, movement
, uBand
);
3398 /* recompute all rectangles */
3399 if (infoPtr
->dwStyle
& CCS_VERT
) {
3400 REBAR_CalcVertBand (infoPtr
, startBand
, endBand
+1,
3404 REBAR_CalcHorzBand (infoPtr
, startBand
, endBand
+1,
3408 TRACE("bands after minimize, see band # %d, %d\n",
3409 startBand
, endBand
);
3410 REBAR_DumpBand (infoPtr
);
3412 REBAR_MoveChildWindows (infoPtr
, startBand
, endBand
+1);
3414 InvalidateRect (infoPtr
->hwndSelf
, &newrect
, TRUE
);
3415 UpdateWindow (infoPtr
->hwndSelf
);
3421 REBAR_MoveBand (REBAR_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
3423 REBAR_BAND
*oldBands
= infoPtr
->bands
;
3425 UINT uFrom
= (UINT
)wParam
;
3426 UINT uTo
= (UINT
)lParam
;
3429 if ((infoPtr
->uNumBands
== 0) ||
3430 ((INT
)uFrom
< 0) || (uFrom
>= infoPtr
->uNumBands
) ||
3431 ((INT
)uTo
< 0) || (uTo
>= infoPtr
->uNumBands
)) {
3433 ERR("Illegal MoveBand, from=%d, to=%d, current band count=%d\n",
3434 (INT
)uFrom
, (INT
)uTo
, infoPtr
->uNumBands
);
3438 /* save one to be moved */
3439 memcpy (&holder
, &oldBands
[uFrom
], sizeof(REBAR_BAND
));
3441 /* close up rest of bands (pseudo delete) */
3442 if (uFrom
< infoPtr
->uNumBands
- 1) {
3443 memcpy (&oldBands
[uFrom
], &oldBands
[uFrom
+1],
3444 (infoPtr
->uNumBands
- uFrom
- 1) * sizeof(REBAR_BAND
));
3447 /* allocate new space and copy rest of bands into it */
3449 (REBAR_BAND
*)Alloc ((infoPtr
->uNumBands
)*sizeof(REBAR_BAND
));
3451 /* pre insert copy */
3453 memcpy (&infoPtr
->bands
[0], &oldBands
[0],
3454 uTo
* sizeof(REBAR_BAND
));
3457 /* set moved band */
3458 memcpy (&infoPtr
->bands
[uTo
], &holder
, sizeof(REBAR_BAND
));
3461 if (uTo
< infoPtr
->uNumBands
- 1) {
3462 memcpy (&infoPtr
->bands
[uTo
+1], &oldBands
[uTo
],
3463 (infoPtr
->uNumBands
- uTo
- 1) * sizeof(REBAR_BAND
));
3468 TRACE("moved band %d to index %d\n", uFrom
, uTo
);
3469 REBAR_DumpBand (infoPtr
);
3471 infoPtr
->fStatus
|= BAND_NEEDS_LAYOUT
;
3472 /* **************************************************** */
3474 /* We do not do a REBAR_Layout here because the native */
3475 /* control does not do that. The actual layout and */
3476 /* repaint is done by the *next* real action, ex.: */
3477 /* RB_INSERTBAND, RB_DELETEBAND, RB_SIZETORECT, etc. */
3479 /* **************************************************** */
3485 /* return TRUE if two strings are different */
3487 REBAR_strdifW( LPCWSTR a
, LPCWSTR b
)
3489 return ( (a
&& !b
) || (b
&& !a
) || (a
&& b
&& lstrcmpW(a
, b
) ) );
3493 REBAR_SetBandInfoA (REBAR_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
3495 LPREBARBANDINFOA lprbbi
= (LPREBARBANDINFOA
)lParam
;
3501 if (lprbbi
->cbSize
< REBARBANDINFOA_V3_SIZE
)
3503 if ((UINT
)wParam
>= infoPtr
->uNumBands
)
3506 TRACE("index %u\n", (UINT
)wParam
);
3507 REBAR_DumpBandInfo (lprbbi
);
3509 /* set band information */
3510 lpBand
= &infoPtr
->bands
[(UINT
)wParam
];
3512 bChanged
= REBAR_CommonSetupBand (infoPtr
->hwndSelf
, lprbbi
, lpBand
);
3513 if (lprbbi
->fMask
& RBBIM_TEXT
) {
3519 len
= MultiByteToWideChar( CP_ACP
, 0, lprbbi
->lpText
, -1, NULL
, 0 );
3521 wstr
= (LPWSTR
)Alloc (len
*sizeof(WCHAR
));
3523 MultiByteToWideChar( CP_ACP
, 0, lprbbi
->lpText
, -1, wstr
, len
);
3525 if (REBAR_strdifW(lpBand
->lpText
, wstr
)) {
3526 if (lpBand
->lpText
) {
3527 Free (lpBand
->lpText
);
3528 lpBand
->lpText
= NULL
;
3531 lpBand
->lpText
= wstr
;
3540 REBAR_ValidateBand (infoPtr
, lpBand
);
3542 REBAR_DumpBand (infoPtr
);
3544 if (bChanged
&& (lprbbi
->fMask
& (RBBIM_CHILDSIZE
| RBBIM_SIZE
))) {
3545 REBAR_Layout (infoPtr
, NULL
, TRUE
, FALSE
);
3546 InvalidateRect(infoPtr
->hwndSelf
, 0, 1);
3553 REBAR_SetBandInfoW (REBAR_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
3555 LPREBARBANDINFOW lprbbi
= (LPREBARBANDINFOW
)lParam
;
3561 if (lprbbi
->cbSize
< REBARBANDINFOW_V3_SIZE
)
3563 if ((UINT
)wParam
>= infoPtr
->uNumBands
)
3566 TRACE("index %u\n", (UINT
)wParam
);
3567 REBAR_DumpBandInfo ((LPREBARBANDINFOA
)lprbbi
);
3569 /* set band information */
3570 lpBand
= &infoPtr
->bands
[(UINT
)wParam
];
3572 bChanged
= REBAR_CommonSetupBand (infoPtr
->hwndSelf
, (LPREBARBANDINFOA
)lprbbi
, lpBand
);
3573 if( (lprbbi
->fMask
& RBBIM_TEXT
) &&
3574 REBAR_strdifW( lpBand
->lpText
, lprbbi
->lpText
) ) {
3575 if (lpBand
->lpText
) {
3576 Free (lpBand
->lpText
);
3577 lpBand
->lpText
= NULL
;
3579 if (lprbbi
->lpText
) {
3580 INT len
= lstrlenW (lprbbi
->lpText
);
3583 lpBand
->lpText
= (LPWSTR
)Alloc ((len
+ 1)*sizeof(WCHAR
));
3584 strcpyW (lpBand
->lpText
, lprbbi
->lpText
);
3590 REBAR_ValidateBand (infoPtr
, lpBand
);
3592 REBAR_DumpBand (infoPtr
);
3594 if ( bChanged
&& (lprbbi
->fMask
& (RBBIM_CHILDSIZE
| RBBIM_SIZE
)) ) {
3595 REBAR_Layout (infoPtr
, NULL
, TRUE
, FALSE
);
3596 InvalidateRect(infoPtr
->hwndSelf
, 0, 1);
3604 REBAR_SetBarInfo (REBAR_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
3606 LPREBARINFO lpInfo
= (LPREBARINFO
)lParam
;
3613 if (lpInfo
->cbSize
< sizeof (REBARINFO
))
3616 TRACE("setting bar info!\n");
3618 if (lpInfo
->fMask
& RBIM_IMAGELIST
) {
3619 infoPtr
->himl
= lpInfo
->himl
;
3620 if (infoPtr
->himl
) {
3622 ImageList_GetIconSize (infoPtr
->himl
, &cx
, &cy
);
3623 infoPtr
->imageSize
.cx
= cx
;
3624 infoPtr
->imageSize
.cy
= cy
;
3627 infoPtr
->imageSize
.cx
= 0;
3628 infoPtr
->imageSize
.cy
= 0;
3630 TRACE("new image cx=%ld, cy=%ld\n", infoPtr
->imageSize
.cx
,
3631 infoPtr
->imageSize
.cy
);
3634 /* revalidate all bands to reset flags for images in headers of bands */
3635 for (i
=0; i
<infoPtr
->uNumBands
; i
++) {
3636 lpBand
= &infoPtr
->bands
[i
];
3637 REBAR_ValidateBand (infoPtr
, lpBand
);
3645 REBAR_SetBkColor (REBAR_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
3649 clrTemp
= infoPtr
->clrBk
;
3650 infoPtr
->clrBk
= (COLORREF
)lParam
;
3652 TRACE("background color 0x%06lx!\n", infoPtr
->clrBk
);
3658 /* << REBAR_SetColorScheme >> */
3659 /* << REBAR_SetPalette >> */
3663 REBAR_SetParent (REBAR_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
3665 HWND hwndTemp
= infoPtr
->hwndNotify
;
3667 infoPtr
->hwndNotify
= (HWND
)wParam
;
3669 return (LRESULT
)hwndTemp
;
3674 REBAR_SetTextColor (REBAR_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
3678 clrTemp
= infoPtr
->clrText
;
3679 infoPtr
->clrText
= (COLORREF
)lParam
;
3681 TRACE("text color 0x%06lx!\n", infoPtr
->clrText
);
3687 /* << REBAR_SetTooltips >> */
3690 inline static LRESULT
3691 REBAR_SetUnicodeFormat (REBAR_INFO
*infoPtr
, WPARAM wParam
)
3693 BOOL bTemp
= infoPtr
->bUnicode
;
3695 TRACE("to %s hwnd=%p, was %s\n",
3696 ((BOOL
)wParam
) ? "TRUE" : "FALSE", infoPtr
->hwndSelf
,
3697 (bTemp
) ? "TRUE" : "FALSE");
3699 infoPtr
->bUnicode
= (BOOL
)wParam
;
3706 REBAR_SetVersion (REBAR_INFO
*infoPtr
, INT iVersion
)
3708 INT iOldVersion
= infoPtr
->iVersion
;
3710 if (iVersion
> COMCTL32_VERSION
)
3713 infoPtr
->iVersion
= iVersion
;
3715 TRACE("new version %d\n", iVersion
);
3722 REBAR_ShowBand (REBAR_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
3726 if (((INT
)wParam
< 0) || ((INT
)wParam
> infoPtr
->uNumBands
))
3729 lpBand
= &infoPtr
->bands
[(INT
)wParam
];
3732 TRACE("show band %d\n", (INT
)wParam
);
3733 lpBand
->fStyle
= lpBand
->fStyle
& ~RBBS_HIDDEN
;
3734 if (IsWindow (lpBand
->hwndChild
))
3735 ShowWindow (lpBand
->hwndChild
, SW_SHOW
);
3738 TRACE("hide band %d\n", (INT
)wParam
);
3739 lpBand
->fStyle
= lpBand
->fStyle
| RBBS_HIDDEN
;
3740 if (IsWindow (lpBand
->hwndChild
))
3741 ShowWindow (lpBand
->hwndChild
, SW_HIDE
);
3744 infoPtr
->fStatus
|= BAND_NEEDS_LAYOUT
;
3745 REBAR_Layout (infoPtr
, NULL
, TRUE
, FALSE
);
3746 InvalidateRect(infoPtr
->hwndSelf
, 0, 1);
3753 REBAR_SizeToRect (REBAR_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
3755 LPRECT lpRect
= (LPRECT
)lParam
;
3761 TRACE("[%ld %ld %ld %ld]\n",
3762 lpRect
->left
, lpRect
->top
, lpRect
->right
, lpRect
->bottom
);
3764 /* what is going on???? */
3765 GetWindowRect(infoPtr
->hwndSelf
, &t1
);
3766 TRACE("window rect [%ld %ld %ld %ld]\n",
3767 t1
.left
, t1
.top
, t1
.right
, t1
.bottom
);
3768 GetClientRect(infoPtr
->hwndSelf
, &t1
);
3769 TRACE("client rect [%ld %ld %ld %ld]\n",
3770 t1
.left
, t1
.top
, t1
.right
, t1
.bottom
);
3772 /* force full _Layout processing */
3773 TRACE("setting NEEDS_LAYOUT\n");
3774 infoPtr
->fStatus
|= BAND_NEEDS_LAYOUT
;
3775 REBAR_Layout (infoPtr
, lpRect
, TRUE
, FALSE
);
3776 InvalidateRect (infoPtr
->hwndSelf
, NULL
, TRUE
);
3783 REBAR_Create (REBAR_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
3785 LPCREATESTRUCTA cs
= (LPCREATESTRUCTA
) lParam
;
3788 if (TRACE_ON(rebar
)) {
3789 GetWindowRect(infoPtr
->hwndSelf
, &wnrc1
);
3790 GetClientRect(infoPtr
->hwndSelf
, &clrc1
);
3791 TRACE("window=(%ld,%ld)-(%ld,%ld) client=(%ld,%ld)-(%ld,%ld) cs=(%d,%d %dx%d)\n",
3792 wnrc1
.left
, wnrc1
.top
, wnrc1
.right
, wnrc1
.bottom
,
3793 clrc1
.left
, clrc1
.top
, clrc1
.right
, clrc1
.bottom
,
3794 cs
->x
, cs
->y
, cs
->cx
, cs
->cy
);
3797 TRACE("created!\n");
3803 REBAR_Destroy (REBAR_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
3809 /* free rebar bands */
3810 if ((infoPtr
->uNumBands
> 0) && infoPtr
->bands
) {
3811 /* clean up each band */
3812 for (i
= 0; i
< infoPtr
->uNumBands
; i
++) {
3813 lpBand
= &infoPtr
->bands
[i
];
3815 /* delete text strings */
3816 if (lpBand
->lpText
) {
3817 Free (lpBand
->lpText
);
3818 lpBand
->lpText
= NULL
;
3820 /* destroy child window */
3821 DestroyWindow (lpBand
->hwndChild
);
3824 /* free band array */
3825 Free (infoPtr
->bands
);
3826 infoPtr
->bands
= NULL
;
3829 DeleteObject (infoPtr
->hcurArrow
);
3830 DeleteObject (infoPtr
->hcurHorz
);
3831 DeleteObject (infoPtr
->hcurVert
);
3832 DeleteObject (infoPtr
->hcurDrag
);
3833 if(infoPtr
->hDefaultFont
) DeleteObject (infoPtr
->hDefaultFont
);
3834 SetWindowLongA (infoPtr
->hwndSelf
, 0, 0);
3836 /* free rebar info data */
3838 TRACE("destroyed!\n");
3844 REBAR_EraseBkGnd (REBAR_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
3848 if (GetClipBox ( (HDC
)wParam
, &cliprect
))
3849 return REBAR_InternalEraseBkGnd (infoPtr
, wParam
, lParam
, &cliprect
);
3855 REBAR_GetFont (REBAR_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
3857 return (LRESULT
)infoPtr
->hFont
;
3861 REBAR_PushChevron(REBAR_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
3863 if (wParam
>= 0 && (UINT
)wParam
< infoPtr
->uNumBands
)
3865 NMREBARCHEVRON nmrbc
;
3866 REBAR_BAND
*lpBand
= &infoPtr
->bands
[wParam
];
3868 TRACE("Pressed chevron on band %d\n", wParam
);
3870 /* redraw chevron in pushed state */
3871 lpBand
->fDraw
|= DRAW_CHEVRONPUSHED
;
3872 RedrawWindow(infoPtr
->hwndSelf
, &lpBand
->rcChevron
,0,
3873 RDW_ERASE
|RDW_INVALIDATE
|RDW_UPDATENOW
);
3875 /* notify app so it can display a popup menu or whatever */
3876 nmrbc
.uBand
= wParam
;
3877 nmrbc
.wID
= lpBand
->wID
;
3878 nmrbc
.lParam
= lpBand
->lParam
;
3879 nmrbc
.rc
= lpBand
->rcChevron
;
3880 nmrbc
.lParamNM
= lParam
;
3881 REBAR_Notify((NMHDR
*)&nmrbc
, infoPtr
, RBN_CHEVRONPUSHED
);
3883 /* redraw chevron in previous state */
3884 lpBand
->fDraw
&= ~DRAW_CHEVRONPUSHED
;
3885 InvalidateRect(infoPtr
->hwndSelf
, &lpBand
->rcChevron
, TRUE
);
3893 REBAR_LButtonDown (REBAR_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
3899 ptMouseDown
.x
= (INT
)LOWORD(lParam
);
3900 ptMouseDown
.y
= (INT
)HIWORD(lParam
);
3902 REBAR_InternalHitTest(infoPtr
, &ptMouseDown
, &htFlags
, &iHitBand
);
3903 lpBand
= &infoPtr
->bands
[iHitBand
];
3905 if (htFlags
== RBHT_CHEVRON
)
3907 REBAR_PushChevron(infoPtr
, iHitBand
, 0);
3909 else if (htFlags
== RBHT_GRABBER
|| htFlags
== RBHT_CAPTION
)
3911 TRACE("Starting drag\n");
3913 SetCapture (infoPtr
->hwndSelf
);
3914 infoPtr
->iGrabbedBand
= iHitBand
;
3916 /* save off the LOWORD and HIWORD of lParam as initial x,y */
3917 infoPtr
->dragStart
= MAKEPOINTS(lParam
);
3918 infoPtr
->dragNow
= infoPtr
->dragStart
;
3919 if (infoPtr
->dwStyle
& CCS_VERT
)
3920 infoPtr
->ihitoffset
= infoPtr
->dragStart
.y
- (lpBand
->rcBand
.top
+REBAR_PRE_GRIPPER
);
3922 infoPtr
->ihitoffset
= infoPtr
->dragStart
.x
- (lpBand
->rcBand
.left
+REBAR_PRE_GRIPPER
);
3928 REBAR_LButtonUp (REBAR_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
3930 if (infoPtr
->iGrabbedBand
>= 0)
3935 infoPtr
->dragStart
.x
= 0;
3936 infoPtr
->dragStart
.y
= 0;
3937 infoPtr
->dragNow
= infoPtr
->dragStart
;
3941 if (infoPtr
->fStatus
& BEGIN_DRAG_ISSUED
) {
3942 REBAR_Notify(&layout
, infoPtr
, RBN_LAYOUTCHANGED
);
3943 REBAR_Notify_NMREBAR (infoPtr
, infoPtr
->iGrabbedBand
, RBN_ENDDRAG
);
3944 infoPtr
->fStatus
&= ~BEGIN_DRAG_ISSUED
;
3947 infoPtr
->iGrabbedBand
= -1;
3949 GetClientRect(infoPtr
->hwndSelf
, &rect
);
3950 InvalidateRect(infoPtr
->hwndSelf
, NULL
, TRUE
);
3957 REBAR_MouseLeave (REBAR_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
3959 if (infoPtr
->ichevronhotBand
>= 0)
3961 REBAR_BAND
*lpChevronBand
= &infoPtr
->bands
[infoPtr
->ichevronhotBand
];
3962 if (lpChevronBand
->fDraw
& DRAW_CHEVRONHOT
)
3964 lpChevronBand
->fDraw
&= ~DRAW_CHEVRONHOT
;
3965 InvalidateRect(infoPtr
->hwndSelf
, &lpChevronBand
->rcChevron
, TRUE
);
3968 infoPtr
->iOldBand
= -1;
3969 infoPtr
->ichevronhotBand
= -2;
3975 REBAR_MouseMove (REBAR_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
3977 REBAR_BAND
*lpChevronBand
;
3980 ptsmove
= MAKEPOINTS(lParam
);
3982 /* if we are currently dragging a band */
3983 if (infoPtr
->iGrabbedBand
>= 0)
3985 REBAR_BAND
*band1
, *band2
;
3987 if (GetCapture() != infoPtr
->hwndSelf
)
3988 ERR("We are dragging but haven't got capture?!?\n");
3990 band1
= &infoPtr
->bands
[infoPtr
->iGrabbedBand
-1];
3991 band2
= &infoPtr
->bands
[infoPtr
->iGrabbedBand
];
3993 /* if mouse did not move much, exit */
3994 if ((abs(ptsmove
.x
- infoPtr
->dragNow
.x
) <= mindragx
) &&
3995 (abs(ptsmove
.y
- infoPtr
->dragNow
.y
) <= mindragy
)) return 0;
3997 /* Test for valid drag case - must not be first band in row */
3998 if (infoPtr
->dwStyle
& CCS_VERT
) {
3999 if ((ptsmove
.x
< band2
->rcBand
.left
) ||
4000 (ptsmove
.x
> band2
->rcBand
.right
) ||
4001 ((infoPtr
->iGrabbedBand
> 0) && (band1
->iRow
!= band2
->iRow
))) {
4002 FIXME("Cannot drag to other rows yet!!\n");
4005 REBAR_HandleLRDrag (infoPtr
, &ptsmove
);
4009 if ((ptsmove
.y
< band2
->rcBand
.top
) ||
4010 (ptsmove
.y
> band2
->rcBand
.bottom
) ||
4011 ((infoPtr
->iGrabbedBand
> 0) && (band1
->iRow
!= band2
->iRow
))) {
4012 FIXME("Cannot drag to other rows yet!!\n");
4015 REBAR_HandleLRDrag (infoPtr
, &ptsmove
);
4024 TRACKMOUSEEVENT trackinfo
;
4026 ptMove
.x
= (INT
)ptsmove
.x
;
4027 ptMove
.y
= (INT
)ptsmove
.y
;
4028 REBAR_InternalHitTest(infoPtr
, &ptMove
, &htFlags
, &iHitBand
);
4030 if (infoPtr
->iOldBand
>= 0 && infoPtr
->iOldBand
== infoPtr
->ichevronhotBand
)
4032 lpChevronBand
= &infoPtr
->bands
[infoPtr
->ichevronhotBand
];
4033 if (lpChevronBand
->fDraw
& DRAW_CHEVRONHOT
)
4035 lpChevronBand
->fDraw
&= ~DRAW_CHEVRONHOT
;
4036 InvalidateRect(infoPtr
->hwndSelf
, &lpChevronBand
->rcChevron
, TRUE
);
4038 infoPtr
->ichevronhotBand
= -2;
4041 if (htFlags
== RBHT_CHEVRON
)
4043 /* fill in the TRACKMOUSEEVENT struct */
4044 trackinfo
.cbSize
= sizeof(TRACKMOUSEEVENT
);
4045 trackinfo
.dwFlags
= TME_QUERY
;
4046 trackinfo
.hwndTrack
= infoPtr
->hwndSelf
;
4047 trackinfo
.dwHoverTime
= 0;
4049 /* call _TrackMouseEvent to see if we are currently tracking for this hwnd */
4050 _TrackMouseEvent(&trackinfo
);
4052 /* Make sure tracking is enabled so we receive a WM_MOUSELEAVE message */
4053 if(!(trackinfo
.dwFlags
& TME_LEAVE
))
4055 trackinfo
.dwFlags
= TME_LEAVE
; /* notify upon leaving */
4057 /* call TRACKMOUSEEVENT so we receive a WM_MOUSELEAVE message */
4058 /* and can properly deactivate the hot chevron */
4059 _TrackMouseEvent(&trackinfo
);
4062 lpChevronBand
= &infoPtr
->bands
[iHitBand
];
4063 if (!(lpChevronBand
->fDraw
& DRAW_CHEVRONHOT
))
4065 lpChevronBand
->fDraw
|= DRAW_CHEVRONHOT
;
4066 InvalidateRect(infoPtr
->hwndSelf
, &lpChevronBand
->rcChevron
, TRUE
);
4067 infoPtr
->ichevronhotBand
= iHitBand
;
4070 infoPtr
->iOldBand
= iHitBand
;
4077 inline static LRESULT
4078 REBAR_NCCalcSize (REBAR_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
4080 if (infoPtr
->dwStyle
& WS_BORDER
) {
4081 InflateRect((LPRECT
)lParam
, -GetSystemMetrics(SM_CXEDGE
),
4082 -GetSystemMetrics(SM_CYEDGE
));
4084 TRACE("new client=(%ld,%ld)-(%ld,%ld)\n",
4085 ((LPRECT
)lParam
)->left
, ((LPRECT
)lParam
)->top
,
4086 ((LPRECT
)lParam
)->right
, ((LPRECT
)lParam
)->bottom
);
4092 REBAR_NCCreate (HWND hwnd
, WPARAM wParam
, LPARAM lParam
)
4094 LPCREATESTRUCTA cs
= (LPCREATESTRUCTA
) lParam
;
4095 REBAR_INFO
*infoPtr
= REBAR_GetInfoPtr (hwnd
);
4097 NONCLIENTMETRICSA ncm
;
4101 if (infoPtr
!= NULL
) {
4102 ERR("Strange info structure pointer *not* NULL\n");
4106 if (TRACE_ON(rebar
)) {
4107 GetWindowRect(hwnd
, &wnrc1
);
4108 GetClientRect(hwnd
, &clrc1
);
4109 TRACE("window=(%ld,%ld)-(%ld,%ld) client=(%ld,%ld)-(%ld,%ld) cs=(%d,%d %dx%d)\n",
4110 wnrc1
.left
, wnrc1
.top
, wnrc1
.right
, wnrc1
.bottom
,
4111 clrc1
.left
, clrc1
.top
, clrc1
.right
, clrc1
.bottom
,
4112 cs
->x
, cs
->y
, cs
->cx
, cs
->cy
);
4115 /* allocate memory for info structure */
4116 infoPtr
= (REBAR_INFO
*)Alloc (sizeof(REBAR_INFO
));
4117 SetWindowLongA (hwnd
, 0, (DWORD
)infoPtr
);
4119 /* initialize info structure - initial values are 0 */
4120 infoPtr
->clrBk
= CLR_NONE
;
4121 infoPtr
->clrText
= CLR_NONE
;
4122 infoPtr
->clrBtnText
= GetSysColor (COLOR_BTNTEXT
);
4123 infoPtr
->clrBtnFace
= GetSysColor (COLOR_BTNFACE
);
4124 infoPtr
->iOldBand
= -1;
4125 infoPtr
->ichevronhotBand
= -2;
4126 infoPtr
->iGrabbedBand
= -1;
4127 infoPtr
->hwndSelf
= hwnd
;
4128 infoPtr
->DoRedraw
= TRUE
;
4129 infoPtr
->hcurArrow
= LoadCursorA (0, (LPSTR
)IDC_ARROW
);
4130 infoPtr
->hcurHorz
= LoadCursorA (0, (LPSTR
)IDC_SIZEWE
);
4131 infoPtr
->hcurVert
= LoadCursorA (0, (LPSTR
)IDC_SIZENS
);
4132 infoPtr
->hcurDrag
= LoadCursorA (0, (LPSTR
)IDC_SIZE
);
4133 infoPtr
->bUnicode
= IsWindowUnicode (hwnd
);
4134 infoPtr
->fStatus
= CREATE_RUNNING
;
4135 infoPtr
->hFont
= GetStockObject (SYSTEM_FONT
);
4137 /* issue WM_NOTIFYFORMAT to get unicode status of parent */
4138 i
= SendMessageA(REBAR_GetNotifyParent (infoPtr
),
4139 WM_NOTIFYFORMAT
, (WPARAM
)hwnd
, NF_QUERY
);
4140 if ((i
< NFR_ANSI
) || (i
> NFR_UNICODE
)) {
4141 ERR("wrong response to WM_NOTIFYFORMAT (%d), assuming ANSI\n",
4145 infoPtr
->NtfUnicode
= (i
== NFR_UNICODE
) ? 1 : 0;
4147 /* add necessary styles to the requested styles */
4148 infoPtr
->dwStyle
= cs
->style
| WS_VISIBLE
| CCS_TOP
;
4149 SetWindowLongA (hwnd
, GWL_STYLE
, infoPtr
->dwStyle
);
4151 /* get font handle for Caption Font */
4152 ncm
.cbSize
= sizeof(NONCLIENTMETRICSA
);
4153 SystemParametersInfoA (SPI_GETNONCLIENTMETRICS
,
4154 ncm
.cbSize
, &ncm
, 0);
4155 /* if the font is bold, set to normal */
4156 if (ncm
.lfCaptionFont
.lfWeight
> FW_NORMAL
) {
4157 ncm
.lfCaptionFont
.lfWeight
= FW_NORMAL
;
4159 tfont
= CreateFontIndirectA (&ncm
.lfCaptionFont
);
4161 infoPtr
->hFont
= infoPtr
->hDefaultFont
= tfont
;
4165 GetSysColor (numerous);
4166 GetSysColorBrush (numerous) (see WM_SYSCOLORCHANGE);
4167 *GetStockObject (SYSTEM_FONT);
4168 *SetWindowLong (hwnd, 0, info ptr);
4170 *SetWindowLong (hwnd, GWL_STYLE, style+0x10000001);
4171 WS_VISIBLE = 0x10000000;
4172 CCS_TOP = 0x00000001;
4173 *SystemParametersInfo (SPI_GETNONCLIENTMETRICS...);
4174 *CreateFontIndirect (lfCaptionFont from above);
4176 SelectObject (hdc, fontabove);
4177 GetTextMetrics (hdc, ); guessing is tmHeight
4178 SelectObject (hdc, oldfont);
4181 MapWindowPoints (0, parent, rectabove, 2);
4184 ClientToScreen (clientrect);
4185 SetWindowPos (hwnd, 0, 0, 0, 0, 0, SWP_NOZORDER);
4192 REBAR_NCHitTest (REBAR_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
4199 LRESULT ret
= HTCLIENT
;
4202 * Differences from doc at MSDN (as observed with version 4.71 of
4204 * 1. doc says nmmouse.pt is in screen coord, trace shows client coord.
4205 * 2. if band is not identified .dwItemSpec is 0xffffffff.
4206 * 3. native always seems to return HTCLIENT if notify return is 0.
4209 shortpt
= MAKEPOINTS (lParam
);
4210 POINTSTOPOINT(pt
, shortpt
);
4212 ScreenToClient (infoPtr
->hwndSelf
, &clpt
);
4213 REBAR_InternalHitTest (infoPtr
, &clpt
, &scrap
,
4214 (INT
*)&nmmouse
.dwItemSpec
);
4215 nmmouse
.dwItemData
= 0;
4217 nmmouse
.dwHitInfo
= 0;
4218 if ((i
= REBAR_Notify((NMHDR
*) &nmmouse
, infoPtr
, NM_NCHITTEST
))) {
4219 TRACE("notify changed return value from %ld to %d\n",
4223 TRACE("returning %ld, client point (%ld,%ld)\n", ret
, clpt
.x
, clpt
.y
);
4229 REBAR_NCPaint (REBAR_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
4234 if (infoPtr
->dwStyle
& WS_MINIMIZE
)
4235 return 0; /* Nothing to do */
4237 if (infoPtr
->dwStyle
& WS_BORDER
) {
4239 /* adjust rectangle and draw the necessary edge */
4240 if (!(hdc
= GetDCEx( infoPtr
->hwndSelf
, 0, DCX_USESTYLE
| DCX_WINDOW
)))
4242 GetWindowRect (infoPtr
->hwndSelf
, &rcWindow
);
4243 OffsetRect (&rcWindow
, -rcWindow
.left
, -rcWindow
.top
);
4244 TRACE("rect (%ld,%ld)-(%ld,%ld)\n",
4245 rcWindow
.left
, rcWindow
.top
,
4246 rcWindow
.right
, rcWindow
.bottom
);
4247 DrawEdge (hdc
, &rcWindow
, EDGE_ETCHED
, BF_RECT
);
4248 ReleaseDC( infoPtr
->hwndSelf
, hdc
);
4256 REBAR_NotifyFormat (REBAR_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
4260 if (lParam
== NF_REQUERY
) {
4261 i
= SendMessageA(REBAR_GetNotifyParent (infoPtr
),
4262 WM_NOTIFYFORMAT
, (WPARAM
)infoPtr
->hwndSelf
, NF_QUERY
);
4263 if ((i
< NFR_ANSI
) || (i
> NFR_UNICODE
)) {
4264 ERR("wrong response to WM_NOTIFYFORMAT (%d), assuming ANSI\n",
4268 infoPtr
->NtfUnicode
= (i
== NFR_UNICODE
) ? 1 : 0;
4271 return (LRESULT
)((infoPtr
->bUnicode
) ? NFR_UNICODE
: NFR_ANSI
);
4276 REBAR_Paint (REBAR_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
4282 GetClientRect(infoPtr
->hwndSelf
, &rc
);
4283 hdc
= wParam
==0 ? BeginPaint (infoPtr
->hwndSelf
, &ps
) : (HDC
)wParam
;
4285 TRACE("painting (%ld,%ld)-(%ld,%ld) client (%ld,%ld)-(%ld,%ld)\n",
4286 ps
.rcPaint
.left
, ps
.rcPaint
.top
,
4287 ps
.rcPaint
.right
, ps
.rcPaint
.bottom
,
4288 rc
.left
, rc
.top
, rc
.right
, rc
.bottom
);
4291 /* Erase area of paint if requested */
4292 REBAR_InternalEraseBkGnd (infoPtr
, wParam
, lParam
, &ps
.rcPaint
);
4295 REBAR_Refresh (infoPtr
, hdc
);
4297 EndPaint (infoPtr
->hwndSelf
, &ps
);
4303 REBAR_SetCursor (REBAR_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
4308 TRACE("code=0x%X id=0x%X\n", LOWORD(lParam
), HIWORD(lParam
));
4311 ScreenToClient (infoPtr
->hwndSelf
, &pt
);
4313 REBAR_InternalHitTest (infoPtr
, &pt
, &flags
, NULL
);
4315 if (flags
== RBHT_GRABBER
) {
4316 if ((infoPtr
->dwStyle
& CCS_VERT
) &&
4317 !(infoPtr
->dwStyle
& RBS_VERTICALGRIPPER
))
4318 SetCursor (infoPtr
->hcurVert
);
4320 SetCursor (infoPtr
->hcurHorz
);
4322 else if (flags
!= RBHT_CLIENT
)
4323 SetCursor (infoPtr
->hcurArrow
);
4330 REBAR_SetFont (REBAR_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
4336 infoPtr
->hFont
= (HFONT
)wParam
;
4338 /* revalidate all bands to change sizes of text in headers of bands */
4339 for (i
=0; i
<infoPtr
->uNumBands
; i
++) {
4340 lpBand
= &infoPtr
->bands
[i
];
4341 REBAR_ValidateBand (infoPtr
, lpBand
);
4345 if (LOWORD(lParam
)) {
4346 GetClientRect (infoPtr
->hwndSelf
, &rcClient
);
4347 REBAR_Layout (infoPtr
, &rcClient
, FALSE
, TRUE
);
4354 inline static LRESULT
4355 REBAR_SetRedraw (REBAR_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
4356 /*****************************************************
4359 * Handles the WM_SETREDRAW message.
4362 * According to testing V4.71 of COMCTL32 returns the
4363 * *previous* status of the redraw flag (either 0 or -1)
4364 * instead of the MSDN documented value of 0 if handled
4366 *****************************************************/
4368 BOOL oldredraw
= infoPtr
->DoRedraw
;
4370 TRACE("set to %s, fStatus=%08x\n",
4371 (wParam
) ? "TRUE" : "FALSE", infoPtr
->fStatus
);
4372 infoPtr
->DoRedraw
= (BOOL
) wParam
;
4374 if (infoPtr
->fStatus
& BAND_NEEDS_REDRAW
) {
4375 REBAR_MoveChildWindows (infoPtr
, 0, infoPtr
->uNumBands
);
4376 REBAR_ForceResize (infoPtr
);
4377 InvalidateRect (infoPtr
->hwndSelf
, 0, TRUE
);
4379 infoPtr
->fStatus
&= ~BAND_NEEDS_REDRAW
;
4381 return (oldredraw
) ? -1 : 0;
4386 REBAR_Size (REBAR_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
4390 /* auto resize deadlock check */
4391 if (infoPtr
->fStatus
& AUTO_RESIZE
) {
4392 infoPtr
->fStatus
&= ~AUTO_RESIZE
;
4393 TRACE("AUTO_RESIZE was set, reset, fStatus=%08x lparam=%08lx\n",
4394 infoPtr
->fStatus
, lParam
);
4398 if (infoPtr
->fStatus
& CREATE_RUNNING
) {
4399 /* still in CreateWindow */
4402 if ((INT
)wParam
!= SIZE_RESTORED
) {
4403 ERR("WM_SIZE in create and flags=%08x, lParam=%08lx\n",
4407 TRACE("still in CreateWindow\n");
4408 infoPtr
->fStatus
&= ~CREATE_RUNNING
;
4409 GetWindowRect ( infoPtr
->hwndSelf
, &rcWin
);
4410 TRACE("win rect (%ld,%ld)-(%ld,%ld)\n",
4411 rcWin
.left
, rcWin
.top
, rcWin
.right
, rcWin
.bottom
);
4413 if ((lParam
== 0) && (rcWin
.right
-rcWin
.left
== 0) &&
4414 (rcWin
.bottom
-rcWin
.top
== 0)) {
4415 /* native control seems to do this */
4416 GetClientRect (GetParent(infoPtr
->hwndSelf
), &rcClient
);
4417 TRACE("sizing rebar, message and client zero, parent client (%ld,%ld)\n",
4418 rcClient
.right
, rcClient
.bottom
);
4423 cx
= rcWin
.right
- rcWin
.left
;
4424 cy
= rcWin
.bottom
- rcWin
.top
;
4425 if ((cx
== LOWORD(lParam
)) && (cy
== HIWORD(lParam
))) {
4429 /* do the actual WM_SIZE request */
4430 GetClientRect (infoPtr
->hwndSelf
, &rcClient
);
4431 TRACE("sizing rebar from (%ld,%ld) to (%d,%d), client (%ld,%ld)\n",
4432 infoPtr
->calcSize
.cx
, infoPtr
->calcSize
.cy
,
4433 LOWORD(lParam
), HIWORD(lParam
),
4434 rcClient
.right
, rcClient
.bottom
);
4438 if ((INT
)wParam
!= SIZE_RESTORED
) {
4439 ERR("WM_SIZE out of create and flags=%08x, lParam=%08lx\n",
4443 /* Handle cases when outside of the CreateWindow process */
4445 GetClientRect (infoPtr
->hwndSelf
, &rcClient
);
4446 if ((lParam
== 0) && (rcClient
.right
+ rcClient
.bottom
!= 0) &&
4447 (infoPtr
->dwStyle
& RBS_AUTOSIZE
)) {
4448 /* on a WM_SIZE to zero and current client not zero and AUTOSIZE */
4449 /* native seems to use the current client rect for the size */
4450 infoPtr
->fStatus
|= BAND_NEEDS_LAYOUT
;
4451 TRACE("sizing rebar to client (%ld,%ld) size is zero but AUTOSIZE set\n",
4452 rcClient
.right
, rcClient
.bottom
);
4455 TRACE("sizing rebar from (%ld,%ld) to (%d,%d), client (%ld,%ld)\n",
4456 infoPtr
->calcSize
.cx
, infoPtr
->calcSize
.cy
,
4457 LOWORD(lParam
), HIWORD(lParam
),
4458 rcClient
.right
, rcClient
.bottom
);
4462 if (infoPtr
->dwStyle
& RBS_AUTOSIZE
) {
4463 NMRBAUTOSIZE autosize
;
4465 GetClientRect(infoPtr
->hwndSelf
, &autosize
.rcTarget
);
4466 autosize
.fChanged
= 0; /* ??? */
4467 autosize
.rcActual
= autosize
.rcTarget
; /* ??? */
4468 REBAR_Notify((NMHDR
*) &autosize
, infoPtr
, RBN_AUTOSIZE
);
4469 TRACE("RBN_AUTOSIZE client=(%ld,%ld), lp=%08lx\n",
4470 autosize
.rcTarget
.right
, autosize
.rcTarget
.bottom
, lParam
);
4473 if ((infoPtr
->calcSize
.cx
!= rcClient
.right
) ||
4474 (infoPtr
->calcSize
.cy
!= rcClient
.bottom
))
4475 infoPtr
->fStatus
|= BAND_NEEDS_LAYOUT
;
4477 REBAR_Layout (infoPtr
, &rcClient
, TRUE
, TRUE
);
4478 infoPtr
->fStatus
&= ~AUTO_RESIZE
;
4485 REBAR_StyleChanged (REBAR_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
4487 STYLESTRUCT
*ss
= (STYLESTRUCT
*)lParam
;
4489 TRACE("current style=%08lx, styleOld=%08lx, style being set to=%08lx\n",
4490 infoPtr
->dwStyle
, ss
->styleOld
, ss
->styleNew
);
4491 infoPtr
->dwStyle
= ss
->styleNew
;
4498 REBAR_WindowPosChanged (REBAR_INFO
*infoPtr
, WPARAM wParam
, LPARAM lParam
)
4500 WINDOWPOS
*lpwp
= (WINDOWPOS
*)lParam
;
4504 /* Save the new origin of this window - used by _ForceResize */
4505 infoPtr
->origin
.x
= lpwp
->x
;
4506 infoPtr
->origin
.y
= lpwp
->y
;
4507 ret
= DefWindowProcA(infoPtr
->hwndSelf
, WM_WINDOWPOSCHANGED
,
4509 GetWindowRect(infoPtr
->hwndSelf
, &rc
);
4510 TRACE("hwnd %p new pos (%ld,%ld)-(%ld,%ld)\n",
4511 infoPtr
->hwndSelf
, rc
.left
, rc
.top
, rc
.right
, rc
.bottom
);
4516 static LRESULT WINAPI
4517 REBAR_WindowProc (HWND hwnd
, UINT uMsg
, WPARAM wParam
, LPARAM lParam
)
4519 REBAR_INFO
*infoPtr
= REBAR_GetInfoPtr (hwnd
);
4521 TRACE("hwnd=%p msg=%x wparam=%x lparam=%lx\n",
4522 hwnd
, uMsg
, wParam
, lParam
);
4523 if (!infoPtr
&& (uMsg
!= WM_NCCREATE
))
4524 return DefWindowProcA (hwnd
, uMsg
, wParam
, lParam
);
4527 /* case RB_BEGINDRAG: */
4530 return REBAR_DeleteBand (infoPtr
, wParam
, lParam
);
4532 /* case RB_DRAGMOVE: */
4533 /* case RB_ENDDRAG: */
4535 case RB_GETBANDBORDERS
:
4536 return REBAR_GetBandBorders (infoPtr
, wParam
, lParam
);
4538 case RB_GETBANDCOUNT
:
4539 return REBAR_GetBandCount (infoPtr
);
4541 case RB_GETBANDINFO_OLD
:
4542 case RB_GETBANDINFOA
:
4543 return REBAR_GetBandInfoA (infoPtr
, wParam
, lParam
);
4545 case RB_GETBANDINFOW
:
4546 return REBAR_GetBandInfoW (infoPtr
, wParam
, lParam
);
4548 case RB_GETBARHEIGHT
:
4549 return REBAR_GetBarHeight (infoPtr
, wParam
, lParam
);
4552 return REBAR_GetBarInfo (infoPtr
, wParam
, lParam
);
4555 return REBAR_GetBkColor (infoPtr
);
4557 /* case RB_GETCOLORSCHEME: */
4558 /* case RB_GETDROPTARGET: */
4561 return REBAR_GetPalette (infoPtr
, wParam
, lParam
);
4564 return REBAR_GetRect (infoPtr
, wParam
, lParam
);
4566 case RB_GETROWCOUNT
:
4567 return REBAR_GetRowCount (infoPtr
);
4569 case RB_GETROWHEIGHT
:
4570 return REBAR_GetRowHeight (infoPtr
, wParam
, lParam
);
4572 case RB_GETTEXTCOLOR
:
4573 return REBAR_GetTextColor (infoPtr
);
4575 case RB_GETTOOLTIPS
:
4576 return REBAR_GetToolTips (infoPtr
);
4578 case RB_GETUNICODEFORMAT
:
4579 return REBAR_GetUnicodeFormat (infoPtr
);
4581 case CCM_GETVERSION
:
4582 return REBAR_GetVersion (infoPtr
);
4585 return REBAR_HitTest (infoPtr
, wParam
, lParam
);
4588 return REBAR_IdToIndex (infoPtr
, wParam
, lParam
);
4590 case RB_INSERTBANDA
:
4591 return REBAR_InsertBandA (infoPtr
, wParam
, lParam
);
4593 case RB_INSERTBANDW
:
4594 return REBAR_InsertBandW (infoPtr
, wParam
, lParam
);
4596 case RB_MAXIMIZEBAND
:
4597 return REBAR_MaximizeBand (infoPtr
, wParam
, lParam
);
4599 case RB_MINIMIZEBAND
:
4600 return REBAR_MinimizeBand (infoPtr
, wParam
, lParam
);
4603 return REBAR_MoveBand (infoPtr
, wParam
, lParam
);
4605 case RB_PUSHCHEVRON
:
4606 return REBAR_PushChevron (infoPtr
, wParam
, lParam
);
4608 case RB_SETBANDINFOA
:
4609 return REBAR_SetBandInfoA (infoPtr
, wParam
, lParam
);
4611 case RB_SETBANDINFOW
:
4612 return REBAR_SetBandInfoW (infoPtr
, wParam
, lParam
);
4615 return REBAR_SetBarInfo (infoPtr
, wParam
, lParam
);
4618 return REBAR_SetBkColor (infoPtr
, wParam
, lParam
);
4620 /* case RB_SETCOLORSCHEME: */
4621 /* case RB_SETPALETTE: */
4622 /* return REBAR_GetPalette (infoPtr, wParam, lParam); */
4625 return REBAR_SetParent (infoPtr
, wParam
, lParam
);
4627 case RB_SETTEXTCOLOR
:
4628 return REBAR_SetTextColor (infoPtr
, wParam
, lParam
);
4630 /* case RB_SETTOOLTIPS: */
4632 case RB_SETUNICODEFORMAT
:
4633 return REBAR_SetUnicodeFormat (infoPtr
, wParam
);
4635 case CCM_SETVERSION
:
4636 return REBAR_SetVersion (infoPtr
, (INT
)wParam
);
4639 return REBAR_ShowBand (infoPtr
, wParam
, lParam
);
4642 return REBAR_SizeToRect (infoPtr
, wParam
, lParam
);
4645 /* Messages passed to parent */
4649 if (infoPtr
->NtfUnicode
)
4650 return SendMessageW (REBAR_GetNotifyParent (infoPtr
),
4651 uMsg
, wParam
, lParam
);
4653 return SendMessageA (REBAR_GetNotifyParent (infoPtr
),
4654 uMsg
, wParam
, lParam
);
4657 /* case WM_CHARTOITEM: supported according to ControlSpy */
4660 return REBAR_Create (infoPtr
, wParam
, lParam
);
4663 return REBAR_Destroy (infoPtr
, wParam
, lParam
);
4666 return REBAR_EraseBkGnd (infoPtr
, wParam
, lParam
);
4669 return REBAR_GetFont (infoPtr
, wParam
, lParam
);
4671 /* case WM_LBUTTONDBLCLK: supported according to ControlSpy */
4673 case WM_LBUTTONDOWN
:
4674 return REBAR_LButtonDown (infoPtr
, wParam
, lParam
);
4677 return REBAR_LButtonUp (infoPtr
, wParam
, lParam
);
4679 /* case WM_MEASUREITEM: supported according to ControlSpy */
4682 return REBAR_MouseMove (infoPtr
, wParam
, lParam
);
4685 return REBAR_MouseLeave (infoPtr
, wParam
, lParam
);
4688 return REBAR_NCCalcSize (infoPtr
, wParam
, lParam
);
4691 return REBAR_NCCreate (hwnd
, wParam
, lParam
);
4694 return REBAR_NCHitTest (infoPtr
, wParam
, lParam
);
4697 return REBAR_NCPaint (infoPtr
, wParam
, lParam
);
4699 case WM_NOTIFYFORMAT
:
4700 return REBAR_NotifyFormat (infoPtr
, wParam
, lParam
);
4703 return REBAR_Paint (infoPtr
, wParam
, lParam
);
4705 /* case WM_PALETTECHANGED: supported according to ControlSpy */
4706 /* case WM_PRINTCLIENT: supported according to ControlSpy */
4707 /* case WM_QUERYNEWPALETTE:supported according to ControlSpy */
4708 /* case WM_RBUTTONDOWN: supported according to ControlSpy */
4709 /* case WM_RBUTTONUP: supported according to ControlSpy */
4712 return REBAR_SetCursor (infoPtr
, wParam
, lParam
);
4715 return REBAR_SetFont (infoPtr
, wParam
, lParam
);
4718 return REBAR_SetRedraw (infoPtr
, wParam
, lParam
);
4721 return REBAR_Size (infoPtr
, wParam
, lParam
);
4723 case WM_STYLECHANGED
:
4724 return REBAR_StyleChanged (infoPtr
, wParam
, lParam
);
4726 /* case WM_SYSCOLORCHANGE: supported according to ControlSpy */
4727 /* "Applications that have brushes using the existing system colors
4728 should delete those brushes and recreate them using the new
4729 system colors." per MSDN */
4731 /* case WM_VKEYTOITEM: supported according to ControlSpy */
4732 /* case WM_WININICHANGE: */
4734 case WM_WINDOWPOSCHANGED
:
4735 return REBAR_WindowPosChanged (infoPtr
, wParam
, lParam
);
4738 if ((uMsg
>= WM_USER
) && (uMsg
< WM_APP
))
4739 ERR("unknown msg %04x wp=%08x lp=%08lx\n",
4740 uMsg
, wParam
, lParam
);
4741 return DefWindowProcA (hwnd
, uMsg
, wParam
, lParam
);
4748 REBAR_Register (void)
4752 ZeroMemory (&wndClass
, sizeof(WNDCLASSA
));
4753 wndClass
.style
= CS_GLOBALCLASS
| CS_DBLCLKS
;
4754 wndClass
.lpfnWndProc
= (WNDPROC
)REBAR_WindowProc
;
4755 wndClass
.cbClsExtra
= 0;
4756 wndClass
.cbWndExtra
= sizeof(REBAR_INFO
*);
4757 wndClass
.hCursor
= 0;
4758 wndClass
.hbrBackground
= (HBRUSH
)(COLOR_BTNFACE
+ 1);
4760 wndClass
.hbrBackground
= CreateSolidBrush(RGB(0,128,0));
4762 wndClass
.lpszClassName
= REBARCLASSNAMEA
;
4764 RegisterClassA (&wndClass
);
4766 mindragx
= GetSystemMetrics (SM_CXDRAG
);
4767 mindragy
= GetSystemMetrics (SM_CYDRAG
);
4773 REBAR_Unregister (void)
4775 UnregisterClassA (REBARCLASSNAMEA
, NULL
);