rebar.c File Reference

#include <assert.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "wine/unicode.h"
#include "winuser.h"
#include "winnls.h"
#include "commctrl.h"
#include "comctl32.h"
#include "uxtheme.h"
#include "vssym32.h"
#include "wine/debug.h"

Include dependency graph for rebar.c:

Go to the source code of this file.

Classes
struct	REBAR_BAND
struct	REBAR_INFO

Macros
#define	GLATESTING   0
#define	CCS_LAYOUT_MASK   0x3
#define	HAS_GRIPPER   0x00000001
#define	HAS_IMAGE   0x00000002
#define	HAS_TEXT   0x00000004
#define	DRAW_GRIPPER   0x00000001
#define	DRAW_IMAGE   0x00000002
#define	DRAW_TEXT   0x00000004
#define	DRAW_CHEVRONHOT   0x00000040
#define	DRAW_CHEVRONPUSHED   0x00000080
#define	NTF_INVALIDATE   0x01000000
#define	BEGIN_DRAG_ISSUED   0x00000001
#define	SELF_RESIZE   0x00000002
#define	BAND_NEEDS_REDRAW   0x00000020
#define	RBBS_UNDOC_FIXEDHEADER   0x40000000
#define	SEP_WIDTH_SIZE   2
#define	SEP_WIDTH   ((infoPtr->dwStyle & RBS_BANDBORDERS) ? SEP_WIDTH_SIZE : 0)
#define	REBAR_ALWAYS_SPACE   4
#define	REBAR_POST_IMAGE   2
#define	REBAR_POST_TEXT   4
#define	GRIPPER_HEIGHT   16
#define	REBAR_PRE_GRIPPER   2
#define	GRIPPER_WIDTH   3
#define	CHEVRON_WIDTH   10
#define	REBAR_POST_CHILD   4
#define	REBAR_DIVIDER   2
#define	REBAR_NO_CHILD_HEIGHT   4
#define	REBAR_MINSIZE   23
#define	REBARSPACE(a)   ((a->fStyle & RBBS_CHILDEDGE) ? 2*REBAR_DIVIDER : 0)
#define	RB_GETBANDINFO_OLD   (WM_USER+5) /* obsoleted after IE3, but we have to support it anyway */
#define	HIDDENBAND(a)
#define	REBAR_GetInfoPtr(wndPtr)   ((REBAR_INFO *)GetWindowLongPtrW (hwnd, 0))

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (rebar)
static LRESULT	REBAR_NotifyFormat (REBAR_INFO *infoPtr, LPARAM lParam)
static void	REBAR_AutoSize (REBAR_INFO *infoPtr, BOOL needsLayout)
static REBAR_BAND *	REBAR_GetBand (const REBAR_INFO *infoPtr, INT i)
static CHAR *	REBAR_FmtStyle (UINT style)
static CHAR *	REBAR_FmtMask (UINT mask)
static VOID	REBAR_DumpBandInfo (const REBARBANDINFOW *pB)
static VOID	REBAR_DumpBand (const REBAR_INFO *iP)
static void	translate_rect (const REBAR_INFO *infoPtr, RECT *dest, const RECT *src)
static int	get_rect_cx (const REBAR_INFO *infoPtr, const RECT *lpRect)
static int	get_rect_cy (const REBAR_INFO *infoPtr, const RECT *lpRect)
static int	round_child_height (const REBAR_BAND *lpBand, int cyHeight)
static void	update_min_band_height (const REBAR_INFO *infoPtr, REBAR_BAND *lpBand)
static void	REBAR_DrawChevron (HDC hdc, INT left, INT top, INT colorRef)
static HWND	REBAR_GetNotifyParent (const REBAR_INFO *infoPtr)
static INT	REBAR_Notify (NMHDR *nmhdr, const REBAR_INFO *infoPtr, UINT code)
static INT	REBAR_Notify_NMREBAR (const REBAR_INFO *infoPtr, UINT uBand, UINT code)
static VOID	REBAR_DrawBand (HDC hdc, const REBAR_INFO *infoPtr, REBAR_BAND *lpBand)
static VOID	REBAR_Refresh (const REBAR_INFO *infoPtr, HDC hdc)
static void	REBAR_CalcHorzBand (const REBAR_INFO *infoPtr, UINT rstart, UINT rend)
static VOID	REBAR_CalcVertBand (const REBAR_INFO *infoPtr, UINT rstart, UINT rend)
static VOID	REBAR_ForceResize (REBAR_INFO *infoPtr)
static VOID	REBAR_MoveChildWindows (const REBAR_INFO *infoPtr, UINT start, UINT endplus)
static int	next_visible (const REBAR_INFO *infoPtr, int i)
static int	prev_visible (const REBAR_INFO *infoPtr, int i)
static int	first_visible (const REBAR_INFO *infoPtr)
static int	get_row_begin_for_band (const REBAR_INFO *infoPtr, INT iBand)
static int	get_row_end_for_band (const REBAR_INFO *infoPtr, INT iBand)
static void	REBAR_SetRowRectsX (const REBAR_INFO *infoPtr, INT iBeginBand, INT iEndBand)
static REBAR_BAND *	REBAR_FindBandToGrow (const REBAR_INFO *infoPtr, INT iBeginBand, INT iEndBand)
static int	REBAR_ShrinkBandsRTL (const REBAR_INFO *infoPtr, INT iBeginBand, INT iEndBand, INT cxShrink, BOOL bEnforce)
static int	REBAR_ShrinkBandsLTR (const REBAR_INFO *infoPtr, INT iBeginBand, INT iEndBand, INT cxShrink, BOOL bEnforce)
static int	REBAR_MoveBandToRowOffset (REBAR_INFO *infoPtr, INT iBand, INT iFirstBand, INT iLastBand, INT xOff, BOOL reorder)
static int	REBAR_SetBandsHeight (const REBAR_INFO *infoPtr, INT iBeginBand, INT iEndBand, INT yStart)
static void	REBAR_LayoutRow (const REBAR_INFO *infoPtr, int iBeginBand, int iEndBand, int cx, int *piRow, int *pyPos)
static VOID	REBAR_Layout (REBAR_INFO *infoPtr)
static int	REBAR_SizeChildrenToHeight (const REBAR_INFO *infoPtr, int iBeginBand, int iEndBand, int extra, BOOL *fChanged)
static VOID	REBAR_SizeToHeight (REBAR_INFO *infoPtr, int height)
static VOID	REBAR_ValidateBand (const REBAR_INFO *infoPtr, REBAR_BAND *lpBand)
static UINT	REBAR_CommonSetupBand (HWND hwnd, const REBARBANDINFOW *lprbbi, REBAR_BAND *lpBand)
static LRESULT	REBAR_EraseBkGnd (const REBAR_INFO *infoPtr, HDC hdc)
static void	REBAR_InternalHitTest (const REBAR_INFO *infoPtr, const POINT *lpPt, UINT *pFlags, INT *pBand)
static void	REBAR_HandleLRDrag (REBAR_INFO *infoPtr, const POINT *ptsmove)
static void	REBAR_HandleUDDrag (REBAR_INFO *infoPtr, const POINT *ptsmove)
static LRESULT	REBAR_DeleteBand (REBAR_INFO *infoPtr, WPARAM wParam)
static LRESULT	REBAR_GetBandBorders (const REBAR_INFO *infoPtr, UINT uBand, RECT *lpRect)
static LRESULT	REBAR_GetBandCount (const REBAR_INFO *infoPtr)
static LRESULT	REBAR_GetBandInfoT (const REBAR_INFO *infoPtr, UINT uIndex, LPREBARBANDINFOW lprbbi, BOOL bUnicode)
static LRESULT	REBAR_GetBarHeight (const REBAR_INFO *infoPtr)
static LRESULT	REBAR_GetBarInfo (const REBAR_INFO *infoPtr, LPREBARINFO lpInfo)
static LRESULT	REBAR_GetBkColor (const REBAR_INFO *infoPtr)
static LRESULT	REBAR_GetPalette (const REBAR_INFO *infoPtr)
static LRESULT	REBAR_GetRect (const REBAR_INFO *infoPtr, INT iBand, RECT *lprc)
static LRESULT	REBAR_GetRowCount (const REBAR_INFO *infoPtr)
static LRESULT	REBAR_GetRowHeight (const REBAR_INFO *infoPtr, INT iRow)
static LRESULT	REBAR_GetTextColor (const REBAR_INFO *infoPtr)
static LRESULT	REBAR_GetToolTips (const REBAR_INFO *infoPtr)
static LRESULT	REBAR_GetUnicodeFormat (const REBAR_INFO *infoPtr)
static LRESULT	REBAR_GetVersion (const REBAR_INFO *infoPtr)
static LRESULT	REBAR_HitTest (const REBAR_INFO *infoPtr, LPRBHITTESTINFO lprbht)
static LRESULT	REBAR_IdToIndex (const REBAR_INFO *infoPtr, UINT uId)
static LRESULT	REBAR_InsertBandT (REBAR_INFO *infoPtr, INT iIndex, const REBARBANDINFOW *lprbbi, BOOL bUnicode)
static LRESULT	REBAR_MaximizeBand (const REBAR_INFO *infoPtr, INT iBand, LPARAM lParam)
static LRESULT	REBAR_MinimizeBand (const REBAR_INFO *infoPtr, INT iBand)
static LRESULT	REBAR_MoveBand (REBAR_INFO *infoPtr, INT iFrom, INT iTo)
static BOOL	REBAR_strdifW (LPCWSTR a, LPCWSTR b)
static LRESULT	REBAR_SetBandInfoT (REBAR_INFO *infoPtr, INT iBand, const REBARBANDINFOW *lprbbi, BOOL bUnicode)
static LRESULT	REBAR_SetBarInfo (REBAR_INFO *infoPtr, const REBARINFO *lpInfo)
static LRESULT	REBAR_SetBkColor (REBAR_INFO *infoPtr, COLORREF clr)
static LRESULT	REBAR_SetParent (REBAR_INFO *infoPtr, HWND parent)
static LRESULT	REBAR_SetTextColor (REBAR_INFO *infoPtr, COLORREF clr)
static LRESULT	REBAR_SetUnicodeFormat (REBAR_INFO *infoPtr, BOOL unicode)
static LRESULT	REBAR_SetVersion (REBAR_INFO *infoPtr, INT iVersion)
static LRESULT	REBAR_ShowBand (REBAR_INFO *infoPtr, INT iBand, BOOL show)
static LRESULT	REBAR_SizeToRect (REBAR_INFO *infoPtr, const RECT *lpRect)
static LRESULT	REBAR_Create (REBAR_INFO *infoPtr, LPCREATESTRUCTW cs)
static LRESULT	REBAR_Destroy (REBAR_INFO *infoPtr)
static LRESULT	REBAR_GetFont (const REBAR_INFO *infoPtr)
static LRESULT	REBAR_PushChevron (const REBAR_INFO *infoPtr, UINT uBand, LPARAM lParam)
static LRESULT	REBAR_LButtonDown (REBAR_INFO *infoPtr, LPARAM lParam)
static LRESULT	REBAR_LButtonUp (REBAR_INFO *infoPtr)
static LRESULT	REBAR_MouseLeave (REBAR_INFO *infoPtr)
static LRESULT	REBAR_MouseMove (REBAR_INFO *infoPtr, LPARAM lParam)
static LRESULT	REBAR_NCCalcSize (const REBAR_INFO *infoPtr, RECT *rect)
static LRESULT	REBAR_NCCreate (HWND hwnd, const CREATESTRUCTW *cs)
static LRESULT	REBAR_NCHitTest (const REBAR_INFO *infoPtr, LPARAM lParam)
static LRESULT	REBAR_NCPaint (const REBAR_INFO *infoPtr)
static LRESULT	REBAR_Paint (const REBAR_INFO *infoPtr, HDC hdc)
static LRESULT	REBAR_SetCursor (const REBAR_INFO *infoPtr, LPARAM lParam)
static LRESULT	REBAR_SetFont (REBAR_INFO *infoPtr, HFONT font)
static LRESULT	REBAR_SetRedraw (REBAR_INFO *infoPtr, BOOL redraw)
static LRESULT	REBAR_Size (REBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
static LRESULT	REBAR_StyleChanged (REBAR_INFO *infoPtr, INT nType, const STYLESTRUCT *lpStyle)
static LRESULT	theme_changed (REBAR_INFO *infoPtr)
static LRESULT	REBAR_WindowPosChanged (const REBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
static LRESULT WINAPI	REBAR_WindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
VOID	REBAR_Register (void)
VOID	REBAR_Unregister (void)

Variables
static UINT	mindragx = 0
static UINT	mindragy = 0
static const char *const	band_stylename []
static const char *const	band_maskname []
static CHAR	line [200]
static const WCHAR	themeClass [] = { 'R','e','b','a','r',0 }

Macro Definition Documentation

BAND_NEEDS_REDRAW

#define BAND_NEEDS_REDRAW   0x00000020

Definition at line 194 of file rebar.c.

BEGIN_DRAG_ISSUED

#define BEGIN_DRAG_ISSUED   0x00000001

Definition at line 192 of file rebar.c.

CCS_LAYOUT_MASK

#define CCS_LAYOUT_MASK   0x3

Definition at line 140 of file rebar.c.

CHEVRON_WIDTH

#define CHEVRON_WIDTH   10

Definition at line 228 of file rebar.c.

DRAW_CHEVRONHOT

#define DRAW_CHEVRONHOT   0x00000040

Definition at line 151 of file rebar.c.

DRAW_CHEVRONPUSHED

#define DRAW_CHEVRONPUSHED   0x00000080

Definition at line 152 of file rebar.c.

DRAW_GRIPPER

#define DRAW_GRIPPER   0x00000001

Definition at line 148 of file rebar.c.

DRAW_IMAGE

#define DRAW_IMAGE   0x00000002

Definition at line 149 of file rebar.c.

DRAW_TEXT

#define DRAW_TEXT   0x00000004

Definition at line 150 of file rebar.c.

GLATESTING

#define GLATESTING   0

Definition at line 71 of file rebar.c.

GRIPPER_HEIGHT

#define GRIPPER_HEIGHT   16

Definition at line 218 of file rebar.c.

GRIPPER_WIDTH

#define GRIPPER_WIDTH   3

Definition at line 225 of file rebar.c.

HAS_GRIPPER

#define HAS_GRIPPER   0x00000001

Definition at line 143 of file rebar.c.

HAS_IMAGE

#define HAS_IMAGE   0x00000002

Definition at line 144 of file rebar.c.

HAS_TEXT

#define HAS_TEXT   0x00000004

Definition at line 145 of file rebar.c.

HIDDENBAND

#define HIDDENBAND

(

a

)

Value:

(((a)->fStyle & RBBS_HIDDEN) ||   \
                        ((infoPtr->dwStyle & CCS_VERT) &&         \
                         ((a)->fStyle & RBBS_NOVERT)))

Definition at line 252 of file rebar.c.

NTF_INVALIDATE

#define NTF_INVALIDATE   0x01000000

Definition at line 153 of file rebar.c.

RB_GETBANDINFO_OLD

#define RB_GETBANDINFO_OLD   (WM_USER+5) /* obsoleted after IE3, but we have to support it anyway */

Definition at line 249 of file rebar.c.

RBBS_UNDOC_FIXEDHEADER

#define RBBS_UNDOC_FIXEDHEADER   0x40000000

Definition at line 197 of file rebar.c.

REBAR_ALWAYS_SPACE

#define REBAR_ALWAYS_SPACE   4

Definition at line 209 of file rebar.c.

REBAR_DIVIDER

#define REBAR_DIVIDER   2

Definition at line 235 of file rebar.c.

REBAR_GetInfoPtr

#define REBAR_GetInfoPtr

(

wndPtr

)

((REBAR_INFO *)GetWindowLongPtrW (hwnd, 0))

Definition at line 256 of file rebar.c.

REBAR_MINSIZE

#define REBAR_MINSIZE   23

Definition at line 242 of file rebar.c.

REBAR_NO_CHILD_HEIGHT

#define REBAR_NO_CHILD_HEIGHT   4

Definition at line 238 of file rebar.c.

REBAR_POST_CHILD

#define REBAR_POST_CHILD   4

Definition at line 231 of file rebar.c.

REBAR_POST_IMAGE

#define REBAR_POST_IMAGE   2

Definition at line 212 of file rebar.c.

REBAR_POST_TEXT

#define REBAR_POST_TEXT   4

Definition at line 215 of file rebar.c.

REBAR_PRE_GRIPPER

#define REBAR_PRE_GRIPPER   2

Definition at line 221 of file rebar.c.

REBARSPACE

#define REBARSPACE

(

a

)

((a->fStyle & RBBS_CHILDEDGE) ? 2*REBAR_DIVIDER : 0)

Definition at line 245 of file rebar.c.

SELF_RESIZE

#define SELF_RESIZE   0x00000002

Definition at line 193 of file rebar.c.

SEP_WIDTH

#define SEP_WIDTH   ((infoPtr->dwStyle & RBS_BANDBORDERS) ? SEP_WIDTH_SIZE : 0)

Definition at line 205 of file rebar.c.

SEP_WIDTH_SIZE

#define SEP_WIDTH_SIZE   2

Definition at line 204 of file rebar.c.

Function Documentation

first_visible()

static int first_visible ( const REBAR_INFO *  infoPtr )

static

Definition at line 1133 of file rebar.c.

{
    return next_visible(infoPtr, -1); /* this works*/
}

Referenced by REBAR_HandleUDDrag(), REBAR_Layout(), and REBAR_SizeToHeight().

get_rect_cx()

static int get_rect_cx ( const REBAR_INFO *  infoPtr, const RECT *  lpRect  )

static

Definition at line 450 of file rebar.c.

{
    if (infoPtr->dwStyle & CCS_VERT)
        return lpRect->bottom - lpRect->top;
    return lpRect->right - lpRect->left;
}

Referenced by REBAR_Layout().

get_rect_cy()

static int get_rect_cy ( const REBAR_INFO *  infoPtr, const RECT *  lpRect  )

static

Definition at line 457 of file rebar.c.

{
    if (infoPtr->dwStyle & CCS_VERT)
        return lpRect->right - lpRect->left;
    return lpRect->bottom - lpRect->top;
}

Referenced by REBAR_AutoSize(), and REBAR_SizeToRect().

get_row_begin_for_band()

static int get_row_begin_for_band ( const REBAR_INFO *  infoPtr, INT  iBand  )

static

Definition at line 1139 of file rebar.c.

{
    int iLastBand = iBand;
    int iRow = REBAR_GetBand(infoPtr, iBand)->iRow;
    while ((iBand = prev_visible(infoPtr, iBand)) >= 0) {
        if (REBAR_GetBand(infoPtr, iBand)->iRow != iRow)
            break;
        else
            iLastBand = iBand;
    }
    return iLastBand;
}

Referenced by REBAR_HandleLRDrag(), REBAR_MaximizeBand(), and REBAR_MinimizeBand().

get_row_end_for_band()

static int get_row_end_for_band ( const REBAR_INFO *  infoPtr, INT  iBand  )

static

Definition at line 1153 of file rebar.c.

{
    int iRow = REBAR_GetBand(infoPtr, iBand)->iRow;
    while ((iBand = next_visible(infoPtr, iBand)) < infoPtr->uNumBands)
        if (REBAR_GetBand(infoPtr, iBand)->iRow != iRow)
            break;
    return iBand;
}

Referenced by REBAR_HandleLRDrag(), REBAR_HandleUDDrag(), REBAR_MaximizeBand(), and REBAR_MinimizeBand().

next_visible()

static int next_visible ( const REBAR_INFO *  infoPtr, int  i  )

static

Definition at line 1112 of file rebar.c.

{
    unsigned int n;
    for (n = i + 1; n < infoPtr->uNumBands; n++)
        if (!HIDDENBAND(REBAR_GetBand(infoPtr, n)))
            break;
    return n;
}

Referenced by first_visible(), get_row_end_for_band(), REBAR_Layout(), REBAR_LayoutRow(), REBAR_MaximizeBand(), REBAR_MinimizeBand(), REBAR_MoveBandToRowOffset(), REBAR_SetBandsHeight(), REBAR_SetRowRectsX(), REBAR_ShrinkBandsLTR(), REBAR_SizeChildrenToHeight(), and REBAR_SizeToHeight().

prev_visible()

static int prev_visible ( const REBAR_INFO *  infoPtr, int  i  )

static

Definition at line 1123 of file rebar.c.

{
    int n;
    for (n = i - 1; n >= 0; n--)
        if (!HIDDENBAND(REBAR_GetBand(infoPtr, n)))
            break;
    return n;
}

Referenced by get_row_begin_for_band(), REBAR_FindBandToGrow(), REBAR_HandleLRDrag(), REBAR_MinimizeBand(), REBAR_ShrinkBandsRTL(), and REBAR_SizeToHeight().

REBAR_AutoSize()

static VOID REBAR_AutoSize ( REBAR_INFO *  infoPtr, BOOL  needsLayout  )

static

Definition at line 1574 of file rebar.c.

{
    RECT rc, rcNew;
    NMRBAUTOSIZE autosize;

    if (needsLayout)
        REBAR_Layout(infoPtr);
    GetClientRect(infoPtr->hwndSelf, &rc);
    REBAR_SizeToHeight(infoPtr, get_rect_cy(infoPtr, &rc));
    GetClientRect(infoPtr->hwndSelf, &rcNew);

    GetClientRect(infoPtr->hwndSelf, &autosize.rcTarget);
    autosize.fChanged = EqualRect(&rc, &rcNew);
    autosize.rcTarget = rc;
    autosize.rcActual = rcNew;
    REBAR_Notify((NMHDR *)&autosize, infoPtr, RBN_AUTOSIZE);
}

Referenced by REBAR_Layout(), and REBAR_Size().

REBAR_CalcHorzBand()

static void REBAR_CalcHorzBand ( const REBAR_INFO *  infoPtr, UINT  rstart, UINT  rend  )

static

Definition at line 718 of file rebar.c.

{
    REBAR_BAND *lpBand;
    UINT i, xoff;
    RECT work;

    for(i=rstart; i<rend; i++){
      lpBand = REBAR_GetBand(infoPtr, i);
      if (HIDDENBAND(lpBand)) {
          SetRect (&lpBand->rcChild,
           lpBand->rcBand.right, lpBand->rcBand.top,
           lpBand->rcBand.right, lpBand->rcBand.bottom);
      continue;
      }

      /* set initial gripper rectangle */
      SetRect (&lpBand->rcGripper, lpBand->rcBand.left, lpBand->rcBand.top,
           lpBand->rcBand.left, lpBand->rcBand.bottom);

      /* calculate gripper rectangle */
      if ( lpBand->fStatus & HAS_GRIPPER) {
      lpBand->fDraw |= DRAW_GRIPPER;
      lpBand->rcGripper.left   += REBAR_PRE_GRIPPER;
      lpBand->rcGripper.right  = lpBand->rcGripper.left + GRIPPER_WIDTH;
          InflateRect(&lpBand->rcGripper, 0, -2);

      SetRect (&lpBand->rcCapImage,
           lpBand->rcGripper.right+REBAR_ALWAYS_SPACE, lpBand->rcBand.top,
           lpBand->rcGripper.right+REBAR_ALWAYS_SPACE, lpBand->rcBand.bottom);
      }
      else {  /* no gripper will be drawn */
      xoff = 0;
      if (lpBand->fStatus & (HAS_IMAGE | HAS_TEXT))
          /* if no gripper but either image or text, then leave space */
          xoff = REBAR_ALWAYS_SPACE;
      SetRect (&lpBand->rcCapImage,
           lpBand->rcBand.left+xoff, lpBand->rcBand.top,
           lpBand->rcBand.left+xoff, lpBand->rcBand.bottom);
      }

      /* image is visible */
      if (lpBand->fStatus & HAS_IMAGE) {
      lpBand->fDraw |= DRAW_IMAGE;
      lpBand->rcCapImage.right  += infoPtr->imageSize.cx;
      lpBand->rcCapImage.bottom = lpBand->rcCapImage.top + infoPtr->imageSize.cy;

      /* set initial caption text rectangle */
      SetRect (&lpBand->rcCapText,
           lpBand->rcCapImage.right+REBAR_POST_IMAGE, lpBand->rcBand.top+1,
           lpBand->rcBand.left+lpBand->cxHeader, lpBand->rcBand.bottom-1);
      }
      else {
      /* set initial caption text rectangle */
      SetRect (&lpBand->rcCapText, lpBand->rcCapImage.right, lpBand->rcBand.top+1,
           lpBand->rcBand.left+lpBand->cxHeader, lpBand->rcBand.bottom-1);
      }

      /* text is visible */
      if ((lpBand->fStatus & HAS_TEXT) && !(lpBand->fStyle & RBBS_HIDETITLE)) {
      lpBand->fDraw |= DRAW_TEXT;
      lpBand->rcCapText.right = max(lpBand->rcCapText.left,
                    lpBand->rcCapText.right-REBAR_POST_TEXT);
      }

      /* set initial child window rectangle if there is a child */
      if (lpBand->hwndChild) {

          lpBand->rcChild.left  = lpBand->rcBand.left + lpBand->cxHeader;
          lpBand->rcChild.right = lpBand->rcBand.right - REBAR_POST_CHILD;

          if (lpBand->cyChild > 0) {

              UINT yoff = (lpBand->rcBand.bottom - lpBand->rcBand.top - lpBand->cyChild) / 2;

              /* center child if height is known */
              lpBand->rcChild.top = lpBand->rcBand.top + yoff;
              lpBand->rcChild.bottom = lpBand->rcBand.top + yoff + lpBand->cyChild;
          }
          else {
              lpBand->rcChild.top = lpBand->rcBand.top;
              lpBand->rcChild.bottom = lpBand->rcBand.bottom;
          }

      if ((lpBand->fStyle & RBBS_USECHEVRON) && (lpBand->rcChild.right - lpBand->rcChild.left < lpBand->cxIdeal))
      {
          lpBand->rcChild.right -= CHEVRON_WIDTH;
          SetRect(&lpBand->rcChevron, lpBand->rcChild.right,
                  lpBand->rcChild.top, lpBand->rcChild.right + CHEVRON_WIDTH,
                  lpBand->rcChild.bottom);
      }
      }
      else {
          SetRect (&lpBand->rcChild,
           lpBand->rcBand.left+lpBand->cxHeader, lpBand->rcBand.top,
           lpBand->rcBand.right, lpBand->rcBand.bottom);
      }

      /* flag if notify required and invalidate rectangle */
      if (lpBand->fDraw & NTF_INVALIDATE) {
      lpBand->fDraw &= ~NTF_INVALIDATE;
      work = lpBand->rcBand;
      work.right += SEP_WIDTH;
      work.bottom += SEP_WIDTH;
      TRACE("invalidating %s\n", wine_dbgstr_rect(&work));
      InvalidateRect(infoPtr->hwndSelf, &work, TRUE);
      if (lpBand->hwndChild) InvalidateRect(lpBand->hwndChild, NULL, TRUE);
      }

    }

}

Referenced by REBAR_HandleLRDrag(), REBAR_Layout(), REBAR_MaximizeBand(), and REBAR_MinimizeBand().

REBAR_CalcVertBand()

static VOID REBAR_CalcVertBand ( const REBAR_INFO *  infoPtr, UINT  rstart, UINT  rend  )

static

Definition at line 835 of file rebar.c.

{
    REBAR_BAND *lpBand;
    UINT i, xoff;
    RECT work;

    for(i=rstart; i<rend; i++){
        RECT rcBand;
        lpBand = REBAR_GetBand(infoPtr, i);
    if (HIDDENBAND(lpBand)) continue;

        translate_rect(infoPtr, &rcBand, &lpBand->rcBand);

        /* set initial gripper rectangle */
    SetRect (&lpBand->rcGripper, rcBand.left, rcBand.top, rcBand.right, rcBand.top);

    /* calculate gripper rectangle */
    if (lpBand->fStatus & HAS_GRIPPER) {
        lpBand->fDraw |= DRAW_GRIPPER;

        if (infoPtr->dwStyle & RBS_VERTICALGRIPPER) {
        /*  vertical gripper  */
        lpBand->rcGripper.left   += 3;
        lpBand->rcGripper.right  = lpBand->rcGripper.left + GRIPPER_WIDTH;
        lpBand->rcGripper.top    += REBAR_PRE_GRIPPER;
        lpBand->rcGripper.bottom = lpBand->rcGripper.top + GRIPPER_HEIGHT;

        /* initialize Caption image rectangle  */
        SetRect (&lpBand->rcCapImage, rcBand.left,
             lpBand->rcGripper.bottom + REBAR_ALWAYS_SPACE,
             rcBand.right,
             lpBand->rcGripper.bottom + REBAR_ALWAYS_SPACE);
        }
        else {
        /*  horizontal gripper  */
                InflateRect(&lpBand->rcGripper, -2, 0);
        lpBand->rcGripper.top    += REBAR_PRE_GRIPPER;
        lpBand->rcGripper.bottom  = lpBand->rcGripper.top + GRIPPER_WIDTH;

        /* initialize Caption image rectangle  */
        SetRect (&lpBand->rcCapImage, rcBand.left,
             lpBand->rcGripper.bottom + REBAR_ALWAYS_SPACE,
             rcBand.right,
             lpBand->rcGripper.bottom + REBAR_ALWAYS_SPACE);
        }
    }
    else {  /* no gripper will be drawn */
        xoff = 0;
        if (lpBand->fStatus & (HAS_IMAGE | HAS_TEXT))
        /* if no gripper but either image or text, then leave space */
        xoff = REBAR_ALWAYS_SPACE;
        /* initialize Caption image rectangle  */
        SetRect (&lpBand->rcCapImage,
                      rcBand.left, rcBand.top+xoff,
                      rcBand.right, rcBand.top+xoff);
    }

    /* image is visible */
    if (lpBand->fStatus & HAS_IMAGE) {
        lpBand->fDraw |= DRAW_IMAGE;

        lpBand->rcCapImage.right  = lpBand->rcCapImage.left + infoPtr->imageSize.cx;
        lpBand->rcCapImage.bottom += infoPtr->imageSize.cy;

        /* set initial caption text rectangle */
        SetRect (&lpBand->rcCapText,
             rcBand.left, lpBand->rcCapImage.bottom+REBAR_POST_IMAGE,
             rcBand.right, rcBand.top+lpBand->cxHeader);
    }
    else {
        /* set initial caption text rectangle */
        SetRect (&lpBand->rcCapText,
             rcBand.left, lpBand->rcCapImage.bottom,
             rcBand.right, rcBand.top+lpBand->cxHeader);
    }

    /* text is visible */
    if ((lpBand->fStatus & HAS_TEXT) && !(lpBand->fStyle & RBBS_HIDETITLE)) {
        lpBand->fDraw |= DRAW_TEXT;
        lpBand->rcCapText.bottom = max(lpBand->rcCapText.top,
                       lpBand->rcCapText.bottom);
    }

    /* set initial child window rectangle if there is a child */
    if (lpBand->hwndChild) {
            int cxBand = rcBand.right - rcBand.left;
            xoff = (cxBand - lpBand->cyChild) / 2;
        SetRect (&lpBand->rcChild,
             rcBand.left + xoff,                   rcBand.top + lpBand->cxHeader,
                     rcBand.left + xoff + lpBand->cyChild, rcBand.bottom - REBAR_POST_CHILD);
    }
    else {
        SetRect (&lpBand->rcChild,
             rcBand.left, rcBand.top+lpBand->cxHeader,
             rcBand.right, rcBand.bottom);
    }

    if (lpBand->fDraw & NTF_INVALIDATE) {
        lpBand->fDraw &= ~NTF_INVALIDATE;
        work = rcBand;
        work.bottom += SEP_WIDTH;
        work.right += SEP_WIDTH;
        TRACE("invalidating %s\n", wine_dbgstr_rect(&work));
        InvalidateRect(infoPtr->hwndSelf, &work, TRUE);
        if (lpBand->hwndChild) InvalidateRect(lpBand->hwndChild, NULL, TRUE);
    }

    }
}

Referenced by REBAR_HandleLRDrag(), REBAR_Layout(), REBAR_MaximizeBand(), and REBAR_MinimizeBand().

REBAR_CommonSetupBand()

static UINT REBAR_CommonSetupBand ( HWND  hwnd, const REBARBANDINFOW *  lprbbi, REBAR_BAND *  lpBand  )

static

Definition at line 1707 of file rebar.c.

{
    UINT uChanged = 0x0;

    lpBand->fMask |= lprbbi->fMask;

    if( (lprbbi->fMask & RBBIM_STYLE) &&
        (lpBand->fStyle != lprbbi->fStyle ) )
    {
    lpBand->fStyle = lprbbi->fStyle;
        uChanged |= RBBIM_STYLE;
    }

    if( (lprbbi->fMask & RBBIM_COLORS) &&
       ( ( lpBand->clrFore != lprbbi->clrFore ) ||
         ( lpBand->clrBack != lprbbi->clrBack ) ) )
    {
    lpBand->clrFore = lprbbi->clrFore;
    lpBand->clrBack = lprbbi->clrBack;
        uChanged |= RBBIM_COLORS;
    }

    if( (lprbbi->fMask & RBBIM_IMAGE) &&
       ( lpBand->iImage != lprbbi->iImage ) )
    {
    lpBand->iImage = lprbbi->iImage;
        uChanged |= RBBIM_IMAGE;
    }

    if( (lprbbi->fMask & RBBIM_CHILD) &&
       (lprbbi->hwndChild != lpBand->hwndChild ) )
    {
    if (lprbbi->hwndChild) {
        lpBand->hwndChild = lprbbi->hwndChild;
        lpBand->hwndPrevParent =
        SetParent (lpBand->hwndChild, hwnd);
        /* below in trace from WinRAR */
        ShowWindow(lpBand->hwndChild, SW_SHOWNOACTIVATE | SW_SHOWNORMAL);
        /* above in trace from WinRAR */
    }
    else {
        TRACE("child: %p  prev parent: %p\n",
           lpBand->hwndChild, lpBand->hwndPrevParent);
        lpBand->hwndChild = 0;
        lpBand->hwndPrevParent = 0;
    }
        uChanged |= RBBIM_CHILD;
    }

    if( (lprbbi->fMask & RBBIM_CHILDSIZE) &&
        ( (lpBand->cxMinChild != lprbbi->cxMinChild) ||
          (lpBand->cyMinChild != lprbbi->cyMinChild ) ||
          ( (lprbbi->cbSize >= REBARBANDINFOA_V6_SIZE && (lpBand->fStyle & RBBS_VARIABLEHEIGHT)) &&
            ( (lpBand->cyChild    != lprbbi->cyChild ) ||
              (lpBand->cyMaxChild != lprbbi->cyMaxChild ) ||
              (lpBand->cyIntegral != lprbbi->cyIntegral ) ) ) ||
          ( (lprbbi->cbSize < REBARBANDINFOA_V6_SIZE) &&
            ( (lpBand->cyChild || 
               lpBand->cyMaxChild || 
               lpBand->cyIntegral ) ) ) ) )
    {
    lpBand->cxMinChild = lprbbi->cxMinChild;
    lpBand->cyMinChild = lprbbi->cyMinChild;
        /* These fields where added in WIN32_IE == 0x400 and are set only for RBBS_VARIABLEHEIGHT bands */
        if (lprbbi->cbSize >= REBARBANDINFOA_V6_SIZE && (lpBand->fStyle & RBBS_VARIABLEHEIGHT)) {
        lpBand->cyMaxChild = lprbbi->cyMaxChild;
            lpBand->cyIntegral = lprbbi->cyIntegral;

            lpBand->cyChild = round_child_height(lpBand, lprbbi->cyChild);  /* make (cyChild - cyMinChild) a multiple of cyIntergral */
        }
    else {
        lpBand->cyChild    = lpBand->cyMinChild;
        lpBand->cyMaxChild = 0x7fffffff;
        lpBand->cyIntegral = 0;
    }
        uChanged |= RBBIM_CHILDSIZE;
    }

    if( (lprbbi->fMask & RBBIM_SIZE) &&
        (lpBand->cx != lprbbi->cx ) )
    {
    lpBand->cx = lprbbi->cx;
        uChanged |= RBBIM_SIZE;
    }

    if( (lprbbi->fMask & RBBIM_BACKGROUND) &&
       ( lpBand->hbmBack != lprbbi->hbmBack ) )
    {
    lpBand->hbmBack = lprbbi->hbmBack;
        uChanged |= RBBIM_BACKGROUND;
    }

    if( (lprbbi->fMask & RBBIM_ID) &&
        (lpBand->wID != lprbbi->wID ) )
    {
    lpBand->wID = lprbbi->wID;
        uChanged |= RBBIM_ID;
    }

    /* check for additional data */
    if (lprbbi->cbSize >= REBARBANDINFOA_V6_SIZE) {
    if( (lprbbi->fMask & RBBIM_IDEALSIZE) &&
            ( lpBand->cxIdeal != lprbbi->cxIdeal ) )
        {
        lpBand->cxIdeal = lprbbi->cxIdeal;
            uChanged |= RBBIM_IDEALSIZE;
        }

    if( (lprbbi->fMask & RBBIM_LPARAM) &&
            (lpBand->lParam != lprbbi->lParam ) )
        {
        lpBand->lParam = lprbbi->lParam;
            uChanged |= RBBIM_LPARAM;
        }

    if( (lprbbi->fMask & RBBIM_HEADERSIZE) &&
            (lpBand->cxHeader != lprbbi->cxHeader ) )
        {
        lpBand->cxHeader = lprbbi->cxHeader;
            lpBand->fStyle |= RBBS_UNDOC_FIXEDHEADER;
            uChanged |= RBBIM_HEADERSIZE;
        }
    }

    return uChanged;
}

Referenced by REBAR_InsertBandT(), and REBAR_SetBandInfoT().

REBAR_Create()

static LRESULT REBAR_Create ( REBAR_INFO *  infoPtr, LPCREATESTRUCTW  cs  )

static

Definition at line 2954 of file rebar.c.

{
    RECT wnrc1, clrc1;

    if (TRACE_ON(rebar)) {
    GetWindowRect(infoPtr->hwndSelf, &wnrc1);
    GetClientRect(infoPtr->hwndSelf, &clrc1);
        TRACE("window=(%s) client=(%s) cs=(%d,%d %dx%d)\n",
              wine_dbgstr_rect(&wnrc1), wine_dbgstr_rect(&clrc1),
          cs->x, cs->y, cs->cx, cs->cy);
    }

    TRACE("created!\n");

    if (OpenThemeData (infoPtr->hwndSelf, themeClass))
    {
        /* native seems to clear WS_BORDER when themed */
        infoPtr->dwStyle &= ~WS_BORDER;
    }

    return 0;
}

Referenced by REBAR_WindowProc().

REBAR_DeleteBand()

static LRESULT REBAR_DeleteBand ( REBAR_INFO *  infoPtr, WPARAM  wParam  )

static

Definition at line 2184 of file rebar.c.

{
    UINT uBand = (UINT)wParam;
    REBAR_BAND *lpBand;

    if (uBand >= infoPtr->uNumBands)
    return FALSE;

    TRACE("deleting band %u!\n", uBand);
    lpBand = REBAR_GetBand(infoPtr, uBand);
    REBAR_Notify_NMREBAR (infoPtr, uBand, RBN_DELETINGBAND);
    /* TODO: a return of 1 should probably cancel the deletion */

    if (lpBand->hwndChild)
        ShowWindow(lpBand->hwndChild, SW_HIDE);
    Free(lpBand->lpText);
    Free(lpBand);

    infoPtr->uNumBands--;
    DPA_DeletePtr(infoPtr->bands, uBand);

    REBAR_Notify_NMREBAR (infoPtr, -1, RBN_DELETEDBAND);

    /* if only 1 band left the re-validate to possible eliminate gripper */
    if (infoPtr->uNumBands == 1)
      REBAR_ValidateBand (infoPtr, REBAR_GetBand(infoPtr, 0));

    REBAR_Layout(infoPtr);

    return TRUE;
}

Referenced by REBAR_WindowProc().

REBAR_Destroy()

static LRESULT REBAR_Destroy ( REBAR_INFO *  infoPtr )

static

Definition at line 2979 of file rebar.c.

{
    REBAR_BAND *lpBand;
    UINT i;

    /* clean up each band */
    for (i = 0; i < infoPtr->uNumBands; i++) {
    lpBand = REBAR_GetBand(infoPtr, i);

    /* delete text strings */
        Free (lpBand->lpText);
    lpBand->lpText = NULL;
    /* destroy child window */
    DestroyWindow (lpBand->hwndChild);
    Free (lpBand);
    }

    /* free band array */
    DPA_Destroy (infoPtr->bands);
    infoPtr->bands = NULL;

    DestroyCursor (infoPtr->hcurArrow);
    DestroyCursor (infoPtr->hcurHorz);
    DestroyCursor (infoPtr->hcurVert);
    DestroyCursor (infoPtr->hcurDrag);
    if (infoPtr->hDefaultFont) DeleteObject (infoPtr->hDefaultFont);
    SetWindowLongPtrW (infoPtr->hwndSelf, 0, 0);
    
    CloseThemeData (GetWindowTheme (infoPtr->hwndSelf));

    /* free rebar info data */
    Free (infoPtr);
    TRACE("destroyed!\n");
    return 0;
}

Referenced by REBAR_WindowProc().

REBAR_DrawBand()

static VOID REBAR_DrawBand ( HDC  hdc, const REBAR_INFO *  infoPtr, REBAR_BAND *  lpBand  )

static

Definition at line 558 of file rebar.c.

{
    HFONT hOldFont = 0;
    INT oldBkMode = 0;
    NMCUSTOMDRAW nmcd;
    HTHEME theme = GetWindowTheme (infoPtr->hwndSelf);
    RECT rcBand;

    translate_rect(infoPtr, &rcBand, &lpBand->rcBand);

    if (lpBand->fDraw & DRAW_TEXT) {
    hOldFont = SelectObject (hdc, infoPtr->hFont);
    oldBkMode = SetBkMode (hdc, TRANSPARENT);
    }

    /* should test for CDRF_NOTIFYITEMDRAW here */
    nmcd.dwDrawStage = CDDS_ITEMPREPAINT;
    nmcd.hdc = hdc;
    nmcd.rc = rcBand;
    nmcd.rc.right = lpBand->rcCapText.right;
    nmcd.rc.bottom = lpBand->rcCapText.bottom;
    nmcd.dwItemSpec = lpBand->wID;
    nmcd.uItemState = 0;
    nmcd.lItemlParam = lpBand->lParam;
    lpBand->uCDret = REBAR_Notify ((NMHDR *)&nmcd, infoPtr, NM_CUSTOMDRAW);
    if (lpBand->uCDret == CDRF_SKIPDEFAULT) {
    if (oldBkMode != TRANSPARENT)
        SetBkMode (hdc, oldBkMode);
    SelectObject (hdc, hOldFont);
    return;
    }

    /* draw gripper */
    if (lpBand->fDraw & DRAW_GRIPPER)
    {
        if (theme)
        {
            RECT rcGripper = lpBand->rcGripper;
            int partId = (infoPtr->dwStyle & CCS_VERT) ? RP_GRIPPERVERT : RP_GRIPPER;
            GetThemeBackgroundExtent (theme, hdc, partId, 0, &rcGripper, &rcGripper);
            OffsetRect (&rcGripper, lpBand->rcGripper.left - rcGripper.left,
                lpBand->rcGripper.top - rcGripper.top);
            DrawThemeBackground (theme, hdc, partId, 0, &rcGripper, NULL);
        }
        else
            DrawEdge (hdc, &lpBand->rcGripper, BDR_RAISEDINNER, BF_RECT | BF_MIDDLE);
    }

    /* draw caption image */
    if (lpBand->fDraw & DRAW_IMAGE) {
    POINT pt;

    /* center image */
    pt.y = (lpBand->rcCapImage.bottom + lpBand->rcCapImage.top - infoPtr->imageSize.cy)/2;
    pt.x = (lpBand->rcCapImage.right + lpBand->rcCapImage.left - infoPtr->imageSize.cx)/2;

    ImageList_Draw (infoPtr->himl, lpBand->iImage, hdc,
            pt.x, pt.y,
            ILD_TRANSPARENT);
    }

    /* draw caption text */
    if (lpBand->fDraw & DRAW_TEXT) {
    /* need to handle CDRF_NEWFONT here */
    INT oldBkMode = SetBkMode (hdc, TRANSPARENT);
    COLORREF oldcolor = CLR_NONE;
    COLORREF new;
    if (lpBand->clrFore != CLR_NONE) {
        new = (lpBand->clrFore == CLR_DEFAULT) ? infoPtr->clrBtnText :
            lpBand->clrFore;
        oldcolor = SetTextColor (hdc, new);
    }

#ifdef __REACTOS__
    if (!theme)
    {
        DrawTextW (hdc, lpBand->lpText, -1, &lpBand->rcCapText, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
    }
    else
    {
        DrawThemeText(theme, hdc, 0, 0, lpBand->lpText, -1, DT_CENTER | DT_VCENTER | DT_SINGLELINE, 0, &lpBand->rcCapText);
    }
#else
    DrawTextW (hdc, lpBand->lpText, -1, &lpBand->rcCapText,
           DT_CENTER | DT_VCENTER | DT_SINGLELINE);
#endif

    if (oldBkMode != TRANSPARENT)
        SetBkMode (hdc, oldBkMode);
    if (lpBand->clrFore != CLR_NONE)
        SetTextColor (hdc, oldcolor);
    SelectObject (hdc, hOldFont);
    }

    if (!IsRectEmpty(&lpBand->rcChevron))
    {
        if (theme)
        {
            int stateId; 
            if (lpBand->fDraw & DRAW_CHEVRONPUSHED)
                stateId = CHEVS_PRESSED;
            else if (lpBand->fDraw & DRAW_CHEVRONHOT)
                stateId = CHEVS_HOT;
            else
                stateId = CHEVS_NORMAL;
            DrawThemeBackground (theme, hdc, RP_CHEVRON, stateId, &lpBand->rcChevron, NULL);
        }
        else
        {
            if (lpBand->fDraw & DRAW_CHEVRONPUSHED)
            {
                DrawEdge(hdc, &lpBand->rcChevron, BDR_SUNKENOUTER, BF_RECT | BF_MIDDLE);
                REBAR_DrawChevron(hdc, lpBand->rcChevron.left+1, lpBand->rcChevron.top + 11, COLOR_WINDOWFRAME);
            }
            else if (lpBand->fDraw & DRAW_CHEVRONHOT)
            {
                DrawEdge(hdc, &lpBand->rcChevron, BDR_RAISEDINNER, BF_RECT | BF_MIDDLE);
                REBAR_DrawChevron(hdc, lpBand->rcChevron.left, lpBand->rcChevron.top + 10, COLOR_WINDOWFRAME);
            }
            else
                REBAR_DrawChevron(hdc, lpBand->rcChevron.left, lpBand->rcChevron.top + 10, COLOR_WINDOWFRAME);
        }
    }

    if (lpBand->uCDret == (CDRF_NOTIFYPOSTPAINT | CDRF_NOTIFYITEMDRAW)) {
    nmcd.dwDrawStage = CDDS_ITEMPOSTPAINT;
    nmcd.hdc = hdc;
    nmcd.rc = rcBand;
    nmcd.rc.right = lpBand->rcCapText.right;
    nmcd.rc.bottom = lpBand->rcCapText.bottom;
    nmcd.dwItemSpec = lpBand->wID;
    nmcd.uItemState = 0;
    nmcd.lItemlParam = lpBand->lParam;
    lpBand->uCDret = REBAR_Notify ((NMHDR *)&nmcd, infoPtr, NM_CUSTOMDRAW);
    }
}

Referenced by REBAR_Refresh().

REBAR_DrawChevron()

static void REBAR_DrawChevron ( HDC  hdc, INT  left, INT  top, INT  colorRef  )

static

Definition at line 482 of file rebar.c.

{
    INT x, y;
    HPEN hPen, hOldPen;

    if (!(hPen = CreatePen( PS_SOLID, 1, GetSysColor( colorRef )))) return;
    hOldPen = SelectObject ( hdc, hPen );
    x = left + 2;
    y = top;
    MoveToEx (hdc, x, y, NULL);
    LineTo (hdc, x+5, y++); x++;
    MoveToEx (hdc, x, y, NULL);
    LineTo (hdc, x+3, y++); x++;
    MoveToEx (hdc, x, y, NULL);
    LineTo (hdc, x+1, y);
    SelectObject( hdc, hOldPen );
    DeleteObject( hPen );
}

Referenced by REBAR_DrawBand().

REBAR_DumpBand()

static VOID REBAR_DumpBand ( const REBAR_INFO *  iP )

static

Definition at line 373 of file rebar.c.

{
    REBAR_BAND *pB;
    UINT i;

    if(! TRACE_ON(rebar) ) return;

    TRACE("hwnd=%p: color=%08x/%08x, bands=%u, rows=%u, cSize=%d,%d\n",
      iP->hwndSelf, iP->clrText, iP->clrBk, iP->uNumBands, iP->uNumRows,
      iP->calcSize.cx, iP->calcSize.cy);
    TRACE("hwnd=%p: flags=%08x, dragStart=%d,%d, dragNow=%d,%d, iGrabbedBand=%d\n",
      iP->hwndSelf, iP->fStatus, iP->dragStart.x, iP->dragStart.y,
      iP->dragNow.x, iP->dragNow.y,
      iP->iGrabbedBand);
    TRACE("hwnd=%p: style=%08x, notify in Unicode=%s, redraw=%s\n",
          iP->hwndSelf, iP->dwStyle, (iP->bUnicode)?"TRUE":"FALSE",
          (iP->DoRedraw)?"TRUE":"FALSE");
    for (i = 0; i < iP->uNumBands; i++) {
    pB = REBAR_GetBand(iP, i);
    TRACE("band # %u:", i);
    if (pB->fMask & RBBIM_ID)
        TRACE(" ID=%u", pB->wID);
    if (pB->fMask & RBBIM_CHILD)
        TRACE(" child=%p", pB->hwndChild);
    if (pB->fMask & RBBIM_COLORS)
            TRACE(" clrF=0x%06x clrB=0x%06x", pB->clrFore, pB->clrBack);
    TRACE("\n");
    TRACE("band # %u: mask=0x%08x (%s)\n", i, pB->fMask, REBAR_FmtMask(pB->fMask));
    if (pB->fMask & RBBIM_STYLE)
        TRACE("band # %u: style=0x%08x (%s)\n",
          i, pB->fStyle, REBAR_FmtStyle(pB->fStyle));
    TRACE("band # %u: xHeader=%u",
          i, pB->cxHeader);
    if (pB->fMask & (RBBIM_SIZE | RBBIM_IDEALSIZE | RBBIM_LPARAM )) {
        if (pB->fMask & RBBIM_SIZE)
        TRACE(" cx=%u", pB->cx);
        if (pB->fMask & RBBIM_IDEALSIZE)
        TRACE(" xIdeal=%u", pB->cxIdeal);
        if (pB->fMask & RBBIM_LPARAM)
        TRACE(" lParam=0x%08lx", pB->lParam);
    }
    TRACE("\n");
    if (RBBIM_CHILDSIZE)
        TRACE("band # %u: xMin=%u, yMin=%u, yChild=%u, yMax=%u, yIntgl=%u\n",
          i, pB->cxMinChild, pB->cyMinChild, pB->cyChild, pB->cyMaxChild, pB->cyIntegral);
    if (pB->fMask & RBBIM_TEXT)
        TRACE("band # %u: text=%s\n",
          i, (pB->lpText) ? debugstr_w(pB->lpText) : "(null)");
        TRACE("band # %u: cxMinBand=%u, cxEffective=%u, cyMinBand=%u\n",
              i, pB->cxMinBand, pB->cxEffective, pB->cyMinBand);
        TRACE("band # %u: fStatus=%08x, fDraw=%08x, Band=(%s), Grip=(%s)\n",
              i, pB->fStatus, pB->fDraw, wine_dbgstr_rect(&pB->rcBand),
              wine_dbgstr_rect(&pB->rcGripper));
        TRACE("band # %u: Img=(%s), Txt=(%s), Child=(%s)\n",
              i, wine_dbgstr_rect(&pB->rcCapImage),
              wine_dbgstr_rect(&pB->rcCapText), wine_dbgstr_rect(&pB->rcChild));
    }

}

Referenced by REBAR_InsertBandT(), REBAR_Layout(), REBAR_MoveBand(), and REBAR_SetBandInfoT().

REBAR_DumpBandInfo()

static VOID REBAR_DumpBandInfo ( const REBARBANDINFOW *  pB )

static

Definition at line 340 of file rebar.c.

{
    if( !TRACE_ON(rebar) ) return;
    TRACE("band info: ");
    if (pB->fMask & RBBIM_ID)
        TRACE("ID=%u, ", pB->wID);
    TRACE("size=%u, child=%p", pB->cbSize, pB->hwndChild);
    if (pB->fMask & RBBIM_COLORS)
        TRACE(", clrF=0x%06x, clrB=0x%06x", pB->clrFore, pB->clrBack);
    TRACE("\n");

    TRACE("band info: mask=0x%08x (%s)\n", pB->fMask, REBAR_FmtMask(pB->fMask));
    if (pB->fMask & RBBIM_STYLE)
    TRACE("band info: style=0x%08x (%s)\n", pB->fStyle, REBAR_FmtStyle(pB->fStyle));
    if (pB->fMask & (RBBIM_SIZE | RBBIM_IDEALSIZE | RBBIM_HEADERSIZE | RBBIM_LPARAM )) {
    TRACE("band info:");
    if (pB->fMask & RBBIM_SIZE)
        TRACE(" cx=%u", pB->cx);
    if (pB->fMask & RBBIM_IDEALSIZE)
        TRACE(" xIdeal=%u", pB->cxIdeal);
    if (pB->fMask & RBBIM_HEADERSIZE)
        TRACE(" xHeader=%u", pB->cxHeader);
    if (pB->fMask & RBBIM_LPARAM)
        TRACE(" lParam=0x%08lx", pB->lParam);
    TRACE("\n");
    }
    if (pB->fMask & RBBIM_CHILDSIZE)
    TRACE("band info: xMin=%u, yMin=%u, yChild=%u, yMax=%u, yIntgl=%u\n",
          pB->cxMinChild,
          pB->cyMinChild, pB->cyChild, pB->cyMaxChild, pB->cyIntegral);
}

Referenced by REBAR_GetBandInfoT(), REBAR_InsertBandT(), and REBAR_SetBandInfoT().

REBAR_EraseBkGnd()

static LRESULT REBAR_EraseBkGnd ( const REBAR_INFO *  infoPtr, HDC  hdc  )

static

Definition at line 1837 of file rebar.c.

{
    REBAR_BAND *lpBand;
    UINT i;
    INT oldrow;
    RECT cr;
    COLORREF old = CLR_NONE, new;
    HTHEME theme = GetWindowTheme (infoPtr->hwndSelf);

    GetClientRect (infoPtr->hwndSelf, &cr);

#ifdef __REACTOS__
    if (theme)
    {
        if (IsThemeBackgroundPartiallyTransparent(theme, 0, 0))
        {
            DrawThemeParentBackground (infoPtr->hwndSelf, hdc, &cr);
        }
        DrawThemeBackground (theme, hdc, 0, 0, &cr, NULL);
    }
#endif

    oldrow = -1;
    for(i=0; i<infoPtr->uNumBands; i++) {
        RECT rcBand;
        lpBand = REBAR_GetBand(infoPtr, i);
    if (HIDDENBAND(lpBand)) continue;
        translate_rect(infoPtr, &rcBand, &lpBand->rcBand);

    /* draw band separator between rows */
    if (lpBand->iRow != oldrow) {
        oldrow = lpBand->iRow;
        if (infoPtr->dwStyle & RBS_BANDBORDERS) {
        RECT rcRowSep;
        rcRowSep = rcBand;
        if (infoPtr->dwStyle & CCS_VERT) {
            rcRowSep.right += SEP_WIDTH_SIZE;
            rcRowSep.bottom = infoPtr->calcSize.cx;
                    if (theme)
                        DrawThemeEdge (theme, hdc, RP_BAND, 0, &rcRowSep, EDGE_ETCHED, BF_RIGHT, NULL);
                    else
                DrawEdge (hdc, &rcRowSep, EDGE_ETCHED, BF_RIGHT);
        }
        else {
            rcRowSep.bottom += SEP_WIDTH_SIZE;
            rcRowSep.right = infoPtr->calcSize.cx;
                    if (theme)
                        DrawThemeEdge (theme, hdc, RP_BAND, 0, &rcRowSep, EDGE_ETCHED, BF_BOTTOM, NULL);
                    else
                DrawEdge (hdc, &rcRowSep, EDGE_ETCHED, BF_BOTTOM);
        }
                TRACE ("drawing band separator bottom (%s)\n",
                       wine_dbgstr_rect(&rcRowSep));
        }
    }

    /* draw band separator between bands in a row */
        if (infoPtr->dwStyle & RBS_BANDBORDERS && lpBand->rcBand.left > 0) {
        RECT rcSep;
        rcSep = rcBand;
        if (infoPtr->dwStyle & CCS_VERT) {
                rcSep.bottom = rcSep.top;
        rcSep.top -= SEP_WIDTH_SIZE;
                if (theme)
                    DrawThemeEdge (theme, hdc, RP_BAND, 0, &rcSep, EDGE_ETCHED, BF_BOTTOM, NULL);
                else
            DrawEdge (hdc, &rcSep, EDGE_ETCHED, BF_BOTTOM);
        }
        else {
                rcSep.right = rcSep.left;
        rcSep.left -= SEP_WIDTH_SIZE;
                if (theme)
                    DrawThemeEdge (theme, hdc, RP_BAND, 0, &rcSep, EDGE_ETCHED, BF_RIGHT, NULL);
                else
            DrawEdge (hdc, &rcSep, EDGE_ETCHED, BF_RIGHT);
        }
            TRACE("drawing band separator right (%s)\n",
                  wine_dbgstr_rect(&rcSep));
    }

    /* draw the actual background */
    if (lpBand->clrBack != CLR_NONE) {
        new = (lpBand->clrBack == CLR_DEFAULT) ? infoPtr->clrBtnFace :
            lpBand->clrBack;
#if GLATESTING
        /* testing only - make background green to see it */
        new = RGB(0,128,0);
#endif
    }
    else {
        /* In the absence of documentation for Rebar vs. CLR_NONE,
         * we will use the default BtnFace color. Note documentation
         * exists for Listview and Imagelist.
         */
        new = infoPtr->clrBtnFace;
#if GLATESTING
        /* testing only - make background green to see it */
        new = RGB(0,128,0);
#endif
    }

        if (theme)
        {
            /* When themed, the background color is ignored (but not a
             * background bitmap */
            DrawThemeBackground (theme, hdc, 0, 0, &cr, &rcBand);
        }
        else
        {
            old = SetBkColor (hdc, new);
            TRACE("%s background color=0x%06x, band %s\n",
                  (lpBand->clrBack == CLR_NONE) ? "none" :
                    ((lpBand->clrBack == CLR_DEFAULT) ? "dft" : ""),
                  GetBkColor(hdc), wine_dbgstr_rect(&rcBand));
            ExtTextOutW (hdc, 0, 0, ETO_OPAQUE, &rcBand, NULL, 0, 0);
            if (lpBand->clrBack != CLR_NONE)
                SetBkColor (hdc, old);
        }
    }
    return TRUE;
}

Referenced by REBAR_Paint(), and REBAR_WindowProc().

REBAR_FindBandToGrow()

static REBAR_BAND* REBAR_FindBandToGrow ( const REBAR_INFO *  infoPtr, INT  iBeginBand, INT  iEndBand  )

static

Definition at line 1186 of file rebar.c.

{
    INT cxMinFirstBand = 0, i;

    cxMinFirstBand = REBAR_GetBand(infoPtr, iBeginBand)->cxMinBand;

    for (i = prev_visible(infoPtr, iEndBand); i >= iBeginBand; i = prev_visible(infoPtr, i))
        if (REBAR_GetBand(infoPtr, i)->cxEffective > cxMinFirstBand &&
          !(REBAR_GetBand(infoPtr, i)->fStyle & RBBS_FIXEDSIZE))
            break;

    if (i < iBeginBand)
        for (i = prev_visible(infoPtr, iEndBand); i >= iBeginBand; i = prev_visible(infoPtr, i))
            if (REBAR_GetBand(infoPtr, i)->cxMinBand == cxMinFirstBand)
                break;

    TRACE("Extra space for row [%d..%d) should be added to band %d\n", iBeginBand, iEndBand, i);
    return REBAR_GetBand(infoPtr, i);
}

Referenced by REBAR_LayoutRow().

REBAR_FmtMask()

static CHAR* REBAR_FmtMask ( UINT  mask )

static

Definition at line 323 of file rebar.c.

{
    INT i = 0;

    *line = 0;
    while (band_maskname[i]) {
    if (mask & (1<<i)) {
        if (*line != 0) strcat(line, " | ");
        strcat(line, band_maskname[i]);
    }
    i++;
    }
    return line;
}

Referenced by REBAR_DumpBand(), and REBAR_DumpBandInfo().

REBAR_FmtStyle()

static CHAR* REBAR_FmtStyle ( UINT  style )

static

Definition at line 306 of file rebar.c.

{
    INT i = 0;

    *line = 0;
    while (band_stylename[i]) {
    if (style & (1<<i)) {
        if (*line != 0) strcat(line, " | ");
        strcat(line, band_stylename[i]);
    }
    i++;
    }
    return line;
}

Referenced by REBAR_DumpBand(), and REBAR_DumpBandInfo().

REBAR_ForceResize()

static VOID REBAR_ForceResize ( REBAR_INFO *  infoPtr )

static

Definition at line 950 of file rebar.c.

{
    INT x, y, width, height;
    INT xedge = 0, yedge = 0;
    RECT rcSelf;

    TRACE("new size [%d x %d]\n", infoPtr->calcSize.cx, infoPtr->calcSize.cy);

    if (infoPtr->dwStyle & CCS_NORESIZE)
        return;

    if (infoPtr->dwStyle & WS_BORDER)
    {
        xedge = GetSystemMetrics(SM_CXEDGE);
        yedge = GetSystemMetrics(SM_CYEDGE);
        /* swap for CCS_VERT? */
    }

    /* compute rebar window rect in parent client coordinates */
    GetWindowRect(infoPtr->hwndSelf, &rcSelf);
    MapWindowPoints(HWND_DESKTOP, GetParent(infoPtr->hwndSelf), (LPPOINT)&rcSelf, 2);
    translate_rect(infoPtr, &rcSelf, &rcSelf);

    height = infoPtr->calcSize.cy + 2*yedge;
    if (!(infoPtr->dwStyle & CCS_NOPARENTALIGN)) {
        RECT rcParent;

        x = -xedge;
        width = infoPtr->calcSize.cx + 2*xedge;
        y = 0; /* quiet compiler warning */
        switch ( infoPtr->dwStyle & CCS_LAYOUT_MASK) {
            case 0:     /* shouldn't happen - see NCCreate */
            case CCS_TOP:
                y = ((infoPtr->dwStyle & CCS_NODIVIDER) ? 0 : REBAR_DIVIDER) - yedge;
                break;
            case CCS_NOMOVEY:
                y = rcSelf.top;
                break;
            case CCS_BOTTOM:
                GetClientRect(GetParent(infoPtr->hwndSelf), &rcParent);
                translate_rect(infoPtr, &rcParent, &rcParent);
                y = rcParent.bottom - infoPtr->calcSize.cy - yedge;
                break;
    }
    }
    else {
    x = rcSelf.left;
    /* As on Windows if the CCS_NODIVIDER is not present the control will move
     * 2 pixel down after every layout */
    y = rcSelf.top + ((infoPtr->dwStyle & CCS_NODIVIDER) ? 0 : REBAR_DIVIDER);
    width = rcSelf.right - rcSelf.left;
    }

    TRACE("hwnd %p, style=%08x, setting at (%d,%d) for (%d,%d)\n",
    infoPtr->hwndSelf, infoPtr->dwStyle, x, y, width, height);

    /* Set flag to ignore next WM_SIZE message and resize the window */
    infoPtr->fStatus |= SELF_RESIZE;
    if ((infoPtr->dwStyle & CCS_VERT) == 0)
        SetWindowPos(infoPtr->hwndSelf, 0, x, y, width, height, SWP_NOZORDER);
    else
        SetWindowPos(infoPtr->hwndSelf, 0, y, x, height, width, SWP_NOZORDER);
    infoPtr->fStatus &= ~SELF_RESIZE;
}

Referenced by REBAR_Layout(), and REBAR_SetRedraw().

REBAR_GetBand()

static REBAR_BAND* REBAR_GetBand ( const REBAR_INFO *  infoPtr, INT  i  )

inlinestatic

Definition at line 262 of file rebar.c.

{
    assert(i >= 0 && i < infoPtr->uNumBands);
    return DPA_GetPtr(infoPtr->bands, i);
}

Referenced by get_row_begin_for_band(), get_row_end_for_band(), next_visible(), prev_visible(), REBAR_CalcHorzBand(), REBAR_CalcVertBand(), REBAR_DeleteBand(), REBAR_Destroy(), REBAR_DumpBand(), REBAR_EraseBkGnd(), REBAR_FindBandToGrow(), REBAR_GetBandBorders(), REBAR_GetBandInfoT(), REBAR_GetRect(), REBAR_GetRowHeight(), REBAR_HandleLRDrag(), REBAR_HandleUDDrag(), REBAR_IdToIndex(), REBAR_InsertBandT(), REBAR_InternalHitTest(), REBAR_Layout(), REBAR_LayoutRow(), REBAR_LButtonDown(), REBAR_MaximizeBand(), REBAR_MinimizeBand(), REBAR_MouseLeave(), REBAR_MouseMove(), REBAR_MoveBand(), REBAR_MoveBandToRowOffset(), REBAR_MoveChildWindows(), REBAR_Notify_NMREBAR(), REBAR_PushChevron(), REBAR_Refresh(), REBAR_SetBandInfoT(), REBAR_SetBandsHeight(), REBAR_SetBarInfo(), REBAR_SetFont(), REBAR_SetRowRectsX(), REBAR_ShowBand(), REBAR_ShrinkBandsLTR(), REBAR_ShrinkBandsRTL(), REBAR_SizeChildrenToHeight(), REBAR_SizeToHeight(), and REBAR_ValidateBand().

REBAR_GetBandBorders()

static LRESULT REBAR_GetBandBorders ( const REBAR_INFO *  infoPtr, UINT  uBand, RECT *  lpRect  )

static

Definition at line 2222 of file rebar.c.

{
    REBAR_BAND *lpBand;

    if (!lpRect)
    return 0;
    if (uBand >= infoPtr->uNumBands)
    return 0;

    lpBand = REBAR_GetBand(infoPtr, uBand);

    /* FIXME - the following values were determined by experimentation */
    /* with the REBAR Control Spy. I have guesses as to what the 4 and */
    /* 1 are, but I am not sure. There doesn't seem to be any actual   */
    /* difference in size of the control area with and without the     */
    /* style.  -  GA                                                   */
    if (infoPtr->dwStyle & RBS_BANDBORDERS) {
    if (infoPtr->dwStyle & CCS_VERT) {
        lpRect->left = 1;
        lpRect->top = lpBand->cxHeader + 4;
        lpRect->right = 1;
        lpRect->bottom = 0;
    }
    else {
        lpRect->left = lpBand->cxHeader + 4;
        lpRect->top = 1;
        lpRect->right = 0;
        lpRect->bottom = 1;
    }
    }
    else {
    lpRect->left = lpBand->cxHeader;
    }
    return 0;
}

Referenced by REBAR_WindowProc().

REBAR_GetBandCount()

static LRESULT REBAR_GetBandCount ( const REBAR_INFO *  infoPtr )

inlinestatic

Definition at line 2260 of file rebar.c.

{
    TRACE("band count %u!\n", infoPtr->uNumBands);

    return infoPtr->uNumBands;
}

Referenced by REBAR_WindowProc().

REBAR_GetBandInfoT()

static LRESULT REBAR_GetBandInfoT ( const REBAR_INFO *  infoPtr, UINT  uIndex, LPREBARBANDINFOW  lprbbi, BOOL  bUnicode  )

static

Definition at line 2269 of file rebar.c.

{
    REBAR_BAND *lpBand;

    if (!lprbbi || lprbbi->cbSize < REBARBANDINFOA_V3_SIZE)
    return FALSE;

    if (uIndex >= infoPtr->uNumBands)
    return FALSE;

    TRACE("index %u (bUnicode=%d)\n", uIndex, bUnicode);

    /* copy band information */
    lpBand = REBAR_GetBand(infoPtr, uIndex);

    if (lprbbi->fMask & RBBIM_STYLE)
    lprbbi->fStyle = lpBand->fStyle;

    if (lprbbi->fMask & RBBIM_COLORS) {
    lprbbi->clrFore = lpBand->clrFore;
    lprbbi->clrBack = lpBand->clrBack;
    if (lprbbi->clrBack == CLR_DEFAULT)
        lprbbi->clrBack = infoPtr->clrBtnFace;
    }

    if (lprbbi->fMask & RBBIM_TEXT) {
        if (bUnicode)
            Str_GetPtrW(lpBand->lpText, lprbbi->lpText, lprbbi->cch);
        else
            Str_GetPtrWtoA(lpBand->lpText, (LPSTR)lprbbi->lpText, lprbbi->cch);
    }

    if (lprbbi->fMask & RBBIM_IMAGE)
    lprbbi->iImage = lpBand->iImage;

    if (lprbbi->fMask & RBBIM_CHILD)
    lprbbi->hwndChild = lpBand->hwndChild;

    if (lprbbi->fMask & RBBIM_CHILDSIZE) {
    lprbbi->cxMinChild = lpBand->cxMinChild;
    lprbbi->cyMinChild = lpBand->cyMinChild;
        /* to make tests pass we follow Windows' behaviour and allow reading these fields only
         * for RBBS_VARIABLEHEIGHTS bands */
        if (lprbbi->cbSize >= REBARBANDINFOW_V6_SIZE && (lpBand->fStyle & RBBS_VARIABLEHEIGHT)) {
        lprbbi->cyChild    = lpBand->cyChild;
        lprbbi->cyMaxChild = lpBand->cyMaxChild;
        lprbbi->cyIntegral = lpBand->cyIntegral;
    }
    }

    if (lprbbi->fMask & RBBIM_SIZE)
    lprbbi->cx = lpBand->cx;

    if (lprbbi->fMask & RBBIM_BACKGROUND)
    lprbbi->hbmBack = lpBand->hbmBack;

    if (lprbbi->fMask & RBBIM_ID)
    lprbbi->wID = lpBand->wID;

    /* check for additional data */
    if (lprbbi->cbSize >= REBARBANDINFOW_V6_SIZE) {
    if (lprbbi->fMask & RBBIM_IDEALSIZE)
        lprbbi->cxIdeal = lpBand->cxIdeal;

    if (lprbbi->fMask & RBBIM_LPARAM)
        lprbbi->lParam = lpBand->lParam;

    if (lprbbi->fMask & RBBIM_HEADERSIZE)
        lprbbi->cxHeader = lpBand->cxHeader;
    }

    REBAR_DumpBandInfo(lprbbi);

    return TRUE;
}

Referenced by REBAR_WindowProc().

REBAR_GetBarHeight()

static LRESULT REBAR_GetBarHeight ( const REBAR_INFO *  infoPtr )

static

Definition at line 2347 of file rebar.c.

{
    INT nHeight;

    nHeight = infoPtr->calcSize.cy;

    TRACE("height = %d\n", nHeight);

    return nHeight;
}

Referenced by REBAR_WindowProc().

REBAR_GetBarInfo()

static LRESULT REBAR_GetBarInfo ( const REBAR_INFO *  infoPtr, LPREBARINFO  lpInfo  )

static

Definition at line 2360 of file rebar.c.

{
    if (!lpInfo || lpInfo->cbSize < sizeof (REBARINFO))
    return FALSE;

    TRACE("getting bar info!\n");

    if (infoPtr->himl) {
    lpInfo->himl = infoPtr->himl;
    lpInfo->fMask |= RBIM_IMAGELIST;
    }

    return TRUE;
}

Referenced by REBAR_WindowProc().

REBAR_GetBkColor()

static LRESULT REBAR_GetBkColor ( const REBAR_INFO *  infoPtr )

inlinestatic

Definition at line 2377 of file rebar.c.

{
    COLORREF clr = infoPtr->clrBk;

    if (clr == CLR_DEFAULT)
      clr = infoPtr->clrBtnFace;

    TRACE("background color 0x%06x!\n", clr);

    return clr;
}

Referenced by REBAR_WindowProc().

REBAR_GetFont()

static LRESULT REBAR_GetFont ( const REBAR_INFO *  infoPtr )

static

Definition at line 3016 of file rebar.c.

{
    return (LRESULT)infoPtr->hFont;
}

Referenced by REBAR_WindowProc().

REBAR_GetNotifyParent()

static HWND REBAR_GetNotifyParent ( const REBAR_INFO *  infoPtr )

static

Definition at line 502 of file rebar.c.

{
    HWND parent, owner;

    parent = infoPtr->hwndNotify;
    if (!parent) {
        parent = GetParent (infoPtr->hwndSelf);
    owner = GetWindow (infoPtr->hwndSelf, GW_OWNER);
    if (owner) parent = owner;
    }
    return parent;
}

Referenced by REBAR_Notify(), REBAR_NotifyFormat(), and REBAR_WindowProc().

REBAR_GetPalette()

static LRESULT REBAR_GetPalette ( const REBAR_INFO *  infoPtr )

static

Definition at line 2395 of file rebar.c.

{
    FIXME("empty stub!\n");

    return 0;
}

Referenced by REBAR_WindowProc().

REBAR_GetRect()

static LRESULT REBAR_GetRect ( const REBAR_INFO *  infoPtr, INT  iBand, RECT *  lprc  )

static

Definition at line 2404 of file rebar.c.

{
    REBAR_BAND *lpBand;

    if (iBand < 0 || iBand >= infoPtr->uNumBands)
    return FALSE;
    if (!lprc)
    return FALSE;

    lpBand = REBAR_GetBand(infoPtr, iBand);
    /* For CCS_VERT the coordinates will be swapped - like on Windows */
    *lprc = lpBand->rcBand;

    TRACE("band %d, (%s)\n", iBand, wine_dbgstr_rect(lprc));

    return TRUE;
}

Referenced by REBAR_WindowProc().

REBAR_GetRowCount()

static LRESULT REBAR_GetRowCount ( const REBAR_INFO *  infoPtr )

inlinestatic

Definition at line 2424 of file rebar.c.

{
    TRACE("%u\n", infoPtr->uNumRows);

    return infoPtr->uNumRows;
}

Referenced by REBAR_WindowProc().

REBAR_GetRowHeight()

static LRESULT REBAR_GetRowHeight ( const REBAR_INFO *  infoPtr, INT  iRow  )

static

Definition at line 2433 of file rebar.c.

{
    int j = 0, ret = 0;
    UINT i;
    REBAR_BAND *lpBand;

    for (i=0; i<infoPtr->uNumBands; i++) {
    lpBand = REBAR_GetBand(infoPtr, i);
    if (HIDDENBAND(lpBand)) continue;
    if (lpBand->iRow != iRow) continue;
        j = lpBand->rcBand.bottom - lpBand->rcBand.top;
    if (j > ret) ret = j;
    }

    TRACE("row %d, height %d\n", iRow, ret);

    return ret;
}

Referenced by REBAR_WindowProc().

REBAR_GetTextColor()

static LRESULT REBAR_GetTextColor ( const REBAR_INFO *  infoPtr )

inlinestatic

Definition at line 2454 of file rebar.c.

{
    TRACE("text color 0x%06x!\n", infoPtr->clrText);

    return infoPtr->clrText;
}

Referenced by REBAR_WindowProc().

REBAR_GetToolTips()

static LRESULT REBAR_GetToolTips ( const REBAR_INFO *  infoPtr )

inlinestatic

Definition at line 2463 of file rebar.c.

{
    return (LRESULT)infoPtr->hwndToolTip;
}

Referenced by REBAR_WindowProc().

REBAR_GetUnicodeFormat()

static LRESULT REBAR_GetUnicodeFormat ( const REBAR_INFO *  infoPtr )

inlinestatic

Definition at line 2470 of file rebar.c.

{
    TRACE("%s hwnd=%p\n",
      infoPtr->bUnicode ? "TRUE" : "FALSE", infoPtr->hwndSelf);

    return infoPtr->bUnicode;
}

Referenced by REBAR_WindowProc().

REBAR_GetVersion()

static LRESULT REBAR_GetVersion ( const REBAR_INFO *  infoPtr )

inlinestatic

Definition at line 2480 of file rebar.c.

{
    TRACE("version %d\n", infoPtr->iVersion);
    return infoPtr->iVersion;
}

Referenced by REBAR_WindowProc().

REBAR_HandleLRDrag()

static void REBAR_HandleLRDrag ( REBAR_INFO *  infoPtr, const POINT *  ptsmove  )

static

Definition at line 2043 of file rebar.c.

{
    REBAR_BAND *hitBand;
    INT iHitBand, iRowBegin, iRowEnd;
    INT movement, xBand, cxLeft = 0;
    BOOL shrunkBands = FALSE;

    iHitBand = infoPtr->iGrabbedBand;
    iRowBegin = get_row_begin_for_band(infoPtr, iHitBand);
    iRowEnd = get_row_end_for_band(infoPtr, iHitBand);
    hitBand = REBAR_GetBand(infoPtr, iHitBand);

    xBand = hitBand->rcBand.left;
    movement = (infoPtr->dwStyle&CCS_VERT ? ptsmove->y : ptsmove->x)
                    - (xBand + REBAR_PRE_GRIPPER - infoPtr->ihitoffset);

    /* Dragging the first band in a row cannot cause shrinking */
    if(iHitBand != iRowBegin)
    {
        if (movement < 0) {
            cxLeft = REBAR_ShrinkBandsRTL(infoPtr, iRowBegin, iHitBand, -movement, TRUE);

            if(cxLeft < -movement)
            {
                hitBand->cxEffective += -movement - cxLeft;
                hitBand->cx = hitBand->cxEffective;
                shrunkBands = TRUE;
            }

        } else if (movement > 0) {

            cxLeft = movement;
            if (prev_visible(infoPtr, iHitBand) >= 0)
                cxLeft = REBAR_ShrinkBandsLTR(infoPtr, iHitBand, iRowEnd, movement, TRUE);

            if(cxLeft < movement)
            {
                REBAR_BAND *lpPrev = REBAR_GetBand(infoPtr, prev_visible(infoPtr, iHitBand));
                lpPrev->cxEffective += movement - cxLeft;
                lpPrev->cx = hitBand->cxEffective;
                shrunkBands = TRUE;
            }

        }
    }

    if(!shrunkBands)
    {
        /* It was not possible to move the band by shrinking bands.
         * Try relocating the band instead. */
        REBAR_MoveBandToRowOffset(infoPtr, iHitBand, iRowBegin,
            iRowEnd, xBand + movement, TRUE);
    }

    REBAR_SetRowRectsX(infoPtr, iRowBegin, iRowEnd);
    if (infoPtr->dwStyle & CCS_VERT)
        REBAR_CalcVertBand(infoPtr, 0, infoPtr->uNumBands);
    else
        REBAR_CalcHorzBand(infoPtr, 0, infoPtr->uNumBands);
    REBAR_MoveChildWindows(infoPtr, iRowBegin, iRowEnd);
}

Referenced by REBAR_MouseMove().

REBAR_HandleUDDrag()

static void REBAR_HandleUDDrag ( REBAR_INFO *  infoPtr, const POINT *  ptsmove  )

static

Definition at line 2110 of file rebar.c.

{
    INT yOff = (infoPtr->dwStyle & CCS_VERT) ? ptsmove->x : ptsmove->y;
    INT iHitBand, iRowBegin, iNextRowBegin;
    REBAR_BAND *hitBand, *rowBeginBand;

    if(infoPtr->uNumBands <= 0)
        ERR("There are no bands in this rebar\n");

    /* Up/down dragging can only occur when there is more than one
     * band in the rebar */
    if(infoPtr->uNumBands <= 1)
        return;

    iHitBand = infoPtr->iGrabbedBand;
    hitBand = REBAR_GetBand(infoPtr, iHitBand);

    /* If we're taking a band that has the RBBS_BREAK style set, this
     * style needs to be reapplied to the band that is going to become
     * the new start of the row. */
    if((hitBand->fStyle & RBBS_BREAK) &&
        (iHitBand < infoPtr->uNumBands - 1))
        REBAR_GetBand(infoPtr, iHitBand + 1)->fStyle |= RBBS_BREAK;

    if(yOff < 0)
    {
        /* Place the band above the current top row */
        if(iHitBand==0 && (infoPtr->uNumBands==1 || REBAR_GetBand(infoPtr, 1)->fStyle&RBBS_BREAK))
            return;
        DPA_DeletePtr(infoPtr->bands, iHitBand);
        hitBand->fStyle &= ~RBBS_BREAK;
        REBAR_GetBand(infoPtr, 0)->fStyle |= RBBS_BREAK;
        infoPtr->iGrabbedBand = DPA_InsertPtr(
            infoPtr->bands, 0, hitBand);
    }
    else if(yOff > REBAR_GetBand(infoPtr, infoPtr->uNumBands - 1)->rcBand.bottom)
    {
        /* Place the band below the current bottom row */
        if(iHitBand == infoPtr->uNumBands-1 && hitBand->fStyle&RBBS_BREAK)
            return;
        DPA_DeletePtr(infoPtr->bands, iHitBand);
        hitBand->fStyle |= RBBS_BREAK;
        infoPtr->iGrabbedBand = DPA_InsertPtr(
            infoPtr->bands, infoPtr->uNumBands - 1, hitBand);
    }
    else
    {
        /* Place the band in the prexisting row the mouse is hovering over */
        iRowBegin = first_visible(infoPtr);
        while(iRowBegin < infoPtr->uNumBands)
        {
            iNextRowBegin = get_row_end_for_band(infoPtr, iRowBegin);
            rowBeginBand = REBAR_GetBand(infoPtr, iRowBegin);
            if(rowBeginBand->rcBand.bottom > yOff)
            {
                REBAR_MoveBandToRowOffset(
                    infoPtr, iHitBand, iRowBegin, iNextRowBegin,
                    ((infoPtr->dwStyle & CCS_VERT) ? ptsmove->y : ptsmove->x)
                        - REBAR_PRE_GRIPPER - infoPtr->ihitoffset, FALSE);
                break;
            }

            iRowBegin = iNextRowBegin;
        }
    }

    REBAR_Layout(infoPtr);
}

Referenced by REBAR_MouseMove().

REBAR_HitTest()

static LRESULT REBAR_HitTest ( const REBAR_INFO *  infoPtr, LPRBHITTESTINFO  lprbht  )

static

Definition at line 2488 of file rebar.c.

{
    if (!lprbht)
    return -1;

    REBAR_InternalHitTest (infoPtr, &lprbht->pt, &lprbht->flags, &lprbht->iBand);

    return lprbht->iBand;
}

Referenced by REBAR_WindowProc().

REBAR_IdToIndex()

static LRESULT REBAR_IdToIndex ( const REBAR_INFO *  infoPtr, UINT  uId  )

static

Definition at line 2500 of file rebar.c.

{
    UINT i;

    if (infoPtr->uNumBands < 1)
    return -1;

    for (i = 0; i < infoPtr->uNumBands; i++) {
    if (REBAR_GetBand(infoPtr, i)->wID == uId) {
        TRACE("id %u is band %u found!\n", uId, i);
        return i;
    }
    }

    TRACE("id %u is not found\n", uId);
    return -1;
}

Referenced by REBAR_WindowProc().

REBAR_InsertBandT()

static LRESULT REBAR_InsertBandT ( REBAR_INFO *  infoPtr, INT  iIndex, const REBARBANDINFOW *  lprbbi, BOOL  bUnicode  )

static

Definition at line 2520 of file rebar.c.

{
    REBAR_BAND *lpBand;

    if (!lprbbi || lprbbi->cbSize < REBARBANDINFOA_V3_SIZE)
    return FALSE;

    /* trace the index as signed to see the -1 */
    TRACE("insert band at %d (bUnicode=%d)!\n", iIndex, bUnicode);
    REBAR_DumpBandInfo(lprbbi);

    if (!(lpBand = Alloc(sizeof(REBAR_BAND)))) return FALSE;
    if ((iIndex == -1) || (iIndex > infoPtr->uNumBands))
        iIndex = infoPtr->uNumBands;
    if (DPA_InsertPtr(infoPtr->bands, iIndex, lpBand) == -1)
    {
        Free(lpBand);
        return FALSE;
    }
    infoPtr->uNumBands++;

    TRACE("index %d!\n", iIndex);

    /* initialize band */
    memset(lpBand, 0, sizeof(*lpBand));
    lpBand->clrFore = infoPtr->clrText == CLR_NONE ? infoPtr->clrBtnText :
                                                     infoPtr->clrText;
    lpBand->clrBack = infoPtr->clrBk == CLR_NONE ? infoPtr->clrBtnFace :
                                                   infoPtr->clrBk;
    lpBand->iImage = -1;

    REBAR_CommonSetupBand(infoPtr->hwndSelf, lprbbi, lpBand);

    /* Make sure the defaults for these are correct */
    if (lprbbi->cbSize < REBARBANDINFOA_V6_SIZE || !(lpBand->fStyle & RBBS_VARIABLEHEIGHT)) {
        lpBand->cyChild    = lpBand->cyMinChild;
        lpBand->cyMaxChild = 0x7fffffff;
        lpBand->cyIntegral = 0;
    }

    if ((lprbbi->fMask & RBBIM_TEXT) && (lprbbi->lpText)) {
        if (bUnicode)
            Str_SetPtrW(&lpBand->lpText, lprbbi->lpText);
        else
            Str_SetPtrAtoW(&lpBand->lpText, (LPSTR)lprbbi->lpText);
    }

    REBAR_ValidateBand (infoPtr, lpBand);
    /* On insert of second band, revalidate band 1 to possible add gripper */
    if (infoPtr->uNumBands == 2)
    REBAR_ValidateBand (infoPtr, REBAR_GetBand(infoPtr, 0));

    REBAR_DumpBand (infoPtr);

    REBAR_Layout(infoPtr);
    InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);

    return TRUE;
}

Referenced by REBAR_WindowProc().

REBAR_InternalHitTest()

static void REBAR_InternalHitTest ( const REBAR_INFO *  infoPtr, const POINT *  lpPt, UINT *  pFlags, INT *  pBand  )

static

Definition at line 1964 of file rebar.c.

{
    REBAR_BAND *lpBand;
    RECT rect;
    UINT  iCount;

    GetClientRect (infoPtr->hwndSelf, &rect);

    *pFlags = RBHT_NOWHERE;
    if (PtInRect (&rect, *lpPt))
    {
    if (infoPtr->uNumBands == 0) {
        *pFlags = RBHT_NOWHERE;
        if (pBand)
        *pBand = -1;
        TRACE("NOWHERE\n");
        return;
    }
    else {
        /* somewhere inside */
        for (iCount = 0; iCount < infoPtr->uNumBands; iCount++) {
                RECT rcBand;
        lpBand = REBAR_GetBand(infoPtr, iCount);
                translate_rect(infoPtr, &rcBand, &lpBand->rcBand);
                if (HIDDENBAND(lpBand)) continue;
        if (PtInRect (&rcBand, *lpPt)) {
            if (pBand)
            *pBand = iCount;
            if (PtInRect (&lpBand->rcGripper, *lpPt)) {
            *pFlags = RBHT_GRABBER;
            TRACE("ON GRABBER %d\n", iCount);
            return;
            }
            else if (PtInRect (&lpBand->rcCapImage, *lpPt)) {
            *pFlags = RBHT_CAPTION;
            TRACE("ON CAPTION %d\n", iCount);
            return;
            }
            else if (PtInRect (&lpBand->rcCapText, *lpPt)) {
            *pFlags = RBHT_CAPTION;
            TRACE("ON CAPTION %d\n", iCount);
            return;
            }
            else if (PtInRect (&lpBand->rcChild, *lpPt)) {
            *pFlags = RBHT_CLIENT;
            TRACE("ON CLIENT %d\n", iCount);
            return;
            }
            else if (PtInRect (&lpBand->rcChevron, *lpPt)) {
            *pFlags = RBHT_CHEVRON;
            TRACE("ON CHEVRON %d\n", iCount);
            return;
            }
            else {
            *pFlags = RBHT_NOWHERE;
            TRACE("NOWHERE %d\n", iCount);
            return;
            }
        }
        }

        *pFlags = RBHT_NOWHERE;
        if (pBand)
        *pBand = -1;

        TRACE("NOWHERE\n");
        return;
    }
    }
    else {
    *pFlags = RBHT_NOWHERE;
    if (pBand)
        *pBand = -1;
    TRACE("NOWHERE\n");
    return;
    }
}

Referenced by REBAR_HitTest(), REBAR_LButtonDown(), REBAR_MouseMove(), REBAR_NCHitTest(), and REBAR_SetCursor().

REBAR_Layout()

static VOID REBAR_Layout ( REBAR_INFO *  infoPtr )

static

Definition at line 1382 of file rebar.c.

{
    REBAR_BAND *lpBand;
    RECT rcAdj;
    SIZE oldSize;
    INT adjcx, i;
    INT rowstart;
    INT row = 0;
    INT xMin, yPos;

    if (infoPtr->dwStyle & (CCS_NORESIZE | CCS_NOPARENTALIGN) || GetParent(infoPtr->hwndSelf) == NULL)
        GetClientRect(infoPtr->hwndSelf, &rcAdj);
    else
        GetClientRect(GetParent(infoPtr->hwndSelf), &rcAdj);
    TRACE("adjustment rect is (%s)\n", wine_dbgstr_rect(&rcAdj));

    adjcx = get_rect_cx(infoPtr, &rcAdj);

    if (infoPtr->uNumBands == 0) {
        TRACE("No bands - setting size to (0,%d), style: %x\n", adjcx, infoPtr->dwStyle);
        infoPtr->calcSize.cx = adjcx;
        /* the calcSize.cy won't change for a 0 band rebar */
        infoPtr->uNumRows = 0;
        REBAR_ForceResize(infoPtr);
        return;
    }

    yPos = 0;
    xMin = 0;
    rowstart = first_visible(infoPtr);
    /* divide rows */
    for (i = rowstart; i < infoPtr->uNumBands; i = next_visible(infoPtr, i))
    {
        lpBand = REBAR_GetBand(infoPtr, i);

        if (i > rowstart && (lpBand->fStyle & RBBS_BREAK || xMin + lpBand->cxMinBand > adjcx)) {
            TRACE("%s break on band %d\n", (lpBand->fStyle & RBBS_BREAK ? "Hard" : "Soft"), i - 1);
            REBAR_LayoutRow(infoPtr, rowstart, i, adjcx, &row, &yPos);
            rowstart = i;
            xMin = 0;
        }
        else
            xMin += SEP_WIDTH;

        xMin += lpBand->cxMinBand;
    }
    if (rowstart < infoPtr->uNumBands)
        REBAR_LayoutRow(infoPtr, rowstart, infoPtr->uNumBands, adjcx, &row, &yPos);

    if (!(infoPtr->dwStyle & RBS_VARHEIGHT))
        yPos = REBAR_SetBandsHeight(infoPtr, first_visible(infoPtr), infoPtr->uNumBands, 0);

    infoPtr->uNumRows = row;

    if (infoPtr->dwStyle & CCS_VERT)
        REBAR_CalcVertBand(infoPtr, 0, infoPtr->uNumBands);
    else
        REBAR_CalcHorzBand(infoPtr, 0, infoPtr->uNumBands);
    /* now compute size of Rebar itself */
    oldSize = infoPtr->calcSize;

    infoPtr->calcSize.cx = adjcx;
    infoPtr->calcSize.cy = yPos;
    TRACE("calcsize size=(%d, %d), origheight=(%d,%d)\n",
            infoPtr->calcSize.cx, infoPtr->calcSize.cy,
        oldSize.cx, oldSize.cy);

    REBAR_DumpBand (infoPtr);
    REBAR_MoveChildWindows (infoPtr, 0, infoPtr->uNumBands);
    REBAR_ForceResize (infoPtr);

    /* note: after a RBN_HEIGHTCHANGE native sends once again all the RBN_CHILDSIZE
     * and does another ForceResize */
    if (oldSize.cy != infoPtr->calcSize.cy)
    {
        NMHDR heightchange;
        REBAR_Notify(&heightchange, infoPtr, RBN_HEIGHTCHANGE);
        REBAR_AutoSize(infoPtr, FALSE);
    }
}

Referenced by REBAR_AutoSize(), REBAR_DeleteBand(), REBAR_HandleUDDrag(), REBAR_InsertBandT(), REBAR_SetBandInfoT(), REBAR_SetFont(), REBAR_ShowBand(), REBAR_Size(), REBAR_SizeToHeight(), and REBAR_StyleChanged().

REBAR_LayoutRow()

static void REBAR_LayoutRow ( const REBAR_INFO *  infoPtr, int  iBeginBand, int  iEndBand, int  cx, int *  piRow, int *  pyPos  )

static

Definition at line 1339 of file rebar.c.

{
    REBAR_BAND *lpBand;
    int i, extra;
    int width = 0;

    TRACE("Adjusting row [%d;%d). Width: %d\n", iBeginBand, iEndBand, cx);
    for (i = iBeginBand; i < iEndBand; i++)
        REBAR_GetBand(infoPtr, i)->iRow = *piRow;

    /* compute the extra space */
    for (i = iBeginBand; i < iEndBand; i = next_visible(infoPtr, i))
    {
        lpBand = REBAR_GetBand(infoPtr, i);
        if (i > iBeginBand)
            width += SEP_WIDTH;
        lpBand->cxEffective = max(lpBand->cxMinBand, lpBand->cx);
        width += lpBand->cxEffective;
    }

    extra = cx - width;
    TRACE("Extra space: %d\n", extra);
    if (extra < 0) {
        int ret = REBAR_ShrinkBandsRTL(infoPtr, iBeginBand, iEndBand, -extra, FALSE);
        if (ret > 0 && next_visible(infoPtr, iBeginBand) != iEndBand)  /* one band may be longer than expected... */
            ERR("Error layouting row %d - couldn't shrink for %d pixels (%d total shrink)\n", *piRow, ret, -extra);
    } else
    if (extra > 0) {
        lpBand = REBAR_FindBandToGrow(infoPtr, iBeginBand, iEndBand);
        lpBand->cxEffective += extra;
    }

    REBAR_SetRowRectsX(infoPtr, iBeginBand, iEndBand);
    if (infoPtr->dwStyle & RBS_VARHEIGHT)
    {
        if (*piRow > 0)
            *pyPos += SEP_WIDTH;
        *pyPos = REBAR_SetBandsHeight(infoPtr, iBeginBand, iEndBand, *pyPos);
    }
    (*piRow)++;
}

Referenced by REBAR_Layout().

REBAR_LButtonDown()

static LRESULT REBAR_LButtonDown ( REBAR_INFO *  infoPtr, LPARAM  lParam  )

static

Definition at line 3054 of file rebar.c.

{
    UINT htFlags;
    INT iHitBand;
    POINT ptMouseDown;
    ptMouseDown.x = (short)LOWORD(lParam);
    ptMouseDown.y = (short)HIWORD(lParam);

    REBAR_InternalHitTest(infoPtr, &ptMouseDown, &htFlags, &iHitBand);

    if (htFlags == RBHT_CHEVRON)
    {
        REBAR_PushChevron(infoPtr, iHitBand, 0);
    }
    else if (htFlags == RBHT_GRABBER || htFlags == RBHT_CAPTION)
    {
        REBAR_BAND *lpBand;

        TRACE("Starting drag\n");

        lpBand = REBAR_GetBand(infoPtr, iHitBand);

        SetCapture (infoPtr->hwndSelf);
        infoPtr->iGrabbedBand = iHitBand;

        /* save off the LOWORD and HIWORD of lParam as initial x,y */
        infoPtr->dragStart.x = (short)LOWORD(lParam);
        infoPtr->dragStart.y = (short)HIWORD(lParam);
        infoPtr->dragNow = infoPtr->dragStart;
        if (infoPtr->dwStyle & CCS_VERT)
            infoPtr->ihitoffset = infoPtr->dragStart.y - (lpBand->rcBand.left + REBAR_PRE_GRIPPER);
        else
            infoPtr->ihitoffset = infoPtr->dragStart.x - (lpBand->rcBand.left + REBAR_PRE_GRIPPER);
    }
    return 0;
}

Referenced by REBAR_WindowProc().

REBAR_LButtonUp()

static LRESULT REBAR_LButtonUp ( REBAR_INFO *  infoPtr )

static

Definition at line 3092 of file rebar.c.

{
    if (infoPtr->iGrabbedBand >= 0)
    {
        NMHDR layout;
        RECT rect;

        infoPtr->dragStart.x = 0;
        infoPtr->dragStart.y = 0;
        infoPtr->dragNow = infoPtr->dragStart;

        ReleaseCapture ();

        if (infoPtr->fStatus & BEGIN_DRAG_ISSUED) {
            REBAR_Notify(&layout, infoPtr, RBN_LAYOUTCHANGED);
            REBAR_Notify_NMREBAR (infoPtr, infoPtr->iGrabbedBand, RBN_ENDDRAG);
            infoPtr->fStatus &= ~BEGIN_DRAG_ISSUED;
        }

        infoPtr->iGrabbedBand = -1;

        GetClientRect(infoPtr->hwndSelf, &rect);
        InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
    }

    return 0;
}

Referenced by REBAR_WindowProc().

REBAR_MaximizeBand()

static LRESULT REBAR_MaximizeBand ( const REBAR_INFO *  infoPtr, INT  iBand, LPARAM  lParam  )

static

Definition at line 2582 of file rebar.c.

{
    REBAR_BAND *lpBand;
    int iRowBegin, iRowEnd;
    int cxDesired, extra, extraOrig;
    int cxIdealBand;

    /* Validate */
    if (infoPtr->uNumBands == 0 || iBand < 0 || iBand >= infoPtr->uNumBands) {
    /* error !!! */
    ERR("Illegal MaximizeBand, requested=%d, current band count=%d\n",
          iBand, infoPtr->uNumBands);
        return FALSE;
    }

    lpBand = REBAR_GetBand(infoPtr, iBand);

    if (lpBand->fStyle & RBBS_HIDDEN)
    {
        /* Windows is buggy and creates a hole */
        WARN("Ignoring maximize request on a hidden band (%d)\n", iBand);
        return FALSE;
    }

    cxIdealBand = lpBand->cxIdeal + lpBand->cxHeader + REBAR_POST_CHILD;
    if (lParam && (lpBand->cxEffective < cxIdealBand))
        cxDesired = cxIdealBand;
    else
        cxDesired = infoPtr->calcSize.cx;

    iRowBegin = get_row_begin_for_band(infoPtr, iBand);
    iRowEnd   = get_row_end_for_band(infoPtr, iBand);
    extraOrig = extra = cxDesired - lpBand->cxEffective;
    if (extra > 0)
        extra = REBAR_ShrinkBandsRTL(infoPtr, iRowBegin, iBand, extra, TRUE);
    if (extra > 0)
        extra</