开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > GIS编程 > 查看源码
sizecbar.cpp
资源名称：GISCode.rar　[点击查看]
上传用户：juying163
上传日期：2014-09-24
资源大小：5867k
文件大小：41k
源码类别：

GIS编程

开发平台：

Visual C++

sizecbar.cpp：源码内容
  1. // sizecbar.cpp : implementation file
  2. //
  4. #include "stdafx.h"
  5. #include "sizecbar.h"
  7. #ifdef _DEBUG
  8. #define new DEBUG_NEW
  9. #undef THIS_FILE
  10. static char THIS_FILE[] = __FILE__;
  11. #endif
  13. /////////////////////////////////////////////////////////////////////////
  14. // CSizingControlBar
  16. IMPLEMENT_DYNAMIC(CSizingControlBar, baseCSizingControlBar);
  18. CSizingControlBar::CSizingControlBar()
  19. {
  20.     m_szMinHorz = CSize(33, 32);
  21.     m_szMinVert = CSize(33, 32);
  22.     m_szMinFloat = CSize(37, 32);
  23.     m_szHorz = CSize(200, 200);
  24.     m_szVert = CSize(200, 200);
  25.     m_szFloat = CSize(200, 200);
  26.     m_bTracking = FALSE;
  27.     m_bKeepSize = FALSE;
  28.     m_bParentSizing = FALSE;
  29.     m_cxEdge = 5;
  30.     m_bDragShowContent = FALSE;
  31.     m_nDockBarID = 0;
  32.     m_dwSCBStyle = 0;
  33. }
  35. CSizingControlBar::~CSizingControlBar()
  36. {
  37. }
  39. BEGIN_MESSAGE_MAP(CSizingControlBar, baseCSizingControlBar)
  40.     //{{AFX_MSG_MAP(CSizingControlBar)
  41.     ON_WM_CREATE()
  42.     ON_WM_PAINT()
  43.     ON_WM_NCPAINT()
  44.     ON_WM_NCCALCSIZE()
  45.     ON_WM_WINDOWPOSCHANGING()
  46.     ON_WM_CAPTURECHANGED()
  47.     ON_WM_SETTINGCHANGE()
  48.     ON_WM_LBUTTONUP()
  49.     ON_WM_MOUSEMOVE()
  50.     ON_WM_NCLBUTTONDOWN()
  51.     ON_WM_LBUTTONDOWN()
  52.     ON_WM_LBUTTONDBLCLK()
  53.     ON_WM_RBUTTONDOWN()
  54.     ON_WM_NCMOUSEMOVE()
  55.     ON_WM_NCHITTEST()
  56.     ON_WM_CLOSE()
  57.     ON_WM_SIZE()
  58.     //}}AFX_MSG_MAP
  59.     ON_MESSAGE(WM_SETTEXT, OnSetText)
  60. END_MESSAGE_MAP()
  62. // old creation method, still here for compatibility reasons
  63. BOOL CSizingControlBar::Create(LPCTSTR lpszWindowName, CWnd* pParentWnd,
  64.                                CSize sizeDefault, BOOL bHasGripper,
  65.                                UINT nID, DWORD dwStyle)
  66. {
  67.     UNUSED_ALWAYS(bHasGripper);
  69.     m_szHorz = m_szVert = m_szFloat = sizeDefault;
  70.     return Create(lpszWindowName, pParentWnd, nID, dwStyle);
  71. }
  73. // preffered creation method
  74. BOOL CSizingControlBar::Create(LPCTSTR lpszWindowName,
  75.                                CWnd* pParentWnd, UINT nID,
  76.                                DWORD dwStyle)
  77. {
  78.     // must have a parent
  79.     ASSERT_VALID(pParentWnd);
  80.     // cannot be both fixed and dynamic
  81.     // (CBRS_SIZE_DYNAMIC is used for resizng when floating)
  82.     ASSERT (!((dwStyle & CBRS_SIZE_FIXED) &&
  83.               (dwStyle & CBRS_SIZE_DYNAMIC)));
  85.     m_dwStyle = dwStyle & CBRS_ALL; // save the control bar styles
  87.     // register and create the window - skip CControlBar::Create()
  88.     CString wndclass = ::AfxRegisterWndClass(CS_DBLCLKS,
  89.         ::LoadCursor(NULL, IDC_ARROW),
  90.         ::GetSysColorBrush(COLOR_BTNFACE), 0);
  92.     dwStyle &= ~CBRS_ALL; // keep only the generic window styles
  93.     dwStyle |= WS_CLIPCHILDREN; // prevents flashing
  94.     if (!CWnd::Create(wndclass, lpszWindowName, dwStyle,
  95.         CRect(0, 0, 0, 0), pParentWnd, nID))
  96.         return FALSE;
  98.     return TRUE;
  99. }
  101. /////////////////////////////////////////////////////////////////////////
  102. // CSizingControlBar operations
  103. #if defined(_SCB_REPLACE_MINIFRAME) && !defined(_SCB_MINIFRAME_CAPTION)
  104. void CSizingControlBar::EnableDocking(DWORD dwDockStyle)
  105. {
  106.     // must be CBRS_ALIGN_XXX or CBRS_FLOAT_MULTI only
  107.     ASSERT((dwDockStyle & ~(CBRS_ALIGN_ANY|CBRS_FLOAT_MULTI)) == 0);
  108.     // cannot have the CBRS_FLOAT_MULTI style
  109.     ASSERT((dwDockStyle & CBRS_FLOAT_MULTI) == 0);
  110.     // the bar must have CBRS_SIZE_DYNAMIC style
  111.     ASSERT((m_dwStyle & CBRS_SIZE_DYNAMIC) != 0);
  113.     m_dwDockStyle = dwDockStyle;
  114.     if (m_pDockContext == NULL)
  115.         m_pDockContext = new CSCBDockContext(this);
  117.     // permanently wire the bar's owner to its current parent
  118.     if (m_hWndOwner == NULL)
  119.         m_hWndOwner = ::GetParent(m_hWnd);
  120. }
  121. #endif
  123. /////////////////////////////////////////////////////////////////////////
  124. // CSizingControlBar message handlers
  126. int CSizingControlBar::OnCreate(LPCREATESTRUCT lpCreateStruct) 
  127. {
  128.     if (baseCSizingControlBar::OnCreate(lpCreateStruct) == -1)
  129.         return -1;
  131.     // query SPI_GETDRAGFULLWINDOWS system parameter
  132.     // OnSettingChange() will update m_bDragShowContent
  133.     m_bDragShowContent = FALSE;
  134.     ::SystemParametersInfo(SPI_GETDRAGFULLWINDOWS, 0,
  135.         &m_bDragShowContent, 0);
  137.     // uncomment this line if you want raised borders
  138. //    m_dwSCBStyle |= SCBS_SHOWEDGES;
  140.     return 0;
  141. }
  144. LRESULT CSizingControlBar::OnSetText(WPARAM wParam, LPARAM lParam)
  145. {
  146.     UNUSED_ALWAYS(wParam);
  148.     LRESULT lResult = CWnd::Default();
  150.     if (IsFloating() &&
  151.         GetParentFrame()->IsKindOf(RUNTIME_CLASS(CMiniDockFrameWnd)))
  152.     {
  153.         m_pDockBar->SetWindowText((LPCTSTR) lParam); // update dockbar
  154.         GetParentFrame()->DelayRecalcLayout(); // refresh miniframe
  155.     }
  157.     return lResult;
  158. }
  160. const BOOL CSizingControlBar::IsFloating() const
  161. {
  162.     return !IsHorzDocked() && !IsVertDocked();
  163. }
  165. const BOOL CSizingControlBar::IsHorzDocked() const
  166. {
  167.     return (m_nDockBarID == AFX_IDW_DOCKBAR_TOP ||
  168.         m_nDockBarID == AFX_IDW_DOCKBAR_BOTTOM);
  169. }
  171. const BOOL CSizingControlBar::IsVertDocked() const
  172. {
  173.     return (m_nDockBarID == AFX_IDW_DOCKBAR_LEFT ||
  174.         m_nDockBarID == AFX_IDW_DOCKBAR_RIGHT);
  175. }
  177. const BOOL CSizingControlBar::IsSideTracking() const
  178. {
  179.     // don't call this when not tracking
  180.     ASSERT(m_bTracking && !IsFloating());
  182.     return (m_htEdge == HTLEFT || m_htEdge == HTRIGHT) ?
  183.         IsHorzDocked() : IsVertDocked();
  184. }
  186. CSize CSizingControlBar::CalcFixedLayout(BOOL bStretch, BOOL bHorz)
  187. {
  188.     if (bStretch) // the bar is stretched (is not the child of a dockbar)
  189.         if (bHorz)
  190.             return CSize(32767, m_szHorz.cy);
  191.         else
  192.             return CSize(m_szVert.cx, 32767);
  194.     // dirty cast - we need access to protected CDockBar members
  195.     CSCBDockBar* pDockBar = (CSCBDockBar*) m_pDockBar;
  197.     // force imediate RecalcDelayShow() for all sizing bars on the row
  198.     // with delayShow/delayHide flags set to avoid IsVisible() problems
  199.     CSCBArray arrSCBars;
  200.     GetRowSizingBars(arrSCBars);
  201.     AFX_SIZEPARENTPARAMS layout;
  202.     layout.hDWP = pDockBar->m_bLayoutQuery ?
  203.         NULL : ::BeginDeferWindowPos(arrSCBars.GetSize());
  204.     for (int i = 0; i < arrSCBars.GetSize(); i++)
  205.         if (arrSCBars[i]->m_nStateFlags & (delayHide|delayShow))
  206.             arrSCBars[i]->RecalcDelayShow(&layout);
  207.     if (layout.hDWP != NULL)
  208.         ::EndDeferWindowPos(layout.hDWP);
  210.     // get available length
  211.     CRect rc = pDockBar->m_rectLayout;
  212.     if (rc.IsRectEmpty())
  213.         m_pDockSite->GetClientRect(&rc);
  214.     int nLengthTotal = bHorz ? rc.Width() + 2 : rc.Height() - 2;
  216.     if (IsVisible() && !IsFloating() &&
  217.         m_bParentSizing && arrSCBars[0] == this)
  218.         if (NegotiateSpace(nLengthTotal, (bHorz != FALSE)))
  219.             AlignControlBars();
  221.     m_bParentSizing = FALSE;
  223.     if (bHorz)
  224.         return CSize(max(m_szMinHorz.cx, m_szHorz.cx),
  225.                      max(m_szMinHorz.cy, m_szHorz.cy));
  227.     return CSize(max(m_szMinVert.cx, m_szVert.cx),
  228.                  max(m_szMinVert.cy, m_szVert.cy));
  229. }
  231. CSize CSizingControlBar::CalcDynamicLayout(int nLength, DWORD dwMode)
  232. {
  233.     if (dwMode & (LM_HORZDOCK | LM_VERTDOCK)) // docked ?
  234.     {
  235.         if (nLength == -1)
  236.             m_bParentSizing = TRUE;
  238.         return baseCSizingControlBar::CalcDynamicLayout(nLength, dwMode);
  239.     }
  241.     if (dwMode & LM_MRUWIDTH) return m_szFloat;
  242.     if (dwMode & LM_COMMIT) return m_szFloat; // already committed
  244. #ifndef _SCB_REPLACE_MINIFRAME
  245.     // check for dialgonal resizing hit test
  246.     int nHitTest = m_pDockContext->m_nHitTest;
  247.     if (IsFloating() &&
  248.         (nHitTest == HTTOPLEFT || nHitTest == HTBOTTOMLEFT ||
  249.         nHitTest == HTTOPRIGHT || nHitTest == HTBOTTOMRIGHT))
  250.     {
  251.         CPoint ptCursor;
  252.         ::GetCursorPos(&ptCursor);
  254.         CRect rFrame, rBar;
  255.         GetParentFrame()->GetWindowRect(&rFrame);
  256.         GetWindowRect(&rBar);
  257.         
  258.         if (nHitTest == HTTOPLEFT || nHitTest == HTBOTTOMLEFT)
  259.         {
  260.             m_szFloat.cx = rFrame.left + rBar.Width() - ptCursor.x;
  261.             m_pDockContext->m_rectFrameDragHorz.left = 
  262.                 min(ptCursor.x, rFrame.left + rBar.Width() - m_szMinFloat.cx);
  263.         }
  265.         if (nHitTest == HTTOPLEFT || nHitTest == HTTOPRIGHT)
  266.         {
  267.             m_szFloat.cy = rFrame.top + rBar.Height() - ptCursor.y;
  268.             m_pDockContext->m_rectFrameDragHorz.top =
  269.                 min(ptCursor.y, rFrame.top + rBar.Height() - m_szMinFloat.cy);
  270.         }
  272.         if (nHitTest == HTTOPRIGHT || nHitTest == HTBOTTOMRIGHT)
  273.             m_szFloat.cx = rBar.Width() + ptCursor.x - rFrame.right;
  275.         if (nHitTest == HTBOTTOMLEFT || nHitTest == HTBOTTOMRIGHT)
  276.             m_szFloat.cy = rBar.Height() + ptCursor.y - rFrame.bottom;
  277.     }
  278.     else
  279. #endif //_SCB_REPLACE_MINIFRAME
  280.         ((dwMode & LM_LENGTHY) ? m_szFloat.cy : m_szFloat.cx) = nLength;
  282.     m_szFloat.cx = max(m_szFloat.cx, m_szMinFloat.cx);
  283.     m_szFloat.cy = max(m_szFloat.cy, m_szMinFloat.cy);
  285.     return m_szFloat;
  286. }
  288. void CSizingControlBar::OnWindowPosChanging(WINDOWPOS FAR* lpwndpos)
  289. {
  290.     // force non-client recalc if moved or resized
  291.     lpwndpos->flags |= SWP_FRAMECHANGED;
  293.     baseCSizingControlBar::OnWindowPosChanging(lpwndpos);
  295.     // find on which side are we docked
  296.     m_nDockBarID = GetParent()->GetDlgCtrlID();
  298.     if (!IsFloating())
  299.         if (lpwndpos->flags & SWP_SHOWWINDOW)
  300.             m_bKeepSize = TRUE;
  301. }
  303. /////////////////////////////////////////////////////////////////////////
  304. // Mouse Handling
  305. //
  306. void CSizingControlBar::OnLButtonDown(UINT nFlags, CPoint point)
  307. {
  308.     if (m_pDockBar != NULL)
  309.     {
  310.         // start the drag
  311.         ASSERT(m_pDockContext != NULL);
  312.         ClientToScreen(&point);
  313.         m_pDockContext->StartDrag(point);
  314.     }
  315.     else
  316.         CWnd::OnLButtonDown(nFlags, point);
  317. }
  319. void CSizingControlBar::OnLButtonDblClk(UINT nFlags, CPoint point)
  320. {
  321.     if (m_pDockBar != NULL)
  322.     {
  323.         // toggle docking
  324.         ASSERT(m_pDockContext != NULL);
  325.         m_pDockContext->ToggleDocking();
  326.     }
  327.     else
  328.         CWnd::OnLButtonDblClk(nFlags, point);
  329. }
  331. void CSizingControlBar::OnNcLButtonDown(UINT nHitTest, CPoint point) 
  332. {
  333.     UNUSED_ALWAYS(point);
  335.     if (m_bTracking || IsFloating())
  336.         return;
  338.     if ((nHitTest >= HTSIZEFIRST) && (nHitTest <= HTSIZELAST))
  339.         StartTracking(nHitTest, point); // sizing edge hit
  340. }
  342. void CSizingControlBar::OnLButtonUp(UINT nFlags, CPoint point)
  343. {
  344.     if (m_bTracking)
  345.         StopTracking();
  347.     baseCSizingControlBar::OnLButtonUp(nFlags, point);
  348. }
  350. void CSizingControlBar::OnRButtonDown(UINT nFlags, CPoint point)
  351. {
  352.     if (m_bTracking)
  353.         StopTracking();
  355.     baseCSizingControlBar::OnRButtonDown(nFlags, point);
  356. }
  358. void CSizingControlBar::OnMouseMove(UINT nFlags, CPoint point)
  359. {
  360.     if (m_bTracking)
  361.     {
  362.         CPoint ptScreen = point;
  363.         ClientToScreen(&ptScreen);
  365.         OnTrackUpdateSize(ptScreen);
  366.     }
  368.     baseCSizingControlBar::OnMouseMove(nFlags, point);
  369. }
  371. void CSizingControlBar::OnCaptureChanged(CWnd *pWnd)
  372. {
  373.     if (m_bTracking && (pWnd != this))
  374.         StopTracking();
  376.     baseCSizingControlBar::OnCaptureChanged(pWnd);
  377. }
  379. void CSizingControlBar::OnNcCalcSize(BOOL bCalcValidRects,
  380.                                      NCCALCSIZE_PARAMS FAR* lpncsp)
  381. {
  382.     UNUSED_ALWAYS(bCalcValidRects);
  384. #ifndef _SCB_REPLACE_MINIFRAME
  385.     // Enable diagonal resizing for floating miniframe
  386.     if (IsFloating())
  387.     {
  388.         CFrameWnd* pFrame = GetParentFrame();
  389.         if (pFrame != NULL &&
  390.             pFrame->IsKindOf(RUNTIME_CLASS(CMiniFrameWnd)))
  391.         {
  392.             DWORD dwStyle = ::GetWindowLong(pFrame->m_hWnd, GWL_STYLE);
  393.             if ((dwStyle & MFS_4THICKFRAME) != 0)
  394.             {
  395.                 pFrame->ModifyStyle(MFS_4THICKFRAME, 0); // clear
  396.                 GetParent()->ModifyStyle(0, WS_CLIPCHILDREN);
  397.             }
  398.         }
  399.     }
  400. #endif _SCB_REPLACE_MINIFRAME
  402.     // compute the the client area
  403.     m_dwSCBStyle &= ~SCBS_EDGEALL;
  405.     // add resizing edges between bars on the same row
  406.     if (!IsFloating() && m_pDockBar != NULL)
  407.     {
  408.         CSCBArray arrSCBars;
  409.         int nThis;
  410.         GetRowSizingBars(arrSCBars, nThis);
  412.         BOOL bHorz = IsHorzDocked();
  413.         if (nThis > 0)
  414.             m_dwSCBStyle |= bHorz ? SCBS_EDGELEFT : SCBS_EDGETOP;
  416.         if (nThis < arrSCBars.GetUpperBound())
  417.             m_dwSCBStyle |= bHorz ? SCBS_EDGERIGHT : SCBS_EDGEBOTTOM;
  418.     }
  420.     NcCalcClient(&lpncsp->rgrc[0], m_nDockBarID);
  421. }
  423. void CSizingControlBar::NcCalcClient(LPRECT pRc, UINT nDockBarID)
  424. {
  425.     CRect rc(pRc);
  427.     rc.DeflateRect(3, 5, 3, 3);
  428.     if (nDockBarID != AFX_IDW_DOCKBAR_FLOAT)
  429.         rc.DeflateRect(2, 0, 2, 2);
  431.     switch(nDockBarID)
  432.     {
  433.     case AFX_IDW_DOCKBAR_TOP:
  434.         m_dwSCBStyle |= SCBS_EDGEBOTTOM;
  435.         break;
  436.     case AFX_IDW_DOCKBAR_BOTTOM:
  437.         m_dwSCBStyle |= SCBS_EDGETOP;
  438.         break;
  439.     case AFX_IDW_DOCKBAR_LEFT:
  440.         m_dwSCBStyle |= SCBS_EDGERIGHT;
  441.         break;
  442.     case AFX_IDW_DOCKBAR_RIGHT:
  443.         m_dwSCBStyle |= SCBS_EDGELEFT;
  444.         break;
  445.     }
  447.     // make room for edges only if they will be painted
  448.     if (m_dwSCBStyle & SCBS_SHOWEDGES)
  449.         rc.DeflateRect(
  450.             (m_dwSCBStyle & SCBS_EDGELEFT) ? m_cxEdge : 0,
  451.             (m_dwSCBStyle & SCBS_EDGETOP) ? m_cxEdge : 0,
  452.             (m_dwSCBStyle & SCBS_EDGERIGHT) ? m_cxEdge : 0,
  453.             (m_dwSCBStyle & SCBS_EDGEBOTTOM) ? m_cxEdge : 0);
  455.     *pRc = rc;
  456. }
  458. void CSizingControlBar::OnNcPaint()
  459. {
  460.     // get window DC that is clipped to the non-client area
  461.     CWindowDC dc(this);
  463.     CRect rcClient, rcBar;
  464.     GetClientRect(rcClient);
  465.     ClientToScreen(rcClient);
  466.     GetWindowRect(rcBar);
  467.     rcClient.OffsetRect(-rcBar.TopLeft());
  468.     rcBar.OffsetRect(-rcBar.TopLeft());
  470.     CDC mdc;
  471.     mdc.CreateCompatibleDC(&dc);
  472.     
  473.     CBitmap bm;
  474.     bm.CreateCompatibleBitmap(&dc, rcBar.Width(), rcBar.Height());
  475.     CBitmap* pOldBm = mdc.SelectObject(&bm);
  477.     // draw borders in non-client area
  478.     CRect rcDraw = rcBar;
  479.     DrawBorders(&mdc, rcDraw);
  481.     // erase the NC background
  482.     mdc.FillRect(rcDraw, CBrush::FromHandle(
  483.         (HBRUSH) GetClassLong(m_hWnd, GCL_HBRBACKGROUND)));
  485.     if (m_dwSCBStyle & SCBS_SHOWEDGES)
  486.     {
  487.         CRect rcEdge; // paint the sizing edges
  488.         for (int i = 0; i < 4; i++)
  489.             if (GetEdgeRect(rcBar, GetEdgeHTCode(i), rcEdge))
  490.                 mdc.Draw3dRect(rcEdge, ::GetSysColor(COLOR_BTNHIGHLIGHT),
  491.                     ::GetSysColor(COLOR_BTNSHADOW));
  492.     }
  494.     NcPaintGripper(&mdc, rcClient);
  496.     // client area is not our bussiness :)
  497.     dc.IntersectClipRect(rcBar);
  498.     dc.ExcludeClipRect(rcClient);
  500.     dc.BitBlt(0, 0, rcBar.Width(), rcBar.Height(), &mdc, 0, 0, SRCCOPY);
  502.     ReleaseDC(&dc);
  504.     mdc.SelectObject(pOldBm);
  505.     bm.DeleteObject();
  506.     mdc.DeleteDC();
  507. }
  509. void CSizingControlBar::NcPaintGripper(CDC* pDC, CRect rcClient)
  510. {
  511.     UNUSED_ALWAYS(pDC);
  512.     UNUSED_ALWAYS(rcClient);
  513. }
  515. void CSizingControlBar::OnPaint()
  516. {
  517.     // overridden to skip border painting based on clientrect
  518.     CPaintDC dc(this);
  519. }
  521. UINT CSizingControlBar::OnNcHitTest(CPoint point)
  522. {
  523.     CRect rcBar, rcEdge;
  524.     GetWindowRect(rcBar);
  526.     if (!IsFloating())
  527.         for (int i = 0; i < 4; i++)
  528.             if (GetEdgeRect(rcBar, GetEdgeHTCode(i), rcEdge))
  529.                 if (rcEdge.PtInRect(point))
  530.                     return GetEdgeHTCode(i);
  532.     return HTCLIENT;
  533. }
  535. void CSizingControlBar::OnSettingChange(UINT uFlags, LPCTSTR lpszSection)
  536. {
  537.     baseCSizingControlBar::OnSettingChange(uFlags, lpszSection);
  539.     m_bDragShowContent = FALSE;
  540.     ::SystemParametersInfo(SPI_GETDRAGFULLWINDOWS, 0,
  541.         &m_bDragShowContent, 0); // update
  542. }
  544. void CSizingControlBar::OnSize(UINT nType, int cx, int cy)
  545. {
  546.     UNUSED_ALWAYS(nType);
  547.     
  548.     if ((m_dwSCBStyle & SCBS_SIZECHILD) != 0)
  549.     {
  550.         // automatic child resizing - only one child is allowed
  551.         CWnd* pWnd = GetWindow(GW_CHILD);
  552.         if (pWnd != NULL)
  553.         {
  554.             pWnd->MoveWindow(0, 0, cx, cy);
  555.             ASSERT(pWnd->GetWindow(GW_HWNDNEXT) == NULL);
  556.         }
  557.     }
  558. }
  560. void CSizingControlBar::OnClose()
  561. {
  562.     // do nothing: protection against accidentally destruction by the
  563.     //   child control (i.e. if user hits Esc in a child editctrl)
  564. }
  566. /////////////////////////////////////////////////////////////////////////
  567. // CSizingControlBar implementation helpers
  569. void CSizingControlBar::StartTracking(UINT nHitTest, CPoint point)
  570. {
  571.     SetCapture();
  573.     // make sure no updates are pending
  574.     if (!m_bDragShowContent)
  575.         RedrawWindow(NULL, NULL, RDW_ALLCHILDREN | RDW_UPDATENOW);
  577.     m_htEdge = nHitTest;
  578.     m_bTracking = TRUE;
  580.     BOOL bHorz = IsHorzDocked();
  581.     BOOL bHorzTracking = m_htEdge == HTLEFT || m_htEdge == HTRIGHT;
  583.     m_nTrackPosOld = bHorzTracking ? point.x : point.y;
  585.     CRect rcBar, rcEdge;
  586.     GetWindowRect(rcBar);
  587.     GetEdgeRect(rcBar, m_htEdge, rcEdge);
  588.     m_nTrackEdgeOfs = m_nTrackPosOld -
  589.         (bHorzTracking ? rcEdge.CenterPoint().x : rcEdge.CenterPoint().y);
  590.     
  591.     CSCBArray arrSCBars;
  592.     int nThis;
  593.     GetRowSizingBars(arrSCBars, nThis);
  595.     m_nTrackPosMin = m_nTrackPosMax = m_nTrackPosOld;
  596.     if (!IsSideTracking())
  597.     {
  598.         // calc minwidth as the max minwidth of the sizing bars on row
  599.         int nMinWidth = bHorz ? m_szMinHorz.cy : m_szMinVert.cx;
  600.         for (int i = 0; i < arrSCBars.GetSize(); i++)
  601.             nMinWidth = max(nMinWidth, bHorz ? 
  602.                 arrSCBars[i]->m_szMinHorz.cy :
  603.                 arrSCBars[i]->m_szMinVert.cx);
  604.         int nExcessWidth = (bHorz ? m_szHorz.cy : m_szVert.cx) - nMinWidth;
  606.         // the control bar cannot grow with more than the width of
  607.         // remaining client area of the mainframe
  608.         CRect rcT;
  609.         m_pDockSite->RepositionBars(0, 0xFFFF, AFX_IDW_PANE_FIRST,
  610.             reposQuery, &rcT, NULL, TRUE);
  611.         int nMaxWidth = bHorz ? rcT.Height() - 2 : rcT.Width() - 2;
  613.         BOOL bTopOrLeft = m_htEdge == HTTOP || m_htEdge == HTLEFT;
  615.         m_nTrackPosMin -= bTopOrLeft ? nMaxWidth : nExcessWidth;
  616.         m_nTrackPosMax += bTopOrLeft ? nExcessWidth : nMaxWidth;
  617.     }
  618.     else
  619.     {
  620.         // side tracking:
  621.         // max size is the actual size plus the amount the other
  622.         // sizing bars can be decreased until they reach their minsize
  623.         if (m_htEdge == HTBOTTOM || m_htEdge == HTRIGHT)
  624.             nThis++;
  626.         for (int i = 0; i < arrSCBars.GetSize(); i++)
  627.         {
  628.             CSizingControlBar* pBar = arrSCBars[i];
  630.             int nExcessWidth = bHorz ? 
  631.                 pBar->m_szHorz.cx - pBar->m_szMinHorz.cx :
  632.                 pBar->m_szVert.cy - pBar->m_szMinVert.cy;
  634.             if (i < nThis)
  635.                 m_nTrackPosMin -= nExcessWidth;
  636.             else
  637.                 m_nTrackPosMax += nExcessWidth;
  638.         }
  639.     }
  641.     OnTrackInvertTracker(); // draw tracker
  642. }
  644. void CSizingControlBar::StopTracking()
  645. {
  646.     OnTrackInvertTracker(); // erase tracker
  648.     m_bTracking = FALSE;
  649.     ReleaseCapture();
  651.     m_pDockSite->DelayRecalcLayout();
  652. }
  654. void CSizingControlBar::OnTrackUpdateSize(CPoint& point)
  655. {
  656.     ASSERT(!IsFloating());
  658.     BOOL bHorzTrack = m_htEdge == HTLEFT || m_htEdge == HTRIGHT;
  660.     int nTrackPos = bHorzTrack ? point.x : point.y;
  661.     nTrackPos = max(m_nTrackPosMin, min(m_nTrackPosMax, nTrackPos));
  663.     int nDelta = nTrackPos - m_nTrackPosOld;
  665.     if (nDelta == 0)
  666.         return; // no pos change
  668.     OnTrackInvertTracker(); // erase tracker
  670.     m_nTrackPosOld = nTrackPos;
  671.     
  672.     BOOL bHorz = IsHorzDocked();
  674.     CSize sizeNew = bHorz ? m_szHorz : m_szVert;
  675.     switch (m_htEdge)
  676.     {
  677.     case HTLEFT:    sizeNew -= CSize(nDelta, 0); break;
  678.     case HTTOP:     sizeNew -= CSize(0, nDelta); break;
  679.     case HTRIGHT:   sizeNew += CSize(nDelta, 0); break;
  680.     case HTBOTTOM:  sizeNew += CSize(0, nDelta); break;
  681.     }
  683.     CSCBArray arrSCBars;
  684.     int nThis;
  685.     GetRowSizingBars(arrSCBars, nThis);
  687.     if (!IsSideTracking())
  688.         for (int i = 0; i < arrSCBars.GetSize(); i++)
  689.         {
  690.             CSizingControlBar* pBar = arrSCBars[i];
  691.             // make same width (or height)
  692.             (bHorz ? pBar->m_szHorz.cy : pBar->m_szVert.cx) =
  693.                 bHorz ? sizeNew.cy : sizeNew.cx;
  694.         }
  695.     else
  696.     {
  697.         int nGrowingBar = nThis;
  698.         BOOL bBefore = m_htEdge == HTTOP || m_htEdge == HTLEFT;
  699.         if (bBefore && nDelta > 0)
  700.             nGrowingBar--;
  701.         if (!bBefore && nDelta < 0)
  702.             nGrowingBar++;
  703.         if (nGrowingBar != nThis)
  704.             bBefore = !bBefore;
  706.         // nGrowing is growing
  707.         nDelta = abs(nDelta);
  708.         CSizingControlBar* pBar = arrSCBars[nGrowingBar];
  709.         (bHorz ? pBar->m_szHorz.cx : pBar->m_szVert.cy) += nDelta;
  711.         // the others are shrinking
  712.         int nFirst = bBefore ? nGrowingBar - 1 : nGrowingBar + 1;
  713.         int nLimit = bBefore ? -1 : arrSCBars.GetSize();
  715.         for (int i = nFirst; nDelta != 0 && i != nLimit; i += (bBefore ? -1 : 1))
  716.         {
  717.             CSizingControlBar* pBar = arrSCBars[i];
  718.                 
  719.             int nDeltaT = min(nDelta,
  720.                 (bHorz ? pBar->m_szHorz.cx : pBar->m_szVert.cy) -
  721.                 (bHorz ? pBar->m_szMinHorz.cx : pBar->m_szMinVert.cy));
  723.             (bHorz ? pBar->m_szHorz.cx : pBar->m_szVert.cy) -= nDeltaT;
  724.             nDelta -= nDeltaT;
  725.         }
  726.     }
  728.     OnTrackInvertTracker(); // redraw tracker at new pos
  730.     if (m_bDragShowContent)
  731.         m_pDockSite->DelayRecalcLayout();
  732. }
  734. void CSizingControlBar::OnTrackInvertTracker()
  735. {
  736.     ASSERT(m_bTracking);
  738.     if (m_bDragShowContent)
  739.         return; // don't show tracker if DragFullWindows is on
  741.     BOOL bHorz = IsHorzDocked();
  742.     CRect rc, rcBar, rcDock, rcFrame;
  743.     GetWindowRect(rcBar);
  744.     m_pDockBar->GetWindowRect(rcDock);
  745.     m_pDockSite->GetWindowRect(rcFrame);
  746.     VERIFY(GetEdgeRect(rcBar, m_htEdge, rc));
  747.     if (!IsSideTracking())
  748.         rc = bHorz ? 
  749.             CRect(rcDock.left + 1, rc.top, rcDock.right - 1, rc.bottom) :
  750.             CRect(rc.left, rcDock.top + 1, rc.right, rcDock.bottom - 1);
  752.     BOOL bHorzTracking = m_htEdge == HTLEFT || m_htEdge == HTRIGHT;
  753.     int nOfs = m_nTrackPosOld - m_nTrackEdgeOfs;
  754.     nOfs -= bHorzTracking ? rc.CenterPoint().x : rc.CenterPoint().y;
  755.     rc.OffsetRect(bHorzTracking ? nOfs : 0, bHorzTracking ? 0 : nOfs);
  756.     rc.OffsetRect(-rcFrame.TopLeft());
  758.     CDC *pDC = m_pDockSite->GetDCEx(NULL,
  759.         DCX_WINDOW | DCX_CACHE | DCX_LOCKWINDOWUPDATE);
  760.     CBrush* pBrush = CDC::GetHalftoneBrush();
  761.     CBrush* pBrushOld = pDC->SelectObject(pBrush);
  763.     pDC->PatBlt(rc.left, rc.top, rc.Width(), rc.Height(), PATINVERT);
  764.     
  765.     pDC->SelectObject(pBrushOld);
  766.     m_pDockSite->ReleaseDC(pDC);
  767. }
  769. BOOL CSizingControlBar::GetEdgeRect(CRect rcWnd, UINT nHitTest,
  770.                                     CRect& rcEdge)
  771. {
  772.     rcEdge = rcWnd;
  773.     if (m_dwSCBStyle & SCBS_SHOWEDGES)
  774.         rcEdge.DeflateRect(1, 1);
  775.     BOOL bHorz = IsHorzDocked();
  777.     switch (nHitTest)
  778.     {
  779.     case HTLEFT:
  780.         if (!(m_dwSCBStyle & SCBS_EDGELEFT)) return FALSE;
  781.         rcEdge.right = rcEdge.left + m_cxEdge;
  782.         rcEdge.DeflateRect(0, bHorz ? m_cxEdge: 0);
  783.         break;
  784.     case HTTOP:
  785.         if (!(m_dwSCBStyle & SCBS_EDGETOP)) return FALSE;
  786.         rcEdge.bottom = rcEdge.top + m_cxEdge;
  787.         rcEdge.DeflateRect(bHorz ? 0 : m_cxEdge, 0);
  788.         break;
  789.     case HTRIGHT:
  790.         if (!(m_dwSCBStyle & SCBS_EDGERIGHT)) return FALSE;
  791.         rcEdge.left = rcEdge.right - m_cxEdge;
  792.         rcEdge.DeflateRect(0, bHorz ? m_cxEdge: 0);
  793.         break;
  794.     case HTBOTTOM:
  795.         if (!(m_dwSCBStyle & SCBS_EDGEBOTTOM)) return FALSE;
  796.         rcEdge.top = rcEdge.bottom - m_cxEdge;
  797.         rcEdge.DeflateRect(bHorz ? 0 : m_cxEdge, 0);
  798.         break;
  799.     default:
  800.         ASSERT(FALSE); // invalid hit test code
  801.     }
  802.     return TRUE;
  803. }
  805. UINT CSizingControlBar::GetEdgeHTCode(int nEdge)
  806. {
  807.     if (nEdge == 0) return HTLEFT;
  808.     if (nEdge == 1) return HTTOP;
  809.     if (nEdge == 2) return HTRIGHT;
  810.     if (nEdge == 3) return HTBOTTOM;
  811.     ASSERT(FALSE); // invalid edge code
  812.     return HTNOWHERE;
  813. }
  815. void CSizingControlBar::GetRowInfo(int& nFirst, int& nLast, int& nThis)
  816. {
  817.     ASSERT_VALID(m_pDockBar); // verify bounds
  819.     nThis = m_pDockBar->FindBar(this);
  820.     ASSERT(nThis != -1);
  822.     int i, nBars = m_pDockBar->m_arrBars.GetSize();
  824.     // find the first and the last bar in row
  825.     for (nFirst = -1, i = nThis - 1; i >= 0 && nFirst == -1; i--)
  826.         if (m_pDockBar->m_arrBars[i] == NULL)
  827.             nFirst = i + 1;
  828.     for (nLast = -1, i = nThis + 1; i < nBars && nLast == -1; i++)
  829.         if (m_pDockBar->m_arrBars[i] == NULL)
  830.             nLast = i - 1;
  832.     ASSERT((nLast != -1) && (nFirst != -1));
  833. }
  835. void CSizingControlBar::GetRowSizingBars(CSCBArray& arrSCBars)
  836. {
  837.     int nThis; // dummy
  838.     GetRowSizingBars(arrSCBars, nThis);
  839. }
  841. void CSizingControlBar::GetRowSizingBars(CSCBArray& arrSCBars, int& nThis)
  842. {
  843.     arrSCBars.RemoveAll();
  845.     int nFirstT, nLastT, nThisT;
  846.     GetRowInfo(nFirstT, nLastT, nThisT);
  848.     nThis = -1;
  849.     for (int i = nFirstT; i <= nLastT; i++)
  850.     {
  851.         CSizingControlBar* pBar =
  852.             (CSizingControlBar*) m_pDockBar->m_arrBars[i];
  853.         if (HIWORD(pBar) == 0) continue; // placeholder
  854.         if (!pBar->IsVisible()) continue;
  855.         if (pBar->IsKindOf(RUNTIME_CLASS(CSizingControlBar)))
  856.         {
  857.             if (pBar == this)
  858.                 nThis = arrSCBars.GetSize();
  860.             arrSCBars.Add(pBar);
  861.         }
  862.     }
  863. }
  865. BOOL CSizingControlBar::NegotiateSpace(int nLengthTotal, BOOL bHorz)
  866. {
  867.     ASSERT(bHorz == IsHorzDocked());
  869.     int nFirst, nLast, nThis;
  870.     GetRowInfo(nFirst, nLast, nThis);
  872.     int nLengthAvail = nLengthTotal;
  873.     int nLengthActual = 0;
  874.     int nLengthMin = 2;
  875.     int nWidthMax = 0;
  876.     CSizingControlBar* pBar;
  878.     for (int i = nFirst; i <= nLast; i++)
  879.     {
  880.         pBar = (CSizingControlBar*) m_pDockBar->m_arrBars[i];
  881.         if (HIWORD(pBar) == 0) continue; // placeholder
  882.         if (!pBar->IsVisible()) continue;
  883.         BOOL bIsSizingBar = 
  884.             pBar->IsKindOf(RUNTIME_CLASS(CSizingControlBar));
  886.         int nLengthBar; // minimum length of the bar
  887.         if (bIsSizingBar)
  888.             nLengthBar = bHorz ? pBar->m_szMinHorz.cx - 2 :
  889.                 pBar->m_szMinVert.cy - 2;
  890.         else
  891.         {
  892.             CRect rcBar;
  893.             pBar->GetWindowRect(&rcBar);
  894.             nLengthBar = bHorz ? rcBar.Width() - 2 : rcBar.Height() - 2;
  895.         }
  897.         nLengthMin += nLengthBar;
  898.         if (nLengthMin > nLengthTotal)
  899.         {
  900.             // split the row after fixed bar
  901.             if (i < nThis)
  902.             {
  903.                 m_pDockBar->m_arrBars.InsertAt(i + 1,
  904.                     (CControlBar*) NULL);
  905.                 return FALSE;
  906.             }
  907.             
  908.             // only this sizebar remains on the row, adjust it to minsize
  909.             if (i == nThis)
  910.             {
  911.                 if (bHorz)
  912.                     m_szHorz.cx = m_szMinHorz.cx;
  913.                 else
  914.                     m_szVert.cy = m_szMinVert.cy;
  916.                 return TRUE; // the dockbar will split the row for us
  917.             }
  919.             // we have enough bars - go negotiate with them
  920.             m_pDockBar->m_arrBars.InsertAt(i, (CControlBar*) NULL);
  921.             nLast = i - 1;
  922.             break;
  923.         }
  925.         if (bIsSizingBar)
  926.         {
  927.             nLengthActual += bHorz ? pBar->m_szHorz.cx - 2 : 
  928.                 pBar->m_szVert.cy - 2;
  929.             nWidthMax = max(nWidthMax, bHorz ? pBar->m_szHorz.cy :
  930.                 pBar->m_szVert.cx);
  931.         }
  932.         else
  933.             nLengthAvail -= nLengthBar;
  934.     }
  936.     CSCBArray arrSCBars;
  937.     GetRowSizingBars(arrSCBars);
  938.     int nNumBars = arrSCBars.GetSize();
  939.     int nDelta = nLengthAvail - nLengthActual;
  941.     // return faster when there is only one sizing bar per row (this one)
  942.     if (nNumBars == 1)
  943.     {
  944.         ASSERT(arrSCBars[0] == this);
  946.         if (nDelta == 0)
  947.             return TRUE;
  948.         
  949.         m_bKeepSize = FALSE;
  950.         (bHorz ? m_szHorz.cx : m_szVert.cy) += nDelta;
  952.         return TRUE;
  953.     }
  955.     // make all the bars the same width
  956.     for (i = 0; i < nNumBars; i++)
  957.         if (bHorz)
  958.             arrSCBars[i]->m_szHorz.cy = nWidthMax;
  959.         else
  960.             arrSCBars[i]->m_szVert.cx = nWidthMax;
  962.     // distribute the difference between the bars,
  963.     // but don't shrink them below their minsizes
  964.     while (nDelta != 0)
  965.     {
  966.         int nDeltaOld = nDelta;
  967.         for (i = 0; i < nNumBars; i++)
  968.         {
  969.             pBar = arrSCBars[i];
  970.             int nLMin = bHorz ?
  971.                 pBar->m_szMinHorz.cx : pBar->m_szMinVert.cy;
  972.             int nL = bHorz ? pBar->m_szHorz.cx : pBar->m_szVert.cy;
  974.             if ((nL == nLMin) && (nDelta < 0) || // already at min length
  975.                 pBar->m_bKeepSize) // or wants to keep its size
  976.                 continue;
  978.             // sign of nDelta
  979.             int nDelta2 = (nDelta == 0) ? 0 : ((nDelta < 0) ? -1 : 1);
  981.             (bHorz ? pBar->m_szHorz.cx : pBar->m_szVert.cy) += nDelta2;
  982.             nDelta -= nDelta2;
  983.             if (nDelta == 0) break;
  984.         }
  985.         // clear m_bKeepSize flags
  986.         if ((nDeltaOld == nDelta) || (nDelta == 0))
  987.             for (i = 0; i < nNumBars; i++)
  988.                 arrSCBars[i]->m_bKeepSize = FALSE;
  989.     }
  991.     return TRUE;
  992. }
  994. void CSizingControlBar::AlignControlBars()
  995. {
  996.     int nFirst, nLast, nThis;
  997.     GetRowInfo(nFirst, nLast, nThis);
  999.     BOOL bHorz = IsHorzDocked();
  1000.     BOOL bNeedRecalc = FALSE;
  1001.     int nAlign = bHorz ? -2 : 0;
  1003.     CRect rc, rcDock;
  1004.     m_pDockBar->GetWindowRect(&rcDock);
  1006.     for (int i = nFirst; i <= nLast; i++)
  1007.     {
  1008.         CSizingControlBar* pBar =
  1009.             (CSizingControlBar*) m_pDockBar->m_arrBars[i];
  1010.         if (HIWORD(pBar) == 0) continue; // placeholder
  1011.         if (!pBar->IsVisible()) continue;
  1013.         pBar->GetWindowRect(&rc);
  1014.         rc.OffsetRect(-rcDock.TopLeft());
  1016.         if (pBar->IsKindOf(RUNTIME_CLASS(CSizingControlBar)))
  1017.             rc = CRect(rc.TopLeft(),
  1018.                 bHorz ? pBar->m_szHorz : pBar->m_szVert);
  1020.         if ((bHorz ? rc.left : rc.top) != nAlign)
  1021.         {
  1022.             if (!bHorz)
  1023.                 rc.OffsetRect(0, nAlign - rc.top - 2);
  1024.             else if (m_nDockBarID == AFX_IDW_DOCKBAR_TOP)
  1025.                 rc.OffsetRect(nAlign - rc.left, -2);
  1026.             else
  1027.                 rc.OffsetRect(nAlign - rc.left, 0);
  1028.             pBar->MoveWindow(rc);
  1029.             bNeedRecalc = TRUE;
  1030.         }
  1031.         nAlign += (bHorz ? rc.Width() : rc.Height()) - 2;
  1032.     }
  1034.     if (bNeedRecalc)
  1035.         m_pDockSite->DelayRecalcLayout();
  1036. }
  1038. void CSizingControlBar::OnUpdateCmdUI(CFrameWnd* pTarget,
  1039.                                       BOOL bDisableIfNoHndler)
  1040. {
  1041.     UNUSED_ALWAYS(bDisableIfNoHndler);
  1042.     UNUSED_ALWAYS(pTarget);
  1043. }
  1045. void CSizingControlBar::LoadState(LPCTSTR lpszProfileName)
  1046. {
  1047.     ASSERT_VALID(this);
  1048.     ASSERT(GetSafeHwnd()); // must be called after Create()
  1050. #if defined(_SCB_REPLACE_MINIFRAME) && !defined(_SCB_MINIFRAME_CAPTION)
  1051.     // compensate the caption miscalculation in CFrameWnd::SetDockState()
  1052.     CDockState state;
  1053.     state.LoadState(lpszProfileName);
  1055.     UINT nID = GetDlgCtrlID();
  1056.     for (int i = 0; i < state.m_arrBarInfo.GetSize(); i++)
  1057.     {
  1058.         CControlBarInfo* pInfo = (CControlBarInfo*)state.m_arrBarInfo[i];
  1059.         ASSERT(pInfo != NULL);
  1060.         if (!pInfo->m_bFloating)
  1061.             continue;
  1062.         
  1063.         // this is a floating dockbar - check the ID array
  1064.         for (int j = 0; j < pInfo->m_arrBarID.GetSize(); j++)
  1065.             if ((DWORD) pInfo->m_arrBarID[j] == nID)
  1066.             {
  1067.                 // found this bar - offset origin and save settings
  1068.                 pInfo->m_pointPos.x++;
  1069.                 pInfo->m_pointPos.y +=
  1070.                     ::GetSystemMetrics(SM_CYSMCAPTION) + 1;
  1071.                 pInfo->SaveState(lpszProfileName, i);
  1072.             }
  1073.     }
  1074. #endif //_SCB_REPLACE_MINIFRAME && !_SCB_MINIFRAME_CAPTION
  1076.     CWinApp* pApp = AfxGetApp();
  1078.     TCHAR szSection[256];
  1079.     wsprintf(szSection, _T("%s-SCBar-%d"), lpszProfileName,
  1080.         GetDlgCtrlID());
  1082.     m_szHorz.cx = max(m_szMinHorz.cx, (int) pApp->GetProfileInt(
  1083.         szSection, _T("sizeHorzCX"), m_szHorz.cx));
  1084.     m_szHorz.cy = max(m_szMinHorz.cy, (int) pApp->GetProfileInt(
  1085.         szSection, _T("sizeHorzCY"), m_szHorz.cy));
  1087.     m_szVert.cx = max(m_szMinVert.cx, (int) pApp->GetProfileInt(
  1088.         szSection, _T("sizeVertCX"), m_szVert.cx));
  1089.     m_szVert.cy = max(m_szMinVert.cy, (int) pApp->GetProfileInt(
  1090.         szSection, _T("sizeVertCY"), m_szVert.cy));
  1092.     m_szFloat.cx = max(m_szMinFloat.cx, (int) pApp->GetProfileInt(
  1093.         szSection, _T("sizeFloatCX"), m_szFloat.cx));
  1094.     m_szFloat.cy = max(m_szMinFloat.cy, (int) pApp->GetProfileInt(
  1095.         szSection, _T("sizeFloatCY"), m_szFloat.cy));
  1096. }
  1098. void CSizingControlBar::SaveState(LPCTSTR lpszProfileName)
  1099. {
  1100.     // place your SaveState or GlobalSaveState call in
  1101.     // CMainFrame's OnClose() or DestroyWindow(), not in OnDestroy()
  1102.     ASSERT_VALID(this);
  1103.     ASSERT(GetSafeHwnd());
  1105.     CWinApp* pApp = AfxGetApp();
  1107.     TCHAR szSection[256];
  1108.     wsprintf(szSection, _T("%s-SCBar-%d"), lpszProfileName,
  1109.         GetDlgCtrlID());
  1111.     pApp->WriteProfileInt(szSection, _T("sizeHorzCX"), m_szHorz.cx);
  1112.     pApp->WriteProfileInt(szSection, _T("sizeHorzCY"), m_szHorz.cy);
  1114.     pApp->WriteProfileInt(szSection, _T("sizeVertCX"), m_szVert.cx);
  1115.     pApp->WriteProfileInt(szSection, _T("sizeVertCY"), m_szVert.cy);
  1117.     pApp->WriteProfileInt(szSection, _T("sizeFloatCX"), m_szFloat.cx);
  1118.     pApp->WriteProfileInt(szSection, _T("sizeFloatCY"), m_szFloat.cy);
  1119. }
  1121. void CSizingControlBar::GlobalLoadState(CFrameWnd* pFrame,
  1122.                                         LPCTSTR lpszProfileName)
  1123. {
  1124.     POSITION pos = pFrame->m_listControlBars.GetHeadPosition();
  1125.     while (pos != NULL)
  1126.     {
  1127.         CSizingControlBar* pBar = 
  1128.             (CSizingControlBar*) pFrame->m_listControlBars.GetNext(pos);
  1129.         ASSERT(pBar != NULL);
  1130.         if (pBar->IsKindOf(RUNTIME_CLASS(CSizingControlBar)))
  1131.             pBar->LoadState(lpszProfileName);
  1132.     }
  1133. }
  1135. void CSizingControlBar::GlobalSaveState(CFrameWnd* pFrame,
  1136.                                         LPCTSTR lpszProfileName)
  1137. {
  1138.     POSITION pos = pFrame->m_listControlBars.GetHeadPosition();
  1139.     while (pos != NULL)
  1140.     {
  1141.         CSizingControlBar* pBar =
  1142.             (CSizingControlBar*) pFrame->m_listControlBars.GetNext(pos);
  1143.         ASSERT(pBar != NULL);
  1144.         if (pBar->IsKindOf(RUNTIME_CLASS(CSizingControlBar)))
  1145.             pBar->SaveState(lpszProfileName);
  1146.     }
  1147. }
  1149. #ifdef _SCB_REPLACE_MINIFRAME
  1150. #ifndef _SCB_MINIFRAME_CAPTION
  1151. /////////////////////////////////////////////////////////////////////////////
  1152. // CSCBDockContext Drag Operations
  1154. static void AdjustRectangle(CRect& rect, CPoint pt)
  1155. {
  1156.     int nXOffset = (pt.x < rect.left) ? (pt.x - rect.left) :
  1157.                     (pt.x > rect.right) ? (pt.x - rect.right) : 0;
  1158.     int nYOffset = (pt.y < rect.top) ? (pt.y - rect.top) :
  1159.                     (pt.y > rect.bottom) ? (pt.y - rect.bottom) : 0;
  1160.     rect.OffsetRect(nXOffset, nYOffset);
  1161. }
  1163. void CSCBDockContext::StartDrag(CPoint pt)
  1164. {
  1165.     ASSERT_VALID(m_pBar);
  1166.     m_bDragging = TRUE;
  1168.     InitLoop();
  1170.     ASSERT((m_pBar->m_dwStyle & CBRS_SIZE_DYNAMIC) != 0);
  1172.     // get true bar size (including borders)
  1173.     CRect rect;
  1174.     m_pBar->GetWindowRect(rect);
  1175.     m_ptLast = pt;
  1176.     CSize sizeHorz = m_pBar->CalcDynamicLayout(0, LM_HORZ | LM_HORZDOCK);
  1177.     CSize sizeVert = m_pBar->CalcDynamicLayout(0, LM_VERTDOCK);
  1178.     CSize sizeFloat = m_pBar->CalcDynamicLayout(0, LM_HORZ | LM_MRUWIDTH);
  1180.     m_rectDragHorz = CRect(rect.TopLeft(), sizeHorz);
  1181.     m_rectDragVert = CRect(rect.TopLeft(), sizeVert);
  1183.     // calculate frame dragging rectangle
  1184.     m_rectFrameDragHorz = CRect(rect.TopLeft(), sizeFloat);
  1186. #ifdef _MAC
  1187.     CMiniFrameWnd::CalcBorders(&m_rectFrameDragHorz,
  1188.         WS_THICKFRAME, WS_EX_FORCESIZEBOX);
  1189. #else
  1190.     CMiniFrameWnd::CalcBorders(&m_rectFrameDragHorz, WS_THICKFRAME);
  1191. #endif
  1192.     m_rectFrameDragHorz.DeflateRect(2, 2);
  1193.     m_rectFrameDragVert = m_rectFrameDragHorz;
  1194.     
  1195.     // adjust rectangles so that point is inside
  1196.     AdjustRectangle(m_rectDragHorz, pt);
  1197.     AdjustRectangle(m_rectDragVert, pt);
  1198.     AdjustRectangle(m_rectFrameDragHorz, pt);
  1199.     AdjustRectangle(m_rectFrameDragVert, pt);
  1201.     // initialize tracking state and enter tracking loop
  1202.     m_dwOverDockStyle = CanDock();
  1203.     Move(pt);   // call it here to handle special keys
  1204.     Track();
  1205. }
  1206. #endif //_SCB_MINIFRAME_CAPTION
  1208. /////////////////////////////////////////////////////////////////////////////
  1209. // CSCBMiniDockFrameWnd
  1211. IMPLEMENT_DYNCREATE(CSCBMiniDockFrameWnd, baseCSCBMiniDockFrameWnd);
  1213. BEGIN_MESSAGE_MAP(CSCBMiniDockFrameWnd, baseCSCBMiniDockFrameWnd)
  1214.     //{{AFX_MSG_MAP(CSCBMiniDockFrameWnd)
  1215.     ON_WM_NCLBUTTONDOWN()
  1216.     ON_WM_GETMINMAXINFO()
  1217.     ON_WM_WINDOWPOSCHANGING()
  1218.     ON_WM_SIZE()
  1219.     //}}AFX_MSG_MAP
  1220. END_MESSAGE_MAP()
  1222. BOOL CSCBMiniDockFrameWnd::Create(CWnd* pParent, DWORD dwBarStyle)
  1223. {
  1224.     // set m_bInRecalcLayout to avoid flashing during creation
  1225.     // RecalcLayout will be called once something is docked
  1226.     m_bInRecalcLayout = TRUE;
  1228.     DWORD dwStyle = WS_POPUP|WS_CAPTION|WS_SYSMENU|MFS_MOVEFRAME|
  1229.         MFS_4THICKFRAME|MFS_SYNCACTIVE|MFS_BLOCKSYSMENU|
  1230.         FWS_SNAPTOBARS;
  1232.     if (dwBarStyle & CBRS_SIZE_DYNAMIC)
  1233.         dwStyle &= ~MFS_MOVEFRAME;
  1235.     DWORD dwExStyle = 0;
  1236. #ifdef _MAC
  1237.     if (dwBarStyle & CBRS_SIZE_DYNAMIC)
  1238.         dwExStyle |= WS_EX_FORCESIZEBOX;
  1239.     else
  1240.         dwStyle &= ~(MFS_MOVEFRAME|MFS_4THICKFRAME);
  1241. #endif
  1243.     if (!CMiniFrameWnd::CreateEx(dwExStyle,
  1244.         NULL, &afxChNil, dwStyle, rectDefault, pParent))
  1245.     {
  1246.         m_bInRecalcLayout = FALSE;
  1247.         return FALSE;
  1248.     }
  1249.     dwStyle = dwBarStyle & (CBRS_ALIGN_LEFT|CBRS_ALIGN_RIGHT) ?
  1250.         CBRS_ALIGN_LEFT : CBRS_ALIGN_TOP;
  1251.     dwStyle |= dwBarStyle & CBRS_FLOAT_MULTI;
  1252.     CMenu* pSysMenu = GetSystemMenu(FALSE);
  1253.     //pSysMenu->DeleteMenu(SC_SIZE, MF_BYCOMMAND);
  1254.     CString strHide;
  1255.     if (strHide.LoadString(AFX_IDS_HIDE))
  1256.     {
  1257.         pSysMenu->DeleteMenu(SC_CLOSE, MF_BYCOMMAND);
  1258.         pSysMenu->AppendMenu(MF_STRING|MF_ENABLED, SC_CLOSE, strHide);
  1259.     }
  1261.     // must initially create with parent frame as parent
  1262.     if (!m_wndDockBar.Create(pParent, WS_CHILD | WS_VISIBLE | dwStyle,
  1263.         AFX_IDW_DOCKBAR_FLOAT))
  1264.     {
  1265.         m_bInRecalcLayout = FALSE;
  1266.         return FALSE;
  1267.     }
  1269.     // set parent to CMiniDockFrameWnd
  1270.     m_wndDockBar.SetParent(this);
  1271.     m_bInRecalcLayout = FALSE;
  1273.     return TRUE;
  1274. }
  1276. void CSCBMiniDockFrameWnd::OnNcLButtonDown(UINT nHitTest, CPoint point)
  1277. {
  1278.     if (nHitTest == HTCAPTION || nHitTest == HTCLOSE)
  1279.     {
  1280.         baseCSCBMiniDockFrameWnd::OnNcLButtonDown(nHitTest, point);
  1281.         return;
  1282.     }
  1284.     if (GetSizingControlBar() != NULL)
  1285.         CMiniFrameWnd::OnNcLButtonDown(nHitTest, point);
  1286.     else
  1287.         baseCSCBMiniDockFrameWnd::OnNcLButtonDown(nHitTest, point);
  1288. }
  1290. CSizingControlBar* CSCBMiniDockFrameWnd::GetSizingControlBar()
  1291. {
  1292.     CWnd* pWnd = GetWindow(GW_CHILD); // get the dockbar
  1293.     if (pWnd == NULL)
  1294.         return NULL;
  1295.     
  1296.     pWnd = pWnd->GetWindow(GW_CHILD); // get the controlbar
  1297.     if (pWnd == NULL)
  1298.         return NULL;
  1300.     if (!pWnd->IsKindOf(RUNTIME_CLASS(CSizingControlBar)))
  1301.         return NULL;
  1303.     return (CSizingControlBar*) pWnd;
  1304. }
  1306. void CSCBMiniDockFrameWnd::OnSize(UINT nType, int cx, int cy) 
  1307. {
  1308.     CSizingControlBar* pBar = GetSizingControlBar();
  1309.     if ((pBar != NULL) && (GetStyle() & MFS_4THICKFRAME) == 0
  1310.         && pBar->IsVisible())
  1311.         pBar->m_szFloat = CSize(cx + 4, cy + 4);
  1313.     baseCSCBMiniDockFrameWnd::OnSize(nType, cx, cy);
  1314. }
  1316. void CSCBMiniDockFrameWnd::OnGetMinMaxInfo(MINMAXINFO FAR* lpMMI)
  1317. {
  1318.     baseCSCBMiniDockFrameWnd::OnGetMinMaxInfo(lpMMI);
  1320.     CSizingControlBar* pBar = GetSizingControlBar();
  1321.     if (pBar != NULL)
  1322.     {
  1323.         CRect r(CPoint(0, 0), pBar->m_szMinFloat - CSize(4, 4));
  1324. #ifndef _SCB_MINIFRAME_CAPTION
  1325.         CMiniFrameWnd::CalcBorders(&r, WS_THICKFRAME);
  1326. #else
  1327.         CMiniFrameWnd::CalcBorders(&r, WS_THICKFRAME|WS_CAPTION);
  1328. #endif //_SCB_MINIFRAME_CAPTION
  1329.         lpMMI->ptMinTrackSize.x = r.Width();
  1330.         lpMMI->ptMinTrackSize.y = r.Height();
  1331.     }
  1332. }
  1334. void CSCBMiniDockFrameWnd::OnWindowPosChanging(WINDOWPOS FAR* lpwndpos) 
  1335. {
  1336.     if ((GetStyle() & MFS_4THICKFRAME) != 0)
  1337.     {
  1338.         CSizingControlBar* pBar = GetSizingControlBar();
  1339.         if (pBar != NULL)
  1340.         {
  1341.             lpwndpos->flags |= SWP_NOSIZE; // don't size this time
  1342.             // prevents flicker
  1343.             pBar->m_pDockBar->ModifyStyle(0, WS_CLIPCHILDREN);
  1344.             // enable diagonal resizing
  1345.             ModifyStyle(MFS_4THICKFRAME, 0);
  1346. #ifndef _SCB_MINIFRAME_CAPTION
  1347.             // remove caption
  1348.             ModifyStyle(WS_SYSMENU|WS_CAPTION, 0);
  1349. #endif
  1350.             DelayRecalcLayout();
  1351.             pBar->PostMessage(WM_NCPAINT);
  1352.         }
  1353.     }
  1355.     CMiniFrameWnd::OnWindowPosChanging(lpwndpos);
  1356. }
  1358. #endif //_SCB_REPLACE_MINIFRAME