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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > IP电话/视频会议 > 查看源码
sizecbar.cpp
资源名称：视频会议系统.rar　[点击查看]
上传用户：popouu88
上传日期：2013-02-11
资源大小：2894k
文件大小：41k
源码类别：

IP电话/视频会议

开发平台：

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_NCPAINT()
  43.     ON_WM_NCCALCSIZE()
  44.     ON_WM_NCHITTEST()
  45.     ON_WM_CAPTURECHANGED()
  46.     ON_WM_SETTINGCHANGE()
  47.     ON_WM_LBUTTONUP()
  48.     ON_WM_MOUSEMOVE()
  49.     ON_WM_NCLBUTTONDOWN()
  50.     ON_WM_LBUTTONDOWN()
  51.     ON_WM_LBUTTONDBLCLK()
  52.     ON_WM_RBUTTONDOWN()
  53.     ON_WM_WINDOWPOSCHANGING()
  54.     ON_WM_PAINT()
  55.     ON_WM_CLOSE()
  56.     ON_WM_SIZE()
  57.     ON_WM_NCMOUSEMOVE()
  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) */ ::CreateSolidBrush( RGB( 90 , 150 , 206 ) ) , 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( WS_SYSMENU | 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.     //新增项目
  653. ( ( CFrameWnd * )this->GetParent( )->GetParent( ) )->RecalcLayout( );
  654. }
  656. void CSizingControlBar::OnTrackUpdateSize(CPoint& point)
  657. {
  658.     ASSERT(!IsFloating());
  660.     BOOL bHorzTrack = m_htEdge == HTLEFT || m_htEdge == HTRIGHT;
  662.     int nTrackPos = bHorzTrack ? point.x : point.y;
  663.     nTrackPos = max(m_nTrackPosMin, min(m_nTrackPosMax, nTrackPos));
  665.     int nDelta = nTrackPos - m_nTrackPosOld;
  667.     if (nDelta == 0)
  668.         return; // no pos change
  670.     OnTrackInvertTracker(); // erase tracker
  672.     m_nTrackPosOld = nTrackPos;
  673.     
  674.     BOOL bHorz = IsHorzDocked();
  676.     CSize sizeNew = bHorz ? m_szHorz : m_szVert;
  677.     switch (m_htEdge)
  678.     {
  679.     case HTLEFT:    sizeNew -= CSize(nDelta, 0); break;
  680.     case HTTOP:     sizeNew -= CSize(0, nDelta); break;
  681.     case HTRIGHT:   sizeNew += CSize(nDelta, 0); break;
  682.     case HTBOTTOM:  sizeNew += CSize(0, nDelta); break;
  683.     }
  685.     CSCBArray arrSCBars;
  686.     int nThis;
  687.     GetRowSizingBars(arrSCBars, nThis);
  689.     if (!IsSideTracking())
  690.         for (int i = 0; i < arrSCBars.GetSize(); i++)
  691.         {
  692.             CSizingControlBar* pBar = arrSCBars[i];
  693.             // make same width (or height)
  694.             (bHorz ? pBar->m_szHorz.cy : pBar->m_szVert.cx) =
  695.                 bHorz ? sizeNew.cy : sizeNew.cx;
  696.         }
  697.     else
  698.     {
  699.         int nGrowingBar = nThis;
  700.         BOOL bBefore = m_htEdge == HTTOP || m_htEdge == HTLEFT;
  701.         if (bBefore && nDelta > 0)
  702.             nGrowingBar--;
  703.         if (!bBefore && nDelta < 0)
  704.             nGrowingBar++;
  705.         if (nGrowingBar != nThis)
  706.             bBefore = !bBefore;
  708.         // nGrowing is growing
  709.         nDelta = abs(nDelta);
  710.         CSizingControlBar* pBar = arrSCBars[nGrowingBar];
  711.         (bHorz ? pBar->m_szHorz.cx : pBar->m_szVert.cy) += nDelta;
  713.         // the others are shrinking
  714.         int nFirst = bBefore ? nGrowingBar - 1 : nGrowingBar + 1;
  715.         int nLimit = bBefore ? -1 : arrSCBars.GetSize();
  717.         for (int i = nFirst; nDelta != 0 && i != nLimit; i += (bBefore ? -1 : 1))
  718.         {
  719.             CSizingControlBar* pBar = arrSCBars[i];
  720.                 
  721.             int nDeltaT = min(nDelta,
  722.                 (bHorz ? pBar->m_szHorz.cx : pBar->m_szVert.cy) -
  723.                 (bHorz ? pBar->m_szMinHorz.cx : pBar->m_szMinVert.cy));
  725.             (bHorz ? pBar->m_szHorz.cx : pBar->m_szVert.cy) -= nDeltaT;
  726.             nDelta -= nDeltaT;
  727.         }
  728.     }
  730.     OnTrackInvertTracker(); // redraw tracker at new pos
  732.     if (m_bDragShowContent)
  733.         m_pDockSite->DelayRecalcLayout();
  734. }
  736. void CSizingControlBar::OnTrackInvertTracker()
  737. {
  738.     ASSERT(m_bTracking);
  740.     if (m_bDragShowContent)
  741.         return; // don't show tracker if DragFullWindows is on
  743.     BOOL bHorz = IsHorzDocked();
  744.     CRect rc, rcBar, rcDock, rcFrame;
  745.     GetWindowRect(rcBar);
  746.     m_pDockBar->GetWindowRect(rcDock);
  747.     m_pDockSite->GetWindowRect(rcFrame);
  748.     VERIFY(GetEdgeRect(rcBar, m_htEdge, rc));
  749.     if (!IsSideTracking())
  750.         rc = bHorz ? 
  751.             CRect(rcDock.left + 1, rc.top, rcDock.right - 1, rc.bottom) :
  752.             CRect(rc.left, rcDock.top + 1, rc.right, rcDock.bottom - 1);
  754.     BOOL bHorzTracking = m_htEdge == HTLEFT || m_htEdge == HTRIGHT;
  755.     int nOfs = m_nTrackPosOld - m_nTrackEdgeOfs;
  756.     nOfs -= bHorzTracking ? rc.CenterPoint().x : rc.CenterPoint().y;
  757.     rc.OffsetRect(bHorzTracking ? nOfs : 0, bHorzTracking ? 0 : nOfs);
  758.     rc.OffsetRect(-rcFrame.TopLeft());
  760.     CDC *pDC = m_pDockSite->GetDCEx(NULL,
  761.         DCX_WINDOW | DCX_CACHE | DCX_LOCKWINDOWUPDATE);
  762.     CBrush* pBrush = CDC::GetHalftoneBrush();
  763.     CBrush* pBrushOld = pDC->SelectObject(pBrush);
  765.     pDC->PatBlt(rc.left, rc.top, rc.Width(), rc.Height(), PATINVERT);
  766.     
  767.     pDC->SelectObject(pBrushOld);
  768.     m_pDockSite->ReleaseDC(pDC);
  769. }
  771. BOOL CSizingControlBar::GetEdgeRect(CRect rcWnd, UINT nHitTest,
  772.                                     CRect& rcEdge)
  773. {
  774.     rcEdge = rcWnd;
  775.     if (m_dwSCBStyle & SCBS_SHOWEDGES)
  776.         rcEdge.DeflateRect(1, 1);
  777.     BOOL bHorz = IsHorzDocked();
  779.     switch (nHitTest)
  780.     {
  781.     case HTLEFT:
  782.         if (!(m_dwSCBStyle & SCBS_EDGELEFT)) return FALSE;
  783.         rcEdge.right = rcEdge.left + m_cxEdge;
  784.         rcEdge.DeflateRect(0, bHorz ? m_cxEdge: 0);
  785.         break;
  786.     case HTTOP:
  787.         if (!(m_dwSCBStyle & SCBS_EDGETOP)) return FALSE;
  788.         rcEdge.bottom = rcEdge.top + m_cxEdge;
  789.         rcEdge.DeflateRect(bHorz ? 0 : m_cxEdge, 0);
  790.         break;
  791.     case HTRIGHT:
  792.         if (!(m_dwSCBStyle & SCBS_EDGERIGHT)) return FALSE;
  793.         rcEdge.left = rcEdge.right - m_cxEdge;
  794.         rcEdge.DeflateRect(0, bHorz ? m_cxEdge: 0);
  795.         break;
  796.     case HTBOTTOM:
  797.         if (!(m_dwSCBStyle & SCBS_EDGEBOTTOM)) return FALSE;
  798.         rcEdge.top = rcEdge.bottom - m_cxEdge;
  799.         rcEdge.DeflateRect(bHorz ? 0 : m_cxEdge, 0);
  800.         break;
  801.     default:
  802.         ASSERT(FALSE); // invalid hit test code
  803.     }
  804.     return TRUE;
  805. }
  807. UINT CSizingControlBar::GetEdgeHTCode(int nEdge)
  808. {
  809.     if (nEdge == 0) return HTLEFT;
  810.     if (nEdge == 1) return HTTOP;
  811.     if (nEdge == 2) return HTRIGHT;
  812.     if (nEdge == 3) return HTBOTTOM;
  813.     ASSERT(FALSE); // invalid edge code
  814.     return HTNOWHERE;
  815. }
  817. void CSizingControlBar::GetRowInfo(int& nFirst, int& nLast, int& nThis)
  818. {
  819.     ASSERT_VALID(m_pDockBar); // verify bounds
  821.     nThis = m_pDockBar->FindBar(this);
  822.     ASSERT(nThis != -1);
  824.     int i, nBars = m_pDockBar->m_arrBars.GetSize();
  826.     // find the first and the last bar in row
  827.     for (nFirst = -1, i = nThis - 1; i >= 0 && nFirst == -1; i--)
  828.         if (m_pDockBar->m_arrBars[i] == NULL)
  829.             nFirst = i + 1;
  830.     for (nLast = -1, i = nThis + 1; i < nBars && nLast == -1; i++)
  831.         if (m_pDockBar->m_arrBars[i] == NULL)
  832.             nLast = i - 1;
  834.     ASSERT((nLast != -1) && (nFirst != -1));
  835. }
  837. void CSizingControlBar::GetRowSizingBars(CSCBArray& arrSCBars)
  838. {
  839.     int nThis; // dummy
  840.     GetRowSizingBars(arrSCBars, nThis);
  841. }
  843. void CSizingControlBar::GetRowSizingBars(CSCBArray& arrSCBars, int& nThis)
  844. {
  845.     arrSCBars.RemoveAll();
  847.     int nFirstT, nLastT, nThisT;
  848.     GetRowInfo(nFirstT, nLastT, nThisT);
  850.     nThis = -1;
  851.     for (int i = nFirstT; i <= nLastT; i++)
  852.     {
  853.         CSizingControlBar* pBar =
  854.             (CSizingControlBar*) m_pDockBar->m_arrBars[i];
  855.         if (HIWORD(pBar) == 0) continue; // placeholder
  856.         if (!pBar->IsVisible()) continue;
  857.         if (pBar->IsKindOf(RUNTIME_CLASS(CSizingControlBar)))
  858.         {
  859.             if (pBar == this)
  860.                 nThis = arrSCBars.GetSize();
  862.             arrSCBars.Add(pBar);
  863.         }
  864.     }
  865. }
  867. BOOL CSizingControlBar::NegotiateSpace(int nLengthTotal, BOOL bHorz)
  868. {
  869.     ASSERT(bHorz == IsHorzDocked());
  871.     int nFirst, nLast, nThis;
  872.     GetRowInfo(nFirst, nLast, nThis);
  874.     int nLengthAvail = nLengthTotal;
  875.     int nLengthActual = 0;
  876.     int nLengthMin = 2;
  877.     int nWidthMax = 0;
  878.     CSizingControlBar* pBar;
  880.     for (int i = nFirst; i <= nLast; i++)
  881.     {
  882.         pBar = (CSizingControlBar*) m_pDockBar->m_arrBars[i];
  883.         if (HIWORD(pBar) == 0) continue; // placeholder
  884.         if (!pBar->IsVisible()) continue;
  885.         BOOL bIsSizingBar = 
  886.             pBar->IsKindOf(RUNTIME_CLASS(CSizingControlBar));
  888.         int nLengthBar; // minimum length of the bar
  889.         if (bIsSizingBar)
  890.             nLengthBar = bHorz ? pBar->m_szMinHorz.cx - 2 :
  891.                 pBar->m_szMinVert.cy - 2;
  892.         else
  893.         {
  894.             CRect rcBar;
  895.             pBar->GetWindowRect(&rcBar);
  896.             nLengthBar = bHorz ? rcBar.Width() - 2 : rcBar.Height() - 2;
  897.         }
  899.         nLengthMin += nLengthBar;
  900.         if (nLengthMin > nLengthTotal)
  901.         {
  902.             // split the row after fixed bar
  903.             if (i < nThis)
  904.             {
  905.                 m_pDockBar->m_arrBars.InsertAt(i + 1,
  906.                     (CControlBar*) NULL);
  907.                 return FALSE;
  908.             }
  909.             
  910.             // only this sizebar remains on the row, adjust it to minsize
  911.             if (i == nThis)
  912.             {
  913.                 if (bHorz)
  914.                     m_szHorz.cx = m_szMinHorz.cx;
  915.                 else
  916.                     m_szVert.cy = m_szMinVert.cy;
  918.                 return TRUE; // the dockbar will split the row for us
  919.             }
  921.             // we have enough bars - go negotiate with them
  922.             m_pDockBar->m_arrBars.InsertAt(i, (CControlBar*) NULL);
  923.             nLast = i - 1;
  924.             break;
  925.         }
  927.         if (bIsSizingBar)
  928.         {
  929.             nLengthActual += bHorz ? pBar->m_szHorz.cx - 2 : 
  930.                 pBar->m_szVert.cy - 2;
  931.             nWidthMax = max(nWidthMax, bHorz ? pBar->m_szHorz.cy :
  932.                 pBar->m_szVert.cx);
  933.         }
  934.         else
  935.             nLengthAvail -= nLengthBar;
  936.     }
  938.     CSCBArray arrSCBars;
  939.     GetRowSizingBars(arrSCBars);
  940.     int nNumBars = arrSCBars.GetSize();
  941.     int nDelta = nLengthAvail - nLengthActual;
  943.     // return faster when there is only one sizing bar per row (this one)
  944.     if (nNumBars == 1)
  945.     {
  946.         ASSERT(arrSCBars[0] == this);
  948.         if (nDelta == 0)
  949.             return TRUE;
  950.         
  951.         m_bKeepSize = FALSE;
  952.         (bHorz ? m_szHorz.cx : m_szVert.cy) += nDelta;
  954.         return TRUE;
  955.     }
  957.     // make all the bars the same width
  958.     for (i = 0; i < nNumBars; i++)
  959.         if (bHorz)
  960.             arrSCBars[i]->m_szHorz.cy = nWidthMax;
  961.         else
  962.             arrSCBars[i]->m_szVert.cx = nWidthMax;
  964.     // distribute the difference between the bars,
  965.     // but don't shrink them below their minsizes
  966.     while (nDelta != 0)
  967.     {
  968.         int nDeltaOld = nDelta;
  969.         for (i = 0; i < nNumBars; i++)
  970.         {
  971.             pBar = arrSCBars[i];
  972.             int nLMin = bHorz ?
  973.                 pBar->m_szMinHorz.cx : pBar->m_szMinVert.cy;
  974.             int nL = bHorz ? pBar->m_szHorz.cx : pBar->m_szVert.cy;
  976.             if ((nL == nLMin) && (nDelta < 0) || // already at min length
  977.                 pBar->m_bKeepSize) // or wants to keep its size
  978.                 continue;
  980.             // sign of nDelta
  981.             int nDelta2 = (nDelta == 0) ? 0 : ((nDelta < 0) ? -1 : 1);
  983.             (bHorz ? pBar->m_szHorz.cx : pBar->m_szVert.cy) += nDelta2;
  984.             nDelta -= nDelta2;
  985.             if (nDelta == 0) break;
  986.         }
  987.         // clear m_bKeepSize flags
  988.         if ((nDeltaOld == nDelta) || (nDelta == 0))
  989.             for (i = 0; i < nNumBars; i++)
  990.                 arrSCBars[i]->m_bKeepSize = FALSE;
  991.     }
  993.     return TRUE;
  994. }
  996. void CSizingControlBar::AlignControlBars()
  997. {
  998.     int nFirst, nLast, nThis;
  999.     GetRowInfo(nFirst, nLast, nThis);
  1001.     BOOL bHorz = IsHorzDocked();
  1002.     BOOL bNeedRecalc = FALSE;
  1003.     int nAlign = bHorz ? -2 : 0;
  1005.     CRect rc, rcDock;
  1006.     m_pDockBar->GetWindowRect(&rcDock);
  1008.     for (int i = nFirst; i <= nLast; i++)
  1009.     {
  1010.         CSizingControlBar* pBar =
  1011.             (CSizingControlBar*) m_pDockBar->m_arrBars[i];
  1012.         if (HIWORD(pBar) == 0) continue; // placeholder
  1013.         if (!pBar->IsVisible()) continue;
  1015.         pBar->GetWindowRect(&rc);
  1016.         rc.OffsetRect(-rcDock.TopLeft());
  1018.         if (pBar->IsKindOf(RUNTIME_CLASS(CSizingControlBar)))
  1019.             rc = CRect(rc.TopLeft(),
  1020.                 bHorz ? pBar->m_szHorz : pBar->m_szVert);
  1022.         if ((bHorz ? rc.left : rc.top) != nAlign)
  1023.         {
  1024.             if (!bHorz)
  1025.                 rc.OffsetRect(0, nAlign - rc.top - 2);
  1026.             else if (m_nDockBarID == AFX_IDW_DOCKBAR_TOP)
  1027.                 rc.OffsetRect(nAlign - rc.left, -2);
  1028.             else
  1029.                 rc.OffsetRect(nAlign - rc.left, 0);
  1030.             pBar->MoveWindow(rc);
  1031.             bNeedRecalc = TRUE;
  1032.         }
  1033.         nAlign += (bHorz ? rc.Width() : rc.Height()) - 2;
  1034.     }
  1036.     if (bNeedRecalc)
  1037.         m_pDockSite->DelayRecalcLayout();
  1038. }
  1040. void CSizingControlBar::OnUpdateCmdUI(CFrameWnd* pTarget,
  1041.                                       BOOL bDisableIfNoHndler)
  1042. {
  1043.     UNUSED_ALWAYS(bDisableIfNoHndler);
  1044.     UNUSED_ALWAYS(pTarget);
  1045. }
  1047. void CSizingControlBar::LoadState(LPCTSTR lpszProfileName)
  1048. {
  1049.     ASSERT_VALID(this);
  1050.     ASSERT(GetSafeHwnd()); // must be called after Create()
  1052. #if defined(_SCB_REPLACE_MINIFRAME) && !defined(_SCB_MINIFRAME_CAPTION)
  1053.     // compensate the caption miscalculation in CFrameWnd::SetDockState()
  1054.     CDockState state;
  1055.     state.LoadState(lpszProfileName);
  1057.     UINT nID = GetDlgCtrlID();
  1058.     for (int i = 0; i < state.m_arrBarInfo.GetSize(); i++)
  1059.     {
  1060.         CControlBarInfo* pInfo = (CControlBarInfo*)state.m_arrBarInfo[i];
  1061.         ASSERT(pInfo != NULL);
  1062.         if (!pInfo->m_bFloating)
  1063.             continue;
  1064.         
  1065.         // this is a floating dockbar - check the ID array
  1066.         for (int j = 0; j < pInfo->m_arrBarID.GetSize(); j++)
  1067.             if ((DWORD) pInfo->m_arrBarID[j] == nID)
  1068.             {
  1069.                 // found this bar - offset origin and save settings
  1070.                 pInfo->m_pointPos.x++;
  1071.                 pInfo->m_pointPos.y +=
  1072.                     ::GetSystemMetrics(SM_CYSMCAPTION) + 1;
  1073.                 pInfo->SaveState(lpszProfileName, i);
  1074.             }
  1075.     }
  1076. #endif //_SCB_REPLACE_MINIFRAME && !_SCB_MINIFRAME_CAPTION
  1078.     CWinApp* pApp = AfxGetApp();
  1080.     TCHAR szSection[256];
  1081.     wsprintf(szSection, _T("%s-SCBar-%d"), lpszProfileName,
  1082.         GetDlgCtrlID());
  1084.     m_szHorz.cx = max(m_szMinHorz.cx, (int) pApp->GetProfileInt(
  1085.         szSection, _T("sizeHorzCX"), m_szHorz.cx));
  1086.     m_szHorz.cy = max(m_szMinHorz.cy, (int) pApp->GetProfileInt(
  1087.         szSection, _T("sizeHorzCY"), m_szHorz.cy));
  1089.     m_szVert.cx = max(m_szMinVert.cx, (int) pApp->GetProfileInt(
  1090.         szSection, _T("sizeVertCX"), m_szVert.cx));
  1091.     m_szVert.cy = max(m_szMinVert.cy, (int) pApp->GetProfileInt(
  1092.         szSection, _T("sizeVertCY"), m_szVert.cy));
  1094.     m_szFloat.cx = max(m_szMinFloat.cx, (int) pApp->GetProfileInt(
  1095.         szSection, _T("sizeFloatCX"), m_szFloat.cx));
  1096.     m_szFloat.cy = max(m_szMinFloat.cy, (int) pApp->GetProfileInt(
  1097.         szSection, _T("sizeFloatCY"), m_szFloat.cy));
  1098. }
  1100. void CSizingControlBar::SaveState(LPCTSTR lpszProfileName)
  1101. {
  1102.     // place your SaveState or GlobalSaveState call in
  1103.     // CMainFrame's OnClose() or DestroyWindow(), not in OnDestroy()
  1104.     ASSERT_VALID(this);
  1105.     ASSERT(GetSafeHwnd());
  1107.     CWinApp* pApp = AfxGetApp();
  1109.     TCHAR szSection[256];
  1110.     wsprintf(szSection, _T("%s-SCBar-%d"), lpszProfileName,
  1111.         GetDlgCtrlID());
  1113.     pApp->WriteProfileInt(szSection, _T("sizeHorzCX"), m_szHorz.cx);
  1114.     pApp->WriteProfileInt(szSection, _T("sizeHorzCY"), m_szHorz.cy);
  1116.     pApp->WriteProfileInt(szSection, _T("sizeVertCX"), m_szVert.cx);
  1117.     pApp->WriteProfileInt(szSection, _T("sizeVertCY"), m_szVert.cy);
  1119.     pApp->WriteProfileInt(szSection, _T("sizeFloatCX"), m_szFloat.cx);
  1120.     pApp->WriteProfileInt(szSection, _T("sizeFloatCY"), m_szFloat.cy);
  1121. }
  1123. void CSizingControlBar::GlobalLoadState(CFrameWnd* pFrame,
  1124.                                         LPCTSTR lpszProfileName)
  1125. {
  1126.     POSITION pos = pFrame->m_listControlBars.GetHeadPosition();
  1127.     while (pos != NULL)
  1128.     {
  1129.         CSizingControlBar* pBar = 
  1130.             (CSizingControlBar*) pFrame->m_listControlBars.GetNext(pos);
  1131.         ASSERT(pBar != NULL);
  1132.         if (pBar->IsKindOf(RUNTIME_CLASS(CSizingControlBar)))
  1133.             pBar->LoadState(lpszProfileName);
  1134.     }
  1135. }
  1137. void CSizingControlBar::GlobalSaveState(CFrameWnd* pFrame,
  1138.                                         LPCTSTR lpszProfileName)
  1139. {
  1140.     POSITION pos = pFrame->m_listControlBars.GetHeadPosition();
  1141.     while (pos != NULL)
  1142.     {
  1143.         CSizingControlBar* pBar =
  1144.             (CSizingControlBar*) pFrame->m_listControlBars.GetNext(pos);
  1145.         ASSERT(pBar != NULL);
  1146.         if (pBar->IsKindOf(RUNTIME_CLASS(CSizingControlBar)))
  1147.             pBar->SaveState(lpszProfileName);
  1148.     }
  1149. }
  1151. #ifdef _SCB_REPLACE_MINIFRAME
  1152. #ifndef _SCB_MINIFRAME_CAPTION
  1153. /////////////////////////////////////////////////////////////////////////////
  1154. // CSCBDockContext Drag Operations
  1156. static void AdjustRectangle(CRect& rect, CPoint pt)
  1157. {
  1158.     int nXOffset = (pt.x < rect.left) ? (pt.x - rect.left) :
  1159.                     (pt.x > rect.right) ? (pt.x - rect.right) : 0;
  1160.     int nYOffset = (pt.y < rect.top) ? (pt.y - rect.top) :
  1161.                     (pt.y > rect.bottom) ? (pt.y - rect.bottom) : 0;
  1162.     rect.OffsetRect(nXOffset, nYOffset);
  1163. }
  1165. void CSCBDockContext::StartDrag(CPoint pt)
  1166. {
  1167.     ASSERT_VALID(m_pBar);
  1168.     m_bDragging = TRUE;
  1170.     InitLoop();
  1172.     ASSERT((m_pBar->m_dwStyle & CBRS_SIZE_DYNAMIC) != 0);
  1174.     // get true bar size (including borders)
  1175.     CRect rect;
  1176.     m_pBar->GetWindowRect(rect);
  1177.     m_ptLast = pt;
  1178.     CSize sizeHorz = m_pBar->CalcDynamicLayout(0, LM_HORZ | LM_HORZDOCK);
  1179.     CSize sizeVert = m_pBar->CalcDynamicLayout(0, LM_VERTDOCK);
  1180.     CSize sizeFloat = m_pBar->CalcDynamicLayout(0, LM_HORZ | LM_MRUWIDTH);
  1182.     m_rectDragHorz = CRect(rect.TopLeft(), sizeHorz);
  1183.     m_rectDragVert = CRect(rect.TopLeft(), sizeVert);
  1185.     // calculate frame dragging rectangle
  1186.     m_rectFrameDragHorz = CRect(rect.TopLeft(), sizeFloat);
  1188. #ifdef _MAC
  1189.     CMiniFrameWnd::CalcBorders(&m_rectFrameDragHorz,
  1190.         WS_THICKFRAME, WS_EX_FORCESIZEBOX);
  1191. #else
  1192.     CMiniFrameWnd::CalcBorders(&m_rectFrameDragHorz, WS_THICKFRAME);
  1193. #endif
  1194.     m_rectFrameDragHorz.DeflateRect(2, 2);
  1195.     m_rectFrameDragVert = m_rectFrameDragHorz;
  1196.     
  1197.     // adjust rectangles so that point is inside
  1198.     AdjustRectangle(m_rectDragHorz, pt);
  1199.     AdjustRectangle(m_rectDragVert, pt);
  1200.     AdjustRectangle(m_rectFrameDragHorz, pt);
  1201.     AdjustRectangle(m_rectFrameDragVert, pt);
  1203.     // initialize tracking state and enter tracking loop
  1204.     m_dwOverDockStyle = CanDock();
  1205.     Move(pt);   // call it here to handle special keys
  1206.     Track();
  1207. }
  1208. #endif //_SCB_MINIFRAME_CAPTION
  1210. /////////////////////////////////////////////////////////////////////////////
  1211. // CSCBMiniDockFrameWnd
  1213. IMPLEMENT_DYNCREATE(CSCBMiniDockFrameWnd, baseCSCBMiniDockFrameWnd);
  1215. BEGIN_MESSAGE_MAP(CSCBMiniDockFrameWnd, baseCSCBMiniDockFrameWnd)
  1216.     //{{AFX_MSG_MAP(CSCBMiniDockFrameWnd)
  1217.     ON_WM_NCLBUTTONDOWN()
  1218.     ON_WM_GETMINMAXINFO()
  1219.     ON_WM_WINDOWPOSCHANGING()
  1220.     ON_WM_SIZE()
  1221.     //}}AFX_MSG_MAP
  1222. END_MESSAGE_MAP()
  1224. BOOL CSCBMiniDockFrameWnd::Create(CWnd* pParent, DWORD dwBarStyle)
  1225. {
  1226.     // set m_bInRecalcLayout to avoid flashing during creation
  1227.     // RecalcLayout will be called once something is docked
  1228.     m_bInRecalcLayout = TRUE;
  1230.     DWORD dwStyle = WS_POPUP|WS_CAPTION|WS_SYSMENU|MFS_MOVEFRAME|
  1231.         MFS_4THICKFRAME|MFS_SYNCACTIVE|MFS_BLOCKSYSMENU|
  1232.         FWS_SNAPTOBARS;
  1234.     if (dwBarStyle & CBRS_SIZE_DYNAMIC)
  1235.         dwStyle &= ~MFS_MOVEFRAME;
  1237.     DWORD dwExStyle = 0;
  1238. #ifdef _MAC
  1239.     if (dwBarStyle & CBRS_SIZE_DYNAMIC)
  1240.         dwExStyle |= WS_EX_FORCESIZEBOX;
  1241.     else
  1242.         dwStyle &= ~(MFS_MOVEFRAME|MFS_4THICKFRAME);
  1243. #endif
  1245.     if (!CMiniFrameWnd::CreateEx(dwExStyle,
  1246.         NULL, &afxChNil, dwStyle, rectDefault, pParent))
  1247.     {
  1248.         m_bInRecalcLayout = FALSE;
  1249.         return FALSE;
  1250.     }
  1251.     dwStyle = dwBarStyle & (CBRS_ALIGN_LEFT|CBRS_ALIGN_RIGHT) ?
  1252.         CBRS_ALIGN_LEFT : CBRS_ALIGN_TOP;
  1253.     dwStyle |= dwBarStyle & CBRS_FLOAT_MULTI;
  1254.     CMenu* pSysMenu = GetSystemMenu(FALSE);
  1255.     //pSysMenu->DeleteMenu(SC_SIZE, MF_BYCOMMAND);
  1256.     CString strHide;
  1257.     if (strHide.LoadString(AFX_IDS_HIDE))
  1258.     {
  1259.         pSysMenu->DeleteMenu(SC_CLOSE, MF_BYCOMMAND);
  1260.         pSysMenu->AppendMenu(MF_STRING|MF_ENABLED, SC_CLOSE, strHide);
  1261.     }
  1263.     // must initially create with parent frame as parent
  1264.     if (!m_wndDockBar.Create(pParent, WS_CHILD | WS_VISIBLE | dwStyle,
  1265.         AFX_IDW_DOCKBAR_FLOAT))
  1266.     {
  1267.         m_bInRecalcLayout = FALSE;
  1268.         return FALSE;
  1269.     }
  1271.     // set parent to CMiniDockFrameWnd
  1272.     m_wndDockBar.SetParent(this);
  1273.     m_bInRecalcLayout = FALSE;
  1275.     return TRUE;
  1276. }
  1278. void CSCBMiniDockFrameWnd::OnNcLButtonDown(UINT nHitTest, CPoint point)
  1279. {
  1280.     if (nHitTest == HTCAPTION || nHitTest == HTCLOSE)
  1281.     {
  1282.         baseCSCBMiniDockFrameWnd::OnNcLButtonDown(nHitTest, point);
  1283.         return;
  1284.     }
  1286.     if (GetSizingControlBar() != NULL)
  1287.         CMiniFrameWnd::OnNcLButtonDown(nHitTest, point);
  1288.     else
  1289.         baseCSCBMiniDockFrameWnd::OnNcLButtonDown(nHitTest, point);
  1290. }
  1292. CSizingControlBar* CSCBMiniDockFrameWnd::GetSizingControlBar()
  1293. {
  1294.     CWnd* pWnd = GetWindow(GW_CHILD); // get the dockbar
  1295.     if (pWnd == NULL)
  1296.         return NULL;
  1297.     
  1298.     pWnd = pWnd->GetWindow(GW_CHILD); // get the controlbar
  1299.     if (pWnd == NULL)
  1300.         return NULL;
  1302.     if (!pWnd->IsKindOf(RUNTIME_CLASS(CSizingControlBar)))
  1303.         return NULL;
  1305.     return (CSizingControlBar*) pWnd;
  1306. }
  1308. void CSCBMiniDockFrameWnd::OnSize(UINT nType, int cx, int cy) 
  1309. {
  1310.     CSizingControlBar* pBar = GetSizingControlBar();
  1311.     if ((pBar != NULL) && (GetStyle() & MFS_4THICKFRAME) == 0
  1312.         && pBar->IsVisible())
  1313.         pBar->m_szFloat = CSize(cx + 4, cy + 4);
  1315.     baseCSCBMiniDockFrameWnd::OnSize(nType, cx, cy);
  1316. }
  1318. void CSCBMiniDockFrameWnd::OnGetMinMaxInfo(MINMAXINFO FAR* lpMMI)
  1319. {
  1320.     baseCSCBMiniDockFrameWnd::OnGetMinMaxInfo(lpMMI);
  1322.     CSizingControlBar* pBar = GetSizingControlBar();
  1323.     if (pBar != NULL)
  1324.     {
  1325.         CRect r(CPoint(0, 0), pBar->m_szMinFloat - CSize(4, 4));
  1326. #ifndef _SCB_MINIFRAME_CAPTION
  1327.         CMiniFrameWnd::CalcBorders(&r, WS_THICKFRAME);
  1328. #else
  1329.         CMiniFrameWnd::CalcBorders(&r, WS_THICKFRAME|WS_CAPTION);
  1330. #endif //_SCB_MINIFRAME_CAPTION
  1331.         lpMMI->ptMinTrackSize.x = r.Width();
  1332.         lpMMI->ptMinTrackSize.y = r.Height();
  1333.     }
  1334. }
  1336. void CSCBMiniDockFrameWnd::OnWindowPosChanging(WINDOWPOS FAR* lpwndpos) 
  1337. {
  1338.     if ((GetStyle() & MFS_4THICKFRAME) != 0)
  1339.     {
  1340.         CSizingControlBar* pBar = GetSizingControlBar();
  1341.         if (pBar != NULL)
  1342.         {
  1343.             lpwndpos->flags |= SWP_NOSIZE; // don't size this time
  1344.             // prevents flicker
  1345.             pBar->m_pDockBar->ModifyStyle(0, WS_CLIPCHILDREN);
  1346.             // enable diagonal resizing
  1347.             ModifyStyle(MFS_4THICKFRAME, 0);
  1348. #ifndef _SCB_MINIFRAME_CAPTION
  1349.             // remove caption
  1350.             ModifyStyle(WS_SYSMENU|WS_CAPTION, 0);
  1351. #endif
  1352.             DelayRecalcLayout();
  1353.             pBar->PostMessage(WM_NCPAINT);
  1354.         }
  1355.     }
  1357.     CMiniFrameWnd::OnWindowPosChanging(lpwndpos);
  1358. }
  1360. #endif //_SCB_REPLACE_MINIFRAME