// Win32++ Version 7.2
// Released: 5th AUgust 2011
//
// David Nash
// email: dnash@bigpond.net.au
// url: https://sourceforge.net/projects/win32-framework
//
//
// Copyright (c) 2005-2011 David Nash
//
// Permission is hereby granted, free of charge, to
// any person obtaining a copy of this software and
// associated documentation files (the "Software"),
// to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify,
// merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom
// the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice
// shall be included in all copies or substantial portions
// of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
// ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
// OR OTHER DEALINGS IN THE SOFTWARE.
//
////////////////////////////////////////////////////////
#ifndef _WIN32XX_REBAR_H_
#define _WIN32XX_REBAR_H_
#include "wincore.h"
#include "gdi.h"
namespace Win32xx
{
struct ReBarTheme
{
BOOL UseThemes; // TRUE if themes are used
COLORREF clrBkgnd1; // Colour 1 for rebar background
COLORREF clrBkgnd2; // Colour 2 for rebar background
COLORREF clrBand1; // Colour 1 for rebar band background. Use NULL if not required
COLORREF clrBand2; // Colour 2 for rebar band background. Use NULL if not required
BOOL FlatStyle; // Bands are rendered with flat rather than raised style
BOOL BandsLeft; // Position bands left on rearrange
BOOL LockMenuBand; // Lock MenuBar's band in dedicated top row, without gripper
BOOL RoundBorders; // Use rounded band borders
BOOL ShortBands; // Allows bands to be shorter than maximum available width
BOOL UseLines; // Displays horizontal lines between bands
};
////////////////////////////////////
// Declaration of the CReBar class
//
class CReBar : public CWnd
{
public:
CReBar();
virtual ~CReBar();
// Operations
BOOL DeleteBand(const int nBand) const;
int HitTest(RBHITTESTINFO& rbht);
HWND HitTest(POINT pt);
int IDToIndex(UINT uBandID) const;
BOOL InsertBand(const int nBand, REBARBANDINFO& rbbi) const;
BOOL IsBandVisible(int nBand) const;
void MaximizeBand(UINT uBand, BOOL fIdeal = FALSE);
void MinimizeBand(UINT uBand);
BOOL MoveBand(UINT uFrom, UINT uTo);
void MoveBandsLeft();
BOOL ResizeBand(const int nBand, const CSize& sz) const;
BOOL ShowGripper(int nBand, BOOL fShow) const;
BOOL ShowBand(int nBand, BOOL fShow) const;
BOOL SizeToRect(CRect& rect) const;
// Attributes
int GetBand(const HWND hWnd) const;
CRect GetBandBorders(int nBand) const;
int GetBandCount() const;
BOOL GetBandInfo(const int nBand, REBARBANDINFO& rbbi) const;
CRect GetBandRect(int i) const;
UINT GetBarHeight() const;
BOOL GetBarInfo(REBARINFO& rbi) const;
HWND GetMenuBar() {return m_hMenuBar;}
ReBarTheme& GetReBarTheme() {return m_Theme;}
UINT GetRowCount() const;
int GetRowHeight(int nRow) const;
UINT GetSizeofRBBI() const;
HWND GetToolTips() const;
BOOL SetBandBitmap(const int nBand, const CBitmap* pBackground) const;
BOOL SetBandColor(const int nBand, const COLORREF clrFore, const COLORREF clrBack) const;
BOOL SetBandInfo(const int nBand, REBARBANDINFO& rbbi) const;
BOOL SetBarInfo(REBARINFO& rbi) const;
void SetMenuBar(HWND hMenuBar) {m_hMenuBar = hMenuBar;}
void SetReBarTheme(ReBarTheme& Theme);
protected:
//Overridables
virtual BOOL OnEraseBkgnd(CDC* pDC);
virtual void PreCreate(CREATESTRUCT& cs);
virtual void PreRegisterClass(WNDCLASS &wc);
virtual LRESULT WndProcDefault(UINT uMsg, WPARAM wParam, LPARAM lParam);
private:
CReBar(const CReBar&); // Disable copy construction
CReBar& operator = (const CReBar&); // Disable assignment operator
ReBarTheme m_Theme;
BOOL m_bIsDragging;
HWND m_hMenuBar;
LPARAM m_Orig_lParam;
};
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
namespace Win32xx
{
///////////////////////////////////
// Definitions for the CReBar class
//
inline CReBar::CReBar() : m_bIsDragging(FALSE), m_hMenuBar(0), m_Orig_lParam(0L)
{
ZeroMemory(&m_Theme, sizeof(ReBarTheme));
}
inline CReBar::~CReBar()
{
}
inline BOOL CReBar::DeleteBand(int nBand) const
// Deletes a band from a rebar control.
{
assert(::IsWindow(m_hWnd));
return (BOOL)SendMessage(RB_DELETEBAND, nBand, 0L);
}
inline int CReBar::GetBand(HWND hWnd) const
// Returns the zero based band number for this window handle
{
assert(::IsWindow(m_hWnd));
int nResult = -1;
if (NULL == hWnd) return nResult;
for (int nBand = 0; nBand < GetBandCount(); ++nBand)
{
REBARBANDINFO rbbi = {0};
rbbi.cbSize = GetSizeofRBBI();
rbbi.fMask = RBBIM_CHILD;
GetBandInfo(nBand, rbbi);
if (rbbi.hwndChild == hWnd)
nResult = nBand;
}
return nResult;
}
inline CRect CReBar::GetBandBorders(int nBand) const
// Retrieves the borders of a band.
{
assert(::IsWindow(m_hWnd));
CRect rc;
SendMessage(RB_GETBANDBORDERS, nBand, (LPARAM)&rc);
return rc;
}
inline int CReBar::GetBandCount() const
// Retrieves the count of bands currently in the rebar control.
{
assert(::IsWindow(m_hWnd));
return (int)SendMessage(RB_GETBANDCOUNT, 0L, 0L);
}
inline BOOL CReBar::GetBandInfo(int nBand, REBARBANDINFO& rbbi) const
// Retrieves information about a specified band in a rebar control.
{
assert(::IsWindow(m_hWnd));
assert(nBand >= 0);
// REBARBANDINFO describes individual BAND characteristics
rbbi.cbSize = GetSizeofRBBI();
return (BOOL)SendMessage(RB_GETBANDINFO, nBand, (LPARAM)&rbbi);
}
inline CRect CReBar::GetBandRect(int i) const
// Retrieves the bounding rectangle for a given band in a rebar control.
{
assert(::IsWindow(m_hWnd));
CRect rc;
SendMessage(RB_GETRECT, i, (LPARAM)&rc);
return rc;
}
inline UINT CReBar::GetBarHeight() const
// Retrieves the height of the rebar control.
{
assert(::IsWindow(m_hWnd));
return (UINT)SendMessage(RB_GETBARHEIGHT, 0L, 0L);
}
inline BOOL CReBar::GetBarInfo(REBARINFO& rbi) const
// Retrieves information about the rebar control and the image list it uses.
{
assert(::IsWindow(m_hWnd));
// REBARINFO describes overall rebar control characteristics
rbi.cbSize = GetSizeofRBBI();
return (BOOL)SendMessage(RB_GETBARINFO, 0L, (LPARAM)&rbi);
}
inline UINT CReBar::GetRowCount() const
// Retrieves the number of rows of bands in a rebar control.
{
assert(::IsWindow(m_hWnd));
return (UINT)SendMessage(RB_GETROWCOUNT, 0L, 0L);
}
inline int CReBar::GetRowHeight(int nRow) const
// Retrieves the height of a specified row in a rebar control.
{
assert(::IsWindow(m_hWnd));
return (int)SendMessage(RB_GETROWHEIGHT, nRow, 0L);
}
inline UINT CReBar::GetSizeofRBBI() const
// The size of the REBARBANDINFO struct changes according to _WIN32_WINNT
// sizeof(REBARBANDINFO) can report an incorrect size for older Window versions,
// or newer Window version without XP themes enabled.
// Use this function to get a safe size for REBARBANDINFO.
{
assert(::IsWindow(m_hWnd));
UINT uSizeof = sizeof(REBARBANDINFO);
#if defined REBARBANDINFO_V6_SIZE // only defined for VS2008 or higher
#if !defined (_WIN32_WINNT) || _WIN32_WINNT >= 0x0600
if ((GetWinVersion() < 2600) || (GetComCtlVersion() < 610)) // Vista and Vista themes?
uSizeof = REBARBANDINFO_V6_SIZE;
#endif
#endif
return uSizeof;
}
inline HWND CReBar::GetToolTips() const
// Retrieves the handle to any ToolTip control associated with the rebar control.
{
assert(::IsWindow(m_hWnd));
return (HWND)SendMessage(RB_GETTOOLTIPS, 0L, 0L);
}
inline int CReBar::HitTest(RBHITTESTINFO& rbht)
// Determines which portion of a rebar band is at a given point on the screen,
// if a rebar band exists at that point.
{
assert(::IsWindow(m_hWnd));
return (int)SendMessage(RB_HITTEST, 0L, (LPARAM)&rbht);
}
inline HWND CReBar::HitTest(POINT pt)
// Return the child HWND at the given point
{
assert(::IsWindow(m_hWnd));
// Convert the point to client co-ordinates
ScreenToClient(pt);
// Get the rebar band with the point
RBHITTESTINFO rbhti = {0};
rbhti.pt = pt;
int iBand = HitTest(rbhti);
if (iBand >= 0)
{
// Get the rebar band's hWnd
REBARBANDINFO rbbi = {0};
rbbi.cbSize = GetSizeofRBBI();
rbbi.fMask = RBBIM_CHILD;
GetBandInfo(iBand, rbbi);
return rbbi.hwndChild;
}
else
return NULL;
}
inline int CReBar::IDToIndex(UINT uBandID) const
// Converts a band identifier to a band index in a rebar control.
{
assert(::IsWindow(m_hWnd));
return (int)SendMessage(RB_IDTOINDEX, (WPARAM)uBandID, 0L);
}
inline BOOL CReBar::InsertBand(int nBand, REBARBANDINFO& rbbi) const
// Inserts a new band in a rebar control.
{
assert(::IsWindow(m_hWnd));
rbbi.cbSize = GetSizeofRBBI();
return (BOOL)SendMessage(RB_INSERTBAND, nBand, (LPARAM)&rbbi);
}
inline BOOL CReBar::IsBandVisible(int nBand) const
// Returns true if the band is visible
{
assert(::IsWindow(m_hWnd));
REBARBANDINFO rbbi = {0};
rbbi.cbSize = GetSizeofRBBI();
rbbi.fMask = RBBIM_STYLE;
GetBandInfo(nBand, rbbi);
return !(rbbi.fStyle & RBBS_HIDDEN);
}
inline BOOL CReBar::OnEraseBkgnd(CDC* pDC)
{
BOOL Erase = TRUE;
if (!m_Theme.UseThemes)
Erase = FALSE;
if (!m_Theme.clrBkgnd1 && !m_Theme.clrBkgnd2 && !m_Theme.clrBand1 && !m_Theme.clrBand2)
Erase = FALSE;
if (Erase)
{
CRect rcReBar = GetClientRect();
int BarWidth = rcReBar.Width();
int BarHeight = rcReBar.Height();
// Create and set up our memory DC
CMemDC MemDC(pDC);
MemDC.CreateCompatibleBitmap(pDC, BarWidth, BarHeight);
// Draw to ReBar background to the memory DC
rcReBar.right = 600;
MemDC.GradientFill(m_Theme.clrBkgnd1, m_Theme.clrBkgnd2, rcReBar, TRUE);
if (BarWidth >= 600)
{
rcReBar.left = 600;
rcReBar.right = BarWidth;
MemDC.SolidFill(m_Theme.clrBkgnd2, rcReBar);
}
if (m_Theme.clrBand1 || m_Theme.clrBand2)
{
// Draw the individual band backgrounds
for (int nBand = 0 ; nBand < GetBandCount(); ++nBand)
{
if (IsBandVisible(nBand))
{
if (nBand != GetBand(m_hMenuBar))
{
// Determine the size of this band
CRect rcBand = GetBandRect(nBand);
// Determine the size of the child window
REBARBANDINFO rbbi = {0};
rbbi.cbSize = GetSizeofRBBI();
rbbi.fMask = RBBIM_CHILD ;
GetBandInfo(nBand, rbbi);
CRect rcChild;
::GetWindowRect(rbbi.hwndChild, &rcChild);
int ChildWidth = rcChild.right - rcChild.left;
// Determine our drawing rectangle
CRect rcDraw = rcBand;
rcDraw.bottom = rcDraw.top + (rcBand.bottom - rcBand.top)/2;
int xPad = IsXPThemed()? 2: 0;
rcDraw.left -= xPad;
// Fill the Source CDC with the band's background
CMemDC SourceDC(pDC);
SourceDC.CreateCompatibleBitmap(pDC, BarWidth, BarHeight);
CRect rcBorder = GetBandBorders(nBand);
rcDraw.right = rcBand.left + ChildWidth + rcBorder.left;
SourceDC.SolidFill(m_Theme.clrBand1, rcDraw);
rcDraw.top = rcDraw.bottom;
rcDraw.bottom = rcBand.bottom;
SourceDC.GradientFill(m_Theme.clrBand1, m_Theme.clrBand2, rcDraw, FALSE);
// Set Curve amount for rounded edges
int Curve = m_Theme.RoundBorders? 12 : 0;
// Create our mask for rounded edges using RoundRect
CMemDC MaskDC(pDC);
MaskDC.CreateCompatibleBitmap(pDC, BarWidth, BarHeight);
rcDraw.top = rcBand.top;
if (!m_Theme.FlatStyle)
::InflateRect(&rcDraw, 1, 1);
int left = rcDraw.left;
int right = rcDraw.right;
int top = rcDraw.top;
int bottom = rcDraw.bottom;
int cx = rcDraw.right - rcBand.left + xPad;
int cy = rcDraw.bottom - rcBand.top;
if (m_Theme.FlatStyle)
{
MaskDC.SolidFill(RGB(0,0,0), rcDraw);
MaskDC.BitBlt(left, top, cx, cy, &MaskDC, left, top, PATINVERT);
MaskDC.RoundRect(left, top, right, bottom, Curve, Curve);
}
else
{
MaskDC.SolidFill(RGB(0,0,0), rcDraw);
MaskDC.RoundRect(left, top, right, bottom, Curve, Curve);
MaskDC.BitBlt(left, top, cx, cy, &MaskDC, left, top, PATINVERT);
}
// Copy Source DC to Memory DC using the RoundRect mask
MemDC.BitBlt(left, top, cx, cy, &SourceDC, left, top, SRCINVERT);
MemDC.BitBlt(left, top, cx, cy, &MaskDC, left, top, SRCAND);
MemDC.BitBlt(left, top, cx, cy, &SourceDC, left, top, SRCINVERT);
// Extra drawing to prevent jagged edge while moving bands
if (m_bIsDragging)
{
CClientDC ReBarDC(this);
ReBarDC.BitBlt(rcDraw.right - ChildWidth, rcDraw.top, ChildWidth, cy, &MemDC, rcDraw.right - ChildWidth, rcDraw.top, SRCCOPY);
}
}
}
}
}
if (m_Theme.UseLines)
{
// Draw lines between bands
for (int j = 0; j < GetBandCount()-1; ++j)
{
rcReBar = GetBandRect(j);
rcReBar.left = MAX(0, rcReBar.left - 4);
rcReBar.bottom +=2;
MemDC.DrawEdge(rcReBar, EDGE_ETCHED, BF_BOTTOM | BF_ADJUST);
}
}
// Copy the Memory DC to the window's DC
pDC->BitBlt(0, 0, BarWidth, BarHeight, &MemDC, 0, 0, SRCCOPY);
}
return Erase;
}
inline void CReBar::PreCreate(CREATESTRUCT &cs)
// Sets the CREATESTRUCT paramaters prior to window creation
{
cs.style = WS_VISIBLE | WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS |
CCS_NODIVIDER | RBS_VARHEIGHT | RBS_BANDBORDERS ;
cs.cy = 100;
}
inline void CReBar::PreRegisterClass(WNDCLASS &wc)
{
// Set the Window Class
wc.lpszClassName = REBARCLASSNAME;
}
inline void CReBar::MaximizeBand(UINT uBand, BOOL fIdeal /*= FALSE*/)
// Resizes a band in a rebar control to either its ideal or largest size.
{
assert(::IsWindow(m_hWnd));
SendMessage(RB_MAXIMIZEBAND, (WPARAM)uBand, (LPARAM)fIdeal);
}
inline void CReBar::MinimizeBand(UINT uBand)
// Resizes a band in a rebar control to its smallest size.
{
assert(::IsWindow(m_hWnd));
SendMessage(RB_MINIMIZEBAND, (WPARAM)uBand, 0L);
}
inline BOOL CReBar::MoveBand(UINT uFrom, UINT uTo)
// Moves a band from one index to another.
{
assert(::IsWindow(m_hWnd));
return (BOOL)SendMessage(RB_MOVEBAND, (WPARAM)uFrom, (LPARAM)uTo);
}
inline void CReBar::MoveBandsLeft()
// Repositions the bands so they are left justified
{
assert(::IsWindow(m_hWnd));
int OldrcTop = -1;
for (int nBand = GetBandCount() -1; nBand >= 0; --nBand)
{
CRect rc = GetBandRect(nBand);
if (rc.top != OldrcTop)
{
// Maximize the last band on each row
if (IsBandVisible(nBand))
{
::SendMessage(GetHwnd(), RB_MAXIMIZEBAND, nBand, 0L);
OldrcTop = rc.top;
}
}
}
}
inline BOOL CReBar::ResizeBand(int nBand, const CSize& sz) const
// Sets a band's size
{
assert(::IsWindow(m_hWnd));
REBARBANDINFO rbbi = {0};
rbbi.cbSize = GetSizeofRBBI();
rbbi.fMask = RBBIM_CHILDSIZE | RBBIM_SIZE;
GetBandInfo(nBand, rbbi);
rbbi.cx = sz.cx + 2;
rbbi.cxMinChild = sz.cx + 2;
rbbi.cyMinChild = sz.cy;
rbbi.cyMaxChild = sz.cy;
return SetBandInfo(nBand, rbbi );
}
inline BOOL CReBar::SetBandBitmap(int nBand, const CBitmap* pBackground) const
// Sets the band's bitmaps
{
assert(::IsWindow(m_hWnd));
assert(pBackground);
REBARBANDINFO rbbi = {0};
rbbi.cbSize = GetSizeofRBBI();
rbbi.fMask = RBBIM_STYLE;
GetBandInfo(nBand, rbbi);
rbbi.fMask |= RBBIM_BACKGROUND;
rbbi.hbmBack = *pBackground;
return (BOOL)SendMessage(RB_SETBANDINFO, nBand, (LPARAM)&rbbi);
}
inline BOOL CReBar::SetBandColor(int nBand, COLORREF clrFore, COLORREF clrBack) const
// Sets the band's color
// Note: No effect with XP themes enabled
// No effect if a bitmap has been set
{
assert(::IsWindow(m_hWnd));
REBARBANDINFO rbbi = {0};
rbbi.cbSize = GetSizeofRBBI();
rbbi.fMask = RBBIM_COLORS;
rbbi.clrFore = clrFore;
rbbi.clrBack = clrBack;
return (BOOL)SendMessage(RB_SETBANDINFO, nBand, (LPARAM)&rbbi);
}
inline BOOL CReBar::SetBandInfo(int nBand, REBARBANDINFO& rbbi) const
// Sets the characteristics of a rebar control.
{
assert(::IsWindow(m_hWnd));
assert(nBand >= 0);
// REBARBANDINFO describes individual BAND characteristics0
rbbi.cbSize = GetSizeofRBBI();
return (BOOL)SendMessage(RB_SETBANDINFO, nBand, (LPARAM)&rbbi);
}
inline BOOL CReBar::SetBarInfo(REBARINFO& rbi) const
// REBARINFO associates an image list with the rebar
// A band will also need to set RBBIM_IMAGE
{
assert(::IsWindow(m_hWnd));
rbi.cbSize = GetSizeofRBBI();
return (BOOL)SendMessage(RB_SETBARINFO, 0L, (LPARAM)&rbi);
}
inline void CReBar::SetReBarTheme(ReBarTheme& Theme)
{
m_Theme.UseThemes = Theme.UseThemes;
m_Theme.clrBkgnd1 = Theme.clrBkgnd1;
m_Theme.clrBkgnd2 = Theme.clrBkgnd2;
m_Theme.clrBand1 = Theme.clrBand1;
m_Theme.clrBand2 = Theme.clrBand2;
m_Theme.BandsLeft = Theme.BandsLeft;
m_Theme.LockMenuBand = Theme.LockMenuBand;
m_Theme.ShortBands = Theme.ShortBands;
m_Theme.UseLines = Theme.UseLines;
m_Theme.FlatStyle = Theme.FlatStyle;
m_Theme.RoundBorders = Theme.RoundBorders;
if (IsWindow())
{
if (m_Theme.LockMenuBand)
ShowGripper(GetBand(m_hMenuBar), FALSE);
else
ShowGripper(GetBand(m_hMenuBar), TRUE);
Invalidate();
}
}
inline BOOL CReBar::ShowBand(int nBand, BOOL fShow) const
// Show or hide a band
{
assert(::IsWindow(m_hWnd));
return (BOOL)SendMessage(RB_SHOWBAND, (WPARAM)nBand, (LPARAM)fShow);
}
inline BOOL CReBar::ShowGripper(int nBand, BOOL fShow) const
// Show or hide the band's gripper
{
assert(::IsWindow(m_hWnd));
REBARBANDINFO rbbi = {0};
rbbi.cbSize = GetSizeofRBBI();
rbbi.fMask = RBBIM_STYLE;
GetBandInfo(nBand, rbbi);
if (fShow)
{
rbbi.fStyle |= RBBS_GRIPPERALWAYS;
rbbi.fStyle &= ~RBBS_NOGRIPPER;
}
else
{
rbbi.fStyle &= ~RBBS_GRIPPERALWAYS;
rbbi.fStyle |= RBBS_NOGRIPPER;
}
return SetBandInfo(nBand, rbbi);
}
inline BOOL CReBar::SizeToRect(CRect& rect) const
// Attempts to find the best layout of the bands for the given rectangle.
// The rebar bands will be arranged and wrapped as necessary to fit the rectangle.
{
assert(::IsWindow(m_hWnd));
return (BOOL)SendMessage(RB_SIZETORECT, 0, (LPARAM) (LPRECT)rect);
}
inline LRESULT CReBar::WndProcDefault(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch (uMsg)
{
case WM_MOUSEMOVE:
if (m_Theme.UseThemes && m_Theme.LockMenuBand)
{
// We want to lock the first row in place, but allow other bands to move!
// Use move messages to limit the resizing of bands
int y = GET_Y_LPARAM(lParam);
if (y <= GetRowHeight(0))
return 0L; // throw this message away
}
break;
case WM_LBUTTONDOWN:
m_Orig_lParam = lParam; // Store the x,y position
m_bIsDragging = TRUE;
break;
case WM_LBUTTONUP:
if (m_Theme.UseThemes && m_Theme.LockMenuBand)
{
// Use move messages to limit the resizing of bands
int y = GET_Y_LPARAM(lParam);
if (y <= GetRowHeight(0))
{
// Use x,y from WM_LBUTTONDOWN for WM_LBUTTONUP position
lParam = m_Orig_lParam;
}
}
m_bIsDragging = FALSE;
break;
case UWM_GETREBARTHEME:
{
ReBarTheme& rm = GetReBarTheme();
return (LRESULT)&rm;
}
case UWM_TOOLBAR_RESIZE:
{
HWND hToolBar = (HWND)wParam;
LPSIZE pToolBarSize = (LPSIZE)lParam;
ResizeBand(GetBand(hToolBar), *pToolBarSize);
}
break;
}
// pass unhandled messages on for default processing
return CWnd::WndProcDefault(uMsg, wParam, lParam);
}
} // namespace Win32xx
#endif // #ifndef _WIN32XX_REBAR_H_