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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 绘图程序 > 查看源码
sizecbar.cpp
资源名称：MiniCAD_ALL.zip　[点击查看]
上传用户：netltd
上传日期：2013-02-12
资源大小：7234k
文件大小：15k
源码类别：

绘图程序

开发平台：

Visual C++

sizecbar.cpp：源码内容
  1. /////////////////////////////////////////////////////////////////////////
  2. // Copyright (C) 1998 by Cristi Posea
  3. // All rights reserved
  5. /////////////////////////////////////////////////////////////////////////
  8. // SizingControlBar.cpp : implementation file
  9. //
  11. #include "stdafx.h"
  12. #include "afxpriv.h"    // for CDockContext
  13. #include "sizecbar.h"
  15. #ifdef _DEBUG
  16. #define new DEBUG_NEW
  17. #undef THIS_FILE
  18. static char THIS_FILE[] = __FILE__;
  19. #endif
  21. /////////////////////////////////////////////////////////////////////////
  22. // CSizingControlBar
  24. CSizingControlBar::CSizingControlBar()
  25. {
  26.     m_sizeMin = CSize(32, 32);
  27.     m_sizeHorz = CSize(200, 200);
  28.     m_sizeVert = CSize(200, 200);
  29.     m_sizeFloat = CSize(200, 200);
  30.     m_bTracking = FALSE;
  31.     m_bInRecalcNC = FALSE;
  32.     m_cxEdge = 5;
  33. m_bDragShowContent = FALSE;
  34. }
  36. CSizingControlBar::~CSizingControlBar()
  37. {
  38. }
  40. BEGIN_MESSAGE_MAP(CSizingControlBar, CControlBar)
  41.     //{{AFX_MSG_MAP(CSizingControlBar)
  42.     ON_WM_LBUTTONUP()
  43.     ON_WM_MOUSEMOVE()
  44.     ON_WM_SETCURSOR()
  45.     ON_WM_WINDOWPOSCHANGED()
  46.     ON_WM_NCPAINT()
  47.     ON_WM_NCLBUTTONDOWN()
  48.     ON_WM_NCHITTEST()
  49.     ON_WM_NCCALCSIZE()
  50.     ON_WM_LBUTTONDOWN()
  51.     ON_WM_CAPTURECHANGED()
  52.     ON_WM_LBUTTONDBLCLK()
  53.     ON_WM_PAINT()
  54.     ON_WM_SIZE()
  55. ON_WM_RBUTTONDOWN()
  56. //}}AFX_MSG_MAP
  57. END_MESSAGE_MAP()
  59. /////////////////////////////////////////////////////////////////////////
  60. // CSizingControlBar message handlers
  62. //sizeDefault.x是停靠或浮动的Bar的宽度，sizeDefault.y是浮动的Bar的高度
  63. BOOL CSizingControlBar::Create(LPCTSTR lpszWindowName, CWnd* pParentWnd,
  64.                                CSize sizeDefault, BOOL bHasGripper,
  65.                                UINT nID, DWORD dwStyle)
  66. {
  67.     ASSERT_VALID(pParentWnd);   // must have a parent
  68.     ASSERT (!((dwStyle & CBRS_SIZE_FIXED)
  69.         && (dwStyle & CBRS_SIZE_DYNAMIC)));
  71.     // save the style
  72.     SetBarStyle(dwStyle & CBRS_ALL);
  74.     CString wndclass = ::AfxRegisterWndClass(CS_DBLCLKS,
  75.         ::LoadCursor(NULL, IDC_ARROW),
  76.         ::GetSysColorBrush(COLOR_BTNFACE), 0); // COLOR_BTNFACE = RGB(192, 192, 192)
  78.     dwStyle &= ~CBRS_ALL;
  79.     dwStyle &= WS_VISIBLE | WS_CHILD;
  80.     if (!CWnd::Create(wndclass, lpszWindowName, dwStyle, CRect(0,0,0,0),
  81.         pParentWnd, nID))
  82.         return FALSE;
  84.     m_sizeHorz = sizeDefault;
  85.     m_sizeVert = sizeDefault;
  86.     m_sizeFloat = sizeDefault;
  88.     m_bHasGripper = bHasGripper;
  89.     m_cyGripper = m_bHasGripper ? 12 : 0;
  91.     return TRUE;
  92. }
  94. BOOL CSizingControlBar::IsHorzDocked() const
  95. {
  96.     return (m_nDockBarID == AFX_IDW_DOCKBAR_TOP ||
  97.         m_nDockBarID == AFX_IDW_DOCKBAR_BOTTOM);
  98. }
  100. BOOL CSizingControlBar::IsVertDocked() const
  101. {
  102.     return (m_nDockBarID == AFX_IDW_DOCKBAR_LEFT ||
  103.         m_nDockBarID == AFX_IDW_DOCKBAR_RIGHT);
  104. }
  106. CSize CSizingControlBar::CalcFixedLayout(BOOL bStretch, BOOL bHorz)
  107. {
  108.     CRect rc;
  110.     m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_TOP)->GetWindowRect(rc);
  111.     int nHorzDockBarWidth = bStretch ? 32767 : rc.Width() + 4;
  112.     m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_LEFT)->GetWindowRect(rc);
  113.     int nVertDockBarHeight = bStretch ? 32767 : rc.Height() + 4;
  115.     if (bHorz)
  116.         return CSize(nHorzDockBarWidth, m_sizeHorz.cy);
  117.     else
  118.         return CSize(m_sizeVert.cx, nVertDockBarHeight);
  119. }
  121. CSize CSizingControlBar::CalcDynamicLayout(int nLength, DWORD dwMode)
  122. {
  123.     if (dwMode & (LM_HORZDOCK | LM_VERTDOCK))
  124.     {
  125.         if (nLength == -1)
  126.             GetDockingFrame()->DelayRecalcLayout();
  127.         return CControlBar::CalcDynamicLayout(nLength,dwMode);
  128.     }
  130.     if (dwMode & LM_MRUWIDTH)
  131.         return m_sizeFloat;
  133.     if (dwMode & LM_COMMIT)
  134.     {
  135.         m_sizeFloat.cx = nLength;
  136.         return m_sizeFloat;
  137.     }
  139.     if (dwMode & LM_LENGTHY)
  140.         return CSize(m_sizeFloat.cx,
  141.             m_sizeFloat.cy = max(m_sizeMin.cy, nLength));
  142.     else
  143.         return CSize(max(m_sizeMin.cx, nLength), m_sizeFloat.cy);
  144. }
  146. void CSizingControlBar::OnWindowPosChanged(WINDOWPOS FAR* lpwndpos) 
  147. {
  148.     CControlBar::OnWindowPosChanged(lpwndpos);
  150.     // Find on which side are we docked
  151.     m_nDockBarID = GetParent()->GetDlgCtrlID();
  153.     if (!m_bInRecalcNC)
  154.     {
  155.         m_bInRecalcNC = TRUE;
  157.         // Force recalc the non-client area
  158.         SetWindowPos(NULL, 0, 0, 0, 0,
  159.             SWP_NOMOVE | SWP_NOSIZE |
  160.             SWP_NOACTIVATE | SWP_NOZORDER |
  161.             SWP_FRAMECHANGED);
  163.         m_bInRecalcNC = FALSE;
  164.     }
  165. }
  167. BOOL CSizingControlBar::OnSetCursor(CWnd* pWnd, UINT nHitTest,
  168.                                     UINT message) 
  169. {
  170.     if ((nHitTest != HTSIZE) || m_bTracking)
  171.         return CControlBar::OnSetCursor(pWnd, nHitTest, message);
  173.     if (IsHorzDocked())
  174.         ::SetCursor(::LoadCursor(NULL, IDC_SIZENS));
  175.     else
  176.         ::SetCursor(::LoadCursor(NULL, IDC_SIZEWE));
  177.     return TRUE;
  178. }
  180. /////////////////////////////////////////////////////////////////////////
  181. // Mouse Handling
  182. //
  183. void CSizingControlBar::OnLButtonDown(UINT nFlags, CPoint point) 
  184. {
  185.     if (m_pDockBar != NULL)
  186.     {
  187.         // start the drag
  188.         ASSERT(m_pDockContext != NULL);
  189.         ClientToScreen(&point);
  190.         m_pDockContext->StartDrag(point);
  191.     }
  192.     else
  193.         CWnd::OnLButtonDown(nFlags, point);
  194. }
  196. void CSizingControlBar::OnLButtonDblClk(UINT nFlags, CPoint point) 
  197. {
  198.     if (m_pDockBar != NULL)
  199.     {
  200.         // toggle docking
  201.         ASSERT(m_pDockContext != NULL);
  202.         m_pDockContext->ToggleDocking();
  203.     }
  204.     else
  205.         CWnd::OnLButtonDblClk(nFlags, point);
  206. }
  208. void CSizingControlBar::OnNcLButtonDown(UINT nHitTest, CPoint point) 
  209. {
  210.     if (m_bTracking) return;
  212.     if ((nHitTest == HTSIZE) && !IsFloating())
  213.         StartTracking();
  214.     else    
  215.         CControlBar::OnNcLButtonDown(nHitTest, point);
  216. }
  218. void CSizingControlBar::OnLButtonUp(UINT nFlags, CPoint point) 
  219. {
  220.     if (m_bTracking)
  221.         StopTracking(TRUE);
  223.     CControlBar::OnLButtonUp(nFlags, point);
  224. }
  226. void CSizingControlBar::OnRButtonDown(UINT nFlags, CPoint point) 
  227. {
  228.     if (m_bTracking)
  229.         StopTracking(FALSE);
  231. CControlBar::OnRButtonDown(nFlags, point);
  232. }
  234. void CSizingControlBar::OnMouseMove(UINT nFlags, CPoint point) 
  235. {
  236.     if (m_bTracking)
  237.     {
  238. ASSERT (!IsFloating());
  239. CPoint pt = point;
  240. ClientToScreen(&pt);
  242. OnTrackUpdateSize(pt);
  243.     }
  245.     CControlBar::OnMouseMove(nFlags, point);
  246. }
  248. void CSizingControlBar::OnCaptureChanged(CWnd *pWnd) 
  249. {
  250.     if (m_bTracking && pWnd != this)
  251.         StopTracking(FALSE); // cancel tracking
  253.     CControlBar::OnCaptureChanged(pWnd);
  254. }
  256. void CSizingControlBar::OnNcCalcSize(BOOL bCalcValidRects,
  257.                                      NCCALCSIZE_PARAMS FAR* lpncsp) 
  258. {
  259.     // Compute the rectangle of the mobile edge
  260.     GetWindowRect(m_rectBorder);
  261.     m_rectBorder.OffsetRect(-m_rectBorder.left, -m_rectBorder.top);
  262.     m_rectBorder.DeflateRect(1, 1);
  263.     
  264.     m_rectGripper = m_rectBorder;
  265.     m_rectGripper.DeflateRect(5, 5);
  266.     m_rectGripper.right -= m_cxEdge;
  267.     m_rectGripper.bottom -= m_cxEdge;
  268.     CRect rc = lpncsp->rgrc[0];
  270.     DWORD dwBorderStyle = m_dwStyle | CBRS_BORDER_ANY;
  272.     switch(m_nDockBarID)
  273.     {
  274.     case AFX_IDW_DOCKBAR_TOP:
  275.         dwBorderStyle &= ~CBRS_BORDER_BOTTOM;
  276.         rc.DeflateRect(m_cyGripper + 2, 2, 2, m_cxEdge + 2);
  277.         m_rectBorder.top = m_rectBorder.bottom - m_cxEdge;
  278.         break;
  279.     case AFX_IDW_DOCKBAR_BOTTOM:
  280.         dwBorderStyle &= ~CBRS_BORDER_TOP;
  281.         rc.DeflateRect(m_cyGripper + 2, m_cxEdge + 2, 2, 2);
  282.         m_rectBorder.bottom = m_rectBorder.top + m_cxEdge;
  283.         m_rectGripper.OffsetRect(0, m_cxEdge);
  284.         break;
  285.     case AFX_IDW_DOCKBAR_LEFT:
  286.         dwBorderStyle &= ~CBRS_BORDER_RIGHT;
  287.         rc.DeflateRect(2, m_cyGripper + 2, m_cxEdge + 2, 6);
  288.         m_rectBorder.left = m_rectBorder.right - m_cxEdge;
  289.         break;
  290.     case AFX_IDW_DOCKBAR_RIGHT:
  291.         dwBorderStyle &= ~CBRS_BORDER_LEFT;
  292.         rc.DeflateRect(m_cxEdge + 2, m_cyGripper + 2, 2, 6);
  293.         m_rectBorder.right = m_rectBorder.left + m_cxEdge;
  294.         m_rectGripper.OffsetRect(m_cxEdge, 0);
  295.         break;
  296.     default:
  297.         m_rectBorder.SetRectEmpty();
  298.         break;
  299.     }
  301.     lpncsp->rgrc[0] = rc;
  303.     SetBarStyle(dwBorderStyle);
  304. }
  306. void CSizingControlBar::OnNcPaint() 
  307. {
  308.     // get window DC that is clipped to the non-client area
  309.     CWindowDC dc(this);
  310.     CRect rectClient;
  311.     GetClientRect(rectClient);
  312.     CRect rectWindow;
  313.     GetWindowRect(rectWindow);
  314.     ScreenToClient(rectWindow);
  315.     rectClient.OffsetRect(-rectWindow.left, -rectWindow.top);
  316.     dc.ExcludeClipRect(rectClient);
  318.     // draw borders in non-client area
  319.     rectWindow.OffsetRect(-rectWindow.left, -rectWindow.top);
  320.     DrawBorders(&dc, rectWindow);
  322.     // erase parts not drawn
  323.     dc.IntersectClipRect(rectWindow);
  325.     // erase NC background the hard way
  326.     HBRUSH hbr = (HBRUSH)GetClassLong(m_hWnd, GCL_HBRBACKGROUND);
  327.     ::FillRect(dc.m_hDC, rectWindow, hbr);
  329.     // paint the mobile edge
  330.     dc.Draw3dRect(m_rectBorder, ::GetSysColor(COLOR_BTNHIGHLIGHT),
  331.         ::GetSysColor(COLOR_BTNSHADOW));
  333.     if (m_bHasGripper)
  334.     {
  335.         // paint the gripper
  336.         CRect gripper = m_rectGripper;
  337.         
  338.         if (IsHorzDocked())
  339.         {
  340.             // gripper at left
  341.             gripper.right = gripper.left + 3;
  342.             dc.Draw3dRect(gripper, ::GetSysColor(COLOR_BTNHIGHLIGHT),
  343.                 ::GetSysColor(COLOR_BTNSHADOW));
  344.             gripper.OffsetRect(3, 0);
  345.             dc.Draw3dRect(gripper, ::GetSysColor(COLOR_BTNHIGHLIGHT),
  346.                 ::GetSysColor(COLOR_BTNSHADOW));
  347.         }
  348.         else if (IsVertDocked())
  349.         {
  350.             // gripper at top
  351.             gripper.bottom = gripper.top + 3;
  352.             dc.Draw3dRect(gripper, ::GetSysColor(COLOR_BTNHIGHLIGHT),
  353.                 ::GetSysColor(COLOR_BTNSHADOW));
  354.             gripper.OffsetRect(0, 3);
  355.             dc.Draw3dRect(gripper, ::GetSysColor(COLOR_BTNHIGHLIGHT),
  356.                 ::GetSysColor(COLOR_BTNSHADOW));
  357.         }
  358.     }
  360.     ReleaseDC(&dc);
  361. }
  363. void CSizingControlBar::OnPaint() 
  364. {
  365.     // overridden to skip border painting based on clientrect
  366.     CPaintDC dc(this);
  367. }
  369. UINT CSizingControlBar::OnNcHitTest(CPoint point) 
  370. {
  371.     if (IsFloating())
  372.         return CControlBar::OnNcHitTest(point);
  374.     CRect rc;
  375.     GetWindowRect(rc);
  376.     point.Offset(-rc.left, -rc.top);
  377.     if (m_rectBorder.PtInRect(point))
  378.         return HTSIZE;
  379.     else
  380.         return HTCLIENT;
  381. }
  383. /////////////////////////////////////////////////////////////////////////
  384. // CSizingControlBar implementation helpers
  386. void CSizingControlBar::StartTracking()
  387. {
  388.     SetCapture();
  390.     // make sure no updates are pending
  391.     RedrawWindow(NULL, NULL, RDW_ALLCHILDREN | RDW_UPDATENOW);
  393. m_bDragShowContent = QueryDragFullWindows();
  395. if (!m_bDragShowContent)
  396.     m_pDockSite->LockWindowUpdate();
  398. m_sizeOld = IsHorzDocked() ? m_sizeHorz : m_sizeVert;
  400. CRect rect;
  401. GetWindowRect(&rect);
  402.     m_ptOld = m_rectBorder.CenterPoint() + rect.TopLeft();
  404. m_sizeMax = CalcMaxSize();
  405.     m_bTracking = TRUE;
  406.     
  407. if (!m_bDragShowContent)
  408.     OnTrackInvertTracker();
  409. }
  411. void CSizingControlBar::StopTracking(BOOL bAccept)
  412. {
  413. if (!m_bDragShowContent)
  414. {
  415. OnTrackInvertTracker();
  416.     m_pDockSite->UnlockWindowUpdate();
  417. }
  419.     m_bTracking = FALSE;
  420.     ReleaseCapture();
  421.     
  422.     if (!bAccept) // resize canceled?
  423. {
  424. // restore old size
  425. if (IsHorzDocked())
  426.         m_sizeHorz = m_sizeOld;
  427. else
  428. m_sizeVert = m_sizeOld;
  429. }
  431.     m_pDockSite->DelayRecalcLayout();
  432. }
  434. void CSizingControlBar::OnTrackUpdateSize(CPoint& point)
  435. {
  436. BOOL bHorz = IsHorzDocked();
  438.     CSize sizeNew = m_sizeOld;
  440.     if ((m_nDockBarID == AFX_IDW_DOCKBAR_TOP) ||
  441. (m_nDockBarID == AFX_IDW_DOCKBAR_LEFT))
  442.         sizeNew += point - m_ptOld;
  443. else
  444.         sizeNew -= point - m_ptOld;
  446. // check limits
  447.    sizeNew.cx = max(m_sizeMin.cx, sizeNew.cx);
  448.    sizeNew.cy = max(m_sizeMin.cy, sizeNew.cy);
  449.    sizeNew.cx = min(m_sizeMax.cx, sizeNew.cx);
  450.    sizeNew.cy = min(m_sizeMax.cy, sizeNew.cy);
  452.     if ((sizeNew.cy == m_sizeHorz.cy) && bHorz ||
  453. (sizeNew.cx == m_sizeVert.cx) && !bHorz)
  454. return; // no size change
  456. if (!m_bDragShowContent)
  457. OnTrackInvertTracker();
  459.     if (bHorz)
  460. m_sizeHorz = sizeNew;
  461. else
  462. m_sizeVert = sizeNew;
  464. if (!m_bDragShowContent)
  465. OnTrackInvertTracker();
  466. else
  467.     m_pDockSite->DelayRecalcLayout();
  468. }
  470. CSize CSizingControlBar::CalcMaxSize()
  471. {
  472. // the control bar cannot grow with more than the size of 
  473. // remaining client area of the frame
  474. CRect rect;
  475. m_pDockSite->GetClientRect(&rect);
  476. CSize size = rect.Size();
  477. CWnd* pBar;
  478. if (IsHorzDocked())
  479. {
  480. if (pBar = m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_TOP))
  481. {
  482. pBar->GetWindowRect(&rect);
  483. size -= rect.Size();
  484. }
  485. if (pBar = m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_BOTTOM))
  486. {
  487. pBar->GetWindowRect(&rect);
  488. size -= rect.Size();
  489. }
  490. if (pBar = m_pDockSite->GetControlBar(AFX_IDW_STATUS_BAR))
  491. {
  492. pBar->GetWindowRect(&rect);
  493. size -= rect.Size();
  494. }
  495. }
  496. else
  497. {
  498. if (pBar = m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_LEFT))
  499. {
  500. pBar->GetWindowRect(&rect);
  501. size -= rect.Size();
  502. }
  503. if (pBar = m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_RIGHT))
  504. {
  505. pBar->GetWindowRect(&rect);
  506. size -= rect.Size();
  507. }
  508. }
  510. size -= CSize(4, 4);
  511.     size += IsHorzDocked() ? m_sizeHorz : m_sizeVert;
  513. return size;
  514. }
  516. void CSizingControlBar::OnTrackInvertTracker()
  517. {
  518.     ASSERT_VALID(this);
  519.     ASSERT(m_bTracking);
  521. CRect rect = m_rectBorder;
  522.     CRect rectBar, rectFrame;
  523.     GetWindowRect(rectBar);
  524.     rect.OffsetRect(rectBar.TopLeft());
  525.     m_pDockSite->GetWindowRect(rectFrame);
  526.     rect.OffsetRect(-rectFrame.left, -rectFrame.top);
  528. switch (m_nDockBarID)
  529. {
  530. case AFX_IDW_DOCKBAR_TOP:
  531. rect.OffsetRect(0, m_sizeHorz.cy - m_sizeOld.cy); break;
  532. case AFX_IDW_DOCKBAR_BOTTOM:
  533. rect.OffsetRect(0, m_sizeOld.cy - m_sizeHorz.cy); break;
  534. case AFX_IDW_DOCKBAR_LEFT:
  535. rect.OffsetRect(m_sizeVert.cx - m_sizeOld.cx, 0); break;
  536. case AFX_IDW_DOCKBAR_RIGHT:
  537. rect.OffsetRect(m_sizeOld.cx - m_sizeVert.cx, 0); break;
  538. }
  539. if (IsVertDocked())
  540.     rect.bottom -= 4;
  541.     rect.DeflateRect(1, 1);
  543.     CDC *pDC = m_pDockSite->GetDCEx(NULL,
  544.         DCX_WINDOW|DCX_CACHE|DCX_LOCKWINDOWUPDATE);
  546.     CBrush* pBrush = CDC::GetHalftoneBrush();
  547.     HBRUSH hOldBrush = NULL;
  548.     if (pBrush != NULL)
  549.         hOldBrush = (HBRUSH)::SelectObject(pDC->m_hDC, pBrush->m_hObject);
  551.     pDC->PatBlt(rect.left, rect.top,
  552. rect.Width(), rect.Height(), PATINVERT);
  554.     if (hOldBrush != NULL)
  555.         ::SelectObject(pDC->m_hDC, hOldBrush);
  557.     m_pDockSite->ReleaseDC(pDC);
  558. }
  560. BOOL CSizingControlBar::QueryDragFullWindows() const
  561. {
  562. TCHAR sDragfullWindows[2];
  563. DWORD cbDragfullWindows = sizeof(DWORD);
  564. DWORD dwType;
  565. HKEY hKey;
  566. BOOL bRet = FALSE;
  568. RegOpenKeyEx(HKEY_CURRENT_USER, _T("Control Panel\desktop"),
  569. 0, KEY_QUERY_VALUE, &hKey);
  571. if (!FAILED(RegQueryValueEx(hKey, _T("DragfullWindows"),
  572. NULL, &dwType, (LPBYTE)&sDragfullWindows, &cbDragfullWindows)))
  573. if (!_tcscmp(sDragfullWindows, _T("1")))
  574. bRet = TRUE;
  576. RegCloseKey(hKey);
  578. return bRet;
  579. }