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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
sizecbar.cpp
资源名称：fullMPCcode.rar　[点击查看]
上传用户：xjjlds
上传日期：2015-12-05
资源大小：22823k
文件大小：44k
源码类别：

多媒体编程

开发平台：

Visual C++

sizecbar.cpp：源码内容
  1. /////////////////////////////////////////////////////////////////////////
  2. //
  3. // CSizingControlBar            Version 2.43
  4. //
  5. // Created: Jan 24, 1998        Last Modified: August 03, 2000
  6. //
  7. // See the official site at www.datamekanix.com for documentation and
  8. // the latest news.
  9. //
  10. /////////////////////////////////////////////////////////////////////////
  11. // Copyright (C) 1998-2000 by Cristi Posea. All rights reserved.
  12. //
  13. // This code is free for personal and commercial use, providing this 
  14. // notice remains intact in the source files and all eventual changes are
  15. // clearly marked with comments.
  16. //
  17. // You must obtain the author's consent before you can include this code
  18. // in a software library.
  19. //
  20. // No warrantee of any kind, express or implied, is included with this
  21. // software; use at your own risk, responsibility for damages (if any) to
  22. // anyone resulting from the use of this software rests entirely with the
  23. // user.
  24. //
  25. // Send bug reports, bug fixes, enhancements, requests, flames, etc. to
  26. // cristi@datamekanix.com or post them at the message board at the site.
  27. //
  28. // The sources and a short version of the docs are also available at
  29. // www.codeproject.com . Look for a "Docking Windows" section and check
  30. // the version to be sure you get the latest one ;)
  31. //
  32. // Hint: These classes are intended to be used as base classes. Do not
  33. // simply add your code to these file - instead create a new class
  34. // derived from one of CSizingControlBarXX classes and put there what
  35. // you need. See CMyBar classes in the demo projects for examples.
  36. // Modify this file only to fix bugs, and don't forget to send me a copy.
  37. /////////////////////////////////////////////////////////////////////////
  38. // Acknowledgements:
  39. //  o   Thanks to Harlan R. Seymour for his continuous support during
  40. //      development of this code.
  41. //  o   Thanks to Dundas Software for the opportunity 
  42. //      to test this code on real-life applications.
  43. //  o   Some ideas for the gripper came from the CToolBarEx flat toolbar
  44. //      by Joerg Koenig. Thanks, Joerg!
  45. //  o   Thanks to Robert Wolpow for the code on which CDockContext based
  46. //      dialgonal resizing is based.
  47. //  o   Thanks to the following people for various bug fixes and/or
  48. //      enhancements: Chris Maunder, Jakawan Ratiwanich, Udo Schaefer,
  49. //      Anatoly Ivasyuk, Peter Hauptmann.
  50. //  o   And, of course, many thanks to all of you who used this code,
  51. //      for the invaluable feedback I received.
  52. /////////////////////////////////////////////////////////////////////////
  54. // sizecbar.cpp : implementation file
  55. //
  57. #include "stdafx.h"
  58. #include "sizecbar.h"
  60. #ifdef _DEBUG
  61. #define new DEBUG_NEW
  62. #undef THIS_FILE
  63. static char THIS_FILE[] = __FILE__;
  64. #endif
  66. /////////////////////////////////////////////////////////////////////////
  67. // CSizingControlBar
  69. IMPLEMENT_DYNAMIC(CSizingControlBar, baseCSizingControlBar);
  71. CSizingControlBar::CSizingControlBar()
  72. {
  73.     m_szMinHorz = CSize(33, 32);
  74.     m_szMinVert = CSize(33, 32);
  75.     m_szMinFloat = CSize(37, 32);
  76.     m_szHorz = CSize(200, 200);
  77.     m_szVert = CSize(200, 200);
  78.     m_szFloat = CSize(200, 200);
  79.     m_bTracking = FALSE;
  80.     m_bKeepSize = FALSE;
  81.     m_bParentSizing = FALSE;
  82.     m_cxEdge = 5;
  83.     m_bDragShowContent = FALSE;
  84.     m_nDockBarID = 0;
  85.     m_dwSCBStyle = 0;
  86. }
  88. CSizingControlBar::~CSizingControlBar()
  89. {
  90. }
  92. BEGIN_MESSAGE_MAP(CSizingControlBar, baseCSizingControlBar)
  93.     //{{AFX_MSG_MAP(CSizingControlBar)
  94.     ON_WM_CREATE()
  95.     ON_WM_PAINT()
  96.     ON_WM_NCPAINT()
  97.     ON_WM_NCCALCSIZE()
  98.     ON_WM_WINDOWPOSCHANGING()
  99.     ON_WM_CAPTURECHANGED()
  100.     ON_WM_SETTINGCHANGE()
  101.     ON_WM_LBUTTONUP()
  102.     ON_WM_MOUSEMOVE()
  103.     ON_WM_NCLBUTTONDOWN()
  104.     ON_WM_LBUTTONDOWN()
  105.     ON_WM_LBUTTONDBLCLK()
  106.     ON_WM_RBUTTONDOWN()
  107.     ON_WM_NCMOUSEMOVE()
  108. //  ON_WM_NCHITTEST()
  109.     ON_WM_CLOSE()
  110.     ON_WM_SIZE()
  111.     //}}AFX_MSG_MAP
  112.     ON_MESSAGE(WM_SETTEXT, OnSetText)
  113. END_MESSAGE_MAP()
  115. // old creation method, still here for compatibility reasons
  116. BOOL CSizingControlBar::Create(LPCTSTR lpszWindowName, CWnd* pParentWnd,
  117.                                CSize sizeDefault, BOOL bHasGripper,
  118.                                UINT nID, DWORD dwStyle)
  119. {
  120.     UNUSED_ALWAYS(bHasGripper);
  122.     m_szHorz = m_szVert = m_szFloat = sizeDefault;
  123.     return Create(lpszWindowName, pParentWnd, nID, dwStyle);
  124. }
  126. // preffered creation method
  127. BOOL CSizingControlBar::Create(LPCTSTR lpszWindowName,
  128.                                CWnd* pParentWnd, UINT nID,
  129.                                DWORD dwStyle)
  130. {
  131.     // must have a parent
  132.     ASSERT_VALID(pParentWnd);
  133.     // cannot be both fixed and dynamic
  134.     // (CBRS_SIZE_DYNAMIC is used for resizng when floating)
  135.     ASSERT (!((dwStyle & CBRS_SIZE_FIXED) &&
  136.               (dwStyle & CBRS_SIZE_DYNAMIC)));
  138.     m_dwStyle = dwStyle & CBRS_ALL; // save the control bar styles
  140.     // register and create the window - skip CControlBar::Create()
  141.     CString wndclass = ::AfxRegisterWndClass(CS_DBLCLKS,
  142.         ::LoadCursor(NULL, IDC_ARROW),
  143.         ::GetSysColorBrush(COLOR_BTNFACE), 0);
  145.     dwStyle &= ~CBRS_ALL; // keep only the generic window styles
  146.     dwStyle |= WS_CLIPCHILDREN; // prevents flashing
  147.     if (!CWnd::Create(wndclass, lpszWindowName, dwStyle,
  148.         CRect(0, 0, 0, 0), pParentWnd, nID))
  149.         return FALSE;
  151.     return TRUE;
  152. }
  154. /////////////////////////////////////////////////////////////////////////
  155. // CSizingControlBar operations
  156. #if defined(_SCB_REPLACE_MINIFRAME) && !defined(_SCB_MINIFRAME_CAPTION)
  157. void CSizingControlBar::EnableDocking(DWORD dwDockStyle)
  158. {
  159.     // must be CBRS_ALIGN_XXX or CBRS_FLOAT_MULTI only
  160.     ASSERT((dwDockStyle & ~(CBRS_ALIGN_ANY|CBRS_FLOAT_MULTI)) == 0);
  161.     // cannot have the CBRS_FLOAT_MULTI style
  162.     ASSERT((dwDockStyle & CBRS_FLOAT_MULTI) == 0);
  163.     // the bar must have CBRS_SIZE_DYNAMIC style
  164.     ASSERT((m_dwStyle & CBRS_SIZE_DYNAMIC) != 0);
  166.     m_dwDockStyle = dwDockStyle;
  167.     if (m_pDockContext == NULL)
  168.         m_pDockContext = new CSCBDockContext(this);
  170.     // permanently wire the bar's owner to its current parent
  171.     if (m_hWndOwner == NULL)
  172.         m_hWndOwner = ::GetParent(m_hWnd);
  173. }
  174. #endif
  176. /////////////////////////////////////////////////////////////////////////
  177. // CSizingControlBar message handlers
  179. int CSizingControlBar::OnCreate(LPCREATESTRUCT lpCreateStruct) 
  180. {
  181.     if (baseCSizingControlBar::OnCreate(lpCreateStruct) == -1)
  182.         return -1;
  184.     // query SPI_GETDRAGFULLWINDOWS system parameter
  185.     // OnSettingChange() will update m_bDragShowContent
  186.     m_bDragShowContent = FALSE;
  187.     ::SystemParametersInfo(SPI_GETDRAGFULLWINDOWS, 0,
  188.         &m_bDragShowContent, 0);
  190.     // uncomment this line if you want raised borders
  191. //    m_dwSCBStyle |= SCBS_SHOWEDGES;
  193.     return 0;
  194. }
  197. LRESULT CSizingControlBar::OnSetText(WPARAM wParam, LPARAM lParam)
  198. {
  199.     UNUSED_ALWAYS(wParam);
  201.     LRESULT lResult = CWnd::Default();
  203.     if (IsFloating() &&
  204.         GetParentFrame()->IsKindOf(RUNTIME_CLASS(CMiniDockFrameWnd)))
  205.     {
  206.         m_pDockBar->SetWindowText((LPCTSTR) lParam); // update dockbar
  207.         GetParentFrame()->DelayRecalcLayout(); // refresh miniframe
  208.     }
  210.     return lResult;
  211. }
  213. const BOOL CSizingControlBar::IsFloating() const
  214. {
  215.     return !IsHorzDocked() && !IsVertDocked();
  216. }
  218. const BOOL CSizingControlBar::IsHorzDocked() const
  219. {
  220.     return (m_nDockBarID == AFX_IDW_DOCKBAR_TOP ||
  221.         m_nDockBarID == AFX_IDW_DOCKBAR_BOTTOM);
  222. }
  224. const BOOL CSizingControlBar::IsVertDocked() const
  225. {
  226.     return (m_nDockBarID == AFX_IDW_DOCKBAR_LEFT ||
  227.         m_nDockBarID == AFX_IDW_DOCKBAR_RIGHT);
  228. }
  230. const BOOL CSizingControlBar::IsSideTracking() const
  231. {
  232.     // don't call this when not tracking
  233.     ASSERT(m_bTracking && !IsFloating());
  235.     return (m_htEdge == HTLEFT || m_htEdge == HTRIGHT) ?
  236.         IsHorzDocked() : IsVertDocked();
  237. }
  239. CSize CSizingControlBar::CalcFixedLayout(BOOL bStretch, BOOL bHorz)
  240. {
  241.     if (bStretch) // the bar is stretched (is not the child of a dockbar)
  242.         if (bHorz)
  243.             return CSize(32767, m_szHorz.cy);
  244.         else
  245.             return CSize(m_szVert.cx, 32767);
  247.     // dirty cast - we need access to protected CDockBar members
  248.     CSCBDockBar* pDockBar = (CSCBDockBar*) m_pDockBar;
  250.     // force imediate RecalcDelayShow() for all sizing bars on the row
  251.     // with delayShow/delayHide flags set to avoid IsVisible() problems
  252.     CSCBArray arrSCBars;
  253.     GetRowSizingBars(arrSCBars);
  254.     AFX_SIZEPARENTPARAMS layout;
  255.     layout.hDWP = pDockBar->m_bLayoutQuery ?
  256.         NULL : ::BeginDeferWindowPos(arrSCBars.GetSize());
  257.     for (int i = 0; i < arrSCBars.GetSize(); i++)
  258.         if (arrSCBars[i]->m_nStateFlags & (delayHide|delayShow))
  259.             arrSCBars[i]->RecalcDelayShow(&layout);
  260.     if (layout.hDWP != NULL)
  261.         ::EndDeferWindowPos(layout.hDWP);
  263.     // get available length
  264.     CRect rc = pDockBar->m_rectLayout;
  265.     if (rc.IsRectEmpty())
  266.         m_pDockSite->GetClientRect(&rc);
  267.     int nLengthTotal = bHorz ? rc.Width() + 2 : rc.Height() - 2;
  269.     if (IsVisible() && !IsFloating() &&
  270.         m_bParentSizing && arrSCBars[0] == this)
  271.         if (NegotiateSpace(nLengthTotal, (bHorz != FALSE)))
  272.             AlignControlBars();
  274.     m_bParentSizing = FALSE;
  276.     if (bHorz)
  277.         return CSize(max(m_szMinHorz.cx, m_szHorz.cx),
  278.                      max(m_szMinHorz.cy, m_szHorz.cy));
  280.     return CSize(max(m_szMinVert.cx, m_szVert.cx),
  281.                  max(m_szMinVert.cy, m_szVert.cy));
  282. }
  284. CSize CSizingControlBar::CalcDynamicLayout(int nLength, DWORD dwMode)
  285. {
  286.     if (dwMode & (LM_HORZDOCK | LM_VERTDOCK)) // docked ?
  287.     {
  288.         if (nLength == -1)
  289.             m_bParentSizing = TRUE;
  291.         return baseCSizingControlBar::CalcDynamicLayout(nLength, dwMode);
  292.     }
  294.     if (dwMode & LM_MRUWIDTH) return m_szFloat;
  295.     if (dwMode & LM_COMMIT) return m_szFloat; // already committed
  297. #ifndef _SCB_REPLACE_MINIFRAME
  298.     // check for dialgonal resizing hit test
  299.     int nHitTest = m_pDockContext->m_nHitTest;
  300.     if (IsFloating() &&
  301.         (nHitTest == HTTOPLEFT || nHitTest == HTBOTTOMLEFT ||
  302.         nHitTest == HTTOPRIGHT || nHitTest == HTBOTTOMRIGHT))
  303.     {
  304.         CPoint ptCursor;
  305.         ::GetCursorPos(&ptCursor);
  307.         CRect rFrame, rBar;
  308.         GetParentFrame()->GetWindowRect(&rFrame);
  309.         GetWindowRect(&rBar);
  310.         
  311.         if (nHitTest == HTTOPLEFT || nHitTest == HTBOTTOMLEFT)
  312.         {
  313.             m_szFloat.cx = rFrame.left + rBar.Width() - ptCursor.x;
  314.             m_pDockContext->m_rectFrameDragHorz.left = 
  315.                 min(ptCursor.x, rFrame.left + rBar.Width() - m_szMinFloat.cx);
  316.         }
  318.         if (nHitTest == HTTOPLEFT || nHitTest == HTTOPRIGHT)
  319.         {
  320.             m_szFloat.cy = rFrame.top + rBar.Height() - ptCursor.y;
  321.             m_pDockContext->m_rectFrameDragHorz.top =
  322.                 min(ptCursor.y, rFrame.top + rBar.Height() - m_szMinFloat.cy);
  323.         }
  325.         if (nHitTest == HTTOPRIGHT || nHitTest == HTBOTTOMRIGHT)
  326.             m_szFloat.cx = rBar.Width() + ptCursor.x - rFrame.right;
  328.         if (nHitTest == HTBOTTOMLEFT || nHitTest == HTBOTTOMRIGHT)
  329.             m_szFloat.cy = rBar.Height() + ptCursor.y - rFrame.bottom;
  330.     }
  331.     else
  332. #endif //_SCB_REPLACE_MINIFRAME
  333.         ((dwMode & LM_LENGTHY) ? m_szFloat.cy : m_szFloat.cx) = nLength;
  335.     m_szFloat.cx = max(m_szFloat.cx, m_szMinFloat.cx);
  336.     m_szFloat.cy = max(m_szFloat.cy, m_szMinFloat.cy);
  338.     return m_szFloat;
  339. }
  341. void CSizingControlBar::OnWindowPosChanging(WINDOWPOS FAR* lpwndpos)
  342. {
  343.     // force non-client recalc if moved or resized
  344.     lpwndpos->flags |= SWP_FRAMECHANGED;
  346.     baseCSizingControlBar::OnWindowPosChanging(lpwndpos);
  348.     // find on which side are we docked
  349.     m_nDockBarID = GetParent()->GetDlgCtrlID();
  351.     if (!IsFloating())
  352.         if (lpwndpos->flags & SWP_SHOWWINDOW)
  353.             m_bKeepSize = TRUE;
  354. }
  356. /////////////////////////////////////////////////////////////////////////
  357. // Mouse Handling
  358. //
  359. void CSizingControlBar::OnLButtonDown(UINT nFlags, CPoint point)
  360. {
  361.     if (m_pDockBar != NULL)
  362.     {
  363.         // start the drag
  364.         ASSERT(m_pDockContext != NULL);
  365.         ClientToScreen(&point);
  366.         m_pDockContext->StartDrag(point);
  367.     }
  368.     else
  369.         CWnd::OnLButtonDown(nFlags, point);
  370. }
  372. void CSizingControlBar::OnLButtonDblClk(UINT nFlags, CPoint point)
  373. {
  374.     if (m_pDockBar != NULL)
  375.     {
  376.         // toggle docking
  377.         ASSERT(m_pDockContext != NULL);
  378.         m_pDockContext->ToggleDocking();
  379.     }
  380.     else
  381.         CWnd::OnLButtonDblClk(nFlags, point);
  382. }
  384. void CSizingControlBar::OnNcLButtonDown(UINT nHitTest, CPoint point) 
  385. {
  386.     UNUSED_ALWAYS(point);
  388.     if (m_bTracking || IsFloating())
  389.         return;
  391.     if ((nHitTest >= HTSIZEFIRST) && (nHitTest <= HTSIZELAST))
  392.         StartTracking(nHitTest, point); // sizing edge hit
  393. }
  395. void CSizingControlBar::OnLButtonUp(UINT nFlags, CPoint point)
  396. {
  397.     if (m_bTracking)
  398.         StopTracking();
  400.     baseCSizingControlBar::OnLButtonUp(nFlags, point);
  401. }
  403. void CSizingControlBar::OnRButtonDown(UINT nFlags, CPoint point)
  404. {
  405.     if (m_bTracking)
  406.         StopTracking();
  408.     baseCSizingControlBar::OnRButtonDown(nFlags, point);
  409. }
  411. void CSizingControlBar::OnMouseMove(UINT nFlags, CPoint point)
  412. {
  413.     if (m_bTracking)
  414.     {
  415.         CPoint ptScreen = point;
  416.         ClientToScreen(&ptScreen);
  418.         OnTrackUpdateSize(ptScreen);
  419.     }
  421.     baseCSizingControlBar::OnMouseMove(nFlags, point);
  422. }
  424. void CSizingControlBar::OnCaptureChanged(CWnd *pWnd)
  425. {
  426.     if (m_bTracking && (pWnd != this))
  427.         StopTracking();
  429.     baseCSizingControlBar::OnCaptureChanged(pWnd);
  430. }
  432. void CSizingControlBar::OnNcCalcSize(BOOL bCalcValidRects,
  433.                                      NCCALCSIZE_PARAMS FAR* lpncsp)
  434. {
  435.     UNUSED_ALWAYS(bCalcValidRects);
  437. #ifndef _SCB_REPLACE_MINIFRAME
  438.     // Enable diagonal resizing for floating miniframe
  439.     if (IsFloating())
  440.     {
  441.         CFrameWnd* pFrame = GetParentFrame();
  442.         if (pFrame != NULL &&
  443.             pFrame->IsKindOf(RUNTIME_CLASS(CMiniFrameWnd)))
  444.         {
  445.             DWORD dwStyle = ::GetWindowLong(pFrame->m_hWnd, GWL_STYLE);
  446.             if ((dwStyle & MFS_4THICKFRAME) != 0)
  447.             {
  448.                 pFrame->ModifyStyle(MFS_4THICKFRAME, 0); // clear
  449.                 GetParent()->ModifyStyle(0, WS_CLIPCHILDREN);
  450.             }
  451.         }
  452.     }
  453. #endif _SCB_REPLACE_MINIFRAME
  455.     // compute the the client area
  456.     m_dwSCBStyle &= ~SCBS_EDGEALL;
  458.     // add resizing edges between bars on the same row
  459.     if (!IsFloating() && m_pDockBar != NULL)
  460.     {
  461.         CSCBArray arrSCBars;
  462.         int nThis;
  463.         GetRowSizingBars(arrSCBars, nThis);
  465.         BOOL bHorz = IsHorzDocked();
  466.         if (nThis > 0)
  467.             m_dwSCBStyle |= bHorz ? SCBS_EDGELEFT : SCBS_EDGETOP;
  469.         if (nThis < arrSCBars.GetUpperBound())
  470.             m_dwSCBStyle |= bHorz ? SCBS_EDGERIGHT : SCBS_EDGEBOTTOM;
  471.     }
  473.     NcCalcClient(&lpncsp->rgrc[0], m_nDockBarID);
  474. }
  476. void CSizingControlBar::NcCalcClient(LPRECT pRc, UINT nDockBarID)
  477. {
  478.     CRect rc(pRc);
  480.     rc.DeflateRect(3, 5, 3, 3);
  481.     if (nDockBarID != AFX_IDW_DOCKBAR_FLOAT)
  482.         rc.DeflateRect(2, 0, 2, 2);
  484.     switch(nDockBarID)
  485.     {
  486.     case AFX_IDW_DOCKBAR_TOP:
  487.         m_dwSCBStyle |= SCBS_EDGEBOTTOM;
  488.         break;
  489.     case AFX_IDW_DOCKBAR_BOTTOM:
  490.         m_dwSCBStyle |= SCBS_EDGETOP;
  491.         break;
  492.     case AFX_IDW_DOCKBAR_LEFT:
  493.         m_dwSCBStyle |= SCBS_EDGERIGHT;
  494.         break;
  495.     case AFX_IDW_DOCKBAR_RIGHT:
  496.         m_dwSCBStyle |= SCBS_EDGELEFT;
  497.         break;
  498.     }
  500.     // make room for edges only if they will be painted
  501.     if (m_dwSCBStyle & SCBS_SHOWEDGES)
  502.         rc.DeflateRect(
  503.             (m_dwSCBStyle & SCBS_EDGELEFT) ? m_cxEdge : 0,
  504.             (m_dwSCBStyle & SCBS_EDGETOP) ? m_cxEdge : 0,
  505.             (m_dwSCBStyle & SCBS_EDGERIGHT) ? m_cxEdge : 0,
  506.             (m_dwSCBStyle & SCBS_EDGEBOTTOM) ? m_cxEdge : 0);
  508.     *pRc = rc;
  509. }
  511. void CSizingControlBar::OnNcPaint()
  512. {
  513.     // get window DC that is clipped to the non-client area
  514.     CWindowDC dc(this);
  516.     CRect rcClient, rcBar;
  517.     GetClientRect(rcClient);
  518.     ClientToScreen(rcClient);
  519.     GetWindowRect(rcBar);
  520.     rcClient.OffsetRect(-rcBar.TopLeft());
  521.     rcBar.OffsetRect(-rcBar.TopLeft());
  523.     CDC mdc;
  524.     mdc.CreateCompatibleDC(&dc);
  525.     
  526.     CBitmap bm;
  527.     bm.CreateCompatibleBitmap(&dc, rcBar.Width(), rcBar.Height());
  528.     CBitmap* pOldBm = mdc.SelectObject(&bm);
  530.     // draw borders in non-client area
  531.     CRect rcDraw = rcBar;
  532.     DrawBorders(&mdc, rcDraw);
  534.     // erase the NC background
  535.     mdc.FillRect(rcDraw, CBrush::FromHandle(
  536.         (HBRUSH) GetClassLong(m_hWnd, GCL_HBRBACKGROUND)));
  538.     if (m_dwSCBStyle & SCBS_SHOWEDGES)
  539.     {
  540.         CRect rcEdge; // paint the sizing edges
  541.         for (int i = 0; i < 4; i++)
  542.             if (GetEdgeRect(rcBar, GetEdgeHTCode(i), rcEdge))
  543.                 mdc.Draw3dRect(rcEdge, ::GetSysColor(COLOR_BTNHIGHLIGHT),
  544.                     ::GetSysColor(COLOR_BTNSHADOW));
  545.     }
  547.     NcPaintGripper(&mdc, rcClient);
  549.     // client area is not our bussiness :)
  550.     dc.IntersectClipRect(rcBar);
  551.     dc.ExcludeClipRect(rcClient);
  553.     dc.BitBlt(0, 0, rcBar.Width(), rcBar.Height(), &mdc, 0, 0, SRCCOPY);
  555.     ReleaseDC(&dc);
  557.     mdc.SelectObject(pOldBm);
  558.     bm.DeleteObject();
  559.     mdc.DeleteDC();
  560. }
  562. void CSizingControlBar::NcPaintGripper(CDC* pDC, CRect rcClient)
  563. {
  564.     UNUSED_ALWAYS(pDC);
  565.     UNUSED_ALWAYS(rcClient);
  566. }
  568. void CSizingControlBar::OnPaint()
  569. {
  570.     // overridden to skip border painting based on clientrect
  571.     CPaintDC dc(this);
  572. }
  574. LRESULT CSizingControlBar::OnNcHitTest(CPoint point)
  575. {
  576.     CRect rcBar, rcEdge;
  577.     GetWindowRect(rcBar);
  579.     if (!IsFloating())
  580.         for (int i = 0; i < 4; i++)
  581.             if (GetEdgeRect(rcBar, GetEdgeHTCode(i), rcEdge))
  582.                 if (rcEdge.PtInRect(point))
  583.                     return GetEdgeHTCode(i);
  585.     return HTCLIENT;
  586. }
  588. void CSizingControlBar::OnSettingChange(UINT uFlags, LPCTSTR lpszSection)
  589. {
  590.     baseCSizingControlBar::OnSettingChange(uFlags, lpszSection);
  592.     m_bDragShowContent = FALSE;
  593.     ::SystemParametersInfo(SPI_GETDRAGFULLWINDOWS, 0,
  594.         &m_bDragShowContent, 0); // update
  595. }
  597. void CSizingControlBar::OnSize(UINT nType, int cx, int cy)
  598. {
  599.     UNUSED_ALWAYS(nType);
  600.     
  601.     if ((m_dwSCBStyle & SCBS_SIZECHILD) != 0)
  602.     {
  603.         // automatic child resizing - only one child is allowed
  604.         CWnd* pWnd = GetWindow(GW_CHILD);
  605.         if (pWnd != NULL)
  606.         {
  607.             pWnd->MoveWindow(0, 0, cx, cy);
  608.             ASSERT(pWnd->GetWindow(GW_HWNDNEXT) == NULL);
  609.         }
  610.     }
  611. }
  613. void CSizingControlBar::OnClose()
  614. {
  615.     // do nothing: protection against accidentally destruction by the
  616.     //   child control (i.e. if user hits Esc in a child editctrl)
  617. }
  619. /////////////////////////////////////////////////////////////////////////
  620. // CSizingControlBar implementation helpers
  622. void CSizingControlBar::StartTracking(UINT nHitTest, CPoint point)
  623. {
  624.     SetCapture();
  626.     // make sure no updates are pending
  627.     if (!m_bDragShowContent)
  628.         RedrawWindow(NULL, NULL, RDW_ALLCHILDREN | RDW_UPDATENOW);
  630.     m_htEdge = nHitTest;
  631.     m_bTracking = TRUE;
  633.     BOOL bHorz = IsHorzDocked();
  634.     BOOL bHorzTracking = m_htEdge == HTLEFT || m_htEdge == HTRIGHT;
  636.     m_nTrackPosOld = bHorzTracking ? point.x : point.y;
  638.     CRect rcBar, rcEdge;
  639.     GetWindowRect(rcBar);
  640.     GetEdgeRect(rcBar, m_htEdge, rcEdge);
  641.     m_nTrackEdgeOfs = m_nTrackPosOld -
  642.         (bHorzTracking ? rcEdge.CenterPoint().x : rcEdge.CenterPoint().y);
  643.     
  644.     CSCBArray arrSCBars;
  645.     int nThis;
  646.     GetRowSizingBars(arrSCBars, nThis);
  648.     m_nTrackPosMin = m_nTrackPosMax = m_nTrackPosOld;
  649.     if (!IsSideTracking())
  650.     {
  651.         // calc minwidth as the max minwidth of the sizing bars on row
  652.         int nMinWidth = bHorz ? m_szMinHorz.cy : m_szMinVert.cx;
  653.         for (int i = 0; i < arrSCBars.GetSize(); i++)
  654.             nMinWidth = max(nMinWidth, bHorz ? 
  655.                 arrSCBars[i]->m_szMinHorz.cy :
  656.                 arrSCBars[i]->m_szMinVert.cx);
  657.         int nExcessWidth = (bHorz ? m_szHorz.cy : m_szVert.cx) - nMinWidth;
  659.         // the control bar cannot grow with more than the width of
  660.         // remaining client area of the mainframe
  661.         CRect rcT;
  662.         m_pDockSite->RepositionBars(0, 0xFFFF, AFX_IDW_PANE_FIRST,
  663.             reposQuery, &rcT, NULL, TRUE);
  664.         int nMaxWidth = bHorz ? rcT.Height() - 2 : rcT.Width() - 2;
  666.         BOOL bTopOrLeft = m_htEdge == HTTOP || m_htEdge == HTLEFT;
  668.         m_nTrackPosMin -= bTopOrLeft ? nMaxWidth : nExcessWidth;
  669.         m_nTrackPosMax += bTopOrLeft ? nExcessWidth : nMaxWidth;
  670.     }
  671.     else
  672.     {
  673.         // side tracking:
  674.         // max size is the actual size plus the amount the other
  675.         // sizing bars can be decreased until they reach their minsize
  676.         if (m_htEdge == HTBOTTOM || m_htEdge == HTRIGHT)
  677.             nThis++;
  679.         for (int i = 0; i < arrSCBars.GetSize(); i++)
  680.         {
  681.             CSizingControlBar* pBar = arrSCBars[i];
  683.             int nExcessWidth = bHorz ? 
  684.                 pBar->m_szHorz.cx - pBar->m_szMinHorz.cx :
  685.                 pBar->m_szVert.cy - pBar->m_szMinVert.cy;
  687.             if (i < nThis)
  688.                 m_nTrackPosMin -= nExcessWidth;
  689.             else
  690.                 m_nTrackPosMax += nExcessWidth;
  691.         }
  692.     }
  694.     OnTrackInvertTracker(); // draw tracker
  695. }
  697. void CSizingControlBar::StopTracking()
  698. {
  699.     OnTrackInvertTracker(); // erase tracker
  701.     m_bTracking = FALSE;
  702.     ReleaseCapture();
  704.     m_pDockSite->DelayRecalcLayout();
  705. }
  707. void CSizingControlBar::OnTrackUpdateSize(CPoint& point)
  708. {
  709.     ASSERT(!IsFloating());
  711.     BOOL bHorzTrack = m_htEdge == HTLEFT || m_htEdge == HTRIGHT;
  713.     int nTrackPos = bHorzTrack ? point.x : point.y;
  714.     nTrackPos = max(m_nTrackPosMin, min(m_nTrackPosMax, nTrackPos));
  716.     int nDelta = nTrackPos - m_nTrackPosOld;
  718.     if (nDelta == 0)
  719.         return; // no pos change
  721.     OnTrackInvertTracker(); // erase tracker
  723.     m_nTrackPosOld = nTrackPos;
  724.     
  725.     BOOL bHorz = IsHorzDocked();
  727.     CSize sizeNew = bHorz ? m_szHorz : m_szVert;
  728.     switch (m_htEdge)
  729.     {
  730.     case HTLEFT:    sizeNew -= CSize(nDelta, 0); break;
  731.     case HTTOP:     sizeNew -= CSize(0, nDelta); break;
  732.     case HTRIGHT:   sizeNew += CSize(nDelta, 0); break;
  733.     case HTBOTTOM:  sizeNew += CSize(0, nDelta); break;
  734.     }
  736.     CSCBArray arrSCBars;
  737.     int nThis;
  738.     GetRowSizingBars(arrSCBars, nThis);
  740.     if (!IsSideTracking())
  741.         for (int i = 0; i < arrSCBars.GetSize(); i++)
  742.         {
  743.             CSizingControlBar* pBar = arrSCBars[i];
  744.             // make same width (or height)
  745.             (bHorz ? pBar->m_szHorz.cy : pBar->m_szVert.cx) =
  746.                 bHorz ? sizeNew.cy : sizeNew.cx;
  747.         }
  748.     else
  749.     {
  750.         int nGrowingBar = nThis;
  751.         BOOL bBefore = m_htEdge == HTTOP || m_htEdge == HTLEFT;
  752.         if (bBefore && nDelta > 0)
  753.             nGrowingBar--;
  754.         if (!bBefore && nDelta < 0)
  755.             nGrowingBar++;
  756.         if (nGrowingBar != nThis)
  757.             bBefore = !bBefore;
  759.         // nGrowing is growing
  760.         nDelta = abs(nDelta);
  761.         CSizingControlBar* pBar = arrSCBars[nGrowingBar];
  762.         (bHorz ? pBar->m_szHorz.cx : pBar->m_szVert.cy) += nDelta;
  764.         // the others are shrinking
  765.         int nFirst = bBefore ? nGrowingBar - 1 : nGrowingBar + 1;
  766.         int nLimit = bBefore ? -1 : arrSCBars.GetSize();
  768.         for (int i = nFirst; nDelta != 0 && i != nLimit; i += (bBefore ? -1 : 1))
  769.         {
  770.             CSizingControlBar* pBar = arrSCBars[i];
  771.                 
  772.             int nDeltaT = min(nDelta,
  773.                 (bHorz ? pBar->m_szHorz.cx : pBar->m_szVert.cy) -
  774.                 (bHorz ? pBar->m_szMinHorz.cx : pBar->m_szMinVert.cy));
  776.             (bHorz ? pBar->m_szHorz.cx : pBar->m_szVert.cy) -= nDeltaT;
  777.             nDelta -= nDeltaT;
  778.         }
  779.     }
  781.     OnTrackInvertTracker(); // redraw tracker at new pos
  783.     if (m_bDragShowContent)
  784.         m_pDockSite->DelayRecalcLayout();
  785. }
  787. void CSizingControlBar::OnTrackInvertTracker()
  788. {
  789.     ASSERT(m_bTracking);
  791.     if (m_bDragShowContent)
  792.         return; // don't show tracker if DragFullWindows is on
  794.     BOOL bHorz = IsHorzDocked();
  795.     CRect rc, rcBar, rcDock, rcFrame;
  796.     GetWindowRect(rcBar);
  797.     m_pDockBar->GetWindowRect(rcDock);
  798.     m_pDockSite->GetWindowRect(rcFrame);
  799.     VERIFY(GetEdgeRect(rcBar, m_htEdge, rc));
  800.     if (!IsSideTracking())
  801.         rc = bHorz ? 
  802.             CRect(rcDock.left + 1, rc.top, rcDock.right - 1, rc.bottom) :
  803.             CRect(rc.left, rcDock.top + 1, rc.right, rcDock.bottom - 1);
  805.     BOOL bHorzTracking = m_htEdge == HTLEFT || m_htEdge == HTRIGHT;
  806.     int nOfs = m_nTrackPosOld - m_nTrackEdgeOfs;
  807.     nOfs -= bHorzTracking ? rc.CenterPoint().x : rc.CenterPoint().y;
  808.     rc.OffsetRect(bHorzTracking ? nOfs : 0, bHorzTracking ? 0 : nOfs);
  809.     rc.OffsetRect(-rcFrame.TopLeft());
  811.     CDC *pDC = m_pDockSite->GetDCEx(NULL,
  812.         DCX_WINDOW | DCX_CACHE | DCX_LOCKWINDOWUPDATE);
  813.     CBrush* pBrush = CDC::GetHalftoneBrush();
  814.     CBrush* pBrushOld = pDC->SelectObject(pBrush);
  816.     pDC->PatBlt(rc.left, rc.top, rc.Width(), rc.Height(), PATINVERT);
  817.     
  818.     pDC->SelectObject(pBrushOld);
  819.     m_pDockSite->ReleaseDC(pDC);
  820. }
  822. BOOL CSizingControlBar::GetEdgeRect(CRect rcWnd, UINT nHitTest,
  823.                                     CRect& rcEdge)
  824. {
  825.     rcEdge = rcWnd;
  826.     if (m_dwSCBStyle & SCBS_SHOWEDGES)
  827.         rcEdge.DeflateRect(1, 1);
  828.     BOOL bHorz = IsHorzDocked();
  830.     switch (nHitTest)
  831.     {
  832.     case HTLEFT:
  833.         if (!(m_dwSCBStyle & SCBS_EDGELEFT)) return FALSE;
  834.         rcEdge.right = rcEdge.left + m_cxEdge;
  835.         rcEdge.DeflateRect(0, bHorz ? m_cxEdge: 0);
  836.         break;
  837.     case HTTOP:
  838.         if (!(m_dwSCBStyle & SCBS_EDGETOP)) return FALSE;
  839.         rcEdge.bottom = rcEdge.top + m_cxEdge;
  840.         rcEdge.DeflateRect(bHorz ? 0 : m_cxEdge, 0);
  841.         break;
  842.     case HTRIGHT:
  843.         if (!(m_dwSCBStyle & SCBS_EDGERIGHT)) return FALSE;
  844.         rcEdge.left = rcEdge.right - m_cxEdge;
  845.         rcEdge.DeflateRect(0, bHorz ? m_cxEdge: 0);
  846.         break;
  847.     case HTBOTTOM:
  848.         if (!(m_dwSCBStyle & SCBS_EDGEBOTTOM)) return FALSE;
  849.         rcEdge.top = rcEdge.bottom - m_cxEdge;
  850.         rcEdge.DeflateRect(bHorz ? 0 : m_cxEdge, 0);
  851.         break;
  852.     default:
  853.         ASSERT(FALSE); // invalid hit test code
  854.     }
  855.     return TRUE;
  856. }
  858. UINT CSizingControlBar::GetEdgeHTCode(int nEdge)
  859. {
  860.     if (nEdge == 0) return HTLEFT;
  861.     if (nEdge == 1) return HTTOP;
  862.     if (nEdge == 2) return HTRIGHT;
  863.     if (nEdge == 3) return HTBOTTOM;
  864.     ASSERT(FALSE); // invalid edge code
  865.     return HTNOWHERE;
  866. }
  868. void CSizingControlBar::GetRowInfo(int& nFirst, int& nLast, int& nThis)
  869. {
  870.     ASSERT_VALID(m_pDockBar); // verify bounds
  872.     nThis = m_pDockBar->FindBar(this);
  873.     ASSERT(nThis != -1);
  875.     int i, nBars = m_pDockBar->m_arrBars.GetSize();
  877.     // find the first and the last bar in row
  878.     for (nFirst = -1, i = nThis - 1; i >= 0 && nFirst == -1; i--)
  879.         if (m_pDockBar->m_arrBars[i] == NULL)
  880.             nFirst = i + 1;
  881.     for (nLast = -1, i = nThis + 1; i < nBars && nLast == -1; i++)
  882.         if (m_pDockBar->m_arrBars[i] == NULL)
  883.             nLast = i - 1;
  885.     ASSERT((nLast != -1) && (nFirst != -1));
  886. }
  888. void CSizingControlBar::GetRowSizingBars(CSCBArray& arrSCBars)
  889. {
  890.     int nThis; // dummy
  891.     GetRowSizingBars(arrSCBars, nThis);
  892. }
  894. void CSizingControlBar::GetRowSizingBars(CSCBArray& arrSCBars, int& nThis)
  895. {
  896.     arrSCBars.RemoveAll();
  898.     int nFirstT, nLastT, nThisT;
  899.     GetRowInfo(nFirstT, nLastT, nThisT);
  901.     nThis = -1;
  902.     for (int i = nFirstT; i <= nLastT; i++)
  903.     {
  904.         CSizingControlBar* pBar =
  905.             (CSizingControlBar*) m_pDockBar->m_arrBars[i];
  906.         if (HIWORD(pBar) == 0) continue; // placeholder
  907.         if (!pBar->IsVisible()) continue;
  908.         if (pBar->IsKindOf(RUNTIME_CLASS(CSizingControlBar)))
  909.         {
  910.             if (pBar == this)
  911.                 nThis = arrSCBars.GetSize();
  913.             arrSCBars.Add(pBar);
  914.         }
  915.     }
  916. }
  918. BOOL CSizingControlBar::NegotiateSpace(int nLengthTotal, BOOL bHorz)
  919. {
  920.     ASSERT(bHorz == IsHorzDocked());
  922.     int nFirst, nLast, nThis;
  923.     GetRowInfo(nFirst, nLast, nThis);
  925.     int nLengthAvail = nLengthTotal;
  926.     int nLengthActual = 0;
  927.     int nLengthMin = 2;
  928.     int nWidthMax = 0;
  929.     CSizingControlBar* pBar;
  931.     for (int i = nFirst; i <= nLast; i++)
  932.     {
  933.         pBar = (CSizingControlBar*) m_pDockBar->m_arrBars[i];
  934.         if (HIWORD(pBar) == 0) continue; // placeholder
  935.         if (!pBar->IsVisible()) continue;
  936.         BOOL bIsSizingBar = 
  937.             pBar->IsKindOf(RUNTIME_CLASS(CSizingControlBar));
  939.         int nLengthBar; // minimum length of the bar
  940.         if (bIsSizingBar)
  941.             nLengthBar = bHorz ? pBar->m_szMinHorz.cx - 2 :
  942.                 pBar->m_szMinVert.cy - 2;
  943.         else
  944.         {
  945.             CRect rcBar;
  946.             pBar->GetWindowRect(&rcBar);
  947.             nLengthBar = bHorz ? rcBar.Width() - 2 : rcBar.Height() - 2;
  948.         }
  950.         nLengthMin += nLengthBar;
  951.         if (nLengthMin > nLengthTotal)
  952.         {
  953.             // split the row after fixed bar
  954.             if (i < nThis)
  955.             {
  956.                 m_pDockBar->m_arrBars.InsertAt(i + 1,
  957.                     (CControlBar*) NULL);
  958.                 return FALSE;
  959.             }
  960.             
  961.             // only this sizebar remains on the row, adjust it to minsize
  962.             if (i == nThis)
  963.             {
  964.                 if (bHorz)
  965.                     m_szHorz.cx = m_szMinHorz.cx;
  966.                 else
  967.                     m_szVert.cy = m_szMinVert.cy;
  969.                 return TRUE; // the dockbar will split the row for us
  970.             }
  972.             // we have enough bars - go negotiate with them
  973.             m_pDockBar->m_arrBars.InsertAt(i, (CControlBar*) NULL);
  974.             nLast = i - 1;
  975.             break;
  976.         }
  978.         if (bIsSizingBar)
  979.         {
  980.             nLengthActual += bHorz ? pBar->m_szHorz.cx - 2 : 
  981.                 pBar->m_szVert.cy - 2;
  982.             nWidthMax = max(nWidthMax, bHorz ? pBar->m_szHorz.cy :
  983.                 pBar->m_szVert.cx);
  984.         }
  985.         else
  986.             nLengthAvail -= nLengthBar;
  987.     }
  989.     CSCBArray arrSCBars;
  990.     GetRowSizingBars(arrSCBars);
  991.     int nNumBars = arrSCBars.GetSize();
  992.     int nDelta = nLengthAvail - nLengthActual;
  994.     // return faster when there is only one sizing bar per row (this one)
  995.     if (nNumBars == 1)
  996.     {
  997.         ASSERT(arrSCBars[0] == this);
  999.         if (nDelta == 0)
  1000.             return TRUE;
  1001.         
  1002.         m_bKeepSize = FALSE;
  1003.         (bHorz ? m_szHorz.cx : m_szVert.cy) += nDelta;
  1005.         return TRUE;
  1006.     }
  1008.     // make all the bars the same width
  1009.     for (int i = 0; i < nNumBars; i++)
  1010.         if (bHorz)
  1011.             arrSCBars[i]->m_szHorz.cy = nWidthMax;
  1012.         else
  1013.             arrSCBars[i]->m_szVert.cx = nWidthMax;
  1015.     // distribute the difference between the bars,
  1016.     // but don't shrink them below their minsizes
  1017.     while (nDelta != 0)
  1018.     {
  1019.         int nDeltaOld = nDelta;
  1020.         for (int i = 0; i < nNumBars; i++)
  1021.         {
  1022.             pBar = arrSCBars[i];
  1023.             int nLMin = bHorz ?
  1024.                 pBar->m_szMinHorz.cx : pBar->m_szMinVert.cy;
  1025.             int nL = bHorz ? pBar->m_szHorz.cx : pBar->m_szVert.cy;
  1027.             if ((nL == nLMin) && (nDelta < 0) || // already at min length
  1028.                 pBar->m_bKeepSize) // or wants to keep its size
  1029.                 continue;
  1031.             // sign of nDelta
  1032.             int nDelta2 = (nDelta == 0) ? 0 : ((nDelta < 0) ? -1 : 1);
  1034.             (bHorz ? pBar->m_szHorz.cx : pBar->m_szVert.cy) += nDelta2;
  1035.             nDelta -= nDelta2;
  1036.             if (nDelta == 0) break;
  1037.         }
  1038.         // clear m_bKeepSize flags
  1039.         if ((nDeltaOld == nDelta) || (nDelta == 0))
  1040.             for (int i = 0; i < nNumBars; i++)
  1041.                 arrSCBars[i]->m_bKeepSize = FALSE;
  1042.     }
  1044.     return TRUE;
  1045. }
  1047. void CSizingControlBar::AlignControlBars()
  1048. {
  1049.     int nFirst, nLast, nThis;
  1050.     GetRowInfo(nFirst, nLast, nThis);
  1052.     BOOL bHorz = IsHorzDocked();
  1053.     BOOL bNeedRecalc = FALSE;
  1054.     int nAlign = bHorz ? -2 : 0;
  1056.     CRect rc, rcDock;
  1057.     m_pDockBar->GetWindowRect(&rcDock);
  1059.     for (int i = nFirst; i <= nLast; i++)
  1060.     {
  1061.         CSizingControlBar* pBar =
  1062.             (CSizingControlBar*) m_pDockBar->m_arrBars[i];
  1063.         if (HIWORD(pBar) == 0) continue; // placeholder
  1064.         if (!pBar->IsVisible()) continue;
  1066.         pBar->GetWindowRect(&rc);
  1067.         rc.OffsetRect(-rcDock.TopLeft());
  1069.         if (pBar->IsKindOf(RUNTIME_CLASS(CSizingControlBar)))
  1070.             rc = CRect(rc.TopLeft(),
  1071.                 bHorz ? pBar->m_szHorz : pBar->m_szVert);
  1073.         if ((bHorz ? rc.left : rc.top) != nAlign)
  1074.         {
  1075.             if (!bHorz)
  1076.                 rc.OffsetRect(0, nAlign - rc.top - 2);
  1077.             else if (m_nDockBarID == AFX_IDW_DOCKBAR_TOP)
  1078.                 rc.OffsetRect(nAlign - rc.left, -2);
  1079.             else
  1080.                 rc.OffsetRect(nAlign - rc.left, 0);
  1081.             pBar->MoveWindow(rc);
  1082.             bNeedRecalc = TRUE;
  1083.         }
  1084.         nAlign += (bHorz ? rc.Width() : rc.Height()) - 2;
  1085.     }
  1087.     if (bNeedRecalc)
  1088.         m_pDockSite->DelayRecalcLayout();
  1089. }
  1091. void CSizingControlBar::OnUpdateCmdUI(CFrameWnd* pTarget,
  1092.                                       BOOL bDisableIfNoHndler)
  1093. {
  1094.     UNUSED_ALWAYS(bDisableIfNoHndler);
  1095.     UNUSED_ALWAYS(pTarget);
  1096. }
  1098. void CSizingControlBar::LoadState(LPCTSTR lpszProfileName)
  1099. {
  1100.     ASSERT_VALID(this);
  1101.     ASSERT(GetSafeHwnd()); // must be called after Create()
  1103. #if defined(_SCB_REPLACE_MINIFRAME) && !defined(_SCB_MINIFRAME_CAPTION)
  1104.     // compensate the caption miscalculation in CFrameWnd::SetDockState()
  1105.     CDockState state;
  1106.     state.LoadState(lpszProfileName);
  1108.     UINT nID = GetDlgCtrlID();
  1109.     for (int i = 0; i < state.m_arrBarInfo.GetSize(); i++)
  1110.     {
  1111.         CControlBarInfo* pInfo = (CControlBarInfo*)state.m_arrBarInfo[i];
  1112.         ASSERT(pInfo != NULL);
  1113.         if (!pInfo->m_bFloating)
  1114.             continue;
  1115.         
  1116.         // this is a floating dockbar - check the ID array
  1117.         for (int j = 0; j < pInfo->m_arrBarID.GetSize(); j++)
  1118.             if ((DWORD) pInfo->m_arrBarID[j] == nID)
  1119.             {
  1120.                 // found this bar - offset origin and save settings
  1121.                 pInfo->m_pointPos.x++;
  1122.                 pInfo->m_pointPos.y +=
  1123.                     ::GetSystemMetrics(SM_CYSMCAPTION) + 1;
  1124.                 pInfo->SaveState(lpszProfileName, i);
  1125.             }
  1126.     }
  1127. #endif //_SCB_REPLACE_MINIFRAME && !_SCB_MINIFRAME_CAPTION
  1129.     CWinApp* pApp = AfxGetApp();
  1131.     TCHAR szSection[256];
  1132.     wsprintf(szSection, _T("%s-SCBar-%d"), lpszProfileName,
  1133.         GetDlgCtrlID());
  1135.     m_szHorz.cx = max(m_szMinHorz.cx, (int) pApp->GetProfileInt(
  1136.         szSection, _T("sizeHorzCX"), m_szHorz.cx));
  1137.     m_szHorz.cy = max(m_szMinHorz.cy, (int) pApp->GetProfileInt(
  1138.         szSection, _T("sizeHorzCY"), m_szHorz.cy));
  1140.     m_szVert.cx = max(m_szMinVert.cx, (int) pApp->GetProfileInt(
  1141.         szSection, _T("sizeVertCX"), m_szVert.cx));
  1142.     m_szVert.cy = max(m_szMinVert.cy, (int) pApp->GetProfileInt(
  1143.         szSection, _T("sizeVertCY"), m_szVert.cy));
  1145.     m_szFloat.cx = max(m_szMinFloat.cx, (int) pApp->GetProfileInt(
  1146.         szSection, _T("sizeFloatCX"), m_szFloat.cx));
  1147.     m_szFloat.cy = max(m_szMinFloat.cy, (int) pApp->GetProfileInt(
  1148.         szSection, _T("sizeFloatCY"), m_szFloat.cy));
  1149. }
  1151. void CSizingControlBar::SaveState(LPCTSTR lpszProfileName)
  1152. {
  1153.     // place your SaveState or GlobalSaveState call in
  1154.     // CMainFrame's OnClose() or DestroyWindow(), not in OnDestroy()
  1155.     ASSERT_VALID(this);
  1156.     ASSERT(GetSafeHwnd());
  1158.     CWinApp* pApp = AfxGetApp();
  1160.     TCHAR szSection[256];
  1161.     wsprintf(szSection, _T("%s-SCBar-%d"), lpszProfileName,
  1162.         GetDlgCtrlID());
  1164.     pApp->WriteProfileInt(szSection, _T("sizeHorzCX"), m_szHorz.cx);
  1165.     pApp->WriteProfileInt(szSection, _T("sizeHorzCY"), m_szHorz.cy);
  1167.     pApp->WriteProfileInt(szSection, _T("sizeVertCX"), m_szVert.cx);
  1168.     pApp->WriteProfileInt(szSection, _T("sizeVertCY"), m_szVert.cy);
  1170.     pApp->WriteProfileInt(szSection, _T("sizeFloatCX"), m_szFloat.cx);
  1171.     pApp->WriteProfileInt(szSection, _T("sizeFloatCY"), m_szFloat.cy);
  1172. }
  1174. void CSizingControlBar::GlobalLoadState(CFrameWnd* pFrame,
  1175.                                         LPCTSTR lpszProfileName)
  1176. {
  1177.     POSITION pos = pFrame->m_listControlBars.GetHeadPosition();
  1178.     while (pos != NULL)
  1179.     {
  1180.         CSizingControlBar* pBar = 
  1181.             (CSizingControlBar*) pFrame->m_listControlBars.GetNext(pos);
  1182.         ASSERT(pBar != NULL);
  1183.         if (pBar->IsKindOf(RUNTIME_CLASS(CSizingControlBar)))
  1184.             pBar->LoadState(lpszProfileName);
  1185.     }
  1186. }
  1188. void CSizingControlBar::GlobalSaveState(CFrameWnd* pFrame,
  1189.                                         LPCTSTR lpszProfileName)
  1190. {
  1191.     POSITION pos = pFrame->m_listControlBars.GetHeadPosition();
  1192.     while (pos != NULL)
  1193.     {
  1194.         CSizingControlBar* pBar =
  1195.             (CSizingControlBar*) pFrame->m_listControlBars.GetNext(pos);
  1196.         ASSERT(pBar != NULL);
  1197.         if (pBar->IsKindOf(RUNTIME_CLASS(CSizingControlBar)))
  1198.             pBar->SaveState(lpszProfileName);
  1199.     }
  1200. }
  1202. #ifdef _SCB_REPLACE_MINIFRAME
  1203. #ifndef _SCB_MINIFRAME_CAPTION
  1204. /////////////////////////////////////////////////////////////////////////////
  1205. // CSCBDockContext Drag Operations
  1207. static void AdjustRectangle(CRect& rect, CPoint pt)
  1208. {
  1209.     int nXOffset = (pt.x < rect.left) ? (pt.x - rect.left) :
  1210.                     (pt.x > rect.right) ? (pt.x - rect.right) : 0;
  1211.     int nYOffset = (pt.y < rect.top) ? (pt.y - rect.top) :
  1212.                     (pt.y > rect.bottom) ? (pt.y - rect.bottom) : 0;
  1213.     rect.OffsetRect(nXOffset, nYOffset);
  1214. }
  1216. void CSCBDockContext::StartDrag(CPoint pt)
  1217. {
  1218.     ASSERT_VALID(m_pBar);
  1219.     m_bDragging = TRUE;
  1221.     InitLoop();
  1223.     ASSERT((m_pBar->m_dwStyle & CBRS_SIZE_DYNAMIC) != 0);
  1225.     // get true bar size (including borders)
  1226.     CRect rect;
  1227.     m_pBar->GetWindowRect(rect);
  1228.     m_ptLast = pt;
  1229.     CSize sizeHorz = m_pBar->CalcDynamicLayout(0, LM_HORZ | LM_HORZDOCK);
  1230.     CSize sizeVert = m_pBar->CalcDynamicLayout(0, LM_VERTDOCK);
  1231.     CSize sizeFloat = m_pBar->CalcDynamicLayout(0, LM_HORZ | LM_MRUWIDTH);
  1233.     m_rectDragHorz = CRect(rect.TopLeft(), sizeHorz);
  1234.     m_rectDragVert = CRect(rect.TopLeft(), sizeVert);
  1236.     // calculate frame dragging rectangle
  1237.     m_rectFrameDragHorz = CRect(rect.TopLeft(), sizeFloat);
  1239. #ifdef _MAC
  1240.     CMiniFrameWnd::CalcBorders(&m_rectFrameDragHorz,
  1241.         WS_THICKFRAME, WS_EX_FORCESIZEBOX);
  1242. #else
  1243.     CMiniFrameWnd::CalcBorders(&m_rectFrameDragHorz, WS_THICKFRAME);
  1244. #endif
  1245.     m_rectFrameDragHorz.DeflateRect(2, 2);
  1246.     m_rectFrameDragVert = m_rectFrameDragHorz;
  1247.     
  1248.     // adjust rectangles so that point is inside
  1249.     AdjustRectangle(m_rectDragHorz, pt);
  1250.     AdjustRectangle(m_rectDragVert, pt);
  1251.     AdjustRectangle(m_rectFrameDragHorz, pt);
  1252.     AdjustRectangle(m_rectFrameDragVert, pt);
  1254.     // initialize tracking state and enter tracking loop
  1255.     m_dwOverDockStyle = CanDock();
  1256.     Move(pt);   // call it here to handle special keys
  1257.     Track();
  1258. }
  1259. #endif //_SCB_MINIFRAME_CAPTION
  1261. /////////////////////////////////////////////////////////////////////////////
  1262. // CSCBMiniDockFrameWnd
  1264. IMPLEMENT_DYNCREATE(CSCBMiniDockFrameWnd, baseCSCBMiniDockFrameWnd);
  1266. BEGIN_MESSAGE_MAP(CSCBMiniDockFrameWnd, baseCSCBMiniDockFrameWnd)
  1267.     //{{AFX_MSG_MAP(CSCBMiniDockFrameWnd)
  1268.     ON_WM_NCLBUTTONDOWN()
  1269.     ON_WM_GETMINMAXINFO()
  1270.     ON_WM_WINDOWPOSCHANGING()
  1271.     ON_WM_SIZE()
  1272.     //}}AFX_MSG_MAP
  1273. END_MESSAGE_MAP()
  1275. BOOL CSCBMiniDockFrameWnd::Create(CWnd* pParent, DWORD dwBarStyle)
  1276. {
  1277.     // set m_bInRecalcLayout to avoid flashing during creation
  1278.     // RecalcLayout will be called once something is docked
  1279.     m_bInRecalcLayout = TRUE;
  1281.     DWORD dwStyle = WS_POPUP|WS_CAPTION|WS_SYSMENU|MFS_MOVEFRAME|
  1282.         MFS_4THICKFRAME|MFS_SYNCACTIVE|MFS_BLOCKSYSMENU|
  1283.         FWS_SNAPTOBARS;
  1285.     if (dwBarStyle & CBRS_SIZE_DYNAMIC)
  1286.         dwStyle &= ~MFS_MOVEFRAME;
  1288.     DWORD dwExStyle = 0;
  1289. #ifdef _MAC
  1290.     if (dwBarStyle & CBRS_SIZE_DYNAMIC)
  1291.         dwExStyle |= WS_EX_FORCESIZEBOX;
  1292.     else
  1293.         dwStyle &= ~(MFS_MOVEFRAME|MFS_4THICKFRAME);
  1294. #endif
  1296.     if (!CMiniFrameWnd::CreateEx(dwExStyle,
  1297.         NULL, &afxChNil, dwStyle, rectDefault, pParent))
  1298.     {
  1299.         m_bInRecalcLayout = FALSE;
  1300.         return FALSE;
  1301.     }
  1302.     dwStyle = dwBarStyle & (CBRS_ALIGN_LEFT|CBRS_ALIGN_RIGHT) ?
  1303.         CBRS_ALIGN_LEFT : CBRS_ALIGN_TOP;
  1304.     dwStyle |= dwBarStyle & CBRS_FLOAT_MULTI;
  1305.     CMenu* pSysMenu = GetSystemMenu(FALSE);
  1306.     //pSysMenu->DeleteMenu(SC_SIZE, MF_BYCOMMAND);
  1307.     CString strHide;
  1308.     if (strHide.LoadString(AFX_IDS_HIDE))
  1309.     {
  1310.         pSysMenu->DeleteMenu(SC_CLOSE, MF_BYCOMMAND);
  1311.         pSysMenu->AppendMenu(MF_STRING|MF_ENABLED, SC_CLOSE, strHide);
  1312.     }
  1314.     // must initially create with parent frame as parent
  1315.     if (!m_wndDockBar.Create(pParent, WS_CHILD | WS_VISIBLE | dwStyle,
  1316.         AFX_IDW_DOCKBAR_FLOAT))
  1317.     {
  1318.         m_bInRecalcLayout = FALSE;
  1319.         return FALSE;
  1320.     }
  1322.     // set parent to CMiniDockFrameWnd
  1323.     m_wndDockBar.SetParent(this);
  1324.     m_bInRecalcLayout = FALSE;
  1326.     return TRUE;
  1327. }
  1329. void CSCBMiniDockFrameWnd::OnNcLButtonDown(UINT nHitTest, CPoint point)
  1330. {
  1331.     if (nHitTest == HTCAPTION || nHitTest == HTCLOSE)
  1332.     {
  1333.         baseCSCBMiniDockFrameWnd::OnNcLButtonDown(nHitTest, point);
  1334.         return;
  1335.     }
  1337.     if (GetSizingControlBar() != NULL)
  1338.         CMiniFrameWnd::OnNcLButtonDown(nHitTest, point);
  1339.     else
  1340.         baseCSCBMiniDockFrameWnd::OnNcLButtonDown(nHitTest, point);
  1341. }
  1343. CSizingControlBar* CSCBMiniDockFrameWnd::GetSizingControlBar()
  1344. {
  1345.     CWnd* pWnd = GetWindow(GW_CHILD); // get the dockbar
  1346.     if (pWnd == NULL)
  1347.         return NULL;
  1348.     
  1349.     pWnd = pWnd->GetWindow(GW_CHILD); // get the controlbar
  1350.     if (pWnd == NULL)
  1351.         return NULL;
  1353.     if (!pWnd->IsKindOf(RUNTIME_CLASS(CSizingControlBar)))
  1354.         return NULL;
  1356.     return (CSizingControlBar*) pWnd;
  1357. }
  1359. void CSCBMiniDockFrameWnd::OnSize(UINT nType, int cx, int cy) 
  1360. {
  1361.     CSizingControlBar* pBar = GetSizingControlBar();
  1362.     if ((pBar != NULL) && (GetStyle() & MFS_4THICKFRAME) == 0
  1363.         && pBar->IsVisible())
  1364.         pBar->m_szFloat = CSize(cx + 4, cy + 4);
  1366.     baseCSCBMiniDockFrameWnd::OnSize(nType, cx, cy);
  1367. }
  1369. void CSCBMiniDockFrameWnd::OnGetMinMaxInfo(MINMAXINFO FAR* lpMMI)
  1370. {
  1371.     baseCSCBMiniDockFrameWnd::OnGetMinMaxInfo(lpMMI);
  1373.     CSizingControlBar* pBar = GetSizingControlBar();
  1374.     if (pBar != NULL)
  1375.     {
  1376.         CRect r(CPoint(0, 0), pBar->m_szMinFloat - CSize(4, 4));
  1377. #ifndef _SCB_MINIFRAME_CAPTION
  1378.         CMiniFrameWnd::CalcBorders(&r, WS_THICKFRAME);
  1379. #else
  1380.         CMiniFrameWnd::CalcBorders(&r, WS_THICKFRAME|WS_CAPTION);
  1381. #endif //_SCB_MINIFRAME_CAPTION
  1382.         lpMMI->ptMinTrackSize.x = r.Width();
  1383.         lpMMI->ptMinTrackSize.y = r.Height();
  1385. if(pBar->m_bFixedFloat)
  1386. {
  1387. lpMMI->ptMinTrackSize.x = pBar->m_szFixedFloat.cx;
  1388. lpMMI->ptMinTrackSize.y = pBar->m_szFixedFloat.cy;
  1389. lpMMI->ptMaxTrackSize.x = pBar->m_szFixedFloat.cx;
  1390. lpMMI->ptMaxTrackSize.y = pBar->m_szFixedFloat.cy;
  1391. }
  1392.     }
  1393. }
  1395. void CSCBMiniDockFrameWnd::OnWindowPosChanging(WINDOWPOS FAR* lpwndpos) 
  1396. {
  1397.     if ((GetStyle() & MFS_4THICKFRAME) != 0)
  1398.     {
  1399.         CSizingControlBar* pBar = GetSizingControlBar();
  1400.         if (pBar != NULL)
  1401.         {
  1402.             lpwndpos->flags |= SWP_NOSIZE; // don't size this time
  1403.             // prevents flicker
  1404.             pBar->m_pDockBar->ModifyStyle(0, WS_CLIPCHILDREN);
  1405.             // enable diagonal resizing
  1406.             ModifyStyle(MFS_4THICKFRAME, 0);
  1407. #ifndef _SCB_MINIFRAME_CAPTION
  1408.             // remove caption
  1409.             ModifyStyle(WS_SYSMENU|WS_CAPTION, 0);
  1410. #endif
  1411.             DelayRecalcLayout();
  1412.             pBar->PostMessage(WM_NCPAINT);
  1413.         }
  1414.     }
  1416.     CMiniFrameWnd::OnWindowPosChanging(lpwndpos);
  1417. }
  1419. #endif //_SCB_REPLACE_MINIFRAME