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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > TreeView控件 > 查看源码
SIZECBAR.CPP
资源名称：TreeMenuDemo.zip　[点击查看]
上传用户：rxhxxy
上传日期：2007-01-02
资源大小：72k
文件大小：12k
源码类别：

TreeView控件

开发平台：

Visual C++

SIZECBAR.CPP：源码内容
  1. // SizingControlBar.cpp : implementation file
  2. //
  4. #include "stdafx.h"
  5. #include "afxpriv.h"    // for CDockContext
  6. #include "sizecbar.h"
  8. #ifdef _DEBUG
  9. #define new DEBUG_NEW
  10. #undef THIS_FILE
  11. static char THIS_FILE[] = __FILE__;
  12. #endif
  14. /////////////////////////////////////////////////////////////////////////////
  15. // CSizingControlBar
  17. #define SCBF_MAXHALFCLIENTX 
  18. #define SCBF_MAXHALFCLIENTY
  20. CSizingControlBar::CSizingControlBar()
  21. {
  22.     m_sizeMin = CSize(10, 10);
  23.     m_sizeHorz = CSize(200, 200);
  24.     m_sizeVert = CSize(200, 200);
  25.     m_sizeFloat = CSize(200, 200);
  26.     m_bTracking = FALSE;
  27.     m_bInRecalcNC = FALSE;
  28.     m_cxEdge = 6;
  29. }
  31. CSizingControlBar::~CSizingControlBar()
  32. {
  33. }
  35. BEGIN_MESSAGE_MAP(CSizingControlBar, CControlBar)
  36.     //{{AFX_MSG_MAP(CSizingControlBar)
  37.     ON_WM_LBUTTONUP()
  38.     ON_WM_MOUSEMOVE()
  39.     ON_WM_SETCURSOR()
  40. ON_WM_WINDOWPOSCHANGING()
  41.     ON_WM_WINDOWPOSCHANGED()
  42.     ON_WM_NCPAINT()
  43.     ON_WM_NCLBUTTONDOWN()
  44.     ON_WM_NCHITTEST()
  45.     ON_WM_NCCALCSIZE()
  46.     ON_WM_LBUTTONDOWN()
  47.     ON_WM_CAPTURECHANGED()
  48.     ON_WM_SIZE()
  49.     ON_WM_LBUTTONDBLCLK()
  50.     //}}AFX_MSG_MAP
  51. END_MESSAGE_MAP()
  53. /////////////////////////////////////////////////////////////////////////////
  54. // CSizingControlBar message handlers
  56. void CSizingControlBar::OnUpdateCmdUI(class CFrameWnd *pTarget, int bDisableIfNoHndler)
  57. {
  58.     UpdateDialogControls(pTarget, bDisableIfNoHndler);
  59. }
  61. BOOL CSizingControlBar::Create(CWnd* pParentWnd, CSize sizeDefault, UINT nID, DWORD dwStyle) 
  62. {
  63.     ASSERT_VALID(pParentWnd);   // must have a parent
  64.     ASSERT (!((dwStyle & CBRS_SIZE_FIXED) && (dwStyle & CBRS_SIZE_DYNAMIC)));
  66.     // save the style
  67.     m_dwStyle = dwStyle;
  69.     dwStyle &= ~CBRS_ALL;
  70.     dwStyle |= CCS_NOMOVEY|CCS_NODIVIDER|CCS_NORESIZE;
  72.     m_sizeHorz = sizeDefault;
  73.     m_sizeVert = sizeDefault;
  74.     m_sizeFloat = sizeDefault;
  76. // without CS_BYTEALIGNWINDOW treectrl doesn't expand, 
  77.     CString wndclass = AfxRegisterWndClass(CS_DBLCLKS|CS_BYTEALIGNWINDOW, LoadCursor(NULL, IDC_ARROW),
  78.         CreateSolidBrush(GetSysColor(COLOR_BTNFACE)), 0);
  80.     if (!CWnd::Create(wndclass, NULL, dwStyle, CRect(0,0,0,0),
  81.         pParentWnd, nID))
  82.         return FALSE;
  84.     return TRUE;
  85. }
  87. CSize CSizingControlBar::CalcFixedLayout(BOOL bStretch, BOOL bHorz)
  88. {
  89.     CRect rc;
  91.     m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_TOP)->GetWindowRect(rc);
  92.     int nHorzDockBarWidth = bStretch ? 32767 : rc.Width() + 4;
  93.     m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_LEFT)->GetWindowRect(rc);
  94.     int nVertDockBarHeight = bStretch ? 32767 : rc.Height() + 4;
  96.     if (bHorz)
  97.         return CSize(nHorzDockBarWidth, m_sizeHorz.cy);
  98.     else
  99.         return CSize(m_sizeVert.cx, nVertDockBarHeight);
  100. }
  102. CSize CSizingControlBar::CalcDynamicLayout(int nLength, DWORD dwMode)
  103. {
  104.     if (dwMode & (LM_HORZDOCK | LM_VERTDOCK))
  105.         return CControlBar::CalcDynamicLayout(nLength,dwMode);
  107.     if (dwMode & LM_MRUWIDTH)
  108.         return m_sizeFloat;
  110.     if (dwMode & LM_COMMIT)
  111.     {
  112.         m_sizeFloat.cx = nLength;
  113.         return m_sizeFloat;
  114.     }
  116.     if (dwMode & LM_LENGTHY)
  117.         return CSize(m_sizeFloat.cx,
  118.             m_sizeFloat.cy = max(m_sizeMin.cy, nLength));
  119.     else
  120.         return CSize(max(m_sizeMin.cx, nLength), m_sizeFloat.cy);
  121. }
  123. void CSizingControlBar::OnWindowPosChanging(LPWINDOWPOS lpwp)
  124. {
  125. CControlBar::OnWindowPosChanging(lpwp);
  127. if (!(lpwp->flags & SWP_NOMOVE)) { // if moved:
  128. CRect rc; // Fill rectangle with..
  129. GetWindowRect(&rc); // ..my rectangle.
  130. ScreenToClient(&rc); // .. and convert to parent coords
  132. InvalidateRect(&rc); // paint old rectangle because
  133. // OnWindowPosChanged() does the rest
  134. }
  135. }
  137. void CSizingControlBar::OnWindowPosChanged(LPWINDOWPOS lpwp) 
  138. {
  139.     CControlBar::OnWindowPosChanged(lpwp);
  141.     if (m_bInRecalcNC) return;
  143.     // Find on which side are we docked
  144.     UINT nDockBarID = GetParent()->GetDlgCtrlID();
  146.     // Return if dropped at same location
  147.     if (nDockBarID == m_nDockBarID // no docking side change
  148.         && (lpwp->flags & SWP_NOSIZE) // no size change
  149.         && ((m_dwStyle & CBRS_BORDER_ANY) != CBRS_BORDER_ANY))
  150.         return; 
  152.     m_nDockBarID = nDockBarID;
  154. // Force recalc the non-client area
  155.     m_bInRecalcNC = TRUE;
  156.     SetWindowPos(NULL, 0, 0, 0, 0,
  157.         SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER |
  158.         SWP_NOACTIVATE | SWP_FRAMECHANGED);
  159.     m_bInRecalcNC = FALSE;
  161. }
  163. BOOL CSizingControlBar::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message) 
  164. {
  165.     if ((nHitTest != HTSIZE) || m_bTracking)
  166.         return CControlBar::OnSetCursor(pWnd, nHitTest, message);
  168.     if (IsHorz())
  169.         SetCursor(LoadCursor(NULL, IDC_SIZENS));
  170.     else
  171.         SetCursor(LoadCursor(NULL, IDC_SIZEWE));
  172.     return TRUE;
  173. }
  175. /////////////////////////////////////////////////////////////////////////
  176. // Mouse Handling
  177. //
  178. void CSizingControlBar::OnLButtonUp(UINT nFlags, CPoint point) 
  179. {
  180.     if (!m_bTracking)
  181.         CControlBar::OnLButtonUp(nFlags, point);
  182.     else
  183.     {
  184.         ClientToWnd(point);
  185.         StopTracking(TRUE);
  186.     }
  187. }
  189. void CSizingControlBar::OnMouseMove(UINT nFlags, CPoint point) 
  190. {
  191.     if (IsFloating() || !m_bTracking)
  192.     {
  193.         CControlBar::OnMouseMove(nFlags, point);
  194.         return;
  195.     }
  197.     CPoint cpt = m_rectTracker.CenterPoint();
  199.     ClientToWnd(point);
  201.     if (IsHorz())
  202.     {
  203.         if (cpt.y != point.y)
  204.         {
  205.             OnInvertTracker(m_rectTracker);
  206.             m_rectTracker.OffsetRect(0, point.y - cpt.y);
  207.             OnInvertTracker(m_rectTracker);
  208.     }
  209.     }
  210.     else 
  211.     {
  212.         if (cpt.x != point.x)
  213.         {
  214.             OnInvertTracker(m_rectTracker);
  215.             m_rectTracker.OffsetRect(point.x - cpt.x, 0);
  216.             OnInvertTracker(m_rectTracker);
  217.         }
  218.     }
  219. }
  221. void CSizingControlBar::OnNcCalcSize(BOOL bCalcValidRects, NCCALCSIZE_PARAMS FAR* lpncsp) 
  222. {
  223.     // Compute the rectangle of the mobile edge
  224.     GetWindowRect(m_rectBorder);
  225.     m_rectBorder = CRect(0, 0, m_rectBorder.Width(), m_rectBorder.Height());
  226.     
  227.     DWORD dwBorderStyle = m_dwStyle | CBRS_BORDER_ANY;
  229.     switch(m_nDockBarID)
  230.     {
  231.     case AFX_IDW_DOCKBAR_TOP:
  232.         dwBorderStyle &= ~CBRS_BORDER_BOTTOM;
  233.         lpncsp->rgrc[0].bottom += -m_cxEdge;
  234.         m_rectBorder.top = m_rectBorder.bottom - m_cxEdge;
  235.         break;
  236.     case AFX_IDW_DOCKBAR_BOTTOM:
  237.         dwBorderStyle &= ~CBRS_BORDER_TOP;
  238.         lpncsp->rgrc[0].top += m_cxEdge;
  239.         m_rectBorder.bottom = m_rectBorder.top + m_cxEdge;
  240.         break;
  241.     case AFX_IDW_DOCKBAR_LEFT:
  242.         dwBorderStyle &= ~CBRS_BORDER_RIGHT;
  243.         lpncsp->rgrc[0].right += -m_cxEdge;
  244.         m_rectBorder.left = m_rectBorder.right - m_cxEdge;
  245.         break;
  246.     case AFX_IDW_DOCKBAR_RIGHT:
  247.         dwBorderStyle &= ~CBRS_BORDER_LEFT;
  248.         lpncsp->rgrc[0].left += m_cxEdge;
  249.         m_rectBorder.right = m_rectBorder.left + m_cxEdge;
  250.         break;
  251.     default:
  252.         m_rectBorder.SetRectEmpty();
  253.         break;
  254.     }
  256.     SetBarStyle(dwBorderStyle);
  257. }
  259. void CSizingControlBar::OnNcPaint() 
  260. {
  261.     EraseNonClient();
  263.     CDC *pDC = GetWindowDC();
  264.     pDC->Draw3dRect(m_rectBorder, GetSysColor(COLOR_BTNHIGHLIGHT),
  265.                     GetSysColor(COLOR_BTNSHADOW));
  266.     ReleaseDC(pDC);
  267. }
  269. void CSizingControlBar::OnNcLButtonDown(UINT nHitTest, CPoint point) 
  270. {
  271.     if (m_bTracking) return;
  273.     if ((nHitTest == HTSIZE) && !IsFloating())
  274.         StartTracking();
  275.     else    
  276.         CControlBar::OnNcLButtonDown(nHitTest, point);
  277. }
  279. UINT CSizingControlBar::OnNcHitTest(CPoint point) 
  280. {
  281.     if (IsFloating())
  282.         return CControlBar::OnNcHitTest(point);
  284.     CRect rc;
  285.     GetWindowRect(rc);
  286.     point.Offset(-rc.left, -rc.top);
  287.     if (m_rectBorder.PtInRect(point))
  288.         return HTSIZE;
  289.     else
  290.         return CControlBar::OnNcHitTest(point);
  291. }
  293. void CSizingControlBar::OnLButtonDown(UINT nFlags, CPoint point) 
  294. {
  295.     // only start dragging if clicked in "void" space
  296.     if (m_pDockBar != NULL )
  297.     {
  298.         // start the drag
  299.         ASSERT(m_pDockContext != NULL);
  300.         ClientToScreen(&point);
  301.         m_pDockContext->StartDrag(point);
  302.     }
  303.     else
  304.     {
  305.         CWnd::OnLButtonDown(nFlags, point);
  306.     }
  307. }
  309. void CSizingControlBar::OnLButtonDblClk(UINT nFlags, CPoint point) 
  310. {
  311.     // only toggle docking if clicked in "void" space
  312.     if (m_pDockBar != NULL)
  313.     {
  314.         // toggle docking
  315.         ASSERT(m_pDockContext != NULL);
  316.         m_pDockContext->ToggleDocking();
  317.     }
  318.     else
  319.     {
  320.         CWnd::OnLButtonDblClk(nFlags, point);
  321.     }
  323. }
  325. void CSizingControlBar::StartTracking()
  326. {
  327.     SetCapture();
  329.     // make sure no updates are pending
  330.     m_pDockSite->LockWindowUpdate();
  332.     m_ptOld = m_rectBorder.CenterPoint();
  333.     m_bTracking = TRUE;
  334.     
  335.     m_rectTracker = m_rectBorder;
  336.     if (!IsHorz()) m_rectTracker.bottom -= 4;
  338.     OnInvertTracker(m_rectTracker);
  339. }
  341. void CSizingControlBar::OnCaptureChanged(CWnd *pWnd) 
  342. {
  343.     if (m_bTracking && pWnd != this)
  344.         StopTracking(FALSE); // cancel tracking
  346.     CControlBar::OnCaptureChanged(pWnd);
  347. }
  349. // <raip
  350. BOOL CSizingControlBar::ShowPane(BOOL bShow) 
  351. {
  352. BOOL bRet;
  353. if (m_sizeVert.cx > 0)
  354. m_sizeStoreVert = m_sizeVert;
  355. if (m_sizeHorz.cy > 0)
  356. m_sizeStoreHorz = m_sizeHorz;
  358. if (!bShow)
  359. {
  360. if (IsHorz())
  361. m_sizeHorz.cy = 0;
  362. else 
  363. m_sizeVert.cx = 0;
  365. bRet = FALSE;
  366. } 
  367. else 
  368. {
  369. m_sizeHorz = m_sizeStoreHorz;
  370. m_sizeVert = m_sizeStoreVert;
  372. bRet = TRUE;
  373. }
  375.     m_pDockSite->DelayRecalcLayout();
  377. return bRet;
  378. }
  379. // raip>
  381. void CSizingControlBar::StopTracking(BOOL bAccept)
  382. {
  383.     OnInvertTracker(m_rectTracker);
  384.     m_pDockSite->UnlockWindowUpdate();
  385.     m_bTracking = FALSE;
  386.     ReleaseCapture();
  387.     
  388.     if (!bAccept) return;
  390.     int maxsize, minsize, newsize;
  391.     CRect rcc;
  392.     m_pDockSite->GetClientRect(rcc);
  394.     newsize = IsHorz() ? m_sizeHorz.cy : m_sizeVert.cx;
  395.     maxsize = newsize + (IsHorz() ? rcc.Height() : rcc.Width());
  396.     minsize = IsHorz() ? m_sizeMin.cy : m_sizeMin.cx;
  398.     CPoint point = m_rectTracker.CenterPoint();
  399.     switch (m_nDockBarID)
  400.     {
  401.     case AFX_IDW_DOCKBAR_TOP:
  402.         newsize += point.y - m_ptOld.y; break;
  403.     case AFX_IDW_DOCKBAR_BOTTOM:
  404.         newsize += -point.y + m_ptOld.y; break;
  405.     case AFX_IDW_DOCKBAR_LEFT:
  406.         newsize += point.x - m_ptOld.x; break;
  407.     case AFX_IDW_DOCKBAR_RIGHT:
  408.         newsize += -point.x + m_ptOld.x; break;
  409.     }
  411.     newsize = max(minsize, min(maxsize, newsize));
  413.     if (IsHorz()) {
  415. #ifdef SCBF_MAXHALFCLIENTY
  417. if (newsize >= rcc.Height()/2)
  418. newsize = rcc.Height()/2;
  419. #endif
  421. m_sizeHorz.cy = newsize;
  422. }
  423.     else {
  425. #ifdef SCBF_MAXHALFCLIENTX
  427. if (newsize >= rcc.Width()/2)
  428. newsize = rcc.Width()/2;
  429. #endif
  431. m_sizeVert.cx = newsize;
  432. }
  434.     m_pDockSite->DelayRecalcLayout();
  435. }
  437. void CSizingControlBar::OnInvertTracker(const CRect& rect)
  438. {
  439.     ASSERT_VALID(this);
  440.     ASSERT(!rect.IsRectEmpty());
  441.     ASSERT(m_bTracking);
  443.     CRect rct = rect, rcc, rcf;
  444.     GetWindowRect(rcc);
  445.     m_pDockSite->GetWindowRect(rcf);
  447.     rct.OffsetRect(rcc.left - rcf.left, rcc.top - rcf.top);
  448.     rct.DeflateRect(1, 1);
  450.     CDC *pDC = m_pDockSite->GetDCEx(NULL,
  451.         DCX_WINDOW|DCX_CACHE|DCX_LOCKWINDOWUPDATE);
  453.     CBrush* pBrush = CDC::GetHalftoneBrush();
  454.     HBRUSH hOldBrush = NULL;
  455.     if (pBrush != NULL)
  456.         hOldBrush = (HBRUSH)SelectObject(pDC->m_hDC, pBrush->m_hObject);
  458.     pDC->PatBlt(rct.left, rct.top, rct.Width(), rct.Height(), PATINVERT);
  460.     if (hOldBrush != NULL)
  461.         SelectObject(pDC->m_hDC, hOldBrush);
  463.     m_pDockSite->ReleaseDC(pDC);
  464. }
  466. BOOL CSizingControlBar::IsHorz() const
  467. {
  468.     return (m_nDockBarID == AFX_IDW_DOCKBAR_TOP ||
  469.         m_nDockBarID == AFX_IDW_DOCKBAR_BOTTOM);
  470. }
  472. CPoint& CSizingControlBar::ClientToWnd(CPoint& point)
  473. {
  474.     if (m_nDockBarID == AFX_IDW_DOCKBAR_BOTTOM)
  475.         point.y += m_cxEdge;
  476.     else if (m_nDockBarID == AFX_IDW_DOCKBAR_RIGHT)
  477.         point.x += m_cxEdge;
  479.     return point;
  480. }