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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 工具条 > 查看源码
SIZECBAR.CPP
资源名称：ctreecontrolbar.rar　[点击查看]
上传用户：nbkytg
上传日期：2021-02-14
资源大小：126k
文件大小：25k
源码类别：

工具条

开发平台：

Visual C++

SIZECBAR.CPP：源码内容
  1. /////////////////////////////////////////////////////////////////////////
  2. // Copyright (C) 1998 by Cristi Posea
  3. // All rights reserved
  4. //
  5. // Distribute freely, except: don't remove my name from the source or
  6. // documentation (don't take credit for my work), mark your changes
  7. // (don't get me blamed for your possible bugs), don't alter or remove
  8. // this notice.
  9. // No warrantee of any kind, express or implied, is included with this
  10. // software; use at your own risk, responsibility for damages (if any) to
  11. // anyone resulting from the use of this software rests entirely with the
  12. // user.
  13. //
  14. // Send bug reports, bug fixes, enhancements, requests, flames, etc.,
  15. // and I'll try to keep a version up to date.  I can be reached at:
  16. //    cristi@gds.ro
  17. /////////////////////////////////////////////////////////////////////////
  18. //
  19. // Acknowledgements:
  20. //  o   Thanks to Harlan R. Seymour (harlan@hcube.com) for motivating me
  21. //      to update this code. Also he prompted me to a bug durring 
  22. //      the developement phase.
  23. //  o   Thanks to Zafir Anjum (zafir@codeguru.com) for publishing this
  24. //      code on his cool site (www.codeguru.com).
  25. //  o   Some ideeas for the gripper came from the CToolBarEx flat toolbar
  26. //      by Joerg Koenig (Joerg.Koenig@rhein-neckar.de). Also he inspired
  27. //      me on writting this notice:) . Thanks, Joerg!
  28. //  o   Thanks to Jakawan Ratiwanich (jack@alpha.fsec.ucf.edu) and to
  29. //      Udo Schaefer(Udo.Schaefer@vcase.de) for the dwStyle bug fix under
  30. //      VC++ 6.0.
  31. //  o   Thanks to Microsoft developers for the MFC source code. After
  32. //      all, most of this class code came from there.
  33. //
  34. /////////////////////////////////////////////////////////////////////////
  35. //
  36. // Usage:
  37. // o    Derive your class from CSizingControlBar. Then create your child
  38. //      controls/windows on it.
  39. // o    Include your class header in Mainfrm.cpp and add a member 
  40. //      variable to CMainFrame. In CMainFrame::OnCreate(), create the
  41. //      control bar, enable it to dock, and so on... like a toolbar or
  42. //      any control bar.
  43. // o    More details at
  44. //      http://www.codeguru.com/docking/docking_window.shtml or search
  45. //      http://www.codeguru.com for my name if the article has moved.
  46. //
  47. /////////////////////////////////////////////////////////////////////////
  50. // SizingControlBar.cpp : implementation file
  51. //
  53. #include "stdafx.h"
  54. #include "afxpriv.h"    // for CDockContext
  55. #include "sizecbar.h"
  56. //#include "afximpl.h"
  58. #ifdef _DEBUG
  59. #define new DEBUG_NEW
  60. #undef THIS_FILE
  61. static char THIS_FILE[] = __FILE__;
  62. #endif
  64. /////////////////////////////////////////////////////////////////////////
  65. // CSizingControlBar
  67. CSizingControlBar::CSizingControlBar()
  68. {
  69.     m_sizeMin = CSize(32, 32);
  70.     m_sizeHorz = CSize(200, 200);
  71.     m_sizeVert = CSize(200, 200);
  72.     m_sizeFloat = CSize(200, 200);
  73.     m_bTracking = FALSE;
  74.     m_bInRecalcNC = FALSE;
  75.     m_cxEdge = 5;
  76. m_bDragShowContent = FALSE;
  77. }
  79. CSizingControlBar::~CSizingControlBar()
  80. {
  81. }
  83. BEGIN_MESSAGE_MAP(CSizingControlBar, CControlBar)
  84.     //{{AFX_MSG_MAP(CSizingControlBar)
  85.     ON_WM_PAINT()
  86.     ON_WM_NCPAINT()
  87.     ON_WM_WINDOWPOSCHANGED()
  88.     ON_WM_NCCALCSIZE()
  89.     ON_WM_LBUTTONUP()
  90.     ON_WM_MOUSEMOVE()
  91.     ON_WM_NCLBUTTONDOWN()
  92.     ON_WM_LBUTTONDOWN()
  93.     ON_WM_LBUTTONDBLCLK()
  94. ON_WM_RBUTTONDOWN()
  95.     ON_WM_CAPTURECHANGED()
  96.     ON_WM_NCHITTEST()
  97.     ON_WM_SETCURSOR()
  98. ON_WM_NCLBUTTONUP()
  99. ON_WM_NCMOUSEMOVE()
  100.     ON_WM_SIZE()
  101. //}}AFX_MSG_MAP
  102. ON_NOTIFY_EX(TTN_NEEDTEXT,0,OnTipNotify)
  103. END_MESSAGE_MAP()
  105. /////////////////////////////////////////////////////////////////////////
  106. // CSizingControlBar message handlers
  108. BOOL CSizingControlBar::Create(LPCTSTR lpszWindowName, CWnd* pParentWnd,
  109.                                CSize sizeDefault, BOOL bHasGripper,
  110.                                UINT nID, DWORD dwStyle)
  111. {
  112.     ASSERT_VALID(pParentWnd);   // must have a parent
  113.     ASSERT (!((dwStyle & CBRS_SIZE_FIXED)
  114.         && (dwStyle & CBRS_SIZE_DYNAMIC)));
  116.     // save the style
  117.     SetBarStyle(dwStyle & CBRS_ALL);
  119.     CString wndclass = ::AfxRegisterWndClass(CS_DBLCLKS,
  120.         ::LoadCursor(NULL, IDC_ARROW),
  121.         ::GetSysColorBrush(COLOR_BTNFACE), 0);
  123.     dwStyle &= ~CBRS_ALL;
  124.     dwStyle &= WS_VISIBLE | WS_CHILD;
  125.     if (!CWnd::Create(wndclass, lpszWindowName, dwStyle, CRect(0,0,0,0),
  126.         pParentWnd, nID))
  127.         return FALSE;
  129.     m_sizeHorz = sizeDefault;
  130.     m_sizeVert = sizeDefault;
  131.     m_sizeFloat = sizeDefault;
  133.     m_bHasGripper = bHasGripper;
  134.     m_cyGripper = m_bHasGripper ? 12 : 0;
  136. //允许ToolTips
  137. EnableToolTips(TRUE);
  139.     return TRUE;
  140. }
  142. BOOL CSizingControlBar::IsHorzDocked() const
  143. {
  144.     return (m_nDockBarID == AFX_IDW_DOCKBAR_TOP ||
  145.         m_nDockBarID == AFX_IDW_DOCKBAR_BOTTOM);
  146. }
  148. BOOL CSizingControlBar::IsVertDocked() const
  149. {
  150.     return (m_nDockBarID == AFX_IDW_DOCKBAR_LEFT ||
  151.         m_nDockBarID == AFX_IDW_DOCKBAR_RIGHT);
  152. }
  154. CSize CSizingControlBar::CalcFixedLayout(BOOL bStretch, BOOL bHorz)
  155. {
  156.     CRect rc;
  158.     m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_TOP)->GetWindowRect(rc);
  159.     int nHorzDockBarWidth = bStretch ? 32767 : rc.Width() + 4;
  160.     m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_LEFT)->GetWindowRect(rc);
  161.     int nVertDockBarHeight = bStretch ? 32767 : rc.Height() + 4;
  163.     if (bHorz)
  164.         return CSize(nHorzDockBarWidth, m_sizeHorz.cy);
  165.     else
  166.         return CSize(m_sizeVert.cx, nVertDockBarHeight);
  167. }
  169. CSize CSizingControlBar::CalcDynamicLayout(int nLength, DWORD dwMode)
  170. {
  171.     if (dwMode & (LM_HORZDOCK | LM_VERTDOCK))
  172.     {
  173.         if (nLength == -1)
  174.             GetDockingFrame()->DelayRecalcLayout();
  175.         return CControlBar::CalcDynamicLayout(nLength,dwMode);
  176.     }
  178.     if (dwMode & LM_MRUWIDTH)
  179.         return m_sizeFloat;
  181.     if (dwMode & LM_COMMIT)
  182.     {
  183.         m_sizeFloat.cx = nLength;
  184.         return m_sizeFloat;
  185.     }
  187.     if (dwMode & LM_LENGTHY)
  188.         return CSize(m_sizeFloat.cx,
  189.             m_sizeFloat.cy = max(m_sizeMin.cy, nLength));
  190.     else
  191.         return CSize(max(m_sizeMin.cx, nLength), m_sizeFloat.cy);
  192. }
  194. void CSizingControlBar::OnWindowPosChanged(WINDOWPOS FAR* lpwndpos) 
  195. {
  196.     CControlBar::OnWindowPosChanged(lpwndpos);
  198.     // Find on which side are we docked
  199.     m_nDockBarID = GetParent()->GetDlgCtrlID();
  201.     if (!m_bInRecalcNC)
  202.     {
  203.         m_bInRecalcNC = TRUE;
  205.         // Force recalc the non-client area
  206.         SetWindowPos(NULL, 0, 0, 0, 0,
  207.             SWP_NOMOVE | SWP_NOSIZE |
  208.             SWP_NOACTIVATE | SWP_NOZORDER |
  209.             SWP_FRAMECHANGED);
  211.         m_bInRecalcNC = FALSE;
  212.     }
  213. }
  215. // cache of last needed cursor
  216. AFX_STATIC_DATA HCURSOR _afx_hcurLast = NULL;
  217. AFX_STATIC_DATA HCURSOR _afx_hcurDestroy = NULL;
  218. AFX_STATIC_DATA UINT _afx_idcPrimaryLast = 0; // store the primary IDC
  220. BOOL CSizingControlBar::OnSetCursor(CWnd* pWnd, UINT nHitTest,
  221.                                     UINT message) 
  222. {
  223.   /*if((nHitTest == HTSYSMENU) && !IsFloating())
  224. {
  225. // MessageBox("aa");
  226. TOOLTIPTEXT m_psttt;
  227.         m_psttt.hdr.hwndFrom=m_hWnd;
  228.         m_psttt.hdr.idFrom=pWnd->GetDlgCtrlID();
  229.         m_psttt.hdr.code=TTN_NEEDTEXT;   
  230. m_psttt.uFlags= TTF_IDISHWND;
  231. SetStatusText(ID_DIALAGBAR_FLOAT);
  232.  //     SendMessage(WM_NOTIFY); 
  234. }
  235.    else if ((nHitTest == HTMINBUTTON) && !IsFloating())
  236. MessageBox("bb");
  237. */
  238. if ((nHitTest != HTSIZE) || m_bTracking)
  239.         return CControlBar::OnSetCursor(pWnd, nHitTest, message);
  241. UINT idcPrimary;        // app supplied cursor
  242. LPCTSTR idcSecondary;    // system supplied cursor (MAKEINTRESOURCE)
  244.     /*if (IsHorzDocked())
  245.         ::SetCursor(::LoadCursor(NULL, IDC_SIZENS));
  246.     else
  247.         ::SetCursor(::LoadCursor(NULL, IDC_SIZEWE));*/
  248. // ------- change by syx
  249. if(IsHorzDocked())
  250. {
  251. idcPrimary = AFX_IDC_VSPLITBAR;
  252. idcSecondary = IDC_SIZENS;
  253. }
  254. else
  255. {
  256. idcPrimary = AFX_IDC_HSPLITBAR;
  257. idcSecondary = IDC_SIZEWE;
  258. }
  259. HCURSOR hcurToDestroy = NULL;
  260. if(idcPrimary != _afx_idcPrimaryLast)
  261. {
  262. HINSTANCE hInst = AfxFindResourceHandle(
  263. MAKEINTRESOURCE(idcPrimary), RT_GROUP_CURSOR);
  265. // load in another cursor
  266. hcurToDestroy = _afx_hcurDestroy;
  268. // Note: If this LoadCursor call fails, it is likely that
  269. //  _AFX_NO_SPLITTER_RESOURCES is defined in your .RC file.
  270. // To correct the situation, remove the following line from your
  271. //  resource script:
  272. //      #define _AFX_NO_SPLITTER_RESOURCES
  273. // This should be done using the Resource.Set Includes... command.
  275. if((_afx_hcurDestroy = _afx_hcurLast =
  276. ::LoadCursor(hInst, MAKEINTRESOURCE(idcPrimary))) == NULL)
  277. {
  278. // will not look as good
  279. TRACE0("Warning: Could not find splitter cursor - using system provided alternative.n");
  281. ASSERT(_afx_hcurDestroy == NULL);    // will not get destroyed
  282. _afx_hcurLast = ::LoadCursor(NULL, idcSecondary);
  283. ASSERT(_afx_hcurLast != NULL);
  284. }
  285. _afx_idcPrimaryLast = idcPrimary;
  286. }
  287. ASSERT(_afx_hcurLast != NULL);
  288. ::SetCursor(_afx_hcurLast);
  289. ASSERT(_afx_hcurLast != hcurToDestroy);
  290. if (hcurToDestroy != NULL)
  291. ::DestroyCursor(hcurToDestroy); // destroy after being set
  292. // ------- change by syx
  294. return TRUE;
  295. }
  297. /////////////////////////////////////////////////////////////////////////
  298. // Mouse Handling
  299. //
  300. void CSizingControlBar::OnLButtonDown(UINT nFlags, CPoint point) 
  301. {
  302.     if (m_pDockBar != NULL)
  303.     {
  304.         // start the drag
  305.         ASSERT(m_pDockContext != NULL);
  306.         ClientToScreen(&point);
  307.         m_pDockContext->StartDrag(point);
  308.     }
  309.     else
  310.         CWnd::OnLButtonDown(nFlags, point);
  311. }
  313. void CSizingControlBar::OnLButtonDblClk(UINT nFlags, CPoint point) 
  314. {
  315.     if (m_pDockBar != NULL)
  316.     {
  317.         // toggle docking
  318.         ASSERT(m_pDockContext != NULL);
  319.         m_pDockContext->ToggleDocking();
  320.     }
  321.     else
  322.         CWnd::OnLButtonDblClk(nFlags, point);
  323. }
  325. void CSizingControlBar::OnNcLButtonDown(UINT nHitTest, CPoint point) 
  326. {
  327.     CWindowDC dc(this);
  328.     if (m_bTracking) return;
  330. if((nHitTest == HTSYSMENU) && !IsFloating())
  331. {
  332. dc.DrawEdge(m_rectClose,EDGE_SUNKEN,BF_RECT);
  333. }
  334.     else if ((nHitTest == HTMINBUTTON) && !IsFloating())
  335. dc.DrawEdge(m_rectUndock,EDGE_SUNKEN,BF_RECT);
  336.     else if ((nHitTest == HTSIZE) && !IsFloating())
  337.         StartTracking();
  338.     else    
  339. CControlBar::OnNcLButtonDown(nHitTest, point);
  341. }
  343. void CSizingControlBar::OnLButtonUp(UINT nFlags, CPoint point) 
  344. {
  345.     if (m_bTracking)
  346.         StopTracking(TRUE);
  348.     CControlBar::OnLButtonUp(nFlags, point);
  349. }
  351. void CSizingControlBar::OnRButtonDown(UINT nFlags, CPoint point) 
  352. {
  353.     if (m_bTracking)
  354.         StopTracking(FALSE);
  356. CControlBar::OnRButtonDown(nFlags, point);
  357. }
  359. void CSizingControlBar::OnMouseMove(UINT nFlags, CPoint point) 
  360. {
  361.     if (m_bTracking)
  362.     {
  363. ASSERT (!IsFloating());
  364. CPoint pt = point;
  365. ClientToScreen(&pt);
  367. OnTrackUpdateSize(pt);
  368.     }
  370.     CControlBar::OnMouseMove(nFlags, point);
  371. }
  373. void CSizingControlBar::OnCaptureChanged(CWnd *pWnd) 
  374. {
  375.     if (m_bTracking && pWnd != this)
  376.         StopTracking(FALSE); // cancel tracking
  378.     CControlBar::OnCaptureChanged(pWnd);
  379. }
  381. void CSizingControlBar::OnNcCalcSize(BOOL bCalcValidRects,
  382.                                      NCCALCSIZE_PARAMS FAR* lpncsp) 
  383. {
  384.     // Compute the rectangle of the mobile edge
  385.     GetWindowRect(m_rectBorder);
  386.     m_rectBorder.OffsetRect(-m_rectBorder.left, -m_rectBorder.top);
  387.     m_rectBorder.DeflateRect(1, 1);
  388.     
  389.     m_rectGripper = m_rectBorder;
  390.     m_rectGripper.DeflateRect(5, 5);
  391.     m_rectGripper.right -= m_cxEdge;
  392.     m_rectGripper.bottom -= m_cxEdge;
  393.     CRect rc = lpncsp->rgrc[0];
  395.     DWORD dwBorderStyle = m_dwStyle | CBRS_BORDER_ANY;
  397.     switch(m_nDockBarID)
  398.     {
  399.     case AFX_IDW_DOCKBAR_TOP:
  400.         dwBorderStyle &= ~CBRS_BORDER_BOTTOM;
  401.         rc.DeflateRect(m_cyGripper + 2, 2, 2, m_cxEdge + 2);
  402.         m_rectBorder.top = m_rectBorder.bottom - m_cxEdge;
  403.         break;
  404.     case AFX_IDW_DOCKBAR_BOTTOM:
  405.         dwBorderStyle &= ~CBRS_BORDER_TOP;
  406.         rc.DeflateRect(m_cyGripper + 2, m_cxEdge + 2, 2, 2);
  407.         m_rectBorder.bottom = m_rectBorder.top + m_cxEdge;
  408.         m_rectGripper.OffsetRect(0, m_cxEdge);
  409.         break;
  410.     case AFX_IDW_DOCKBAR_LEFT:
  411.         dwBorderStyle &= ~CBRS_BORDER_RIGHT;
  412.         rc.DeflateRect(2, m_cyGripper + 2, m_cxEdge + 2, 6);
  413.         m_rectBorder.left = m_rectBorder.right - m_cxEdge;
  414.         break;
  415.     case AFX_IDW_DOCKBAR_RIGHT:
  416.         dwBorderStyle &= ~CBRS_BORDER_LEFT;
  417.         rc.DeflateRect(m_cxEdge + 2, m_cyGripper + 2, 2, 6);
  418.         m_rectBorder.right = m_rectBorder.left + m_cxEdge;
  419.         m_rectGripper.OffsetRect(m_cxEdge, 0);
  420.         break;
  421.     default:
  422.         m_rectBorder.SetRectEmpty();
  423.         break;
  424.     }
  426.     lpncsp->rgrc[0] = rc;
  428.     SetBarStyle(dwBorderStyle);
  429. }
  431. void CSizingControlBar::OnNcPaint() 
  432. {
  433.     // get window DC that is clipped to the non-client area
  434.     CWindowDC dc(this);
  435.     CRect rectClient;
  436.     GetClientRect(rectClient);
  437.     CRect rectWindow;
  438.     GetWindowRect(rectWindow);
  439.     ScreenToClient(rectWindow);
  440.     rectClient.OffsetRect(-rectWindow.left, -rectWindow.top);
  441.     dc.ExcludeClipRect(rectClient);
  443.     // draw borders in non-client area
  444.     rectWindow.OffsetRect(-rectWindow.left, -rectWindow.top);
  445.     DrawBorders(&dc, rectWindow);
  447.     // erase parts not drawn
  448.     dc.IntersectClipRect(rectWindow);
  450.     // erase NC background the hard way
  451.     HBRUSH hbr = (HBRUSH)GetClassLong(m_hWnd, GCL_HBRBACKGROUND);
  452.     ::FillRect(dc.m_hDC, rectWindow, hbr);
  454.     // paint the mobile edge
  455.     dc.Draw3dRect(m_rectBorder, ::GetSysColor(COLOR_BTNHIGHLIGHT),
  456.         ::GetSysColor(COLOR_BTNSHADOW));
  458.     if (m_bHasGripper)
  459.     {
  460.         // paint the gripper
  461.  //       CRect gripper = m_rectGripper;
  462.      CRect gripper;
  463. GetWindowRect( gripper );
  464. ScreenToClient( gripper );
  465. gripper.OffsetRect( -gripper.left, -gripper.top );
  466.     
  467.         if (IsHorzDocked())
  468.         {
  469.             // gripper at left
  470.      /*       gripper.right = gripper.left + 3;
  471.             dc.Draw3dRect(gripper, ::GetSysColor(COLOR_BTNHIGHLIGHT),
  472.                 ::GetSysColor(COLOR_BTNSHADOW));
  473.             gripper.OffsetRect(3, 0);
  474.             dc.Draw3dRect(gripper, ::GetSysColor(COLOR_BTNHIGHLIGHT),
  475.                 ::GetSysColor(COLOR_BTNSHADOW));
  477. // gripper at left
  478. m_rectGripper.top = gripper.top + 40;
  479. m_rectGripper.bottom = gripper.bottom;
  480. m_rectGripper.left = gripper.left;
  481. m_rectGripper.right = gripper.left + 20;
  482. */
  483. // draw close box
  484. m_rectClose.left = gripper.left + 3;
  485. m_rectClose.right = m_rectClose.left + 12;
  486. m_rectClose.top = gripper.top + 10;
  487. m_rectClose.bottom = m_rectClose.top + 12;
  488. dc.DrawFrameControl(m_rectClose, DFC_CAPTION, DFCS_CAPTIONCLOSE);
  490. // draw docking toggle box
  491. m_rectUndock = m_rectClose;
  492. m_rectUndock.OffsetRect(0,13);
  493. dc.DrawFrameControl(m_rectUndock, DFC_CAPTION, DFCS_CAPTIONMAX);
  495. gripper.top += 38;
  496. gripper.bottom -= 10;
  497. gripper.left += 5;
  498. gripper.right = gripper.left+3;
  499.         dc.Draw3dRect( gripper, ::GetSysColor(COLOR_BTNHIGHLIGHT),
  500.                 ::GetSysColor(COLOR_BTNSHADOW) );
  502. gripper.OffsetRect(4, 0);
  503.         dc.Draw3dRect( gripper, ::GetSysColor(COLOR_BTNHIGHLIGHT),
  504.                 ::GetSysColor(COLOR_BTNSHADOW));        
  505. }
  506.         else if (IsVertDocked())
  507.         {
  508.             // gripper at top
  509.      /*      gripper.bottom = gripper.top + 3;
  510.             dc.Draw3dRect(gripper, ::GetSysColor(COLOR_BTNHIGHLIGHT),
  511.                 ::GetSysColor(COLOR_BTNSHADOW));
  512.             gripper.OffsetRect(0, 3);
  513.             dc.Draw3dRect(gripper, ::GetSysColor(COLOR_BTNHIGHLIGHT),
  514.                 ::GetSysColor(COLOR_BTNSHADOW));
  515.         */
  516. // gripper at top
  517. /* m_rectGripper.top = gripper.top;
  518. m_rectGripper.bottom = gripper.top + 20;
  519. m_rectGripper.left = gripper.left;
  520. m_rectGripper.right = gripper.right - 24;
  521. */
  522. // draw close box
  523. m_rectClose.right = gripper.right - 10;
  524. m_rectClose.left = m_rectClose.right - 11;
  525. m_rectClose.top = gripper.top+3;//+ 7
  526. m_rectClose.bottom = m_rectClose.top + 11;
  527. dc.DrawFrameControl(m_rectClose, DFC_CAPTION, DFCS_CAPTIONCLOSE);
  530. // draw docking toggle box
  531. m_rectUndock = m_rectClose;
  532. m_rectUndock.OffsetRect(-13,0);
  533. dc.DrawFrameControl(m_rectUndock, DFC_CAPTION, DFCS_CAPTIONMAX);
  535. gripper.right -= 38;
  536. gripper.left += 10;
  537. gripper.top += 5;
  538. gripper.bottom = gripper.top + 3;
  539. dc.Draw3dRect( gripper, ::GetSysColor(COLOR_BTNHIGHLIGHT),
  540.                 ::GetSysColor(COLOR_BTNSHADOW) );
  542. gripper.OffsetRect(0, 4);
  543.         dc.Draw3dRect( gripper, ::GetSysColor(COLOR_BTNHIGHLIGHT),
  544.                 ::GetSysColor(COLOR_BTNSHADOW) );
  546. }
  547.     }
  549.     ReleaseDC(&dc);
  550. }
  552. void CSizingControlBar::OnPaint() 
  553. {
  554.     // overridden to skip border painting based on clientrect
  555.     CPaintDC dc(this);
  556. }
  558. UINT CSizingControlBar::OnNcHitTest(CPoint point) 
  559. {
  560.     if (IsFloating())
  561.         return CControlBar::OnNcHitTest(point);
  563.     CRect rc;
  564.     GetWindowRect(rc);
  565.     point.Offset(-rc.left, -rc.top);
  566. if(m_rectClose.PtInRect(point))
  567. return HTSYSMENU;
  568. else if (m_rectUndock.PtInRect(point))
  569. return HTMINBUTTON;
  570. /* else if (m_rectGripper.PtInRect(point))
  571. return HTCAPTION;
  572.     else if (m_rectBorder.PtInRect(point))
  573.         return HTSIZE;
  574.     else
  575.         return CControlBar::OnNcHitTest(point);
  576. */
  577.     if (m_rectBorder.PtInRect(point))
  578.         return HTSIZE;
  579.     else
  580.         return HTCLIENT;
  581. }
  583. /////////////////////////////////////////////////////////////////////////
  584. // CSizingControlBar implementation helpers
  586. void CSizingControlBar::StartTracking()
  587. {
  588.     SetCapture();
  590.     // make sure no updates are pending
  591.     RedrawWindow(NULL, NULL, RDW_ALLCHILDREN | RDW_UPDATENOW);
  593. m_bDragShowContent = QueryDragFullWindows();
  595. if (!m_bDragShowContent)
  596.     m_pDockSite->LockWindowUpdate();
  598. m_sizeOld = IsHorzDocked() ? m_sizeHorz : m_sizeVert;
  600. CRect rect;
  601. GetWindowRect(&rect);
  602.     m_ptOld = m_rectBorder.CenterPoint() + rect.TopLeft();
  604. m_sizeMax = CalcMaxSize();
  605.     m_bTracking = TRUE;
  606.     
  607. if (!m_bDragShowContent)
  608.     OnTrackInvertTracker();
  609. }
  611. void CSizingControlBar::StopTracking(BOOL bAccept)
  612. {
  613. if (!m_bDragShowContent)
  614. {
  615. OnTrackInvertTracker();
  616.     m_pDockSite->UnlockWindowUpdate();
  617. }
  619.     m_bTracking = FALSE;
  620.     ReleaseCapture();
  621.     
  622.     if (!bAccept) // resize canceled?
  623. {
  624. // restore old size
  625. if (IsHorzDocked())
  626.         m_sizeHorz = m_sizeOld;
  627. else
  628. m_sizeVert = m_sizeOld;
  629. }
  631.     m_pDockSite->DelayRecalcLayout();
  632. }
  634. void CSizingControlBar::OnTrackUpdateSize(CPoint& point)
  635. {
  636. BOOL bHorz = IsHorzDocked();
  638.     CSize sizeNew = m_sizeOld;
  640.     if ((m_nDockBarID == AFX_IDW_DOCKBAR_TOP) ||
  641. (m_nDockBarID == AFX_IDW_DOCKBAR_LEFT))
  642.         sizeNew += point - m_ptOld;
  643. else
  644.         sizeNew -= point - m_ptOld;
  646. // check limits
  647.    sizeNew.cx = max(m_sizeMin.cx, sizeNew.cx);
  648.    sizeNew.cy = max(m_sizeMin.cy, sizeNew.cy);
  649.    sizeNew.cx = min(m_sizeMax.cx, sizeNew.cx);
  650.    sizeNew.cy = min(m_sizeMax.cy, sizeNew.cy);
  652.     if ((sizeNew.cy == m_sizeHorz.cy) && bHorz ||
  653. (sizeNew.cx == m_sizeVert.cx) && !bHorz)
  654. return; // no size change
  656. if (!m_bDragShowContent)
  657. OnTrackInvertTracker();
  659.     if (bHorz)
  660. m_sizeHorz = sizeNew;
  661. else
  662. m_sizeVert = sizeNew;
  664. if (!m_bDragShowContent)
  665. OnTrackInvertTracker();
  666. else
  667.     m_pDockSite->DelayRecalcLayout();
  668. }
  670. CSize CSizingControlBar::CalcMaxSize()
  671. {
  672. // the control bar cannot grow with more than the size of 
  673. // remaining client area of the frame
  674. CRect rect;
  675. m_pDockSite->GetClientRect(&rect);
  676. CSize size = rect.Size();
  677. CWnd* pBar;
  678. if (IsHorzDocked())
  679. {
  680. if (pBar = m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_TOP))
  681. {
  682. pBar->GetWindowRect(&rect);
  683. size -= rect.Size();
  684. }
  685. if (pBar = m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_BOTTOM))
  686. {
  687. pBar->GetWindowRect(&rect);
  688. size -= rect.Size();
  689. }
  690. if (pBar = m_pDockSite->GetControlBar(AFX_IDW_STATUS_BAR))
  691. {
  692. pBar->GetWindowRect(&rect);
  693. size -= rect.Size();
  694. }
  695. }
  696. else
  697. {
  698. if (pBar = m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_LEFT))
  699. {
  700. pBar->GetWindowRect(&rect);
  701. size -= rect.Size();
  702. }
  703. if (pBar = m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_RIGHT))
  704. {
  705. pBar->GetWindowRect(&rect);
  706. size -= rect.Size();
  707. }
  708. }
  710. size -= CSize(4, 4);
  711.     size += IsHorzDocked() ? m_sizeHorz : m_sizeVert;
  713. return size;
  714. }
  716. void CSizingControlBar::OnTrackInvertTracker()
  717. {
  718.     ASSERT_VALID(this);
  719.     ASSERT(m_bTracking);
  721. CRect rect = m_rectBorder;
  722.     CRect rectBar, rectFrame;
  723.     GetWindowRect(rectBar);
  724.     rect.OffsetRect(rectBar.TopLeft());
  725.     m_pDockSite->GetWindowRect(rectFrame);
  726.     rect.OffsetRect(-rectFrame.left, -rectFrame.top);
  728. switch (m_nDockBarID)
  729. {
  730. case AFX_IDW_DOCKBAR_TOP:
  731. rect.OffsetRect(0, m_sizeHorz.cy - m_sizeOld.cy); break;
  732. case AFX_IDW_DOCKBAR_BOTTOM:
  733. rect.OffsetRect(0, m_sizeOld.cy - m_sizeHorz.cy); break;
  734. case AFX_IDW_DOCKBAR_LEFT:
  735. rect.OffsetRect(m_sizeVert.cx - m_sizeOld.cx, 0); break;
  736. case AFX_IDW_DOCKBAR_RIGHT:
  737. rect.OffsetRect(m_sizeOld.cx - m_sizeVert.cx, 0); break;
  738. }
  739. if (IsVertDocked())
  740.     rect.bottom -= 4;
  741.     rect.DeflateRect(1, 1);
  743.     CDC *pDC = m_pDockSite->GetDCEx(NULL,
  744.         DCX_WINDOW|DCX_CACHE|DCX_LOCKWINDOWUPDATE);
  746.     CBrush* pBrush = CDC::GetHalftoneBrush();
  747.     HBRUSH hOldBrush = NULL;
  748.     if (pBrush != NULL)
  749.         hOldBrush = (HBRUSH)::SelectObject(pDC->m_hDC, pBrush->m_hObject);
  751.     pDC->PatBlt(rect.left, rect.top,
  752. rect.Width(), rect.Height(), PATINVERT);
  754.     if (hOldBrush != NULL)
  755.         ::SelectObject(pDC->m_hDC, hOldBrush);
  757.     m_pDockSite->ReleaseDC(pDC);
  758. }
  760. BOOL CSizingControlBar::QueryDragFullWindows() const
  761. {
  762. TCHAR sDragfullWindows[2];
  763. DWORD cbDragfullWindows = sizeof(DWORD);
  764. DWORD dwType;
  765. HKEY hKey;
  766. BOOL bRet = FALSE;
  768. RegOpenKeyEx(HKEY_CURRENT_USER, _T("Control Panel\desktop"),
  769. 0, KEY_QUERY_VALUE, &hKey);
  771. if (!FAILED(RegQueryValueEx(hKey, _T("DragfullWindows"),
  772. NULL, &dwType, (LPBYTE)&sDragfullWindows, &cbDragfullWindows)))
  773. if (!_tcscmp(sDragfullWindows, _T("1")))
  774. bRet = TRUE;
  776. RegCloseKey(hKey);
  778. return bRet;
  779. }
  781. void CSizingControlBar::OnNcLButtonUp(UINT nHitTest, CPoint point) 
  782. {
  783. // TODO: Add your message handler code here and/or call default
  784. /*    if (m_bTracking) return;
  786.     if ((nHitTest == HTSIZE) && !IsFloating())
  787.         StartTracking();
  788.     else    
  789.         CControlBar::OnNcLButtonDown(nHitTest, point);
  790. */
  791.     if (m_bTracking) return;
  793. if((nHitTest == HTSYSMENU) && !IsFloating())
  794. {
  795. // CFrameWnd::ShowControlBar((CControlBar*),((GetStyle() & WS_VISIBLE)==0),FALSE);
  796. ShowWindow(SW_HIDE);
  797. m_pDockContext->ToggleDocking();
  798. }
  799.     else if ((nHitTest == HTMINBUTTON) && !IsFloating())
  800.         m_pDockContext->ToggleDocking();
  801. else if ((nHitTest == HTCAPTION) && !IsFloating() && (m_pDockBar != NULL))
  802.     {
  803.         // start the drag
  804.         ASSERT(m_pDockContext != NULL);
  805.         m_pDockContext->StartDrag(point);
  806.     }
  807.     else if ((nHitTest == HTSIZE) && !IsFloating())
  808.         StartTracking();
  809.     else    
  810.      //   CControlBar::OnNcLButtonDown(nHitTest, point);
  811. CControlBar::OnNcLButtonUp(nHitTest, point);
  812. }
  814. void CSizingControlBar::OnNcMouseMove(UINT nHitTest, CPoint point) 
  815. {
  816. // TODO: Add your message handler code here and/or call default
  817.     CWindowDC dc(this);
  818. if(!(m_rectClose.PtInRect(point)) && !IsFloating())
  819. dc.DrawEdge(m_rectClose,EDGE_RAISED,BF_RECT);
  820.     if(!(m_rectUndock.PtInRect(point)) && !IsFloating())
  821. dc.DrawEdge(m_rectUndock,EDGE_RAISED,BF_RECT);
  823. CControlBar::OnNcMouseMove(nHitTest, point);
  824. }
  826. void CSizingControlBar::ShowContrl(BOOL m_show)
  827. {
  828. if(m_show)
  829. ShowWindow(SW_SHOWNORMAL);
  830. else
  831. ShowWindow(SW_HIDE);
  832. }
  833. void CSizingControlBar::SetStatusText(UINT nID)
  834. {  
  835. if(nID==0)//HTSYSMENU
  836.         nID=AFX_IDS_IDLEMESSAGE;
  837.     CWnd *pWnd=AfxGetMainWnd()->GetDescendantWindow(AFX_IDW_STATUS_BAR);
  838.     if(pWnd)  
  839. {     
  840. AfxGetMainWnd()->SendMessage(WM_SETMESSAGESTRING ,nID);
  841.     pWnd->SendMessage(WM_IDLEUPDATECMDUI);
  842.         pWnd->UpdateWindow();
  843.     }
  844. }
  845. BOOL CSizingControlBar::OnTipNotify( UINT id, NMHDR * pNMHDR, LRESULT * pResult )
  846. {
  848. TOOLTIPTEXT *pTTT = (TOOLTIPTEXT *)pNMHDR; 
  849. UINT nID =pNMHDR->idFrom;
  850.     if (pTTT->uFlags & TTF_IDISHWND)
  851.     {
  852.         nID = ::GetDlgCtrlID((HWND)nID);  
  853. if(nID)
  854.         {
  855. CString szFullText;
  856. CString StrTipText;
  857. szFullText.LoadString(nID);
  858. AfxExtractSubString(StrTipText,szFullText,1,'n');   
  859. if(!StrTipText.IsEmpty())
  860.  strcpy(pTTT->lpszText,StrTipText);
  861. pTTT->hinst = AfxGetResourceHandle(); 
  862. return(TRUE);
  863.         }  
  864. }   
  865. return FALSE;
  866. }