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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 绘图程序 > 查看源码
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. BOOL CSizingControlBar::Create(LPCTSTR lpszWindowName, CWnd* pParentWnd,
  63.                                CSize sizeDefault, BOOL bHasGripper,
  64.                                UINT nID, DWORD dwStyle)
  65. {
  66.     ASSERT_VALID(pParentWnd);   // must have a parent
  67.     ASSERT (!((dwStyle & CBRS_SIZE_FIXED)
  68.         && (dwStyle & CBRS_SIZE_DYNAMIC)));
  70.     // save the style
  71.     SetBarStyle(dwStyle & CBRS_ALL);
  73.     CString wndclass = ::AfxRegisterWndClass(CS_DBLCLKS,
  74.         ::LoadCursor(NULL, IDC_ARROW),
  75.         ::GetSysColorBrush(COLOR_BTNFACE), 0); // COLOR_BTNFACE = RGB(192, 192, 192)
  77.     dwStyle &= ~CBRS_ALL;
  78.     dwStyle &= WS_VISIBLE | WS_CHILD;
  79.     if (!CWnd::Create(wndclass, lpszWindowName, dwStyle, CRect(0,0,0,0),
  80.         pParentWnd, nID))
  81.         return FALSE;
  83.     m_sizeHorz = sizeDefault;
  84.     m_sizeVert = sizeDefault;
  85.     m_sizeFloat = sizeDefault;
  87.     m_bHasGripper = bHasGripper;
  88.     m_cyGripper = m_bHasGripper ? 12 : 0;
  90.     return TRUE;
  91. }
  93. BOOL CSizingControlBar::IsHorzDocked() const
  94. {
  95.     return (m_nDockBarID == AFX_IDW_DOCKBAR_TOP ||
  96.         m_nDockBarID == AFX_IDW_DOCKBAR_BOTTOM);
  97. }
  99. BOOL CSizingControlBar::IsVertDocked() const
  100. {
  101.     return (m_nDockBarID == AFX_IDW_DOCKBAR_LEFT ||
  102.         m_nDockBarID == AFX_IDW_DOCKBAR_RIGHT);
  103. }
  105. CSize CSizingControlBar::CalcFixedLayout(BOOL bStretch, BOOL bHorz)
  106. {
  107.     CRect rc;
  109.     m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_TOP)->GetWindowRect(rc);
  110.     int nHorzDockBarWidth = bStretch ? 32767 : rc.Width() + 4;
  111.     m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_LEFT)->GetWindowRect(rc);
  112.     int nVertDockBarHeight = bStretch ? 32767 : rc.Height() + 4;
  114.     if (bHorz)
  115.         return CSize(nHorzDockBarWidth, m_sizeHorz.cy);
  116.     else
  117.         return CSize(m_sizeVert.cx, nVertDockBarHeight);
  118. }
  120. CSize CSizingControlBar::CalcDynamicLayout(int nLength, DWORD dwMode)
  121. {
  122.     if (dwMode & (LM_HORZDOCK | LM_VERTDOCK))
  123.     {
  124.         if (nLength == -1)
  125.             GetDockingFrame()->DelayRecalcLayout();
  126.         return CControlBar::CalcDynamicLayout(nLength,dwMode);
  127.     }
  129.     if (dwMode & LM_MRUWIDTH)
  130.         return m_sizeFloat;
  132.     if (dwMode & LM_COMMIT)
  133.     {
  134.         m_sizeFloat.cx = nLength;
  135.         return m_sizeFloat;
  136.     }
  138.     if (dwMode & LM_LENGTHY)
  139.         return CSize(m_sizeFloat.cx,
  140.             m_sizeFloat.cy = max(m_sizeMin.cy, nLength));
  141.     else
  142.         return CSize(max(m_sizeMin.cx, nLength), m_sizeFloat.cy);
  143. }
  145. void CSizingControlBar::OnWindowPosChanged(WINDOWPOS FAR* lpwndpos) 
  146. {
  147.     CControlBar::OnWindowPosChanged(lpwndpos);
  149.     // Find on which side are we docked
  150.     m_nDockBarID = GetParent()->GetDlgCtrlID();
  152.     if (!m_bInRecalcNC)
  153.     {
  154.         m_bInRecalcNC = TRUE;
  156.         // Force recalc the non-client area
  157.         SetWindowPos(NULL, 0, 0, 0, 0,
  158.             SWP_NOMOVE | SWP_NOSIZE |
  159.             SWP_NOACTIVATE | SWP_NOZORDER |
  160.             SWP_FRAMECHANGED);
  162.         m_bInRecalcNC = FALSE;
  163.     }
  164. }
  166. BOOL CSizingControlBar::OnSetCursor(CWnd* pWnd, UINT nHitTest,
  167.                                     UINT message) 
  168. {
  169.     if ((nHitTest != HTSIZE) || m_bTracking)
  170.         return CControlBar::OnSetCursor(pWnd, nHitTest, message);
  172.     if (IsHorzDocked())
  173.         ::SetCursor(::LoadCursor(NULL, IDC_SIZENS));
  174.     else
  175.         ::SetCursor(::LoadCursor(NULL, IDC_SIZEWE));
  176.     return TRUE;
  177. }
  179. /////////////////////////////////////////////////////////////////////////
  180. // Mouse Handling
  181. //
  182. void CSizingControlBar::OnLButtonDown(UINT nFlags, CPoint point) 
  183. {
  184.     if (m_pDockBar != NULL)
  185.     {
  186.         // start the drag
  187.         ASSERT(m_pDockContext != NULL);
  188.         ClientToScreen(&point);
  189.         m_pDockContext->StartDrag(point);
  190.     }
  191.     else
  192.         CWnd::OnLButtonDown(nFlags, point);
  193. }
  195. void CSizingControlBar::OnLButtonDblClk(UINT nFlags, CPoint point) 
  196. {
  197.     if (m_pDockBar != NULL)
  198.     {
  199.         // toggle docking
  200.         ASSERT(m_pDockContext != NULL);
  201.         m_pDockContext->ToggleDocking();
  202.     }
  203.     else
  204.         CWnd::OnLButtonDblClk(nFlags, point);
  205. }
  207. void CSizingControlBar::OnNcLButtonDown(UINT nHitTest, CPoint point) 
  208. {
  209.     if (m_bTracking) return;
  211.     if ((nHitTest == HTSIZE) && !IsFloating())
  212.         StartTracking();
  213.     else    
  214.         CControlBar::OnNcLButtonDown(nHitTest, point);
  215. }
  217. void CSizingControlBar::OnLButtonUp(UINT nFlags, CPoint point) 
  218. {
  219.     if (m_bTracking)
  220.         StopTracking(TRUE);
  222.     CControlBar::OnLButtonUp(nFlags, point);
  223. }
  225. void CSizingControlBar::OnRButtonDown(UINT nFlags, CPoint point) 
  226. {
  227.     if (m_bTracking)
  228.         StopTracking(FALSE);
  230. CControlBar::OnRButtonDown(nFlags, point);
  231. }
  233. void CSizingControlBar::OnMouseMove(UINT nFlags, CPoint point) 
  234. {
  235.     if (m_bTracking)
  236.     {
  237. ASSERT (!IsFloating());
  238. CPoint pt = point;
  239. ClientToScreen(&pt);
  241. OnTrackUpdateSize(pt);
  242.     }
  244.     CControlBar::OnMouseMove(nFlags, point);
  245. }
  247. void CSizingControlBar::OnCaptureChanged(CWnd *pWnd) 
  248. {
  249.     if (m_bTracking && pWnd != this)
  250.         StopTracking(FALSE); // cancel tracking
  252.     CControlBar::OnCaptureChanged(pWnd);
  253. }
  255. void CSizingControlBar::OnNcCalcSize(BOOL bCalcValidRects,
  256.                                      NCCALCSIZE_PARAMS FAR* lpncsp) 
  257. {
  258.     // Compute the rectangle of the mobile edge
  259.     GetWindowRect(m_rectBorder);
  260.     m_rectBorder.OffsetRect(-m_rectBorder.left, -m_rectBorder.top);
  261.     m_rectBorder.DeflateRect(1, 1);
  262.     
  263.     m_rectGripper = m_rectBorder;
  264.     m_rectGripper.DeflateRect(5, 5);
  265.     m_rectGripper.right -= m_cxEdge;
  266.     m_rectGripper.bottom -= m_cxEdge;
  267.     CRect rc = lpncsp->rgrc[0];
  269.     DWORD dwBorderStyle = m_dwStyle | CBRS_BORDER_ANY;
  271.     switch(m_nDockBarID)
  272.     {
  273.     case AFX_IDW_DOCKBAR_TOP:
  274.         dwBorderStyle &= ~CBRS_BORDER_BOTTOM;
  275.         rc.DeflateRect(m_cyGripper + 2, 2, 2, m_cxEdge + 2);
  276.         m_rectBorder.top = m_rectBorder.bottom - m_cxEdge;
  277.         break;
  278.     case AFX_IDW_DOCKBAR_BOTTOM:
  279.         dwBorderStyle &= ~CBRS_BORDER_TOP;
  280.         rc.DeflateRect(m_cyGripper + 2, m_cxEdge + 2, 2, 2);
  281.         m_rectBorder.bottom = m_rectBorder.top + m_cxEdge;
  282.         m_rectGripper.OffsetRect(0, m_cxEdge);
  283.         break;
  284.     case AFX_IDW_DOCKBAR_LEFT:
  285.         dwBorderStyle &= ~CBRS_BORDER_RIGHT;
  286.         rc.DeflateRect(2, m_cyGripper + 2, m_cxEdge + 2, 6);
  287.         m_rectBorder.left = m_rectBorder.right - m_cxEdge;
  288.         break;
  289.     case AFX_IDW_DOCKBAR_RIGHT:
  290.         dwBorderStyle &= ~CBRS_BORDER_LEFT;
  291.         rc.DeflateRect(m_cxEdge + 2, m_cyGripper + 2, 2, 6);
  292.         m_rectBorder.right = m_rectBorder.left + m_cxEdge;
  293.         m_rectGripper.OffsetRect(m_cxEdge, 0);
  294.         break;
  295.     default:
  296.         m_rectBorder.SetRectEmpty();
  297.         break;
  298.     }
  300.     lpncsp->rgrc[0] = rc;
  302.     SetBarStyle(dwBorderStyle);
  303. }
  305. void CSizingControlBar::OnNcPaint() 
  306. {
  307.     // get window DC that is clipped to the non-client area
  308.     CWindowDC dc(this);
  309.     CRect rectClient;
  310.     GetClientRect(rectClient);
  311.     CRect rectWindow;
  312.     GetWindowRect(rectWindow);
  313.     ScreenToClient(rectWindow);
  314.     rectClient.OffsetRect(-rectWindow.left, -rectWindow.top);
  315.     dc.ExcludeClipRect(rectClient);
  317.     // draw borders in non-client area
  318.     rectWindow.OffsetRect(-rectWindow.left, -rectWindow.top);
  319.     DrawBorders(&dc, rectWindow);
  321.     // erase parts not drawn
  322.     dc.IntersectClipRect(rectWindow);
  324.     // erase NC background the hard way
  325.     HBRUSH hbr = (HBRUSH)GetClassLong(m_hWnd, GCL_HBRBACKGROUND);
  326.     ::FillRect(dc.m_hDC, rectWindow, hbr);
  328.     // paint the mobile edge
  329.     dc.Draw3dRect(m_rectBorder, ::GetSysColor(COLOR_BTNHIGHLIGHT),
  330.         ::GetSysColor(COLOR_BTNSHADOW));
  332.     if (m_bHasGripper)
  333.     {
  334.         // paint the gripper
  335.         CRect gripper = m_rectGripper;
  336.         
  337.         if (IsHorzDocked())
  338.         {
  339.             // gripper at left
  340.             gripper.right = gripper.left + 3;
  341.             dc.Draw3dRect(gripper, ::GetSysColor(COLOR_BTNHIGHLIGHT),
  342.                 ::GetSysColor(COLOR_BTNSHADOW));
  343.             gripper.OffsetRect(3, 0);
  344.             dc.Draw3dRect(gripper, ::GetSysColor(COLOR_BTNHIGHLIGHT),
  345.                 ::GetSysColor(COLOR_BTNSHADOW));
  346.         }
  347.         else if (IsVertDocked())
  348.         {
  349.             // gripper at top
  350.             gripper.bottom = gripper.top + 3;
  351.             dc.Draw3dRect(gripper, ::GetSysColor(COLOR_BTNHIGHLIGHT),
  352.                 ::GetSysColor(COLOR_BTNSHADOW));
  353.             gripper.OffsetRect(0, 3);
  354.             dc.Draw3dRect(gripper, ::GetSysColor(COLOR_BTNHIGHLIGHT),
  355.                 ::GetSysColor(COLOR_BTNSHADOW));
  356.         }
  357.     }
  359.     ReleaseDC(&dc);
  360. }
  362. void CSizingControlBar::OnPaint() 
  363. {
  364.     // overridden to skip border painting based on clientrect
  365.     CPaintDC dc(this);
  366. }
  368. UINT CSizingControlBar::OnNcHitTest(CPoint point) 
  369. {
  370.     if (IsFloating())
  371.         return CControlBar::OnNcHitTest(point);
  373.     CRect rc;
  374.     GetWindowRect(rc);
  375.     point.Offset(-rc.left, -rc.top);
  376.     if (m_rectBorder.PtInRect(point))
  377.         return HTSIZE;
  378.     else
  379.         return HTCLIENT;
  380. }
  382. /////////////////////////////////////////////////////////////////////////
  383. // CSizingControlBar implementation helpers
  385. void CSizingControlBar::StartTracking()
  386. {
  387.     SetCapture();
  389.     // make sure no updates are pending
  390.     RedrawWindow(NULL, NULL, RDW_ALLCHILDREN | RDW_UPDATENOW);
  392. m_bDragShowContent = QueryDragFullWindows();
  394. if (!m_bDragShowContent)
  395.     m_pDockSite->LockWindowUpdate();
  397. m_sizeOld = IsHorzDocked() ? m_sizeHorz : m_sizeVert;
  399. CRect rect;
  400. GetWindowRect(&rect);
  401.     m_ptOld = m_rectBorder.CenterPoint() + rect.TopLeft();
  403. m_sizeMax = CalcMaxSize();
  404.     m_bTracking = TRUE;
  405.     
  406. if (!m_bDragShowContent)
  407.     OnTrackInvertTracker();
  408. }
  410. void CSizingControlBar::StopTracking(BOOL bAccept)
  411. {
  412. if (!m_bDragShowContent)
  413. {
  414. OnTrackInvertTracker();
  415.     m_pDockSite->UnlockWindowUpdate();
  416. }
  418.     m_bTracking = FALSE;
  419.     ReleaseCapture();
  420.     
  421.     if (!bAccept) // resize canceled?
  422. {
  423. // restore old size
  424. if (IsHorzDocked())
  425.         m_sizeHorz = m_sizeOld;
  426. else
  427. m_sizeVert = m_sizeOld;
  428. }
  430.     m_pDockSite->DelayRecalcLayout();
  431. }
  433. void CSizingControlBar::OnTrackUpdateSize(CPoint& point)
  434. {
  435. BOOL bHorz = IsHorzDocked();
  437.     CSize sizeNew = m_sizeOld;
  439.     if ((m_nDockBarID == AFX_IDW_DOCKBAR_TOP) ||
  440. (m_nDockBarID == AFX_IDW_DOCKBAR_LEFT))
  441.         sizeNew += point - m_ptOld;
  442. else
  443.         sizeNew -= point - m_ptOld;
  445. // check limits
  446.    sizeNew.cx = max(m_sizeMin.cx, sizeNew.cx);
  447.    sizeNew.cy = max(m_sizeMin.cy, sizeNew.cy);
  448.    sizeNew.cx = min(m_sizeMax.cx, sizeNew.cx);
  449.    sizeNew.cy = min(m_sizeMax.cy, sizeNew.cy);
  451.     if ((sizeNew.cy == m_sizeHorz.cy) && bHorz ||
  452. (sizeNew.cx == m_sizeVert.cx) && !bHorz)
  453. return; // no size change
  455. if (!m_bDragShowContent)
  456. OnTrackInvertTracker();
  458.     if (bHorz)
  459. m_sizeHorz = sizeNew;
  460. else
  461. m_sizeVert = sizeNew;
  463. if (!m_bDragShowContent)
  464. OnTrackInvertTracker();
  465. else
  466.     m_pDockSite->DelayRecalcLayout();
  467. }
  469. CSize CSizingControlBar::CalcMaxSize()
  470. {
  471. // the control bar cannot grow with more than the size of 
  472. // remaining client area of the frame
  473. CRect rect;
  474. m_pDockSite->GetClientRect(&rect);
  475. CSize size = rect.Size();
  476. CWnd* pBar;
  477. if (IsHorzDocked())
  478. {
  479. if (pBar = m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_TOP))
  480. {
  481. pBar->GetWindowRect(&rect);
  482. size -= rect.Size();
  483. }
  484. if (pBar = m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_BOTTOM))
  485. {
  486. pBar->GetWindowRect(&rect);
  487. size -= rect.Size();
  488. }
  489. if (pBar = m_pDockSite->GetControlBar(AFX_IDW_STATUS_BAR))
  490. {
  491. pBar->GetWindowRect(&rect);
  492. size -= rect.Size();
  493. }
  494. }
  495. else
  496. {
  497. if (pBar = m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_LEFT))
  498. {
  499. pBar->GetWindowRect(&rect);
  500. size -= rect.Size();
  501. }
  502. if (pBar = m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_RIGHT))
  503. {
  504. pBar->GetWindowRect(&rect);
  505. size -= rect.Size();
  506. }
  507. }
  509. size -= CSize(4, 4);
  510.     size += IsHorzDocked() ? m_sizeHorz : m_sizeVert;
  512. return size;
  513. }
  515. void CSizingControlBar::OnTrackInvertTracker()
  516. {
  517.     ASSERT_VALID(this);
  518.     ASSERT(m_bTracking);
  520. CRect rect = m_rectBorder;
  521.     CRect rectBar, rectFrame;
  522.     GetWindowRect(rectBar);
  523.     rect.OffsetRect(rectBar.TopLeft());
  524.     m_pDockSite->GetWindowRect(rectFrame);
  525.     rect.OffsetRect(-rectFrame.left, -rectFrame.top);
  527. switch (m_nDockBarID)
  528. {
  529. case AFX_IDW_DOCKBAR_TOP:
  530. rect.OffsetRect(0, m_sizeHorz.cy - m_sizeOld.cy); break;
  531. case AFX_IDW_DOCKBAR_BOTTOM:
  532. rect.OffsetRect(0, m_sizeOld.cy - m_sizeHorz.cy); break;
  533. case AFX_IDW_DOCKBAR_LEFT:
  534. rect.OffsetRect(m_sizeVert.cx - m_sizeOld.cx, 0); break;
  535. case AFX_IDW_DOCKBAR_RIGHT:
  536. rect.OffsetRect(m_sizeOld.cx - m_sizeVert.cx, 0); break;
  537. }
  538. if (IsVertDocked())
  539.     rect.bottom -= 4;
  540.     rect.DeflateRect(1, 1);
  542.     CDC *pDC = m_pDockSite->GetDCEx(NULL,
  543.         DCX_WINDOW|DCX_CACHE|DCX_LOCKWINDOWUPDATE);
  545.     CBrush* pBrush = CDC::GetHalftoneBrush();
  546.     HBRUSH hOldBrush = NULL;
  547.     if (pBrush != NULL)
  548.         hOldBrush = (HBRUSH)::SelectObject(pDC->m_hDC, pBrush->m_hObject);
  550.     pDC->PatBlt(rect.left, rect.top,
  551. rect.Width(), rect.Height(), PATINVERT);
  553.     if (hOldBrush != NULL)
  554.         ::SelectObject(pDC->m_hDC, hOldBrush);
  556.     m_pDockSite->ReleaseDC(pDC);
  557. }
  559. BOOL CSizingControlBar::QueryDragFullWindows() const
  560. {
  561. TCHAR sDragfullWindows[2];
  562. DWORD cbDragfullWindows = sizeof(DWORD);
  563. DWORD dwType;
  564. HKEY hKey;
  565. BOOL bRet = FALSE;
  567. RegOpenKeyEx(HKEY_CURRENT_USER, _T("Control Panel\desktop"),
  568. 0, KEY_QUERY_VALUE, &hKey);
  570. if (!FAILED(RegQueryValueEx(hKey, _T("DragfullWindows"),
  571. NULL, &dwType, (LPBYTE)&sDragfullWindows, &cbDragfullWindows)))
  572. if (!_tcscmp(sDragfullWindows, _T("1")))
  573. bRet = TRUE;
  575. RegCloseKey(hKey);
  577. return bRet;
  578. }