#include "ctlspriv.h" #include "image.h" #define ANIMSTEPS 10 #define ANIMSTEPTIME 5 #define CX_CHEVRON (g_cxScrollbar) #define CX_OFFSET (2 * g_cxEdge) #define GRABWIDTH 5 //*** RBC_* -- commands #define RBC_QUERY 0 #define RBC_SET 1 typedef struct tagREBARBAND { UINT fStyle; COLORREF clrFore; COLORREF clrBack; LPTSTR lpText; int cxText; // width of header text int iImage; int cxMinChild; // min width for hwndChild int cyMinChild; // min height for hwndChild int cxBmp; int cyBmp; int x; // left edge of band, relative to rebar int y; // top edge of band, relative to rebar int cx; // total width of band int cy; // height of band int cxRequest; // 'requested' width for band; either requested by host or used as temp var during size recalculation int cxMin; // min width for band int cxIdeal; // hwndChild's desired width int cyMaxChild; // hwndChild's max height int cyIntegral; // ?? int cyChild; // this differs from cyMinChild only in RBBS_VARIABLEHEIGHT mode HWND hwndChild; HBITMAP hbmBack; UINT wID; LPARAM lParam; BOOL fChevron; // band is showing chevron button RECT rcChevron; // chevron button rect UINT wChevState; // chevron button state (DFCS_PUSHED, etc.) } RBB, *PRBB; class CReBar { public: private: void _CacheThemeInfo(BOOL fOpenNew); int _GetGripperWidth(); void _Realize(HDC hdcParam, BOOL fBackground, BOOL fForceRepaint); LRESULT _SendNotify(UINT uBand, int iCode); BOOL _InvalidateRect(RECT* prc); static LRESULT s_DragCallback(HWND hwnd, UINT code, WPARAM wp, LPARAM lp); BOOL _CanBandMove(PRBB prbb); void _BandCalcMinWidth(PRBB prbb); BOOL _ShouldDrawGripper(PRBB prbb); BOOL _BandCalcTextExtent(PRBB prbb, HDC hdcIn); int _BandGetHeight(PRBB prbb); UINT _GetRowCount(); int _GetLineHeight(UINT iStart, UINT iEnd); void _BandRecalcChevron(PRBB prbb, BOOL fChevron); void _ResizeChildren(); BOOL _MoveBand(UINT iFrom, UINT iTo); int _Recalc(LPRECT prc, BOOL fForce = FALSE); void _ResizeNow(); void _Resize(BOOL fForceHeightChange); void _SetRecalc(BOOL fRecalc); BOOL _SetRedraw(BOOL fRedraw); BOOL _AfterSetFont(); BOOL _OnSetFont(HFONT hFont); BOOL _SetFont(WPARAM wParam); void _VertMungeGripperRect(LPRECT lprc); void _DrawChevron(PRBB prbb, HDC hdc); void _UpdateChevronState(PRBB prbb, WORD wControlState); void _DrawBand(PRBB prbb, HDC hdc); void _OnPaint(HDC hdcIn); void _BandTileBlt(PRBB prbb, int x, int y, int cx, int cy, HDC hdcDst, HDC hdcSrc); int _InternalHitTest(LPRBHITTESTINFO prbht, int x, int y); int _HitTest(LPRBHITTESTINFO prbht); BOOL _EraseBkgnd(HDC hdc, int iBand); BOOL _GetBarInfo(LPREBARINFO lprbi); BOOL _SetBarInfo(LPREBARINFO lprbi); BOOL _GetBandInfo(UINT uBand, LPREBARBANDINFO lprbbi); BOOL _ValidateBandInfo(LPREBARBANDINFO *pprbbi, LPREBARBANDINFO prbbi); BOOL _SetBandInfo(UINT uBand, LPREBARBANDINFO lprbbi, BOOL fAllowRecalc); BOOL _ReallocBands(UINT cBands); BOOL _RecalcFirst(int nCmd, PRBB prbbDelHide); BOOL _ShowBand(UINT uBand, BOOL fShow); BOOL _DeleteBand(UINT uBand); BOOL _InsertBand(UINT uBand, LPREBARBANDINFO lprbbi); PRBB _GetFirstInRow(PRBB prbbRow); PRBB _GetLastInRow(PRBB prbbRow, BOOL fStopAtFixed); PRBB _GetPrev(PRBB prbb, UINT uStyleSkip); PRBB _GetNext(PRBB prbb, UINT uStyleSkip); int _CountBands(UINT uStyleSkip); PRBB _EnumBand(int i, UINT uStyleSkip); int _MinX(PRBB prbb); int _MaxX(PRBB prbb); BOOL _MinimizeBand(UINT uBand, BOOL fAnim); BOOL _MaximizeBand(UINT uBand, BOOL fIdeal, BOOL fAnim); void _ToggleBand(BOOL fAnim); void _SetCursor(int x, int y, BOOL fMouseDown); BOOL _SetBandPos(PRBB prbb, int xLeft); BOOL _SetBandPosAnim(PRBB prbb, int xLeft); void _OnBeginDrag(UINT uBand); void _PassBreak(PRBB prbbSrc, PRBB prbbDest); void _GetClientRect(LPRECT prc); BOOL _RecalcIfMove(PRBB prbb); BOOL _RoomForBandVert(PRBB prbbSkip); BOOL _MakeNewRow(PRBB prbb, int y); void _DragBand(int x, int y); HPALETTE _SetPalette(HPALETTE hpal); BOOL _OnDestroy(); void _InitPaletteHack(); UINT _IDToIndex(UINT id); int _GetRowHeight(UINT uRow); int _GrowBand(PRBB prbb, int dy, BOOL fResize, int iLineHeight); int _SizeDifference(LPRECT prc); int _GetRowHeightExtra(PRBB *pprbb, PRBB prbbSkip); BOOL _BandsAtMinHeight(); BOOL _SizeBandsToRect(LPRECT prc); void _SizeBandToRowHeight(int i, int uRowHeight); void _SizeBandsToRowHeight(); BOOL _OkayToChangeBreak(PRBB prbb, UINT uMsg); LRESULT _SizeBarToRect(DWORD dwFlags, LPRECT prc); void _AutoSize(); LRESULT _GetBandBorders(int wParam, LPRECT prc); void _OnStyleChanged(WPARAM wParam, LPSTYLESTRUCT lpss); void _OnMouseMove(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam); void _OnPushChevron(HWND hwnd, PRBB prbb, LPARAM lParamNM); void _InvalidateBorders(PRBB prbb); void _OnCreate(HWND hwnd, LPCREATESTRUCT pcs); static LRESULT CALLBACK s_WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam); LRESULT _WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam); PRBB CReBar::_GetPrevVisible(PRBB prbb) { return _GetPrev(prbb, RBBS_HIDDEN); } PRBB CReBar::_GetNextVisible(PRBB prbb) { return _GetNext(prbb, RBBS_HIDDEN); } BOOL CReBar::_DragSize(int xLeft) { // adjust the captured band's starting location to the given location return _SetBandPos(_GetBand(_uCapture), xLeft); } int _FudgeWidth(int cx) { if (_UseBandBorders()) cx += g_cxEdge; return cx + _mBand.cxLeftWidth + _mBand.cxRightWidth; } int _BandWidth(PRBB prbb) { ASSERT(!(prbb->fStyle & RBBS_HIDDEN)); return _FudgeWidth(prbb->cx); } int _BandMinWidth(PRBB prbb) { ASSERT(!(prbb->fStyle & RBBS_HIDDEN)); return _FudgeWidth(prbb->cxMin); } BOOL _UseBandBorders() { return _ci.style & RBS_BANDBORDERS; } BOOL _UseChevron(PRBB prbb) { return (prbb->fStyle & RBBS_USECHEVRON) && !(prbb->fStyle & RBBS_FIXEDSIZE) && (prbb->cxIdeal > prbb->cxMinChild); } BOOL _ShowText(PRBB prbb) { return !(prbb->fStyle & RBBS_HIDETITLE) && prbb->lpText && prbb->lpText[0]; } BOOL _IsVertical() { return (_ci.style & CCS_VERT); } BOOL _IsVerticalGripper() { return _IsVertical() && (_ci.style & RBS_VERTICALGRIPPER); } PRBB _GetLastBand() { if (_cBands > 0) return _GetBand(_cBands - 1); return NULL; } BOOL _IsBandStartOfRow(PRBB prbb) { return (prbb->x == _mBand.cxLeftWidth) && !(prbb->fStyle & RBBS_HIDDEN); } PRBB _GetBand(UINT i) { _ValidateRangeInd(i); return &_rbbList[i]; } UINT _BandToIndex(PRBB prbb) { return (UINT)(prbb - _rbbList); } int _GetHeaderWidth(PRBB prbb) { return (prbb->cxMin - (prbb->cxMinChild + (_UseChevron(prbb) ? CX_CHEVRON : 0))); } BOOL _IsBandVisible(PRBB prbb) { return !(prbb->fStyle & RBBS_HIDDEN); } BOOL _IsRowAtMinHeight(PRBB* pprbb) { return !_GetRowHeightExtra(pprbb, NULL); } int _GetBarHeight() { return (_cBands && _cy == 0) ? _Recalc(NULL, TRUE) : _cy; } BOOL _IsValidIndex(UINT i) { return (BOOL)(i < _cBands); } BOOL _IsValidBand(PRBB prbb) { return _IsValidIndex(_BandToIndex(prbb)); } COLORREF _GetBkColor() { if (_clrBk == CLR_DEFAULT) return g_clrBtnFace; else return _clrBk; } COLORREF _GetTextColor() { if (_clrText == CLR_DEFAULT) return g_clrBtnText; else return _clrText; } COLORREF _BandGetBkColor(PRBB prbb) { switch(prbb->clrBack) { case CLR_NONE: // CLR_NONE means "use our dad's color" return _GetBkColor(); case CLR_DEFAULT: return g_clrBtnFace; default: return prbb->clrBack; } } COLORREF _BandGetTextColor(PRBB prbb) { switch (prbb->clrFore) { case CLR_NONE: // CLR_NONE means "use our dad's color" return _GetTextColor(); case CLR_DEFAULT: return g_clrBtnText; default: return prbb->clrFore; } } // // Our use of CLR_DEFAULT for the band background colors is new for // version 5.01. Since we don't want to confuse apps by returning // CLR_DEFAULT when they used to see a real colorref, we convert it // before returning it to them. If the background color is CLR_NONE, // though, we need to return it without conversion (like version 4 did). // The *External functions handle these cases. // COLORREF _BandGetTextColorExternal(PRBB prbb) { if (prbb->clrFore == CLR_NONE) return CLR_NONE; else return _BandGetTextColor(prbb); } COLORREF _BandGetBkColorExternal(PRBB prbb) { if (prbb->clrBack == CLR_NONE) return CLR_NONE; else return _BandGetBkColor(prbb); } BOOL _ValidateRangePtr(PRBB prbb) { #ifdef DEBUG if (prbb < _GetBand(0)) { ASSERT(0); return FALSE; } if (_GetLastBand() + 1 < prbb) { // +1 to allow for "p = first; p < last+1; p++" kinds of loops ASSERT(0); return FALSE; } #endif return TRUE; } BOOL _ValidateRangeInd(UINT i) { #ifdef DEBUG if ( !IsInRange(i, 0, _cBands) ) { // if !(0 <= i <= _cBands) // +1 to allow for "p = first; p < last+1; p++" kinds of loops ASSERT(0); return FALSE; } #endif return TRUE; } CCONTROLINFO _ci; HPALETTE _hpal; BOOL _fResizeRecursed; BOOL _fResizePending; BOOL _fResizeNotify; BOOL _fRedraw; BOOL _fRecalcPending; BOOL _fRecalc; BOOL _fParentDrag; BOOL _fRefreshPending; BOOL _fResizing; BOOL _fUserPalette; BOOL _fFontCreated; BOOL _fFullOnDrag; BOOL _fHasBorder; HDRAGPROXY _hDragProxy; HWND _hwndToolTips; int _xBmpOrg; int _yBmpOrg; int _cyFont; int _cy; int _cxImage; int _cyImage; int _xStart; MARGINS _mBand; HIMAGELIST _himl; HFONT _hFont; UINT _cBands; UINT _uCapture; UINT _uResizeNext; // this marks the next band to resize vertically if needed and allowed (VARIABLEHEIGHT set) POINT _ptCapture; PRBB _rbbList; COLORREF _clrBk; COLORREF _clrText; DWORD _dwStyleEx; COLORSCHEME _clrsc; POINT _ptLastDragPos; PRBB _prbbHot; // band w/ hot chevron HTHEME _hTheme; friend BOOL InitReBarClass(HINSTANCE hInstance); }; void CReBar::_CacheThemeInfo(BOOL fOpenNew) { if (_hTheme) CloseThemeData(_hTheme); _hTheme = NULL; if (fOpenNew) _hTheme = OpenThemeData(_ci.hwnd, L"Rebar"); if (_hTheme) { // Get the cached metrics. These are things that can be slow to get during a calculation GetThemeMargins(_hTheme, NULL, RP_BAND, 0, TMT_CONTENTMARGINS, NULL, &_mBand); SetWindowBits(_ci.hwnd, GWL_STYLE, WS_BORDER, 0); } else { if (_fHasBorder) SetWindowBits(_ci.hwnd, GWL_STYLE, WS_BORDER, WS_BORDER); ZeroMemory(&_mBand, sizeof(MARGINS)); } _AfterSetFont(); } int CReBar::_GetGripperWidth() { BOOL fVert; RECT rcClient; RECT rc; if (!_hTheme) return GRABWIDTH; GetClientRect(_ci.hwnd, &rcClient); fVert = _IsVerticalGripper(); SetRect(&rc, 0, 0, fVert?RECTWIDTH(rcClient):3, fVert?3:RECTHEIGHT(rcClient)); GetThemeBackgroundExtent(_hTheme, NULL, RP_GRIPPER, 0, &rc, &rc); return fVert?RECTHEIGHT(rc):RECTWIDTH(rc); } /// // // Map a rect to parent should be based on the visual right edge // for calculating the client coordinates for a RTL mirrored windows. // This routine should only be used when calculating client // coordinates in a RTL mirrored window. [samera] // BOOL MapRectInRTLMirroredWindow( LPRECT lprc, HWND hwnd) { int iWidth = lprc->right - lprc->left; int iHeight = lprc->bottom- lprc->top; RECT rc={0,0,0,0}; if (hwnd) { GetClientRect(hwnd, &rc); MapWindowPoints(hwnd, NULL, (LPPOINT)&rc.left, 2); } lprc->left = rc.right - lprc->right; lprc->top = lprc->top-rc.top; lprc->bottom = lprc->top + iHeight; lprc->right = lprc->left + iWidth; return TRUE; } void CReBar::_Realize(HDC hdcParam, BOOL fBackground, BOOL fForceRepaint) { if (_hpal) { HDC hdc = hdcParam ? hdcParam : GetDC(_ci.hwnd); if (hdc) { BOOL fRepaint; SelectPalette(hdc, _hpal, fBackground); fRepaint = RealizePalette(hdc) || fForceRepaint; if (!hdcParam) ReleaseDC(_ci.hwnd, hdc); if (fRepaint) { InvalidateRect(_ci.hwnd, NULL, TRUE); } } } } ////////////////////////////////////////////////////////////////// // _SendNotify // // sends a wm_notify of code iCode and packages up all the data for you // for band uBand // ////////////////////////////////////////////////////////////////// LRESULT CReBar::_SendNotify(UINT uBand, int iCode) { NMREBAR nm = {0}; nm.uBand = uBand; if (uBand != (UINT)-1) { nm.dwMask = RBNM_ID | RBNM_STYLE | RBNM_LPARAM; nm.wID = _GetBand(uBand)->wID; nm.fStyle = _GetBand(uBand)->fStyle; nm.lParam = _GetBand(uBand)->lParam; } return CCSendNotify(&_ci, iCode, &nm.hdr); } BOOL CReBar::_InvalidateRect(RECT* prc) { if (_fRedraw) { RECT rc; if (prc && _IsVertical()) { CopyRect(&rc, prc); FlipRect(&rc); prc = &rc; } _fRefreshPending = FALSE; InvalidateRect(_ci.hwnd, prc, TRUE); return TRUE; } else { _fRefreshPending = TRUE; return FALSE; } } LRESULT CReBar::s_DragCallback(HWND hwnd, UINT code, WPARAM wp, LPARAM lp) { CReBar* prb = (CReBar*)GetWindowPtr(hwnd, 0); LRESULT lres; switch (code) { case DPX_DRAGHIT: if (lp) { int iBand; RBHITTESTINFO rbht; rbht.pt.x = ((POINTL *)lp)->x; rbht.pt.y = ((POINTL *)lp)->y; MapWindowPoints(NULL, prb->_ci.hwnd, &rbht.pt, 1); iBand = prb->_HitTest(&rbht); *(DWORD*)wp = rbht.flags; lres = (LRESULT)(iBand != -1 ? prb->_rbbList[iBand].wID : -1); } else lres = -1; break; case DPX_GETOBJECT: lres = (LRESULT)GetItemObject(&prb->_ci, RBN_GETOBJECT, &IID_IDropTarget, (LPNMOBJECTNOTIFY)lp); break; default: lres = -1; break; } return lres; } // ---------------------------------------------------------------------------- // // _CanBandMove // // returns TRUE if the given band can be moved and FALSE if it cannot // // ---------------------------------------------------------------------------- BOOL CReBar::_CanBandMove(PRBB prbb) { // If there is only one visible band it cannot move if (_EnumBand(1, RBBS_HIDDEN) > _GetLastBand()) return FALSE; ASSERT(!(prbb->fStyle & RBBS_HIDDEN)); if ((_ci.style & RBS_FIXEDORDER) && (prbb == _EnumBand(0, RBBS_HIDDEN))) // the first (visible) band in fixed order rebars can't be moved return(FALSE); // fixed size bands can't be moved return(!(prbb->fStyle & RBBS_FIXEDSIZE)); } // ---------------------------------------------------------------------------- // // _BandCalcMinWidth // // calculates minimum width for the given band // // ---------------------------------------------------------------------------- void CReBar::_BandCalcMinWidth(PRBB prbb) { BOOL fDrawGripper = _ShouldDrawGripper(prbb); BOOL fVertical; int cEdge; BOOL fEmpty = (prbb->iImage == -1 && !_ShowText(prbb)); if (prbb->fStyle & RBBS_HIDDEN) { ASSERT(0); return; } // did the user specify the size explicitly? if (prbb->fStyle & RBBS_FIXEDHEADERSIZE) return; prbb->cxMin = prbb->cxMinChild; if (_UseChevron(prbb)) prbb->cxMin += CX_CHEVRON; if (!fDrawGripper && fEmpty) return; fVertical = (_ci.style & CCS_VERT); if (_IsVerticalGripper()) { prbb->cxMin += 4 * g_cyEdge; prbb->cxMin += max(_cyImage, _cyFont); } else { cEdge = fVertical ? g_cyEdge : g_cxEdge; prbb->cxMin += 2 * cEdge; if (fDrawGripper) { prbb->cxMin += _GetGripperWidth() * (fVertical ? g_cyBorder : g_cxBorder); if (fEmpty) return; } prbb->cxMin += 2 * cEdge; if (prbb->iImage != -1) prbb->cxMin += (fVertical ? _cyImage : _cxImage); if (_ShowText(prbb)) { if (fVertical) prbb->cxMin += _cyFont; else prbb->cxMin += prbb->cxText; if (prbb->iImage != -1) // has both image and text -- add in edge between 'em prbb->cxMin += cEdge; } } } BOOL CReBar::_ShouldDrawGripper(PRBB prbb) { if (prbb->fStyle & RBBS_NOGRIPPER) return FALSE; if ((prbb->fStyle & RBBS_GRIPPERALWAYS) || _CanBandMove(prbb)) return TRUE; return FALSE; } // ---------------------------------------------------------------------------- // // _BandCalcTextExtent // // computes the horizontal extent of the given band's title text in the current // title font for the rebar // // returns TRUE if text extent changed, FALSE otherwise // // ---------------------------------------------------------------------------- BOOL CReBar::_BandCalcTextExtent(PRBB prbb, HDC hdcIn) { HDC hdc = hdcIn; HFONT hFontOld; int cx; if (prbb->fStyle & RBBS_HIDDEN) { ASSERT(0); // caller should have skipped return FALSE; } if (!_ShowText(prbb)) { cx = 0; } else { RECT rc = {0,0,0,0}; HRESULT hr = E_FAIL; if (!hdcIn && !(hdc = GetDC(_ci.hwnd))) return FALSE; hFontOld = SelectFont(hdc, _hFont); if (_hTheme) hr = GetThemeTextExtent(_hTheme, hdc, 0, 0, prbb->lpText, -1, DT_CALCRECT, &rc, &rc); if (FAILED(hr)) { DrawText(hdc, prbb->lpText, lstrlen(prbb->lpText), &rc, DT_CALCRECT); } SelectObject(hdc, hFontOld); cx = RECTWIDTH(rc); if (!hdcIn) ReleaseDC(_ci.hwnd, hdc); } if (prbb->cxText != cx) { prbb->cxText = cx; _BandCalcMinWidth(prbb); return TRUE; } return FALSE; } // ---------------------------------------------------------------------------- // // _BandGetHeight // // returns minimum height for the given band // TODO: make this a field in the band structure instead of always calling this // // ---------------------------------------------------------------------------- int CReBar::_BandGetHeight(PRBB prbb) { UINT cy = 0; BOOL fVertical = (_ci.style & CCS_VERT); UINT cyCheck, cyBorder; cyBorder = (fVertical ? g_cxEdge : g_cyEdge) * 2; if (prbb->hwndChild) { cy = prbb->cyChild; if (!(prbb->fStyle & RBBS_CHILDEDGE)) // add edge to top and bottom of child window cy -= cyBorder; } if (_ShowText(prbb) && !fVertical) { cyCheck = _cyFont; if (cyCheck > cy) cy = cyCheck; } if (prbb->iImage != -1) { cyCheck = (fVertical) ? _cxImage : _cyImage; if (cyCheck > cy) cy = cyCheck; } return(cy + cyBorder); } // ---------------------------------------------------------------------------- // // _GetRowCount // // returns the number of rows in the rebar's current configuration // // ---------------------------------------------------------------------------- UINT CReBar::_GetRowCount() { UINT i; UINT cRows = 0; for (i = 0; i < _cBands; i++) { PRBB prbb = _GetBand(i); if (!(prbb->fStyle & RBBS_HIDDEN) && _IsBandStartOfRow(prbb)) { cRows++; } } return cRows; } // ---------------------------------------------------------------------------- // // _GetLineHeight // // returns the height of the line of bands from iStart to iEnd, inclusively // // ---------------------------------------------------------------------------- int CReBar::_GetLineHeight(UINT iStart, UINT iEnd) { int cy = 0; PRBB prbb; int cyMinChild = 0; int iMinExtra = -1; if (!(_ci.style & RBS_VARHEIGHT)) { // for fixed height bars, line height is maximum height of ALL bands iStart = 0; iEnd = _cBands - 1; } UINT i = iStart; for (prbb = _rbbList + i; i <= iEnd; prbb++, i++) { if (prbb->fStyle & RBBS_HIDDEN) continue; cy = max(cy, (int)_BandGetHeight(prbb)); if (prbb->cyMinChild > cyMinChild) { cyMinChild = prbb->cyMinChild; } } i = iStart; for (prbb = _rbbList + i; i <= iEnd; prbb++, i++) { if (prbb->fStyle & RBBS_HIDDEN) continue; if ((prbb->fStyle & RBBS_VARIABLEHEIGHT) && prbb->cyIntegral) { int iExtra = (cy - prbb->cyMinChild) % prbb->cyIntegral; if ((iMinExtra == -1) || (iExtra < iMinExtra)) { iMinExtra = iExtra; } } } if (iMinExtra != -1) { cy -= iMinExtra; } if (cy < cyMinChild) { cy = cyMinChild; } return cy; } // _BandRecalcChevron: update & refresh chevron void CReBar::_BandRecalcChevron(PRBB prbb, BOOL fChevron) { RECT rcChevron; if (fChevron) { rcChevron.right = prbb->x + prbb->cx; rcChevron.left = rcChevron.right - CX_CHEVRON; rcChevron.top = prbb->y; rcChevron.bottom = rcChevron.top + prbb->cy; } else SetRect(&rcChevron, -1, -1, -1, -1); if (!EqualRect(&rcChevron, &prbb->rcChevron)) { if (prbb->fChevron) _InvalidateRect(&prbb->rcChevron); prbb->fChevron = fChevron; CopyRect(&prbb->rcChevron, &rcChevron); if (prbb->fChevron) _InvalidateRect(&prbb->rcChevron); } } void CReBar::_InvalidateBorders(PRBB prbb) { if (_mBand.cxLeftWidth || _mBand.cyTopHeight || _mBand.cxRightWidth || _mBand.cyBottomHeight) { RECT rcOuter = {prbb->x - _mBand.cxLeftWidth, prbb->y - _mBand.cyTopHeight, prbb->x + prbb->cx + _mBand.cxRightWidth, prbb->y + prbb->cy + _mBand.cyBottomHeight}; RECT rcInner = {prbb->x + _mBand.cxLeftWidth, prbb->y + _mBand.cyTopHeight, prbb->x + prbb->cx - _mBand.cxRightWidth, prbb->y + prbb->cy - _mBand.cyBottomHeight}; if (_ci.style & CCS_VERT) { FlipRect(&rcOuter); FlipRect(&rcInner); } HRGN hrgnOuter = CreateRectRgnIndirect(&rcOuter); if (hrgnOuter) { HRGN hrgnInner = CreateRectRgnIndirect(&rcInner); if (hrgnInner) { CombineRgn(hrgnOuter, hrgnOuter, hrgnInner, RGN_DIFF); DeleteObject(hrgnInner); } InvalidateRgn(_ci.hwnd, hrgnOuter, FALSE); DeleteObject(hrgnOuter); } } } // ---------------------------------------------------------------------------- // // _ResizeChildren // // resizes children to fit properly in their respective bands' bounding rects // // ---------------------------------------------------------------------------- void CReBar::_ResizeChildren() { int cx, cy, x, y, cxHeading; HDWP hdwp; BOOL fVertical = (_ci.style & CCS_VERT); PRBB prbb, prbbEnd; if (!_cBands || !_fRedraw) return; hdwp = BeginDeferWindowPos(_cBands); prbb = _GetBand(0); prbbEnd = _GetLastBand(); for ( ; prbb <= prbbEnd ; prbb++) { NMREBARCHILDSIZE nm; BOOL fChevron = FALSE; if (prbb->fStyle & RBBS_HIDDEN) continue; if (!prbb->hwndChild) continue; cxHeading = _GetHeaderWidth(prbb); x = prbb->x + cxHeading; cx = prbb->cx - cxHeading; // if we're not giving child ideal size, make space for chevron button if ((cx < prbb->cxIdeal) && _UseChevron(prbb)) { fChevron = TRUE; cx -= CX_CHEVRON; } if (!(prbb->fStyle & RBBS_FIXEDSIZE)) { if (fVertical) { PRBB prbbNext = _GetNextVisible(prbb); if (prbbNext && !_IsBandStartOfRow(prbbNext)) cx -= g_cyEdge * 2; } else cx -= CX_OFFSET; } if (cx < 0) cx = 0; y = prbb->y; cy = prbb->cy; if (prbb->cyChild && (prbb->cyChild < cy)) { if (!(prbb->fStyle & RBBS_TOPALIGN)) { y += (cy - prbb->cyChild) / 2; } cy = prbb->cyChild; } nm.rcChild.left = x; nm.rcChild.top = y; nm.rcChild.right = x + cx; nm.rcChild.bottom = y + cy; nm.rcBand.left = prbb->x + _GetHeaderWidth(prbb); nm.rcBand.right = prbb->x + prbb->cx; nm.rcBand.top = prbb->y; nm.rcBand.bottom = prbb->y + prbb->cy; nm.uBand = _BandToIndex(prbb); nm.wID = prbb->wID; if (fVertical) { FlipRect(&nm.rcChild); FlipRect(&nm.rcBand); } CCSendNotify(&_ci, RBN_CHILDSIZE, &nm.hdr); if (!_IsValidBand(prbb)) { // somebody responded to notify by nuking bands; bail break; } _BandRecalcChevron(prbb, fChevron); _InvalidateBorders(prbb); DeferWindowPos(hdwp, prbb->hwndChild, NULL, nm.rcChild.left, nm.rcChild.top, RECTWIDTH(nm.rcChild), RECTHEIGHT(nm.rcChild), SWP_NOZORDER); } EndDeferWindowPos(hdwp); // // The SQL 7.0 Enterprise Manager Data Transformation Services MMC Snap-In // (and the Visual Basic Coolbar Sample App, too) has problems. // It hosts a rebar but doesn't set the WS_CLIPCHILDREN flag, // so when it erases its background, it wipes out the rebar. So don't // call UpdateWindow() here, or we will paint *first*, then SQL will // erase us by mistake. We have to leave our paint pending, so that // when SQL erases us by mistake, we will eventually get a WM_PAINT // message afterwards. // #if 0 UpdateWindow(_ci.hwnd); #endif } // ---------------------------------------------------------------------------- // // _MoveBand // // moves the band from one position to another in the rebar's band array, // updating the rebar's iCapture field as needed // // returns TRUE or FALSE if something moved // ---------------------------------------------------------------------------- BOOL CReBar::_MoveBand(UINT iFrom, UINT iTo) { RBB rbbMove; int iShift; BOOL fCaptureChanged = (_uCapture == -1); if (iFrom != iTo) { rbbMove = *_GetBand(iFrom); if (_uCapture == iFrom) { _uCapture = iTo; fCaptureChanged = TRUE; } iShift = (iFrom > iTo) ? -1 : 1; while (iFrom != iTo) { if (!fCaptureChanged && (_uCapture == (iFrom + iShift))) { _uCapture = iFrom; fCaptureChanged = TRUE; } *_GetBand(iFrom) = *_GetBand(iFrom + iShift); iFrom += iShift; } *_GetBand(iTo) = rbbMove; return TRUE; } return(FALSE); } // ---------------------------------------------------------------------------- // // _Recalc // // recomputes bounding rects for all bands in given rebar // // ---------------------------------------------------------------------------- int CReBar::_Recalc(LPRECT prc, BOOL fForce /* = FALSE */) { PRBB prbb = _GetBand(0); PRBB prbbWalk; UINT cHidden; // # of hidden guys we've seen in current row int cxRow; int cxMin; UINT i; UINT j; UINT k; UINT iFixed = 0xFFFF; int cy; int y; int x; int cxBar; RECT rc; HWND hwndSize; BOOL fNewLine = FALSE; BOOL fChanged; BOOL fVertical = (_ci.style & CCS_VERT); BOOL fBandBorders; int iBarWidth; if (!_cBands) return(0); if ((_ci.style & CCS_NORESIZE) || (_ci.style & CCS_NOPARENTALIGN)) { // size based on rebar window itself hwndSize = _ci.hwnd; } else if (!(hwndSize = _ci.hwndParent)) { // size based on parent window -- if no parent window, bail now return(0); } if (!_fRecalc && !fForce) { // defer this recalc _fRecalcPending = TRUE; return 0; } else { _fRecalcPending = FALSE; } if (prc) { rc = *prc; } else { GetClientRect(hwndSize, &rc); } iBarWidth = (fVertical ? (rc.bottom - rc.top) : (rc.right - rc.left)); // this can happen because we adjust the client rect, but wedon't change // the getminmaxinfo. if (iBarWidth <= 0) iBarWidth = 1; cxBar = iBarWidth; fBandBorders = _UseBandBorders(); for (i = 0; i < _cBands; i++) { _rbbList[i].cx = _rbbList[i].cxRequest; } y = 0; i = 0; // Main Loop -- loop until all bands are calculated while (i < _cBands) { TraceMsg(TF_REBAR, "_Recalc: outer loop i=%d", i); if (fBandBorders && (y > 0)) y += g_cyEdge; y += _mBand.cyTopHeight; ReLoop: cxRow = 0; cxMin = _mBand.cxLeftWidth + _mBand.cxRightWidth; x = _mBand.cxLeftWidth; cHidden = 0; // Row Loop -- loop until hard line break is found or soft line break // is necessary for (j = i, prbbWalk = prbb; j < _cBands; j++, prbbWalk++) { TraceMsg(TF_REBAR, "_Recalc: inner loop j=%d", j); if (prbbWalk->fStyle & RBBS_HIDDEN) { ++cHidden; continue; } if (j > i + cHidden) { // not the first band in the row -- check for break style if ((prbbWalk->fStyle & RBBS_BREAK) && !(prbbWalk->fStyle & RBBS_FIXEDSIZE)) break; if (fBandBorders) // add in space for vertical etch on palettized display cxMin += g_cxEdge; } if (prbbWalk->fStyle & RBBS_FIXEDSIZE) { // remember location of branding brick iFixed = j; // if this is the first band, the next band cannot have a forced break. if (i + cHidden == j) { // if the first index in the row (i) plus the number of hidden items (cHidden) leaves us at this band, // then it's the first visible in this row. PRBB prbbNextVis = _GetNextVisible(prbbWalk); if (prbbNextVis && (prbbNextVis->fStyle & RBBS_BREAK)) { // can't do this unilaterally because on startup // some folks (net meeting) initialize it in reverse order // and we whack off this break bit incorrectly if (_fRedraw && IsWindowVisible(_ci.hwnd)) prbbNextVis->fStyle &= ~RBBS_BREAK; } } prbbWalk->cx = prbbWalk->cxMin; } if (prbbWalk->cx < prbbWalk->cxMin) prbbWalk->cx = prbbWalk->cxMin; cxMin += prbbWalk->cxMin; // update running total of min widths // read the assert comment below if (j > i + cHidden) { // not the first band in row -- check for need to autobreak if ((cxMin > cxBar) && (_OkayToChangeBreak(prbbWalk, RBAB_AUTOSIZE))) // autobreak here break; if (fBandBorders) { // add in space for vertical etch on palettized display cxRow += g_cxEdge; } } cxRow += prbbWalk->cx; // update running total of current widths cxRow += _mBand.cxLeftWidth + _mBand.cxRightWidth; } if (!i) { // first row -- handle proper placement of branding band if (iFixed == 0xFFFF) { // branding band not yet found; look in the remaining bands k = j; for ( ; j < _cBands; j++) { if (_GetBand(j)->fStyle & RBBS_HIDDEN) continue; if (_GetBand(j)->fStyle & RBBS_FIXEDSIZE) { // branding band found; move to 1st row and recompute ASSERT(j != k); _MoveBand(j, k); goto ReLoop; } } // no branding band found -- reset j and continue on j = k; } else { // we have a branding band; move it to // the rightmost position in the row _MoveBand(iFixed, j - 1); } TraceMsg(TF_REBAR, "_Recalc: after brand i=%d", i); } // variant: // now the current row of bands is from i to j - 1 // n.b. i (and some following bands) might be hidden // assert that j != i because then the above variant won't be true ASSERT(j != i); if (cxRow > cxBar) { // bands are too long -- shrink bands from right to left for (k = i; k < j; k++) { prbbWalk--; if (prbbWalk->fStyle & RBBS_HIDDEN) continue; if (prbbWalk->cx > prbbWalk->cxMin) { cxRow -= prbbWalk->cx - prbbWalk->cxMin; prbbWalk->cx = prbbWalk->cxMin; if (cxRow <= cxBar) { prbbWalk->cx += cxBar - cxRow; break; } } } TraceMsg(TF_REBAR, "_Recalc: after shrink i=%d", i); } else if (cxRow < cxBar) { // bands are too short -- grow rightmost non-minimized band for (k = j - 1; k >= i; k--) { ASSERT(k != (UINT)-1); // catch infinite loop prbbWalk--; if ((k == i) || (!(prbbWalk->fStyle & (RBBS_HIDDEN | RBBS_FIXEDSIZE)) && (prbbWalk->cx > prbb->cxMin))) { // the k == i check means we've made it to the first // band on this row and so he has to get the cx change if (prbbWalk->fStyle & RBBS_HIDDEN) { ASSERT(k == i); prbbWalk = _GetNextVisible(prbbWalk); if (!prbbWalk) break; } prbbWalk->cx += cxBar - cxRow; break; } } TraceMsg(TF_REBAR, "_Recalc: after grow i=%d", i); } // items from index i to index j-1 (inclusive) WILL fit on one line cy = _GetLineHeight(i, j - 1); fChanged = FALSE; // set if any bands on current row changed position for ( ; i < j; i++, prbb++) { if (prbb->fStyle & RBBS_HIDDEN) continue; // go through row of bands, updating positions and heights, // invalidating as needed if ((prbb->y != y) || (prbb->x != x) || (prbb->cy != cy)) { TraceMsg(TF_REBAR, "_Recalc: invalidate i=%d", _BandToIndex(prbb)); fChanged = TRUE; rc.left = min(prbb->x, x); rc.top = min(prbb->y, y); rc.right = cxBar; rc.bottom = max(prbb->y + prbb->cy, y + cy); if (fBandBorders) { // acount for etch line that will need to move rc.left -= g_cxEdge; rc.bottom += g_cyEdge/2; } else { rc.left -= _mBand.cxLeftWidth; rc.right += _mBand.cxRightWidth; rc.top -= _mBand.cyTopHeight; rc.bottom += _mBand.cyBottomHeight; } if (!prc) { _InvalidateRect(&rc); } } prbb->x = x; prbb->y = y; prbb->cy = cy; x += _BandWidth(prbb); } // i and prbb now refer to the first band in the next row of bands y += cy + _mBand.cyBottomHeight; } _cy = y; return(y); } // ---------------------------------------------------------------------------- // // _ResizeNow // // recomputes bounding rects for all bands and then resizes rebar and children // based on these rects // // ---------------------------------------------------------------------------- void CReBar::_ResizeNow() { RECT rc; BOOL bMirroredWnd=(_ci.dwExStyle&RTL_MIRRORED_WINDOW); if (!_ci.hwndParent) return; GetWindowRect(_ci.hwnd, &rc); // // If this is a mirrored window, we don't won't to refect the // coordinates since they are coming from the screen coord // which they are not mirrored. [samera] // if (bMirroredWnd) MapRectInRTLMirroredWindow(&rc, _ci.hwndParent); else MapWindowPoints(HWND_DESKTOP, _ci.hwndParent, (LPPOINT)&rc, 2); _ResizeChildren(); NewSize(_ci.hwnd, _cy, _ci.style, rc.left, rc.top, RECTWIDTH(rc), RECTHEIGHT(rc)); if (_fResizeNotify) CCSendNotify(&_ci, RBN_HEIGHTCHANGE, NULL); _fResizeNotify = FALSE; _fResizePending = FALSE; } void CReBar::_Resize(BOOL fForceHeightChange) { int cy; StartOver: // lots of the code relies on having cy calculated synchronously with _Resize, // but we're going to delay the actual changing of the window cy = _cy; _Recalc(NULL); if (_fResizing) { _fResizeRecursed = TRUE; return; } _fResizing = TRUE; // true overrides always if (fForceHeightChange || (cy != _cy)) _fResizeNotify = TRUE; if (_fRedraw) { _ResizeNow(); } else { _fResizePending = TRUE; } _fResizing = FALSE; // we do this to avoid infinite loop... _Resize can cause NewSize which causes // a notify in which the parent sizes us, which causes us to loop. // if the parent does any message pumping during the NewSize, we're in a loop if (_fResizeRecursed) { _fResizeRecursed = FALSE; fForceHeightChange = FALSE; goto StartOver; } } void CReBar::_SetRecalc(BOOL fRecalc) { _fRecalc = fRecalc; if (fRecalc) { if (_fRecalcPending) _Recalc(NULL); } } BOOL CReBar::_SetRedraw(BOOL fRedraw) { BOOL fOld = _fRedraw; _fRedraw = fRedraw; if (fRedraw) { // save off _fRefreshPending since this can // get changed by call to _ResizeNow BOOL fRefreshPending = _fRefreshPending; if (_fResizePending) _ResizeNow(); if (fRefreshPending) _InvalidateRect(NULL); } return fOld; } BOOL CReBar::_AfterSetFont() { BOOL fChange = FALSE; UINT i; HFONT hOldFont; HDC hdc = GetDC(_ci.hwnd); if (!hdc) return FALSE; hOldFont = SelectFont(hdc, _hFont); TEXTMETRIC tm; if (_hTheme) { GetThemeTextMetrics(_hTheme, hdc, 0, 0, &tm); } else { GetTextMetrics(hdc, &tm); } if (_cyFont != tm.tmHeight) { _cyFont = tm.tmHeight; fChange = TRUE; } // adjust bands for (i = 0; i < _cBands; i++) { if (_GetBand(i)->fStyle & RBBS_HIDDEN) continue; fChange |= _BandCalcTextExtent(_GetBand(i), hdc); } SelectObject(hdc, hOldFont); ReleaseDC(_ci.hwnd, hdc); if (fChange) { _Resize(FALSE); // invalidate, o.w. title doesn't redraw 1st time after font growth _InvalidateRect(NULL); } return TRUE; } BOOL CReBar::_OnSetFont(HFONT hFont) { if (_fFontCreated) { DeleteObject(_hFont); } _hFont = hFont; _fFontCreated = FALSE; if (!_hFont) _SetFont(0); else return _AfterSetFont(); return TRUE; } // ---------------------------------------------------------------------------- // // _SetFont // // sets the rebar band title font to the current system-wide caption font // // ---------------------------------------------------------------------------- BOOL CReBar::_SetFont(WPARAM wParam) { NONCLIENTMETRICS ncm; HFONT hOldFont; if ((wParam != 0) && (wParam != SPI_SETNONCLIENTMETRICS)) return(FALSE); ncm.cbSize = sizeof(NONCLIENTMETRICS); if (!SystemParametersInfo(SPI_GETNONCLIENTMETRICS, ncm.cbSize, &ncm, 0)) return(FALSE); hOldFont = _hFont; ncm.lfCaptionFont.lfWeight = FW_NORMAL; if (!(_hFont = CreateFontIndirect(&ncm.lfCaptionFont))) { _hFont = hOldFont; return(FALSE); } _fFontCreated = TRUE; if (hOldFont) DeleteObject(hOldFont); return _AfterSetFont(); } // ---------------------------------------------------------------------------- // // Draws a horizontal or vertical dotted line from the given (x,y) location // for the given length (c). (From TReeView's TV_DrawDottedLine) // // ---------------------------------------------------------------------------- void CReBar::_VertMungeGripperRect(LPRECT lprc) { if (_IsVerticalGripper()) { OffsetRect(lprc, -lprc->left + lprc->top, -lprc->top + lprc->left); lprc->bottom -= g_cyEdge; } else { FlipRect(lprc); } } void CReBar::_DrawChevron(PRBB prbb, HDC hdc) { RECT rc; DWORD dwFlags = prbb->wChevState | DCHF_HORIZONTAL | DCHF_TRANSPARENT; CopyRect(&rc, &prbb->rcChevron); int iPart; if (_IsVertical()) { FlipRect(&rc); iPart = RP_CHEVRONVERT; } else { dwFlags |= DCHF_TOPALIGN; iPart = RP_CHEVRON; } DrawChevron(_hTheme, iPart, hdc, &rc, dwFlags); } void CReBar::_UpdateChevronState(PRBB prbb, WORD wControlState) { if (prbb) { // if no change in state, bail if (!(wControlState ^ prbb->wChevState)) return; prbb->wChevState = wControlState; // if active (pushed or hottracked) if (!(wControlState & DCHF_INACTIVE)) { // then we're now the hot band _prbbHot = prbb; } // else if we were the hot band then clear else if (prbb == _prbbHot) { _prbbHot = NULL; } // clear background & repaint _InvalidateRect(&prbb->rcChevron); UpdateWindow(_ci.hwnd); } } // ---------------------------------------------------------------------------- // // _DrawBand // // draws the title icon and title text of the given band into the given DC; // also the band's chevron // // ---------------------------------------------------------------------------- void CReBar::_DrawBand(PRBB prbb, HDC hdc) { COLORREF clrBackSave, clrForeSave; int iModeSave; BOOL fVertical = _IsVertical(); BOOL fDrawHorizontal = (!fVertical || _IsVerticalGripper()); NMCUSTOMDRAW nmcd; LRESULT dwRet; if (prbb->fStyle & RBBS_HIDDEN) { ASSERT(0); return; } clrForeSave = SetTextColor(hdc, _BandGetTextColor(prbb)); clrBackSave = SetBkColor(hdc, _BandGetBkColor(prbb)); if (prbb->hbmBack || _hTheme) iModeSave = SetBkMode(hdc, TRANSPARENT); nmcd.hdc = hdc; nmcd.dwItemSpec = prbb->wID; nmcd.uItemState = 0; nmcd.lItemlParam = prbb->lParam; nmcd.rc.top = prbb->y; nmcd.rc.left = prbb->x; nmcd.rc.bottom = nmcd.rc.top + prbb->cy; nmcd.rc.right = nmcd.rc.left + _GetHeaderWidth(prbb); if (_ci.style & CCS_VERT) { FlipRect(&nmcd.rc); } RECT rcTemp = {0, 0, 0, 0}; HRGN hrgnOld = CreateRectRgnIndirect(&rcTemp); if (GetClipRgn(hdc, hrgnOld) == 0) { DeleteObject(hrgnOld); hrgnOld = NULL; } if (_ci.style & CCS_VERT) { IntersectClipRect(hdc, prbb->y, prbb->x, prbb->y + prbb->cy, prbb->x + prbb->cx); } else { IntersectClipRect(hdc, prbb->x, prbb->y, prbb->x + prbb->cx, prbb->y + prbb->cy); } if (_hTheme) { RECT rcBand = {prbb->x - _mBand.cxLeftWidth, prbb->y - _mBand.cyTopHeight, prbb->x + prbb->cx + _mBand.cxRightWidth, prbb->y + prbb->cy + _mBand.cyBottomHeight}; if (_ci.style & CCS_VERT) { FlipRect(&rcBand); } DrawThemeBackground(_hTheme, hdc, RP_BAND, 0, &rcBand, 0); } dwRet = CICustomDrawNotify(&_ci, CDDS_ITEMPREPAINT, &nmcd); if (!(dwRet & CDRF_SKIPDEFAULT)) { int cy = prbb->cy; int yCenter = prbb->y + (cy / 2); if (_IsVerticalGripper()) { cy = _GetHeaderWidth(prbb); yCenter = prbb->x + (cy / 2); } int xStart = prbb->x; if (_ShouldDrawGripper(prbb)) { RECT rc; if (_hTheme) { int cxGripper = _GetGripperWidth(); int iPart = RP_GRIPPER; SetRect(&rc, xStart, prbb->y, xStart + cxGripper, prbb->y + cy); if (fVertical) { iPart = RP_GRIPPERVERT; _VertMungeGripperRect(&rc); } DrawThemeBackground(_hTheme, hdc, iPart, 0, &rc, 0); xStart += cxGripper; } else { int c; int dy; c = 3 * g_cyBorder; xStart += 2 * g_cxBorder; dy = g_cxEdge; SetRect(&rc, xStart, prbb->y + dy, xStart + c, prbb->y + cy - dy); if (fVertical) { _VertMungeGripperRect(&rc); if (_IsVerticalGripper()) xStart = rc.left; } CCDrawEdge(hdc, &rc, BDR_RAISEDINNER, BF_RECT | BF_MIDDLE, &(_clrsc)); xStart += c; } } xStart += 2 * (fVertical ? g_cyEdge : g_cxEdge); if (prbb->iImage != -1) { int yStart; IMAGELISTDRAWPARAMS imldp = {0}; yStart = yCenter - ((!fDrawHorizontal ? _cxImage : _cyImage) / 2); imldp.cbSize = sizeof(imldp); imldp.himl = _himl; imldp.i = prbb->iImage; imldp.hdcDst = hdc; imldp.x = (!fDrawHorizontal ? yStart : xStart); imldp.y = (!fDrawHorizontal ? xStart : yStart); imldp.rgbBk = CLR_DEFAULT; imldp.rgbFg = CLR_DEFAULT; imldp.fStyle = ILD_TRANSPARENT; imldp.fState = 0; ImageList_DrawIndirect(&imldp); xStart += (fDrawHorizontal ? (_cxImage + g_cxEdge) : (_cyImage + g_cyEdge)); } if (_ShowText(prbb)) { UINT uFormat=0; RECT rcText; HRESULT hr = E_FAIL; rcText.left = fDrawHorizontal ? xStart : yCenter - (prbb->cxText / 2); rcText.top = fDrawHorizontal ? yCenter - (_cyFont / 2) : xStart; if (fDrawHorizontal) rcText.top -= 1; // fudge rcText.right = rcText.left + prbb->cxText; rcText.bottom = rcText.top + _cyFont; // for clients >= v5, we draw text with prefix processing (& underlines next char) if (CCGetUIState(&(_ci)) & UISF_HIDEACCEL) uFormat= DT_HIDEPREFIX; HFONT hFontSave = SelectFont(hdc, _hFont); if (_hTheme) hr = DrawThemeText(_hTheme, hdc, 0, 0, prbb->lpText, lstrlen(prbb->lpText), uFormat, 0, &rcText); if (FAILED(hr)) { DrawText(hdc, prbb->lpText, lstrlen(prbb->lpText), &rcText, uFormat); } SelectObject(hdc, hFontSave); } // maybe draw chevron if (_UseChevron(prbb) && prbb->fChevron) _DrawChevron(prbb, hdc); } if (dwRet & CDRF_NOTIFYPOSTPAINT) CICustomDrawNotify(&_ci, CDDS_ITEMPOSTPAINT, &nmcd); if (prbb->hbmBack || _hTheme) SetBkMode(hdc, iModeSave); SetTextColor(hdc, clrForeSave); SetBkColor(hdc, clrBackSave); SelectClipRgn(hdc, hrgnOld); if (hrgnOld) { DeleteObject(hrgnOld); } } // ---------------------------------------------------------------------------- // // _OnPaint // // processes WM_PAINT message // // ---------------------------------------------------------------------------- void CReBar::_OnPaint(HDC hdcIn) { HDC hdc = hdcIn; PAINTSTRUCT ps; UINT i; NMCUSTOMDRAW nmcd; if (!hdcIn) { hdc = BeginPaint(_ci.hwnd, &ps); } nmcd.hdc = hdc; nmcd.uItemState = 0; nmcd.lItemlParam = 0; nmcd.rc = ps.rcPaint; _ci.dwCustom = CICustomDrawNotify(&_ci, CDDS_PREPAINT, &nmcd); if (!(_ci.dwCustom & CDRF_SKIPDEFAULT)) { for (i = 0; i < _cBands; i++) { if (_GetBand(i)->fStyle & RBBS_HIDDEN) continue; _DrawBand(_GetBand(i), hdc); } } if (_ci.dwCustom & CDRF_NOTIFYPOSTPAINT) CICustomDrawNotify(&_ci, CDDS_POSTPAINT, &nmcd); if (!hdcIn) EndPaint(_ci.hwnd, &ps); } // ---------------------------------------------------------------------------- // // _BandTileBlt // // Fills the given rectangle with the rebar's background bitmap, tiling if // necessary // // ---------------------------------------------------------------------------- void CReBar::_BandTileBlt(PRBB prbb, int x, int y, int cx, int cy, HDC hdcDst, HDC hdcSrc) { int xOff = 0; int yOff = 0; BOOL fxTile, fyTile; int cxPart, cyPart; int iPixelOffset = 0; if (!(prbb->fStyle & RBBS_FIXEDBMP)) { if (_ci.style & CCS_VERT) { xOff = -prbb->y; yOff = -prbb->x; } else { xOff = -prbb->x; yOff = -prbb->y; } } xOff += x; if (xOff >= prbb->cxBmp) xOff %= prbb->cxBmp; yOff += y; if (yOff >= prbb->cyBmp) yOff %= prbb->cyBmp; ReCheck: fxTile = ((xOff + cx) > prbb->cxBmp); fyTile = ((yOff + cy) > prbb->cyBmp); if (!fxTile && !fyTile) { // no tiling needed -- blt and leave BitBlt(hdcDst, x , y, cx, cy, hdcSrc, xOff + iPixelOffset, yOff, SRCCOPY); return; } if (!fxTile) { // vertically tile cyPart = prbb->cyBmp - yOff; BitBlt(hdcDst, x, y, cx, cyPart, hdcSrc, xOff + iPixelOffset, yOff, SRCCOPY); y += cyPart; cy -= cyPart; yOff = 0; goto ReCheck; } if (!fyTile) { // horizontally tile cxPart = prbb->cxBmp - xOff; BitBlt(hdcDst, x, y, cxPart, cy, hdcSrc, xOff + iPixelOffset, yOff, SRCCOPY); x += cxPart; cx -= cxPart; xOff = 0; goto ReCheck; } // tile both ways cyPart = prbb->cyBmp - yOff; _BandTileBlt(prbb, x, y, cx, cyPart, hdcDst, hdcSrc); y += cyPart; cy -= cyPart; yOff = 0; goto ReCheck; } // this is using virtual coordinate space (internal always horizontal) int CReBar::_InternalHitTest(LPRBHITTESTINFO prbht, int x, int y) { BOOL fVert = (_ci.style & CCS_VERT); UINT i; PRBB prbb = _GetBand(0); int cx; RBHITTESTINFO rbht; if (!prbht) prbht = &rbht; for (i = 0; i < _cBands; i++, prbb++) { if (prbb->fStyle & RBBS_HIDDEN) continue; if (x >= prbb->x - _mBand.cxLeftWidth && y >= prbb->y - _mBand.cyTopHeight && x <= prbb->x + prbb->cx + _mBand.cxRightWidth && y <= prbb->y + prbb->cy + _mBand.cyTopHeight) { cx = _GetHeaderWidth(prbb); if (x <= prbb->x + cx + _mBand.cxRightWidth) { prbht->flags = RBHT_CAPTION; if (_IsVerticalGripper()) { if (y - prbb->y < _GetGripperWidth()) prbht->flags = RBHT_GRABBER; } else { cx = _GetGripperWidth() * (fVert ? g_cyBorder : g_cxBorder); if (_ShouldDrawGripper(_GetBand(i)) && (x <= prbb->x + cx + _mBand.cxRightWidth)) { prbht->flags = RBHT_GRABBER; } } } else { POINT pt; pt.x = x; pt.y = y; if (_UseChevron(prbb) && prbb->fChevron && PtInRect(&prbb->rcChevron, pt)) { prbht->flags = RBHT_CHEVRON; } else { prbht->flags = RBHT_CLIENT; } } prbht->iBand = i; return i; } } prbht->flags = RBHT_NOWHERE; prbht->iBand = -1; return -1; } // ---------------------------------------------------------------------------- // // _HitTest // // returns the index to the band that the given point lies in, or -1 if outside // of all bands. Also, sets flags to indicate which part of the band the // point lies in. // // ---------------------------------------------------------------------------- int CReBar::_HitTest(LPRBHITTESTINFO prbht) { BOOL fVert = (_ci.style & CCS_VERT); POINT pt; if (fVert) { pt.x = prbht->pt.y; pt.y = prbht->pt.x; } else pt = prbht->pt; return _InternalHitTest(prbht, pt.x, pt.y); } // ---------------------------------------------------------------------------- // // _EraseBkgnd // // processes WM_ERASEBKGND message by drawing band borders, if necessary, and // filling in the rebar bands with their background color // // ---------------------------------------------------------------------------- BOOL CReBar::_EraseBkgnd(HDC hdc, int iBand) { BOOL fVertical = (_ci.style & CCS_VERT); NMCUSTOMDRAW nmcd; LRESULT dwItemRet; BOOL fBandBorders = _UseBandBorders(); RECT rcClient; HDC hdcMem = NULL; UINT i; PRBB prbb = _GetBand(0); nmcd.hdc = hdc; nmcd.uItemState = 0; nmcd.lItemlParam = 0; _ci.dwCustom = CICustomDrawNotify(&_ci, CDDS_PREERASE, &nmcd); if (!(_ci.dwCustom & CDRF_SKIPDEFAULT)) { COLORREF clrBk; GetClientRect(_ci.hwnd, &rcClient); if (_hTheme) { RECT rcClip; if (GetClipBox(hdc, &rcClip) == NULLREGION) rcClip = rcClient; if (CCShouldAskForBits(&_ci, _hTheme, 0, 0)) CCForwardPrint(&_ci, hdc); DrawThemeBackground(_hTheme, hdc, 0, 0, &rcClient, &rcClip); } else { clrBk = _GetBkColor(); if (clrBk != CLR_NONE) { FillRectClr(hdc, &rcClient, clrBk); } } for (i = 0; i < _cBands; i++, prbb++) { if (prbb->fStyle & RBBS_HIDDEN) continue; if (fVertical) SetRect(&nmcd.rc, prbb->y, prbb->x, prbb->y + prbb->cy, prbb->x + prbb->cx); else SetRect(&nmcd.rc, prbb->x, prbb->y, prbb->x + prbb->cx, prbb->y + prbb->cy); if (fBandBorders) { if (prbb->x != _mBand.cxLeftWidth) { // draw etch between bands on same row if (fVertical) { nmcd.rc.right += g_cxEdge / 2; nmcd.rc.top -= g_cyEdge; CCThemeDrawEdge(_hTheme, hdc, &nmcd.rc, RP_BAND, 0, EDGE_ETCHED, BF_TOP, &(_clrsc)); nmcd.rc.right -= g_cxEdge / 2; nmcd.rc.top += g_cyEdge; } else { nmcd.rc.bottom += g_cyEdge / 2; nmcd.rc.left -= g_cxEdge; CCThemeDrawEdge(_hTheme, hdc, &nmcd.rc, RP_BAND, 0, EDGE_ETCHED, BF_LEFT, &(_clrsc)); nmcd.rc.bottom -= g_cyEdge / 2; nmcd.rc.left += g_cxEdge; } } else { // draw etch between rows if (fVertical) { rcClient.right = prbb->y + prbb->cy + g_cxEdge; CCThemeDrawEdge(_hTheme, hdc, &rcClient, RP_BAND, 0, EDGE_ETCHED, BF_RIGHT, &(_clrsc)); } else { rcClient.bottom = prbb->y + prbb->cy + g_cyEdge; CCThemeDrawEdge(_hTheme, hdc, &rcClient, RP_BAND, 0, EDGE_ETCHED, BF_BOTTOM, &(_clrsc)); } } } nmcd.dwItemSpec = prbb->wID; nmcd.uItemState = 0; dwItemRet = CICustomDrawNotify(&_ci, CDDS_ITEMPREERASE, &nmcd); if (!(dwItemRet & CDRF_SKIPDEFAULT)) { if (prbb->hbmBack) { if (!hdcMem) { hdcMem = CreateCompatibleDC(hdc); if (!hdcMem) continue; _Realize(hdc, TRUE, FALSE); } SelectObject(hdcMem, prbb->hbmBack); _BandTileBlt(prbb, nmcd.rc.left, nmcd.rc.top, nmcd.rc.right - nmcd.rc.left, nmcd.rc.bottom - nmcd.rc.top, hdc, hdcMem); } else if (_hTheme) { DrawThemeBackground(_hTheme, hdc, RP_BAND, 0, &nmcd.rc, 0); } else { // if the color for this band is the same as the // rebar's default background color, then we // don't need to paint this specially COLORREF clr = _BandGetBkColor(prbb); if (clr != _GetBkColor()) { FillRectClr(hdc, &nmcd.rc, clr); } } } if (dwItemRet & CDRF_NOTIFYPOSTERASE) CICustomDrawNotify(&_ci, CDDS_ITEMPOSTERASE, &nmcd); } if (hdcMem) { DeleteDC(hdcMem); } } if (_ci.dwCustom & CDRF_NOTIFYPOSTERASE) { nmcd.uItemState = 0; nmcd.dwItemSpec = 0; nmcd.lItemlParam = 0; CICustomDrawNotify(&_ci, CDDS_POSTERASE, &nmcd); } return(TRUE); } // ---------------------------------------------------------------------------- // // _GetBarInfo // // retrieves the indicated values from the rebar's internal structure // // ---------------------------------------------------------------------------- BOOL CReBar::_GetBarInfo(LPREBARINFO lprbi) { if (lprbi->cbSize != sizeof(REBARINFO)) return(FALSE); if (lprbi->fMask & RBIM_IMAGELIST) lprbi->himl = _himl; return(TRUE); } // ---------------------------------------------------------------------------- // // _SetBarInfo // // sets the indicated values in the rebar's internal structure, recalculating // and refreshing as needed // // ---------------------------------------------------------------------------- BOOL CReBar::_SetBarInfo(LPREBARINFO lprbi) { if (lprbi->cbSize != sizeof(REBARINFO)) return(FALSE); if (lprbi->fMask & RBIM_IMAGELIST) { HIMAGELIST himl = _himl; int cxOld, cyOld; //todo:validate lprbi->himl _himl = lprbi->himl; cxOld = _cxImage; cyOld = _cyImage; ImageList_GetIconSize(_himl, (LPINT)&_cxImage, (LPINT)&_cyImage); if ((_cxImage != cxOld) || (_cyImage != cyOld)) { UINT i; for (i = 0; i < _cBands; i++) { if (_GetBand(i)->fStyle & RBBS_HIDDEN) continue; _BandCalcMinWidth(_GetBand(i)); } _Resize(FALSE); } else _InvalidateRect(NULL); lprbi->himl = himl; } return(TRUE); } // ---------------------------------------------------------------------------- // // _GetBandInfo // // retrieves the indicated values from the specified band's internal structure // // ---------------------------------------------------------------------------- BOOL CReBar::_GetBandInfo(UINT uBand, LPREBARBANDINFO lprbbi) { PRBB prbb; if (!_IsValidIndex(uBand) || lprbbi->cbSize > SIZEOF(REBARBANDINFO)) return(FALSE); prbb = _GetBand(uBand); if (lprbbi->fMask & RBBIM_SIZE) { if (prbb->fStyle & RBBS_FIXEDSIZE) lprbbi->cx = prbb->cx; else lprbbi->cx = prbb->cxRequest; } if (lprbbi->fMask & RBBIM_STYLE) lprbbi->fStyle = prbb->fStyle; if (lprbbi->fMask & RBBIM_COLORS) { lprbbi->clrFore = _BandGetTextColorExternal(prbb); lprbbi->clrBack = _BandGetBkColorExternal(prbb); } if (lprbbi->fMask & RBBIM_TEXT) { UINT cch = prbb->lpText ? lstrlen(prbb->lpText) : 0; if (!lprbbi->cch || !lprbbi->lpText || (lprbbi->cch <= cch)) lprbbi->cch = cch + 1; else if (prbb->lpText) lstrcpy(lprbbi->lpText, prbb->lpText); else // no text -- so just make it an empty string lprbbi->lpText[0] = 0; } if (lprbbi->fMask & RBBIM_IMAGE) lprbbi->iImage = prbb->iImage; if (lprbbi->fMask & RBBIM_CHILD) lprbbi->hwndChild = prbb->hwndChild; if (lprbbi->fMask & RBBIM_CHILDSIZE) { // HACKHACK: (tjgreen) Subtract the offset we added in SetBandInfo (see // comments there). lprbbi->cxMinChild = prbb->cxMinChild ? prbb->cxMinChild - CX_OFFSET : 0; lprbbi->cyMinChild = prbb->cyMinChild; } if (lprbbi->fMask & RBBIM_BACKGROUND) lprbbi->hbmBack = prbb->hbmBack; if (lprbbi->fMask & RBBIM_ID) lprbbi->wID = prbb->wID; if (lprbbi->cbSize > REBARBANDINFO_V3_SIZE) { if ((lprbbi->fMask & RBBIM_CHILDSIZE) && (prbb->fStyle & RBBS_VARIABLEHEIGHT)) { lprbbi->cyIntegral = prbb->cyIntegral; lprbbi->cyMaxChild = prbb->cyMaxChild; lprbbi->cyChild = prbb->cyChild; } if (lprbbi->fMask & RBBIM_HEADERSIZE) lprbbi->cxHeader = _GetHeaderWidth(prbb); if (lprbbi->fMask & RBBIM_IDEALSIZE) // HACKHACK: (tjgreen) Subtract the offset we added in SetBandInfo (see // comments there). lprbbi->cxIdeal = prbb->cxIdeal ? prbb->cxIdeal - CX_OFFSET : 0; if (lprbbi->fMask & RBBIM_LPARAM) lprbbi->lParam = prbb->lParam; } return(TRUE); } BOOL CReBar::_ValidateBandInfo(LPREBARBANDINFO *pprbbi, LPREBARBANDINFO prbbi) { BOOL fRet = ((*pprbbi)->cbSize == sizeof(REBARBANDINFO)); if (!fRet) { if ((*pprbbi)->cbSize < SIZEOF(REBARBANDINFO)) { hmemcpy(prbbi, (*pprbbi), (*pprbbi)->cbSize); (*pprbbi) = prbbi; prbbi->cbSize = SIZEOF(REBARBANDINFO); fRet = TRUE; } } return fRet; } // ---------------------------------------------------------------------------- // // _SetBandInfo // // sets the indicated values in the specified band's internal structure, // recalculating and refreshing as needed // // ---------------------------------------------------------------------------- BOOL CReBar::_SetBandInfo(UINT uBand, LPREBARBANDINFO lprbbi, BOOL fAllowRecalc) { PRBB prbb; BOOL fRefresh = FALSE; BOOL fRecalc = FALSE; BOOL fRecalcMin = FALSE; BOOL fTextChanged = FALSE; REBARBANDINFO rbbi = {0}; RECT rc; if (!_IsValidIndex(uBand) || !_ValidateBandInfo(&lprbbi, &rbbi)) return(FALSE); prbb = _GetBand(uBand); if (lprbbi->fMask & RBBIM_TEXT) { if (!lprbbi->lpText || !prbb->lpText || lstrcmp(lprbbi->lpText, prbb->lpText)) { if (lprbbi->lpText != prbb->lpText) { Str_Set(&prbb->lpText, lprbbi->lpText); fTextChanged = TRUE; } } } if (lprbbi->fMask & RBBIM_STYLE) { UINT fStylePrev = prbb->fStyle; UINT fChanged = lprbbi->fStyle ^ fStylePrev; prbb->fStyle = lprbbi->fStyle; if (fChanged) fRecalc = TRUE; if ((prbb->fStyle & RBBS_FIXEDSIZE) && !(fStylePrev & RBBS_FIXEDSIZE)) prbb->cxMin = prbb->cx; else if (fChanged & RBBS_FIXEDSIZE) fRecalcMin = TRUE; if (fChanged & RBBS_GRIPPERALWAYS) fRecalcMin = TRUE; if (fChanged & RBBS_HIDDEN) _ShowBand(uBand, !(prbb->fStyle & RBBS_HIDDEN)); if (fChanged & RBBS_HIDETITLE) fTextChanged = TRUE; // can't have both of these if (prbb->fStyle & RBBS_FIXEDSIZE) prbb->fStyle &= ~RBBS_BREAK; } // RBBIM_TEXT does calculations that want to take some RBBIM_STYLE bits // into account, so delay those calculations until we grab the style bits. // if (fTextChanged && !(prbb->fStyle & RBBS_HIDDEN)) { if (_BandCalcTextExtent(prbb, NULL)) fRecalc = TRUE; else fRefresh = TRUE; } if (lprbbi->fMask & RBBIM_IDEALSIZE) { // HACKHACK: (tjgreen) Add an offset to the width the caller specifies. // This offset gets clipped off in _ResizeChildren, so the child window is // rendered with the width specified by caller, and we get a little space on // the toolbar after the buttons. If caller specifies zero-width, though, // we don't want this extra space, so don't add offset. int cxIdeal = lprbbi->cxIdeal ? lprbbi->cxIdeal + CX_OFFSET : 0; if (cxIdeal != prbb->cxIdeal) { prbb->cxIdeal = cxIdeal; fRecalcMin = TRUE; fRecalc = TRUE; } } if (lprbbi->fMask & RBBIM_SIZE) { if (prbb->cxRequest != (int)lprbbi->cx) { fRecalc = TRUE; prbb->cxRequest = lprbbi->cx; } if (prbb->fStyle & RBBS_FIXEDSIZE) prbb->cxMin = prbb->cxRequest; } if (lprbbi->fMask & RBBIM_HEADERSIZE) { if ((lprbbi->cxHeader == -1) || !(prbb->fStyle & RBBS_FIXEDHEADERSIZE) || (prbb->cxMin != (int)lprbbi->cxHeader + prbb->cxMinChild)) { if (lprbbi->cxHeader == -1) { prbb->fStyle &= ~RBBS_FIXEDHEADERSIZE; fRecalcMin = TRUE; } else { prbb->fStyle |= RBBS_FIXEDHEADERSIZE; prbb->cxMin = lprbbi->cxHeader + prbb->cxMinChild; } fRecalc = TRUE; fRefresh = TRUE; } } if (lprbbi->fMask & RBBIM_COLORS) { prbb->clrFore = lprbbi->clrFore; prbb->clrBack = lprbbi->clrBack; fRefresh = TRUE; } if ((lprbbi->fMask & RBBIM_IMAGE) && (prbb->iImage != lprbbi->iImage)) { BOOL fToggleBmp = ((prbb->iImage == -1) || (lprbbi->iImage == -1)); prbb->iImage = lprbbi->iImage; if (fToggleBmp) { fRecalc = TRUE; fRecalcMin = TRUE; } else fRefresh = TRUE; } if (lprbbi->fMask & RBBIM_CHILD && lprbbi->hwndChild != prbb->hwndChild && (NULL == lprbbi->hwndChild || !IsChild(lprbbi->hwndChild, _ci.hwnd))) { if (IsWindow(prbb->hwndChild)) ShowWindow(prbb->hwndChild, SW_HIDE); prbb->hwndChild = lprbbi->hwndChild; if (prbb->hwndChild) { SetParent(prbb->hwndChild, _ci.hwnd); ShowWindow(prbb->hwndChild, SW_SHOW); } fRecalc = TRUE; } if (lprbbi->fMask & RBBIM_CHILDSIZE) { int cyChildOld = prbb->cyChild; if (lprbbi->cyMinChild != -1) prbb->cyMinChild = lprbbi->cyMinChild; if (prbb->fStyle & RBBS_VARIABLEHEIGHT) { BOOL fIntegralLarger = FALSE; if (lprbbi->cyIntegral != -1) { fIntegralLarger = ((int)lprbbi->cyIntegral > prbb->cyIntegral); prbb->cyIntegral = lprbbi->cyIntegral; } if (lprbbi->cyMaxChild != -1) prbb->cyMaxChild = lprbbi->cyMaxChild; if (lprbbi->cyChild != -1) prbb->cyChild = lprbbi->cyChild; if (prbb->cyChild < prbb->cyMinChild) prbb->cyChild = prbb->cyMinChild; if (prbb->cyChild > prbb->cyMaxChild) prbb->cyChild = prbb->cyMaxChild; // validate the child size. cyChild must be cyMinChild plux n*cyIntegral if (prbb->cyIntegral) { int iExtra; iExtra = (prbb->cyChild - prbb->cyMinChild) % prbb->cyIntegral; // Don't change cyChild if it is already an valid integral height if (iExtra) { if (fIntegralLarger) { // Round up prbb->cyChild += (prbb->cyIntegral - iExtra); } else { // Round down prbb->cyChild -= iExtra; } } } } else { // if we're not in variable height mode, then // the cyChild is the same as cyMinChild. // this is a little peculiar, but done this way for backcompat. // cyMinChild came before cyChild prbb->cyChild = lprbbi->cyMinChild; } if (lprbbi->cxMinChild != -1) { // HACKHACK: (tjgreen) Add an offset to the width the caller specifies. // This offset gets clipped off in _ResizeChildren, so the child window is // rendered with the width specified by caller, and we get a little space on // the toolbar after the buttons. However, if caller specifies zero-width or // if the band is fixed size, we don't want this extra space, so don't add offset. int cxMinChild = lprbbi->cxMinChild; if ((lprbbi->cxMinChild != 0) && !(prbb->fStyle & RBBS_FIXEDSIZE)) cxMinChild += CX_OFFSET; if (prbb->cxMinChild != cxMinChild) { int cxOldHeaderMin = _GetHeaderWidth(prbb); if (prbb->fStyle & RBBS_FIXEDSIZE) fRecalc = TRUE; prbb->cxMinChild = cxMinChild; if (prbb->fStyle & RBBS_FIXEDHEADERSIZE) prbb->cxMin = cxOldHeaderMin + prbb->cxMinChild; fRecalcMin = TRUE; } if (cyChildOld != prbb->cyChild) { // TODO: revisit optimization: // if (_BandGetHeight(prbb) != prbb->cy) fRecalc = TRUE; } } } if (lprbbi->fMask & RBBIM_BACKGROUND) { DIBSECTION dib; if (lprbbi->hbmBack && !GetObject(lprbbi->hbmBack, sizeof(DIBSECTION), &dib)) return(FALSE); prbb->hbmBack = lprbbi->hbmBack; prbb->cxBmp = dib.dsBm.bmWidth; prbb->cyBmp = dib.dsBm.bmHeight; fRefresh = TRUE; } if (lprbbi->fMask & RBBIM_ID) prbb->wID = lprbbi->wID; if (lprbbi->fMask & RBBIM_LPARAM) prbb->lParam = lprbbi->lParam; if (fRecalcMin && !(prbb->fStyle & RBBS_HIDDEN)) _BandCalcMinWidth(prbb); if (fAllowRecalc) { if (fRecalc) _Resize(FALSE); if (fRefresh || fRecalc) { // '|| fRecalc' so we catch add/grow of text. // testcase: remove title from band; add back; make sure the text // shows up (used to just leave old band contents there) SetRect(&rc, prbb->x, prbb->y, prbb->x + prbb->cx, prbb->y + prbb->cy); _InvalidateRect(&rc); } } return(TRUE); } // ---------------------------------------------------------------------------- // // _ReallocBands // // reallocates the array of bands pointed to by _rbbList to the given // number of bands // // ---------------------------------------------------------------------------- BOOL CReBar::_ReallocBands(UINT cBands) { PRBB rbbList; if (!(rbbList = (PRBB) CCLocalReAlloc(_rbbList, sizeof(RBB) * cBands)) && cBands) return(FALSE); _rbbList = rbbList; return(TRUE); } // // NOTES // for now caller does this in two calls (query, set). eventually we // should be able to have it do everything up front. BOOL CReBar::_RecalcFirst(int nCmd, PRBB prbbDelHide) { switch (nCmd) { case RBC_QUERY: { BOOL fRecalcFirst; // if we're nuking the 1st visible guy, // and there are visible guys after us, // then we need to recompute stuff // // for a testcase, start w/: // row1: 'standard buttons' + 'brand' // row2: 'address' + 'links' // now hide 'standard buttons', you should end up w/: // row1: 'address' + 'links' + 'brand' // if there's a bug, you'll end up w/ (since the break isn't recomputed): // row1: 'brand' // row2: 'address' + 'links' // fRecalcFirst = (!uBand && _cBands); // if brbbDelHide is the first non-hidden band, and there are other non-hidden bands after it, fRecalcFirst = TRUE; fRecalcFirst = (_EnumBand(0, RBBS_HIDDEN) == prbbDelHide) && _GetNextVisible(prbbDelHide); return fRecalcFirst; } case RBC_SET: // set { PRBB prbb1 = _EnumBand(0, RBBS_HIDDEN); if (_IsValidBand(prbb1) && (prbb1->fStyle & RBBS_FIXEDSIZE)) { PRBB prbb2 = _EnumBand(1, RBBS_HIDDEN); if (_IsValidBand(prbb2)) { // get rid of line break on NEW first item prbb2->fStyle &= ~RBBS_BREAK; } if (_ci.style & RBS_FIXEDORDER) { // this is because the min width is now based on it's movability -- // and since we are deleting (or hiding) the first item, // the new first item becomes immovable _BandCalcMinWidth(prbb1); } } return TRUE; } default: ASSERT(0); } return FALSE; } // ---------------------------------------------------------------------------- // // _ShowBand // // updates show/hide state for the indicated band in the rebar's band array // (rbbList). // // ---------------------------------------------------------------------------- BOOL CReBar::_ShowBand(UINT uBand, BOOL fShow) { PRBB prbb; BOOL fRecalcFirst; if (!_IsValidIndex(uBand)) return(FALSE); prbb = _GetBand(uBand); // if we're nuking the 1st visible guy, // then we need to recompute stuff fRecalcFirst = _RecalcFirst(RBC_QUERY, prbb); if (fShow) { prbb->fStyle &= ~RBBS_HIDDEN; if (!_BandCalcTextExtent(prbb, NULL)) _BandCalcMinWidth(prbb); if (prbb->hwndChild) ShowWindow(prbb->hwndChild, SW_SHOW); } else { prbb->fStyle |= RBBS_HIDDEN; if (prbb->hwndChild) ShowWindow(prbb->hwndChild, SW_HIDE); } if (fRecalcFirst) _RecalcFirst(RBC_SET, NULL); _InvalidateRect(NULL); // Since _Resize is followed by _AutoSize, // redraw must be TRUE for _Resize to do anything. BOOL fRedrawOld = _SetRedraw(TRUE); _Resize(FALSE); _AutoSize(); _SetRedraw(fRedrawOld); return(TRUE); } // ---------------------------------------------------------------------------- // // _DeleteBand // // deletes the indicated band from the rebar's band array (rbbList) and // decrements the rebar's band count (cBands) // // ---------------------------------------------------------------------------- BOOL CReBar::_DeleteBand(UINT uBand) { PRBB prbb; PRBB prbbStop; BOOL fRecalcFirst; NMREBAR nm = {0}; // we need to clean up // // a) captured band and // b) hottracked band // // before we delete this band if (_uCapture != -1) { _SendNotify(_uCapture, RBN_ENDDRAG); _OnBeginDrag((UINT)-1); } if (!_IsValidIndex(uBand)) return FALSE; prbb = _GetBand(uBand); // Notify the client of the delete _SendNotify(uBand, RBN_DELETINGBAND); nm.dwMask = RBNM_ID; nm.wID = _GetBand(uBand)->wID; // Save this Str_Set(&prbb->lpText, NULL); // don't destroy the hbmBack 'cause it's given to us by app // if we're nuking the 1st visible guy, // then we need to recompute stuff // if this is the first visible guy and there are other visible bands after it, fRecalcFirst = TRUE fRecalcFirst = _RecalcFirst(RBC_QUERY, prbb); if (IsWindow(prbb->hwndChild)) ShowWindow(prbb->hwndChild, SW_HIDE); // prbbStop gets the address of the last band prbbStop = _GetLastBand(); for ( ; prbb < prbbStop; prbb++) *prbb = *(prbb + 1); _cBands--; if (_uResizeNext >= uBand && _uResizeNext > 0) { // (defer RBBS_HIDDEN stuff to use of uResizeNext) _uResizeNext--; } // Notify the client of the delete CCSendNotify(&_ci, RBN_DELETEDBAND, &nm.hdr); if (fRecalcFirst) _RecalcFirst(RBC_SET, NULL); _ReallocBands(_cBands); _InvalidateRect(NULL); _Resize(FALSE); _AutoSize(); return(TRUE); } // ---------------------------------------------------------------------------- // // _InsertBand // // inserts a new band at the given position in the rebar's band array (rbbList), // increments the rebar's band count (cBands), and sets the band's structure // based on the given REBARBANDINFO structure. // // ---------------------------------------------------------------------------- BOOL CReBar::_InsertBand(UINT uBand, LPREBARBANDINFO lprbbi) { PRBB prbb; REBARBANDINFO rbbi = {0}; if (!_ValidateBandInfo(&lprbbi, &rbbi)) return(FALSE); if (uBand == -1) uBand = _cBands; else if (uBand > _cBands) return(FALSE); if (!_ReallocBands(_cBands + 1)) return(FALSE); ++_cBands; MoveMemory(_GetBand(uBand + 1), _GetBand(uBand), (_cBands-1-uBand) * sizeof(_rbbList[0])); prbb = _GetBand(uBand); // movememory does not zero init for us... ZeroMemory(prbb, SIZEOF(RBB)); // Init text color if (_clrText == CLR_NONE) { // Default to system text color prbb->clrFore = CLR_DEFAULT; } else { // Default to rebar's custom text color prbb->clrFore = CLR_NONE; } // Init background color if (_clrBk == CLR_NONE) { // Default to system background color prbb->clrBack = CLR_DEFAULT; } else { // Default to rebar's custom background color prbb->clrBack = CLR_NONE; } prbb->iImage = -1; prbb->cyMaxChild = MAXINT; prbb->wChevState = DCHF_INACTIVE; ASSERT(prbb->fStyle == 0); ASSERT(prbb->lpText == NULL); ASSERT(prbb->cxText == 0); ASSERT(prbb->hwndChild == NULL); ASSERT(prbb->cxMinChild == 0); ASSERT(prbb->cyMinChild == 0); ASSERT(prbb->hbmBack == 0); ASSERT(prbb->x == 0); ASSERT(prbb->y == 0); ASSERT(prbb->cx == 0); ASSERT(prbb->cy == 0); if (!_SetBandInfo(uBand, lprbbi, FALSE)) { _DeleteBand(uBand); return(FALSE); } if (!(prbb->fStyle & RBBS_HIDDEN)) { PRBB prbbFirst = _EnumBand(0, RBBS_HIDDEN); if (!prbb->cxMin) _BandCalcMinWidth(prbb); if (prbbFirst != prbb) { int cxMin = prbbFirst->cxMin; _BandCalcMinWidth(prbbFirst); } _Resize(FALSE); } _SizeBandToRowHeight(uBand, -1); if (_CountBands(RBBS_HIDDEN) == 1) { // typcially, when you insert a band, we put it in a row with another band. // thus the total bounding rect doesn't change. however, on the addition of the first band, // the bound rect does change, so we need to autosize as necessary. _AutoSize(); } return(TRUE); } BOOL InitReBarClass(HINSTANCE hInstance) { WNDCLASS wc; wc.lpfnWndProc = CReBar::s_WndProc; wc.lpszClassName= c_szReBarClass; wc.style = CS_GLOBALCLASS | CS_DBLCLKS; wc.cbClsExtra = 0; wc.cbWndExtra = sizeof(CReBar*); wc.hInstance = hInstance; // use DLL instance if in DLL wc.hIcon = NULL; wc.hCursor = NULL; wc.hbrBackground= (HBRUSH)(COLOR_BTNFACE + 1); wc.lpszMenuName = NULL; if (!RegisterClass(&wc) && !GetClassInfo(hInstance, c_szReBarClass, &wc)) return FALSE; return(TRUE); } // get the first band in the same row as rbbRow // n.b. we may return an RBBS_HIDDEN band! PRBB CReBar::_GetFirstInRow(PRBB prbbRow) { // n.b. we don't pay attention to hidden here, that's up to caller. // in fact we *can't*, since there might be no non-hidden guys left // (e.g. when _OnDestroy is deleting all the bands), in which case // we'd loop forever. while (prbbRow > _GetBand(0) && !_IsBandStartOfRow(prbbRow)) { _ValidateRangePtr(prbbRow); prbbRow--; } return prbbRow; } // get the last band in the same row as rbbRow. // fStopAtFixed says whether to continue over fixed bands or // stop at them // n.b. we may return an RBBS_HIDDEN band! PRBB CReBar::_GetLastInRow(PRBB prbbRow, BOOL fStopAtFixed) { do { prbbRow++; } while (prbbRow <= _GetLastBand() && !_IsBandStartOfRow(prbbRow) && (!fStopAtFixed || (prbbRow->fStyle & (RBBS_FIXEDSIZE|RBBS_HIDDEN)) == RBBS_FIXEDSIZE)); // loop steps to the start of the NEXT line prbbRow--; return prbbRow; } //*** _GetPrev, _GetNext -- get prev (next) band, skipping guys // of style uStyleSkip (e.g. RBBS_HIDDEN) PRBB CReBar::_GetPrev(PRBB prbb, UINT uStyleSkip) { while (--prbb >= _GetBand(0)) { if (prbb->fStyle & uStyleSkip) continue; return prbb; } return NULL; } PRBB CReBar::_GetNext(PRBB prbb, UINT uStyleSkip) { while (++prbb <= _GetLastBand()) { if (prbb->fStyle & uStyleSkip) continue; return prbb; } return NULL; } //*** _CountBands -- get count of bands, skipping guys // of style uStyleSkip (e.g. RBBS_HIDDEN) int CReBar::_CountBands(UINT uStyleSkip) { int i; PRBB prbb; if (_cBands == 0) return 0; i = 0; for (prbb = _GetBand(0); prbb <= _GetLastBand(); prbb++) { if (prbb->fStyle & uStyleSkip) continue; i++; } return i; } //*** _EnumBand -- get Nth band, skipping guys // of style uStyleSkip (e.g. RBBS_HIDDEN) // 'skipping' means don't include in count PRBB CReBar::_EnumBand(int i, UINT uStyleSkip) { PRBB prbb; for (prbb = _GetBand(0); prbb <= _GetLastBand(); prbb++) { if (prbb->fStyle & uStyleSkip) continue; if (i-- == 0) break; } // if we found it, this is the band; // if we ran out of bands, this is 1 past the end return prbb; } // returns the minimum x position prbb can be int CReBar::_MinX(PRBB prbb) { int xLimit = 0; ASSERT(!(prbb->fStyle & RBBS_HIDDEN)); // o.w. might loop forever while (!_IsBandStartOfRow(prbb)) { prbb--; if (!(prbb->fStyle & RBBS_HIDDEN)) xLimit += _FudgeWidth(prbb->cxMin); } return xLimit + _mBand.cxLeftWidth; } int CReBar::_MaxX(PRBB prbb) { int xLimit = 0; if (prbb) { PRBB prbbLast = _rbbList + _cBands; PRBB prbbWalk; for (prbbWalk = prbb; prbbWalk < prbbLast; prbbWalk++) { if (prbbWalk->fStyle & RBBS_HIDDEN) continue; if (_IsBandStartOfRow(prbbWalk)) break; if (prbbWalk != prbb) xLimit += _FudgeWidth(prbbWalk->cxMin); else xLimit += prbbWalk->cxMin; } prbbWalk = _GetPrevVisible(prbbWalk); // prbbWalk--; if (prbbWalk) xLimit = prbbWalk->x + prbbWalk->cx - xLimit; } return xLimit; } BOOL CReBar::_MinimizeBand(UINT uBand, BOOL fAnim) { PRBB prbb; if (!_IsValidIndex(uBand)) return FALSE; prbb = _GetBand(uBand); if (prbb->fStyle & RBBS_FIXEDSIZE) return FALSE; ASSERT(!(prbb->fStyle & RBBS_HIDDEN)); if (_IsBandStartOfRow(prbb)) { // if it's the start of a row, the way to minimize it is to maximize the next guy // if it's on the same row prbb = _GetNextVisible(prbb); if (!prbb || _IsBandStartOfRow(prbb)) return FALSE; return _MaximizeBand(_BandToIndex(prbb), FALSE, fAnim); } if (fAnim) return _SetBandPosAnim(prbb, prbb->x + (prbb->cx - prbb->cxMin)); else return _SetBandPos(prbb, prbb->x + (prbb->cx - prbb->cxMin)); } // fIdeal - FALSE == full maximization... // TRUE == go to cxIdeal // fAnim - TRUE means we were called due to UI action (via _ToggleBand), so animate BOOL CReBar::_MaximizeBand(UINT uBand, BOOL fIdeal, BOOL fAnim) { int x, dx; BOOL fChanged = FALSE; PRBB prbbMaximize; if (!_IsValidIndex(uBand)) return FALSE; prbbMaximize = _GetBand(uBand); if (prbbMaximize->fStyle & RBBS_FIXEDSIZE) return FALSE; dx = prbbMaximize->cxIdeal + _GetHeaderWidth(prbbMaximize) - prbbMaximize->cx; if (fIdeal && dx > 0) { PRBB prbb; // first move the next guy over if possible. prbb = _GetNextVisible(prbbMaximize); if (prbb && (!_IsBandStartOfRow(prbb))) { int dxRbb; x = _MaxX(prbb); // dxRbb is the maximum that prbb can move dxRbb = x - prbb->x; if (dxRbb > dx) { // if that's more than enough space, then limit dx dxRbb = dx; } x = prbb->x + dxRbb; fChanged |= (fAnim)?_SetBandPosAnim(prbb, x):_SetBandPos(prbb,x); dx -= dxRbb; } if (dx) { int dxRbb; // the one on the right didn't move enough. // now move us back x = _MinX(prbbMaximize); dxRbb = prbbMaximize->x - x; if (dxRbb > dx) { x = prbbMaximize->x - dx; } fChanged |= (fAnim)?_SetBandPosAnim(prbbMaximize, x):_SetBandPos(prbbMaximize, x); } } else { x = _MinX(prbbMaximize); fChanged |= (fAnim)?_SetBandPosAnim(prbbMaximize, x):_SetBandPos(prbbMaximize, x); prbbMaximize = _GetNextVisible(prbbMaximize); if (prbbMaximize && !_IsBandStartOfRow(prbbMaximize)) { x = _MaxX(prbbMaximize); fChanged |= (fAnim)?_SetBandPosAnim(prbbMaximize, x):_SetBandPos(prbbMaximize, x); } } return fChanged; } // ---------------------------------------------------------------------------- // // _ToggleBand // // switches a band between it's maximized and minimized state, based on where // the user clicked // // ---------------------------------------------------------------------------- void CReBar::_ToggleBand(BOOL fAnim) { BOOL fDidSomething = FALSE; // try to maximize this band. if failed (meaning already maximize) // then minimize if (CCSendNotify(&_ci, RBN_MINMAX, NULL)) return; fDidSomething = _MaximizeBand(_uCapture, TRUE,fAnim); if (!fDidSomething) fDidSomething = _MinimizeBand(_uCapture,fAnim); if (fDidSomething) CCPlaySound(TEXT("ShowBand")); } // ---------------------------------------------------------------------------- // // _SetCursor // // sets the cursor to either the move cursor or the arrow cursor, depending // on whether or not the cursor is on a band's caption // // ---------------------------------------------------------------------------- void CReBar::_SetCursor(int x, int y, BOOL fMouseDown) { int iBand; RBHITTESTINFO rbht; rbht.pt.x = x; rbht.pt.y = y; iBand = _HitTest(&rbht); if (rbht.flags == RBHT_GRABBER) { if (fMouseDown) SetCursor(LoadCursor(HINST_THISDLL, (_ci.style & CCS_VERT) ? MAKEINTRESOURCE(IDC_DIVOPENV) : MAKEINTRESOURCE(IDC_DIVOPEN) )); else SetCursor(LoadCursor(NULL, (_ci.style & CCS_VERT) ? IDC_SIZENS : IDC_SIZEWE)); return; } if ((fMouseDown) && ((rbht.flags == RBHT_GRABBER) || (rbht.flags == RBHT_CAPTION) && _ShouldDrawGripper(_GetBand(iBand)))) { // No longer IE3 compatible, per RichSt SetCursor(LoadCursor(NULL, IDC_SIZEALL)); return; } SetCursor(LoadCursor(NULL, IDC_ARROW)); } // adjust's a band's (prbb) starting location to the given location BOOL CReBar::_SetBandPos(PRBB prbb, int xLeft) { RECT rc; PRBB prbbPrev; int xRight; BOOL fBandBorders = _UseBandBorders(); BOOL fRight; if (!prbb) return (FALSE); ASSERT(!(prbb->fStyle & RBBS_HIDDEN)); ASSERT((xLeft >= 0)); // We've got problems if someone is trying to set us negative if (prbb->x == xLeft) return(FALSE); prbbPrev = _GetPrevVisible(prbb); // band has moved within valid range -- adjust band sizes and redraw // window fRight = (prbb->x < xLeft); SetRect(&rc, prbb->x - _mBand.cxLeftWidth, prbb->y- _mBand.cyTopHeight, prbb->x + prbb->cxMin + _mBand.cxRightWidth, prbb->y + prbb->cy + _mBand.cyBottomHeight); xRight = prbb->x + prbb->cx; prbb->x = xLeft; prbb->cx = xRight - xLeft; prbb->cxRequest = prbb->cx; if (fRight) { if (prbbPrev) { //moving right prbbPrev->cx = prbb->x - _mBand.cxRightWidth - prbbPrev->x - _mBand.cxLeftWidth; if (fBandBorders) { prbbPrev->cx -= g_cxEdge; rc.left -= g_cxEdge; } rc.left = rc.left - _mBand.cxRightWidth; prbbPrev->cxRequest = prbbPrev->cx; //check for compacting of following bands while (prbb && prbb->cx < prbb->cxMin) { prbb->cx = prbb->cxMin; prbb->cxRequest = prbb->cx; xLeft += _BandWidth(prbb); prbb = _GetNextVisible(prbb); // prbb++; if (prbb) { xRight = prbb->x + prbb->cx; prbb->x = xLeft; prbb->cx = xRight - xLeft; prbb->cxRequest = prbb->cx; } } if (prbb) rc.right = xLeft + prbb->cxMin + _mBand.cxRightWidth; } } else { //moving left //check for compacting of preceding bands while (prbbPrev) { if (fBandBorders) xLeft -= g_cxEdge; prbbPrev->cx = xLeft - prbbPrev->x - _mBand.cxLeftWidth - _mBand.cxRightWidth; prbbPrev->cxRequest = prbbPrev->cx; if (prbbPrev->cx < prbbPrev->cxMin) { prbbPrev->x = xLeft - _mBand.cxLeftWidth - _mBand.cxRightWidth - prbbPrev->cxMin; prbbPrev->cx = prbbPrev->cxMin; prbbPrev->cxRequest = prbbPrev->cx; xLeft = prbbPrev->x; prbbPrev = _GetPrevVisible(prbbPrev); // prbbPrev-- } else { break; } } rc.left = xLeft - _mBand.cxLeftWidth - _mBand.cxRightWidth; } if (fBandBorders) rc.bottom += g_cyEdge / 2; _ResizeChildren(); if (_InvalidateRect(&rc)) { UpdateWindow(_ci.hwnd); } return(TRUE); } BOOL CReBar::_SetBandPosAnim(PRBB prbb, int xLeft) { int ctr=0,dx, xCur = prbb->x; DWORD dwStartTime; if (xCur == xLeft) return FALSE; dwStartTime=GetTickCount(); dx = (xLeft - xCur)/ANIMSTEPS; if (dx != 0) { if (xCur < xLeft) { // move right for (; xCur < (xLeft-dx); ctr++,xCur += dx) { _SetBandPos(prbb, xCur); // If something caused us to take more than 10 times the time we // should be, break out, and let the final _SetBandPos finish if (GetTickCount() - dwStartTime > 10*ANIMSTEPS*ANIMSTEPTIME) break; Sleep(ANIMSTEPTIME); // Start slowing us down 80% of the way through // Cut speed by 2/3 each time, but never move less than 4 pixels if ((ctr >= 4*ANIMSTEPS/5) && (dx >= 4)) dx = 2*dx/3; } } else { // move left for (; xCur > (xLeft-dx); ctr++, xCur += dx) { _SetBandPos(prbb, xCur); if (GetTickCount() > (dwStartTime + 10*ANIMSTEPS*ANIMSTEPTIME)) break; Sleep(ANIMSTEPTIME); if ((ctr >= 4*ANIMSTEPS/5) && (dx <= -4)) dx = 2*dx/3; } } } _SetBandPos(prbb, xLeft); return TRUE; } void CReBar::_OnBeginDrag(UINT uBand) { _uCapture = uBand; _ptLastDragPos.x = -1; _ptLastDragPos.y = -1; if (_uCapture == -1) { // aborting drag _fParentDrag = FALSE; _fFullOnDrag = FALSE; // we could have unwrapped rows, in which case, we need to grow bands (but not wrap) // to fill the empty space. if (_ci.style & RBS_AUTOSIZE) { _SizeBandsToRect(NULL); _SizeBandsToRowHeight(); } } else { _fParentDrag = TRUE; _fFullOnDrag = TRUE; } } int minmax(int x, int min, int max) { x = max(x, min); x = min(x, max); return x; } // pass the break bit along void CReBar::_PassBreak(PRBB prbbSrc, PRBB prbbDest) { if (prbbSrc->fStyle & RBBS_BREAK) { prbbSrc->fStyle &= ~RBBS_BREAK; if (prbbDest) prbbDest->fStyle |= RBBS_BREAK; } } void CReBar::_GetClientRect(LPRECT prc) { GetClientRect(_ci.hwnd, prc); if (_ci.style & CCS_VERT) FlipRect(prc); } //tells if prbb is the first band and the next band is fixed. // if this is true then we need to do a recalc if we move prbb BOOL CReBar::_RecalcIfMove(PRBB prbb) { if (_EnumBand(0, RBBS_HIDDEN) == prbb) { PRBB prbbNext = _GetNextVisible(prbb); if (prbbNext && prbbNext->fStyle & RBBS_FIXEDSIZE) return TRUE; } return FALSE; } // find out if the prbb at it's min height could fit within the current window // if all the others shrunk as much as they could BOOL CReBar::_RoomForBandVert(PRBB prbbSkip) { int yExtra = 0; UINT cBands = _cBands; int iNewRowHeight = prbbSkip->cyMinChild; PRBB prbb = _GetBand(0); if (_UseBandBorders()) iNewRowHeight += g_cyEdge; iNewRowHeight += _mBand.cyBottomHeight + _mBand.cyTopHeight; while (prbb) { if (_IsBandVisible(prbb)) { if (_IsBandStartOfRow(prbb)) { yExtra += _GetRowHeightExtra(&prbb, prbbSkip); if (yExtra >= iNewRowHeight) return TRUE; continue; } } prbb = _GetNextVisible(prbb); } return FALSE; } // we should make a new row if prbb isn't the start of the row already // and we're off the end of the control // // poweruser hack of holding the control down will make a new row if you hit the border between lines BOOL CReBar::_MakeNewRow(PRBB prbb, int y) { BOOL fRet = FALSE; RECT rc; // if we're off the top of the control, move this band to the end (or beginning) _GetClientRect(&rc); InflateRect(&rc, 0, -g_cyEdge); if (!(_ci.style & RBS_FIXEDORDER)) { int iOutsideLimit = g_cyEdge * 4; // how far do you have to move outside the bounds of the window to force a new row if (_RoomForBandVert(prbb)) { iOutsideLimit = -g_cyEdge; } if (y < rc.top - iOutsideLimit) { // top of control PRBB prbbNext = _EnumBand(0, RBBS_HIDDEN); if (prbbNext == prbb) prbbNext = _GetNextVisible(prbb); fRet |= _MoveBand(_BandToIndex(prbb), 0); ASSERT(prbbNext <= _GetLastBand()); if (prbbNext && !(prbbNext->fStyle & RBBS_BREAK)) { prbbNext->fStyle |= RBBS_BREAK; fRet = TRUE; } } else if (y >= rc.bottom) { // move to the end if (!(prbb->fStyle & RBBS_BREAK)) { prbb->fStyle |= RBBS_BREAK; fRet = TRUE; } prbb->cyChild = prbb->cyMinChild; fRet |= _MoveBand(_BandToIndex(prbb), _cBands-1); } else { // create a new row in the middle if (!_IsBandStartOfRow(prbb) && GetAsyncKeyState(VK_CONTROL) < 0) { // make sure they're on different rows and on the border if (y > prbb->y + prbb->cy + _mBand.cyBottomHeight && y < prbb->y + prbb->cy + _mBand.cyBottomHeight + g_cyEdge) { PRBB prbbLast = _GetLastInRow(prbb, FALSE); // move it right before the first in this row prbb->fStyle |= RBBS_BREAK; _MoveBand(_BandToIndex(prbb), _BandToIndex(prbbLast)); fRet = TRUE; } } } } else { // fixed guys can't move, they can only make a new row if (!_IsBandStartOfRow(prbb)) { if (y > prbb->y + prbb->cy + _mBand.cyBottomHeight) { prbb->fStyle |= RBBS_BREAK; fRet = TRUE; } } } return fRet; } // ---------------------------------------------------------------------------- // // _DragBand // // resizes the currently tracked band based on the user's mouse movement as // indicated in the given point (x, y) // // ---------------------------------------------------------------------------- void CReBar::_DragBand(int x, int y) { PRBB prbb = _GetBand(_uCapture); UINT iHit = -1; // Do nothing if the mouse didn't actually move // otherwise, multiple WM_MOUSEMOVE messages will be generated by resizing windows if (x==_ptLastDragPos.x && y==_ptLastDragPos.y) return; else { _ptLastDragPos.x = x; _ptLastDragPos.y = y; } if (_ci.style & CCS_VERT) SWAP(x,y, int); if (!_fFullOnDrag) { // don't begin dragging until mouse is moved outside of an edge-thick // tolerance border if ((y < (_ptCapture.y - g_cyEdge)) || (y > (_ptCapture.y + g_cyEdge)) || (x < (_ptCapture.x - g_cxEdge)) || (x > (_ptCapture.x + g_cxEdge))) { // did parent abort? if (_SendNotify(_uCapture, RBN_BEGINDRAG)) return; if (!_IsValidBand(prbb)) { // somebody responded to RBN_BEGINDRAG by nuking bands; bail return; } _fFullOnDrag = TRUE; } else return; } // bail for right now on fRecalcIfMoved (ie3 did the same thing). nice feature for later if (!_CanBandMove(prbb)) return; /* what type of drag operation depends on what we drag hit on. if we hit on the band before us, or ourself and it's the same row and we're not the first band of the row then we just to a size move otherwise if we hit on a band then we do a move if we hit outside of any band, we grow to meet the cursor in all of the above, a band that's hit must be NOT fixed and not hidden */ BOOL fResize = FALSE; RECT rc; _GetClientRect(&rc); if (y < rc.bottom - 1) { iHit = _InternalHitTest(NULL, x, y); } if (iHit != -1) { PRBB prbbPrev = _GetPrevVisible(prbb); PRBB prbbHit = _GetBand(iHit); prbbHit = _GetPrev(++prbbHit, RBBS_FIXEDSIZE); // skip over fixed guys if (prbbHit) { ASSERT(prbbHit >= _rbbList); // this should never happen. if (prbbHit < _rbbList) return; iHit = _BandToIndex(prbbHit); // if we're on the same row ... and it's us or the previous one if (prbbHit->y == prbb->y && (prbbHit == prbb || prbbHit == prbbPrev)) { if (x < _GetGripperWidth() + _mBand.cxLeftWidth && !(_ci.style & RBS_FIXEDORDER)) { // special case dragging to the far left. there's no other way to move to first in row _PassBreak(prbbHit, prbb); if (_MoveBand(_uCapture, iHit)) fResize = TRUE; } else if (!_IsBandStartOfRow(prbb)) { // and we're not the first band of the row // then just size it int xLeft = _xStart + (x - _ptCapture.x); xLeft = minmax(xLeft, _MinX(prbb), _MaxX(prbb)); _DragSize(xLeft); } } else if (_MakeNewRow(prbb, y)) { fResize = TRUE; } else { // otherwise do a move if we're not in a fixed order if (!(_ci.style & RBS_FIXEDORDER)) { if (iHit < _BandToIndex(prbb)) iHit++; // +1 because if you hit a band, you're moving to the right of him // if one with a break is moving, the next one inherits the break _PassBreak(prbb, _GetNextVisible(prbb)); _MoveBand(_uCapture, iHit); } else { if (iHit < _BandToIndex(prbb)) _PassBreak(prbb, _GetNextVisible(prbb)); } fResize = TRUE; } } } else if (_MakeNewRow(prbb, y)) { fResize = TRUE; } if (fResize) { _Resize(FALSE); _AutoSize(); } } HPALETTE CReBar::_SetPalette(HPALETTE hpal) { HPALETTE hpalOld = _hpal; if (hpal != hpalOld) { if (!_fUserPalette) { if (_hpal) { DeleteObject(_hpal); _hpal = NULL; } } if (hpal) { _fUserPalette = TRUE; _hpal = hpal; } _InvalidateRect(NULL); } return hpalOld; } // ---------------------------------------------------------------------------- // // _OnDestroy // // frees all memory allocated by rebar // // ---------------------------------------------------------------------------- BOOL CReBar::_OnDestroy() { UINT c = _cBands; _SetRedraw(FALSE); _SetRecalc(FALSE); while (c--) _DeleteBand(c); // so that we don't keep trying to autosize _ci.style &= ~RBS_AUTOSIZE; ASSERT(!_rbbList); _SetPalette(NULL); if (_hFont && _fFontCreated) { DeleteObject(_hFont); } if ((_ci.style & RBS_TOOLTIPS) && IsWindow(_hwndToolTips)) { DestroyWindow (_hwndToolTips); _hwndToolTips = NULL; } // don't destroy the himl 'cause it's given to us by app if (_hDragProxy) DestroyDragProxy(_hDragProxy); if (_hTheme) CloseThemeData(_hTheme); return TRUE; } // ---------------------------------------------------------------------------- // // _InitPaletteHack // // this is a hack to use the halftone palette until we have a way of asking // the client what palette they are using // // ---------------------------------------------------------------------------- void CReBar::_InitPaletteHack() { if (!_fUserPalette) { HDC hdc = CreateCompatibleDC(NULL); if (hdc) { if (GetDeviceCaps(hdc, BITSPIXEL) <= 8) { if (_hpal) DeleteObject(_hpal); _hpal = CreateHalftonePalette(hdc); // this is a hack } DeleteDC(hdc); } } } UINT CReBar::_IDToIndex(UINT id) { UINT i; REBARBANDINFO rbbi; rbbi.cbSize = sizeof(REBARBANDINFO); rbbi.fMask = RBBIM_ID; for (i = 0; i < _cBands; i++) { if (_GetBandInfo(i, &rbbi)) { if (rbbi.wID == (WORD)id) return i; } } return -1; } int CReBar::_GetRowHeight(UINT uRow) { if (uRow < _cBands) { // move back to start of line PRBB prbbFirst = _GetFirstInRow(_GetBand(uRow)); PRBB prbbLast = _GetLastInRow(_GetBand(uRow), FALSE); return _GetLineHeight(_BandToIndex(prbbFirst), _BandToIndex(prbbLast)); } return -1; } // fOneStep == whether to allow only one cyIntegral or as many as will fit to // fill dy int CReBar::_GrowBand(PRBB prbb, int dy, BOOL fResize, int iLineHeight) { int dyBand = 0; // how much the band changes if (prbb->cyIntegral) { if (iLineHeight == -1) { iLineHeight = _GetRowHeight(_BandToIndex(prbb)); } // get the proposed new size int cyDesiredHeight = min(iLineHeight + dy, prbb->cyMaxChild) - prbb->cyMinChild; // Limit new height to band's min and max int iNumOfIntegrals = max(cyDesiredHeight / prbb->cyIntegral, 0); int cyNewHeight = prbb->cyMinChild + (iNumOfIntegrals * prbb->cyIntegral); DebugMsg(TF_REBAR, TEXT("REBAR._gb Band {%d}, Line Height {%d} Desired Height {%d} New Height {%d} Old Height {%d} dy {%d}"), _BandToIndex(prbb), iLineHeight, cyDesiredHeight + prbb->cyMinChild, cyNewHeight, prbb->cyChild, dy); dyBand = cyNewHeight - prbb->cyChild; prbb->cyChild = cyNewHeight; if (fResize) { _Resize(TRUE); } } return dyBand; } // returns the delta in size that the rebar is from prc. // taking into account vertical mode int CReBar::_SizeDifference(LPRECT prc) { int d; d = (_IsVertical() ? RECTWIDTH(*prc) : RECTHEIGHT(*prc)) - _cy; return d; } // returns how much this row could shrink int CReBar::_GetRowHeightExtra(PRBB *pprbb, PRBB prbbSkip) { // this is the largest minimum child size for the row. // even if something is not at it's min size, if it's smaller than this // then it doesn't matter because someone else on that row can't be sized int yLimit = 0; int yExtra = 0; PRBB prbb = *pprbb; while (prbb) { if (prbb != prbbSkip) { int yMin; int yExtraBand = 0; // the min height is the cyChild if it's not variable height yMin = prbb->cyChild; if (prbb->fStyle & RBBS_VARIABLEHEIGHT) { // if it is variable height, and there's still room to shrink, then cyMinChild is // the minimum. if (prbb->cyChild >= prbb->cyMinChild + prbb->cyIntegral) { yMin = prbb->cyMinChild; yExtraBand = prbb->cyChild - prbb->cyMinChild; } } if (yMin == yLimit) { if (yExtraBand > yExtra) yExtra = yExtraBand; } else if (yMin > yLimit) { yExtra = yExtraBand; } } prbb = _GetNextVisible(prbb); } *pprbb = prbb; return yExtra; } // are allt he bands at the minimum size? BOOL CReBar::_BandsAtMinHeight() { BOOL fRet = TRUE; PRBB prbb = _GetBand(0); while (prbb) { if (_IsBandVisible(prbb)) { if (_IsBandStartOfRow(prbb)) { fRet = _IsRowAtMinHeight(&prbb); if (!fRet) break; continue; } } prbb = _GetNextVisible(prbb); } return fRet; } // this is like _SizeBarToRect except that it resizes the actual bands if they // are VARIABLEHEIGHT BOOL CReBar::_SizeBandsToRect(LPRECT prc) { int dy; RECT rc; BOOL fRedrawOld; BOOL fChanged = FALSE; // Turn recalc on to ensure calculations actually do something // (else we can loop forever since _cy never actually changes). _SetRecalc(TRUE); if (prc) { rc = *prc; } else { GetClientRect(_ci.hwnd, &rc); } DebugMsg(TF_REBAR, TEXT("REBAR._sbandstr starting rect is {%d, %d, %d, %d}"), rc.left, rc.top, rc.right, rc.bottom); fRedrawOld = _SetRedraw(FALSE); dy = _SizeDifference(&rc); for (int iAttempt = 0; (iAttempt < 2) && dy; iAttempt++) { PRBB prbb = _rbbList; BOOL fValidBand = FALSE; while ((prbb - _rbbList < (int)_cBands) && !fValidBand) { if (!(prbb->fStyle & RBBS_HIDDEN) && (prbb->fStyle & RBBS_VARIABLEHEIGHT) && !(prbb->fStyle & RBBS_FIXEDSIZE)) { fValidBand = TRUE; } else { prbb++; } } if ((prbb - _rbbList < (int)_cBands) && !(prbb->fStyle & RBBS_HIDDEN) && (prbb->fStyle & RBBS_VARIABLEHEIGHT) && !(prbb->fStyle & RBBS_FIXEDSIZE)) { PRBB prbbMaxIntegral = prbb; do { if (!(prbb->fStyle & RBBS_HIDDEN) && (prbb->fStyle & RBBS_VARIABLEHEIGHT) && !(prbb->fStyle & RBBS_FIXEDSIZE)) { if (prbbMaxIntegral->cyIntegral < prbb->cyIntegral) { prbbMaxIntegral = prbb; } } prbb++; } while ((prbb - _rbbList < (int)_cBands) && !_IsBandStartOfRow(prbb)); int old_cyChild = prbbMaxIntegral->cyChild; if (prbbMaxIntegral->cyIntegral) { _GrowBand(prbbMaxIntegral, dy, FALSE, -1); } else { prbbMaxIntegral->cyChild += dy; } if (prbbMaxIntegral->cyChild != old_cyChild) { fChanged = TRUE; } UINT uFirst = _BandToIndex(_GetFirstInRow(prbbMaxIntegral)); UINT uLast = _BandToIndex(_GetLastInRow(prbbMaxIntegral, FALSE)); for (UINT uBand = uFirst; uBand <= uLast; uBand++) { prbb = _GetBand(uBand); // if it's a variable height kind of guy, grow/shrink it if ((prbb != prbbMaxIntegral) && !(prbb->fStyle & RBBS_HIDDEN) && (prbb->fStyle & RBBS_VARIABLEHEIGHT) && !(prbb->fStyle & RBBS_FIXEDSIZE)) { old_cyChild = prbb->cyChild; if (prbb->cyIntegral && prbbMaxIntegral->cyIntegral) { prbb->cyChild = prbbMaxIntegral->cyChild - ((prbbMaxIntegral->cyChild - prbb->cyMinChild) % prbb->cyIntegral); } else { prbb->cyChild = prbbMaxIntegral->cyChild; } if (prbb->cyChild != old_cyChild) { fChanged = TRUE; } } } for (UINT uBand = uLast + 1; uBand < _cBands; uBand++) { prbb = _GetBand(uBand); if (!(prbb->fStyle & RBBS_HIDDEN) && (prbb->fStyle & RBBS_VARIABLEHEIGHT) && !(prbb->fStyle & RBBS_FIXEDSIZE)) { if (prbb->cyChild != prbb->cyMinChild) { prbb->cyChild = prbb->cyMinChild; fChanged = TRUE; } } } } if (fChanged) { _Resize(TRUE); dy = _SizeDifference(&rc); } } _SetRedraw(fRedrawOld); return fChanged; } void CReBar::_SizeBandToRowHeight(int i, int uRowHeight) { PRBB prbb = _GetBand(i); if (prbb && prbb->fStyle & RBBS_VARIABLEHEIGHT) { if (uRowHeight == -1) uRowHeight = _GetRowHeight(i); if (uRowHeight > prbb->cyChild) { _GrowBand(prbb, 0, TRUE, uRowHeight); } } } // in the process of sizing, one band in a row of several bands might have // grow pretty large. we need to let the other bands have a chance to fill // the extra space as well void CReBar::_SizeBandsToRowHeight() { UINT i; int iRowHeight = -1; for (i = 0; i < _cBands; i++) { PRBB prbb = _GetBand(i); if (prbb->fStyle & RBBS_HIDDEN) continue; if (_IsBandStartOfRow(prbb)) iRowHeight = _GetRowHeight(i); _SizeBandToRowHeight(i, iRowHeight); } } BOOL CReBar::_OkayToChangeBreak(PRBB prbb, UINT uMsg) { NMREBARAUTOBREAK nm; nm.uBand = _BandToIndex(prbb); nm.wID = prbb->wID; nm.lParam = prbb->lParam; nm.uMsg = uMsg; nm.fStyleCurrent = prbb->fStyle; nm.fAutoBreak = TRUE; CCSendNotify(&_ci, RBN_AUTOBREAK, &nm.hdr); return nm.fAutoBreak; } // this will add/remove rebar band breaks to get to the requested size. // it returns TRUE/FALSE whether something was done or not. LRESULT CReBar::_SizeBarToRect(DWORD dwFlags, LPRECT prc) { BOOL fChanged = FALSE; RECT rc; BOOL fRedrawOld = _SetRedraw(FALSE); if (!prc) { GetClientRect(_ci.hwnd, &rc); prc = &rc; } if (_cBands) { int c; UINT cBands = _cBands; BOOL fRearrangeBands = (_cBands > 0); BOOL fGrowing = TRUE; // if we're shrinking the rebar, we first want to shrink the bands before we start // removing breaks c = _SizeDifference(prc); if (c < 0) fGrowing = FALSE; fChanged = _SizeBandsToRect(prc); if (!fGrowing && !_BandsAtMinHeight()) { // if we're shrinking and all the bands are not down to // the minimum height, don't try doing any of the breaking stuff goto Bail; } while (fRearrangeBands) { int cyRowHalf = _GetRowHeight(_cBands-1) / 2 ; REBARBANDINFO rbbi; PRBB prbb; fRearrangeBands = FALSE; rbbi.cbSize = sizeof(REBARBANDINFO); rbbi.fMask = RBBIM_STYLE; c = _SizeDifference(prc); if (c < -cyRowHalf) { // we've shrunk the rebar, try to remove breaks while (--cBands) { prbb = _GetBand(cBands); if (prbb->fStyle & RBBS_HIDDEN) continue; if ((prbb->fStyle & RBBS_BREAK) && (_OkayToChangeBreak(prbb, RBAB_AUTOSIZE))) { fChanged = TRUE; fRearrangeBands = TRUE; rbbi.fStyle = prbb->fStyle & ~RBBS_BREAK; _SetBandInfo(cBands, &rbbi, TRUE); break; } } } else if (c > cyRowHalf) { // we're enlarging the rebar while (--cBands) { prbb = _GetBand(cBands); if (prbb->fStyle & RBBS_HIDDEN) continue; if ((!(prbb->fStyle & (RBBS_BREAK | RBBS_FIXEDSIZE))) && (_OkayToChangeBreak(prbb, RBAB_AUTOSIZE))) { // no break here, add it fChanged = TRUE; fRearrangeBands = TRUE; rbbi.fStyle = (prbb->fStyle | RBBS_BREAK); _SetBandInfo(cBands, &rbbi, TRUE); break; } } } } // if we did as much breaking as we could // and we walked all the way down to the 0th band (we start at the Nth band) // then we try to grow the bands that are VARIABLEHEIGHT // for fGrowing, see comment at top of function // // wedo the % because cBands == _cBands if we didn't go through // any of the breaking loops at all if (!(cBands % _cBands) && fGrowing) fChanged |= _SizeBandsToRect(prc); } Bail: _SizeBandsToRowHeight(); _SetRedraw(fRedrawOld); if (prc && (dwFlags & RBSTR_CHANGERECT)) { if (_IsVertical()) { prc->right = prc->left + _cy; } else { prc->bottom = prc->top + _cy; } } return (LRESULT)fChanged; } void CReBar::_AutoSize() { NMRBAUTOSIZE nm; // if this is an internal autosize call, but we're not in autosize mode // do nothing if (!(_ci.style & RBS_AUTOSIZE)) return; GetClientRect(_ci.hwnd, &nm.rcTarget); nm.fChanged = (BOOL) _SizeBarToRect(0, &nm.rcTarget); GetClientRect(_ci.hwnd, &nm.rcActual); CCSendNotify(&_ci, RBN_AUTOSIZE, &nm.hdr); } LRESULT CReBar::_GetBandBorders(int wParam, LPRECT prc) { BOOL fBandBorders = _UseBandBorders(); PRBB prbb = &_rbbList[wParam]; prc->left = _GetHeaderWidth(prbb); if (fBandBorders) { prc->left += 2*g_cxEdge; prc->right = 0; prc->top = g_cyEdge/2; prc->bottom = g_cyEdge /2; } else { prc->right = 0; prc->top = 0; prc->bottom = 0; } if (_ci.style & CCS_VERT) FlipRect(prc); return 0; } void CReBar::_OnStyleChanged(WPARAM wParam, LPSTYLESTRUCT lpss) { if (wParam == GWL_STYLE) { DWORD dwChanged; _ci.style = lpss->styleNew; dwChanged = (lpss->styleOld ^ lpss->styleNew); // update to reflect style change if (dwChanged & CCS_VERT) { DebugMsg(TF_REBAR, TEXT("REBAR._osc ReBar is now {%s}"), (lpss->styleNew & CCS_VERT) ? TEXT("Horizontal") : TEXT("Vertical")); UINT i; for (i = 0; i < _cBands; i++) { PRBB prbb = _GetBand(i); if (prbb->fStyle & RBBS_HIDDEN) continue; if (!(lpss->styleNew & CCS_VERT)) { prbb->cyChild = 0; _cy = 0; } _BandCalcMinWidth(prbb); } } if (dwChanged & RBS_REGISTERDROP) { if (_ci.style & RBS_REGISTERDROP) { ASSERT(!_hDragProxy); _hDragProxy = CreateDragProxy(_ci.hwnd, s_DragCallback, TRUE); } else { ASSERT(_hDragProxy); DestroyDragProxy(_hDragProxy); } } } else if (wParam == GWL_EXSTYLE) { // // If the RTL_MIRROR extended style bit had changed, let's // repaint the control window // if ((_ci.dwExStyle&RTL_MIRRORED_WINDOW) != (lpss->styleNew&RTL_MIRRORED_WINDOW)) { _InvalidateRect(NULL); } // // Save the new ex-style bits // _ci.dwExStyle = lpss->styleNew; } } void CReBar::_OnMouseMove(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { RelayToToolTips(_hwndToolTips, hwnd, uMsg, wParam, lParam); if (_uCapture != -1) { // captured band -- mouse is down if (hwnd != GetCapture() && !_fParentDrag) { _SendNotify(_uCapture, RBN_ENDDRAG); _OnBeginDrag((UINT)-1); } else _DragBand(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)); } else { // hottracking int iBand; PRBB prbb = NULL; PRBB prbbHotOld = _prbbHot; RBHITTESTINFO rbht; rbht.pt.x = GET_X_LPARAM(lParam); rbht.pt.y = GET_Y_LPARAM(lParam); iBand = _HitTest(&rbht); if (iBand != -1) prbb = _GetBand(iBand); if (prbbHotOld && (prbbHotOld->wChevState & DCHF_PUSHED)) return; if (prbb && (rbht.flags & RBHT_CHEVRON)) { SetCapture(hwnd); _UpdateChevronState(prbb, DCHF_HOT); if (prbb == prbbHotOld) prbbHotOld = NULL; } if (prbbHotOld) { CCReleaseCapture(&_ci); _UpdateChevronState(prbbHotOld, DCHF_INACTIVE); } } } void CReBar::_OnPushChevron(HWND hwnd, PRBB prbb, LPARAM lParamNM) { NMREBARCHEVRON nm; nm.uBand = _BandToIndex(prbb); nm.wID = prbb->wID; nm.lParam = prbb->lParam; nm.lParamNM = lParamNM; CopyRect(&nm.rc, &prbb->rcChevron); if (_IsVertical()) FlipRect(&nm.rc); _UpdateChevronState(prbb, DCHF_PUSHED); CCReleaseCapture(&_ci); CCSendNotify(&_ci, RBN_CHEVRONPUSHED, &nm.hdr); _UpdateChevronState(_prbbHot, DCHF_INACTIVE); } void CReBar::_OnCreate(HWND hwnd, LPCREATESTRUCT pcs) { InitGlobalColors(); _uCapture = -1; _clrBk = CLR_NONE; _clrText = CLR_NONE; // Init the dwSize because we block-copy it back to the app _clrsc.dwSize = sizeof(COLORSCHEME); _clrsc.clrBtnHighlight = _clrsc.clrBtnShadow = CLR_DEFAULT; _fRedraw = TRUE; _fRecalc = TRUE; CIInitialize(&_ci, hwnd, pcs); _CacheThemeInfo(TRUE); if (!(_ci.style & (CCS_TOP | CCS_NOMOVEY | CCS_BOTTOM))) { _ci.style |= CCS_TOP; SetWindowLong(hwnd, GWL_STYLE, _ci.style); } if (_ci.style & WS_BORDER) _fHasBorder = TRUE; _SetFont(0); if (pcs->lpCreateParams) _SetBarInfo((LPREBARINFO) (pcs->lpCreateParams)); } LRESULT CALLBACK CReBar::s_WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { CReBar* prb = (CReBar*) GetWindowPtr(hwnd, 0); if (prb) { LRESULT lres = prb->_WndProc(hwnd, uMsg, wParam, lParam); if (uMsg == WM_NCDESTROY) { SetWindowPtr(hwnd, 0, 0); delete prb; } return lres; } else if (uMsg == WM_NCCREATE) { prb = new CReBar(); if (prb) { SetWindowPtr(hwnd, 0, prb); return prb->_WndProc(hwnd, uMsg, wParam, lParam); } return FALSE; } return DefWindowProc(hwnd, uMsg, wParam, lParam); } LRESULT CReBar::_WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { switch (uMsg) { case WM_SETREDRAW: _SetRecalc(BOOLFROMPTR(wParam)); return _SetRedraw(BOOLFROMPTR(wParam)); case WM_NCCREATE: _OnCreate(hwnd, (LPCREATESTRUCT)lParam); return TRUE; case WM_NCDESTROY: _OnDestroy(); break; case WM_CREATE: // Do delayed stuff for speed. PostMessage(hwnd, RB_PRIV_DODELAYEDSTUFF, 0, 0); goto CallDWP; case RB_PRIV_DODELAYEDSTUFF: // Delay done stuff for speed: if (_ci.style & RBS_REGISTERDROP) _hDragProxy = CreateDragProxy(_ci.hwnd, s_DragCallback, TRUE); if (_ci.style & RBS_TOOLTIPS) { TOOLINFO ti; // don't bother setting the rect because we'll do it below // in FlushToolTipsMgr; ti.cbSize = sizeof(ti); ti.uFlags = TTF_IDISHWND; ti.hwnd = hwnd; ti.uId = (UINT_PTR)hwnd; ti.lpszText = 0; _hwndToolTips = CreateWindowEx(WS_EX_TRANSPARENT, c_szSToolTipsClass, NULL, WS_POPUP, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, hwnd, NULL, (HINSTANCE)GetWindowLongPtr(hwnd, GWLP_HINSTANCE), NULL); SendMessage(_hwndToolTips, TTM_ADDTOOL, 0, (LPARAM)(LPTOOLINFO) &ti); } _InitPaletteHack(); break; case WM_NCHITTEST: { RBHITTESTINFO rbht; int iBand; rbht.pt.x = GET_X_LPARAM(lParam); rbht.pt.y = GET_Y_LPARAM(lParam); ScreenToClient(_ci.hwnd, &rbht.pt); iBand = _HitTest(&rbht); { NMMOUSE nm; LRESULT lres; nm.dwItemSpec = iBand; nm.pt = rbht.pt; nm.dwHitInfo = rbht.flags; // send to the parent to give them a chance to override lres = CCSendNotify(&_ci, NM_NCHITTEST, &nm.hdr); if (lres) return lres; } } return HTCLIENT; case WM_NCCALCSIZE: if (_ci.style & WS_BORDER) { InflateRect((LPRECT) lParam, -g_cxEdge, -g_cyEdge); break; } goto CallDWP; case WM_NCPAINT: if (_ci.style & WS_BORDER) { RECT rc; HDC hdc; GetWindowRect(hwnd, &rc); OffsetRect(&rc, -rc.left, -rc.top); hdc = GetWindowDC(hwnd); if (hdc) { CCDrawEdge(hdc, &rc, EDGE_ETCHED, BF_RECT, &(_clrsc)); ReleaseDC(hwnd, hdc); } break; } goto CallDWP; case WM_PALETTECHANGED: if ((HWND)wParam == hwnd) break; case WM_QUERYNEWPALETTE: // Want to pass FALSE if WM_QUERYNEWPALETTE... _Realize(NULL, uMsg == WM_PALETTECHANGED, uMsg == WM_PALETTECHANGED); return TRUE; case WM_PAINT: case WM_PRINTCLIENT: _OnPaint((HDC)wParam); break; case WM_ERASEBKGND: if (_EraseBkgnd((HDC) wParam, -1)) return(TRUE); goto CallDWP; case WM_SYSCOLORCHANGE: _InitPaletteHack(); if (_hwndToolTips) SendMessage(_hwndToolTips, uMsg, wParam, lParam); InitGlobalColors(); InvalidateRect(_ci.hwnd, NULL, TRUE); break; case RB_SETPALETTE: return (LRESULT)_SetPalette((HPALETTE)lParam); case RB_GETPALETTE: return (LRESULT)_hpal; case RB_GETBANDMARGINS: { MARGINS* pMargin = (MARGINS*)lParam; if (pMargin) *pMargin = _mBand; return 1; } case WM_SIZE: _AutoSize(); _Resize(FALSE); break; case WM_GETFONT: return (LRESULT)_hFont; case WM_COMMAND: case WM_DRAWITEM: case WM_MEASUREITEM: case WM_VKEYTOITEM: case WM_CHARTOITEM: SendMessage(_ci.hwndParent, uMsg, wParam, lParam); break; case WM_LBUTTONDBLCLK: // DBLCLK sent in place of LBUTTONDOWN case WM_RBUTTONDOWN: // right button drags too case WM_LBUTTONDOWN: { RBHITTESTINFO rbht; PRBB prbb = NULL; rbht.pt.x = GET_X_LPARAM(lParam); rbht.pt.y = GET_Y_LPARAM(lParam); RelayToToolTips(_hwndToolTips, hwnd, uMsg, wParam, lParam); int iBand = _HitTest(&rbht); if (iBand != -1) prbb = _GetBand(iBand); if (!prbb) { /* nothing */ ; } else if (rbht.flags & RBHT_CHEVRON) { _OnPushChevron(hwnd, prbb, 0); } else if (rbht.flags != RBHT_CLIENT && _ShouldDrawGripper(prbb)) { _uCapture = iBand; _ptCapture = rbht.pt; if (_ci.style & CCS_VERT) SWAP(_ptCapture.x, _ptCapture.y, int); _xStart = prbb->x; SetCapture(hwnd); _fFullOnDrag = FALSE; if (uMsg == WM_LBUTTONDBLCLK && (_ci.style & RBS_DBLCLKTOGGLE)) _ToggleBand(TRUE); } } break; case WM_SETCURSOR: // Give the parent first crack, if it sets the cursor then // leave it at that. Otherwise if the cursor is over our // window then set it to what we want it to be. if (!DefWindowProc(hwnd, uMsg, wParam, lParam) && (hwnd == (HWND)wParam)) { POINT pt; GetMessagePosClient(_ci.hwnd, &pt); _SetCursor(pt.x, pt.y, (HIWORD(lParam) == WM_LBUTTONDOWN || HIWORD(lParam) == WM_RBUTTONDOWN)); } return TRUE; case WM_MOUSEMOVE: _OnMouseMove(hwnd, uMsg, wParam, lParam); break; case WM_RBUTTONUP: if (!_fFullOnDrag && !_fParentDrag) { CCReleaseCapture(&_ci); // if we're not doing drag drop, go to def window proc so that // wm_contextmenu gets propagated _OnBeginDrag((UINT)-1); goto CallDWP; } // fall through case WM_LBUTTONUP: RelayToToolTips(_hwndToolTips, hwnd, uMsg, wParam, lParam); if (_uCapture != -1) { UINT uiIndex; if (!_fParentDrag) CCReleaseCapture(&_ci); // if there was no significant mouse motion, treat as a click if (!(_ci.style & RBS_DBLCLKTOGGLE) && !_fFullOnDrag) _ToggleBand(TRUE); _GetBand(_uCapture)->fStyle &= ~RBBS_DRAGBREAK; CCSendNotify(&_ci, RBN_LAYOUTCHANGED, NULL); _SendNotify(_uCapture, RBN_ENDDRAG); _OnBeginDrag((UINT)-1); for (uiIndex = 0; uiIndex < _cBands; uiIndex++) { if (_GetBand(uiIndex)->fStyle & RBBS_HIDDEN) continue; _BandCalcMinWidth(_GetBand(uiIndex)); } _SizeBandsToRect(NULL); _InvalidateRect(NULL); } break; case WM_WININICHANGE: InitGlobalMetrics(wParam); if (_fFontCreated) _SetFont(wParam); if (_hwndToolTips) SendMessage(_hwndToolTips, uMsg, wParam, lParam); for (DWORD dwIndex = 0; dwIndex < _cBands; dwIndex++) { PRBB prbb = _rbbList + dwIndex; SendMessage(prbb->hwndChild, WM_WININICHANGE, wParam, lParam); } break; case WM_SETFONT: _OnSetFont((HFONT)wParam); break; case WM_NOTIFYFORMAT: return(CIHandleNotifyFormat(&_ci, lParam)); case WM_NOTIFY: // We are just going to pass this on to the real parent // Note that -1 is used as the hwndFrom. This prevents SendNotifyEx // from updating the NMHDR structure. return(SendNotifyEx(_ci.hwndParent, (HWND) -1, ((LPNMHDR) lParam)->code, (LPNMHDR) lParam, _ci.bUnicode)); case WM_STYLECHANGED: _OnStyleChanged(wParam, (LPSTYLESTRUCT)lParam); break; case WM_UPDATEUISTATE: if (CCOnUIState(&(_ci), WM_UPDATEUISTATE, wParam, lParam)) { InvalidateRect(hwnd, NULL, TRUE); } goto CallDWP; case RB_SETBANDINFOA: case RB_INSERTBANDA: if (EVAL(lParam)) { LPWSTR lpStrings = NULL; LPSTR lpAnsiString; int iResult; // lParam starts out pointing to a REBARBANDINFOA, and // we secretly change it into a REBARBANDINFOW, and then // change it back. LPREBARBANDINFOW prbiW = (LPREBARBANDINFOW)lParam; LPREBARBANDINFOA prbiA = (LPREBARBANDINFOA)lParam; COMPILETIME_ASSERT(sizeof(REBARBANDINFOW) == sizeof(REBARBANDINFOA)); // Bug#94345 - raymondc - Is it safe to modify the incoming // REBARBANDINFOA structure? lpAnsiString = prbiA->lpText; if ((prbiA->fMask & RBBIM_TEXT) && prbiA->lpText) { lpStrings = ProduceWFromA(_ci.uiCodePage, lpAnsiString); if (!lpStrings) return -1; // Presto! Now it's a REBARBANDINFOW! prbiW->lpText = lpStrings; } if (uMsg == RB_INSERTBANDA) iResult = _InsertBand((UINT) wParam, prbiW); else iResult = _SetBandInfo((UINT) wParam, prbiW, TRUE); // Change-o! Now it's a REBARBANDINFOA! prbiA->lpText = lpAnsiString; if (lpStrings) FreeProducedString(lpStrings); return iResult; } case RB_INSERTBAND: return(_InsertBand((UINT) wParam, (LPREBARBANDINFO) lParam)); case RB_DELETEBAND: return(_DeleteBand((UINT) wParam)); case RB_SHOWBAND: return(_ShowBand((UINT) wParam, BOOLFROMPTR(lParam))); case RB_GETBANDINFOA: { LPREBARBANDINFOA prbbi = (LPREBARBANDINFOA)lParam; LPWSTR pszW = NULL; LPSTR lpAnsiString = prbbi->lpText; int iResult; if (prbbi->fMask & RBBIM_TEXT) { pszW = (LPWSTR)LocalAlloc(LPTR, prbbi->cch * sizeof(WCHAR)); if (!pszW) return 0; prbbi->lpText = (LPSTR)pszW; } iResult = _GetBandInfo((UINT)wParam, (LPREBARBANDINFO)lParam); if (pszW) { ConvertWToAN(_ci.uiCodePage, lpAnsiString, prbbi->cch, (LPWSTR)prbbi->lpText, -1); prbbi->lpText = lpAnsiString; LocalFree(pszW); } return iResult; } // we have getbandinfoold because in ie3, we did not thunk // and getbandinfo always return OS native string (dumb) case RB_GETBANDINFOOLD: case RB_GETBANDINFO: return(_GetBandInfo((UINT) wParam, (LPREBARBANDINFO) lParam)); case RB_GETTOOLTIPS: return (LPARAM)_hwndToolTips; case RB_SETTOOLTIPS: _hwndToolTips = (HWND)wParam; break; case RB_SETBKCOLOR: { COLORREF clr = _clrBk; _clrBk = (COLORREF)lParam; if (clr != _clrBk) InvalidateRect(_ci.hwnd, NULL, TRUE); return clr; } case RB_GETBKCOLOR: return _clrBk; case RB_SETTEXTCOLOR: { COLORREF clr = _clrText; _clrText = (COLORREF)lParam; return clr; } case RB_GETTEXTCOLOR: return _clrText; case RB_IDTOINDEX: return _IDToIndex((UINT) wParam); case RB_GETROWCOUNT: return(_GetRowCount()); case RB_GETROWHEIGHT: return _GetRowHeight((UINT)wParam); case RB_GETBANDBORDERS: return _GetBandBorders((UINT)wParam, (LPRECT)lParam); case RB_GETBANDCOUNT: return(_cBands); case RB_SETBANDINFO: return(_SetBandInfo((UINT) wParam, (LPREBARBANDINFO) lParam, TRUE)); case RB_GETBARINFO: return(_GetBarInfo((LPREBARINFO) lParam)); case RB_SETBARINFO: return(_SetBarInfo((LPREBARINFO) lParam)); case RB_SETPARENT: { HWND hwndOld = _ci.hwndParent; _ci.hwndParent = (HWND) wParam; return (LRESULT)hwndOld; } break; case RB_GETRECT: if (_IsValidIndex((UINT)wParam)) { PRBB prbb = _GetBand((UINT)wParam); LPRECT lprc = (LPRECT) lParam; lprc->left = prbb->x; lprc->top = prbb->y; lprc->right = prbb->x + prbb->cx; lprc->bottom = prbb->y + prbb->cy; return(TRUE); } break; case RB_HITTEST: return(_HitTest((LPRBHITTESTINFO) lParam)); case RB_SIZETORECT: return _SizeBarToRect((DWORD)wParam, (LPRECT)lParam); case RB_BEGINDRAG: if (_IsValidIndex((UINT)wParam)) { // -1 means do it yourself. // -2 means use what you had saved before if (lParam != (LPARAM)-2) { if (lParam == (LPARAM)-1) { GetMessagePosClient(_ci.hwnd, &_ptCapture); } else { _ptCapture.x = GET_X_LPARAM(lParam); _ptCapture.y = GET_Y_LPARAM(lParam); } if (_ci.style & CCS_VERT) SWAP(_ptCapture.x, _ptCapture.y, int); } _xStart = _GetBand((UINT)wParam)->x; _OnBeginDrag((UINT)wParam); } break; case RB_GETBARHEIGHT: return _GetBarHeight(); case RB_ENDDRAG: _OnBeginDrag((UINT)-1); break; case RB_DRAGMOVE: if (_uCapture != -1) { if (lParam == (LPARAM)-1) { lParam = GetMessagePosClient(_ci.hwnd, NULL); } _DragBand(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)); } break; case RB_MINIMIZEBAND: _MinimizeBand((UINT) wParam,FALSE); break; case RB_MAXIMIZEBAND: _MaximizeBand((UINT)wParam, BOOLFROMPTR(lParam),FALSE); break; case RB_MOVEBAND: if (!_IsValidIndex((UINT)wParam) || !_IsValidIndex((UINT)lParam)) break; return _MoveBand((UINT) wParam, (UINT) lParam); case RB_GETDROPTARGET: if (!_hDragProxy) _hDragProxy = CreateDragProxy(_ci.hwnd, s_DragCallback, FALSE); GetDragProxyTarget(_hDragProxy, (IDropTarget**)lParam); break; case RB_GETCOLORSCHEME: { LPCOLORSCHEME lpclrsc = (LPCOLORSCHEME) lParam; if (lpclrsc) { if (lpclrsc->dwSize == sizeof(COLORSCHEME)) *lpclrsc = _clrsc; } return (LRESULT) lpclrsc; } case RB_SETCOLORSCHEME: if (lParam) { if (((LPCOLORSCHEME) lParam)->dwSize == sizeof(COLORSCHEME)) { _clrsc.clrBtnHighlight = ((LPCOLORSCHEME) lParam)->clrBtnHighlight; _clrsc.clrBtnShadow = ((LPCOLORSCHEME) lParam)->clrBtnShadow; InvalidateRect(hwnd, NULL, FALSE); if (_ci.style & WS_BORDER) CCInvalidateFrame(hwnd); } } break; case RB_PUSHCHEVRON: if (_IsValidIndex((UINT)wParam)) { PRBB prbb = _GetBand((UINT)wParam); _OnPushChevron(hwnd, prbb, lParam); } break; case RB_SETWINDOWTHEME: if (lParam) { SetWindowTheme(hwnd, (LPWSTR)lParam, NULL); } break; case WM_THEMECHANGED: _CacheThemeInfo((BOOL)wParam); InvalidateRect(_ci.hwnd, NULL, TRUE); return 0; default: LRESULT lres; if (CCWndProc(&_ci, uMsg, wParam, lParam, &lres)) return lres; CallDWP: return DefWindowProc(hwnd, uMsg, wParam, lParam); } return 0; }