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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > SNMP编程 > 查看源码
OAMCONTROLBAR.CPP
资源名称：SNMP_source.rar　[点击查看]
上传用户：lvjun8202
上传日期：2013-04-30
资源大小：797k
文件大小：19k
源码类别：

SNMP编程

开发平台：

C/C++

OAMCONTROLBAR.CPP：源码内容
  1. // OAMControlBar.cpp : implementation file
  2. //
  4. #include "stdafx.h"
  5. #include "OAMControlBar.h"
  6. #include "OAMDockContext.h"
  7. #include "OAMSizeDockBar.h"
  8. #include "resource.h"
  10. #ifdef _DEBUG
  11. #define new DEBUG_NEW
  12. #undef THIS_FILE
  13. static char THIS_FILE[] = __FILE__;
  14. #endif
  16. #define GRIP_LEFTSPACING 3
  17. #define GRIP_STARTGRIP 8
  18. #define GRIP_SIZE 3
  19. #define GRIP_BUTTONSPACING 3
  20. #define GRIP_INTRASPACING 1
  22. #define _HIDECROSS 0
  23. #define _MAXORZDISABLE 1
  24. #define _MAXORZENABLE 2
  25. #define _MAXVERTDISABLE 3
  26. #define _MAXVERTENABLE 4
  27. #define _NORMORZDISABLE 5
  28. #define _NORMORZENABLE 6
  29. #define _NORMVERTDISABLE 7
  30. #define _NORMVERTENABLE 8
  32. HBITMAP hBkBitmap = NULL;
  33. COLORREF _clrText = RGB(0,0,0);
  34. CBrush  m_brBk;
  35. /////////////////////////////////////////////////////////////////////////////
  36. // COAMControlBar
  38. COAMControlBar::COAMControlBar()
  39. {
  40. m_iTrackBorderSize = 4;
  41. m_iAuxImage = -1;
  42. m_menuID = -1;
  43. m_bToFit = FALSE;
  44. m_bOkToDrag = FALSE;
  45. m_bDragging = FALSE;
  46. m_bMaximized = FALSE;
  47. m_bUnique = FALSE;
  48. m_bGripper = TRUE;
  49. m_bButtons = TRUE;
  50. m_sizeDesired = CSize(200,100);
  51. m_sizeNormal = CSize(200,100);
  52. m_cxOffset = 5;
  53. m_cyOffset = 3;
  55. // Create the image list used by frame buttons.
  56. m_ImageList.Create(IDB_BUTTON_IMAGES,
  57. 10, 1, RGB(255,255,255));
  59. m_pChildWnd = NULL;
  61. m_clrBtnHilite = ::GetSysColor(COLOR_BTNHILIGHT);
  62. m_clrBtnShadow = ::GetSysColor(COLOR_BTNSHADOW);
  63. m_clrBtnFace   = ::GetSysColor(COLOR_BTNFACE);
  65. }
  67. COAMControlBar::~COAMControlBar()
  68. {
  69. m_ImageList.DeleteImageList();
  70. }
  72. IMPLEMENT_DYNAMIC(COAMControlBar, CControlBar)
  74. BEGIN_MESSAGE_MAP(COAMControlBar, CControlBar)
  75. //{{AFX_MSG_MAP(COAMControlBar)
  76. ON_WM_NCPAINT()
  77. ON_WM_PAINT()
  78. ON_WM_MOUSEMOVE()
  79. ON_WM_SETCURSOR()
  80. ON_WM_LBUTTONUP()
  81. ON_WM_NCHITTEST()
  82. ON_WM_ERASEBKGND()
  83. ON_WM_SYSCOLORCHANGE()
  84. ON_WM_CREATE()
  85. ON_WM_WINDOWPOSCHANGED()
  86. ON_WM_CONTEXTMENU()
  87. ON_WM_LBUTTONDOWN()
  88. ON_COMMAND(IDC_BUTTON_HIDE, OnButtonClose)
  89. ON_UPDATE_COMMAND_UI(IDC_BUTTON_HIDE, OnUpdateButtonClose)
  90. ON_COMMAND(IDC_BUTTON_MINI, OnButtonMinimize)
  91. ON_UPDATE_COMMAND_UI(IDC_BUTTON_MINI, OnUpdateButtonMinimize)
  92. //}}AFX_MSG_MAP
  93. END_MESSAGE_MAP()
  95. /////////////////////////////////////////////////////////////////////////////
  96. // COAMControlBar overrides
  98. BOOL COAMControlBar::Create(CWnd *pParentWnd, UINT nID, LPCTSTR lpszWindowName, CSize sizeDefault, DWORD dwStyle)
  99. {
  100.     ASSERT_VALID(pParentWnd);   // must have a parent
  102.     // Set initial control bar style.
  103.     SetBarStyle(dwStyle & CBRS_ALL|CBRS_HIDE_INPLACE|CBRS_SIZE_DYNAMIC|CBRS_FLOAT_MULTI);
  105.     dwStyle &= ~CBRS_ALL;
  106.     dwStyle |= WS_VISIBLE | WS_CHILD | WS_CLIPCHILDREN;
  107.     
  108. m_sizeDesired = m_sizeNormal = sizeDefault;
  110. CString wndClass = ::AfxRegisterWndClass(
  111. CS_DBLCLKS, 0, ::GetSysColorBrush(COLOR_BTNFACE));
  113. return CWnd::Create(wndClass, lpszWindowName,
  114.   dwStyle, CRect(0,0,0,0), pParentWnd, nID);
  116. }
  118. BOOL COAMControlBar::PreTranslateMessage(MSG* pMsg) 
  119. {
  120. if (m_bButtons)
  121. m_ToolTip.RelayEvent(pMsg);
  122. return CControlBar::PreTranslateMessage(pMsg);
  123. }
  125. void COAMControlBar::OnUpdateCmdUI(CFrameWnd* pTarget, BOOL bDisableIfNoHndler)
  126. {
  127. if (m_bButtons)
  128. {
  129. UINT NewImage;
  130. BOOL bEnable = FALSE;
  132. if (IsHorzDocked())
  133. {
  134. if (m_bUnique) {
  135. m_ToolTip.UpdateTipText (IDS_EXPAND, &m_btnMinim);
  136. NewImage = _MAXORZDISABLE;
  137. bEnable = FALSE;
  138. }
  140. else if (!m_bMaximized) {
  141. m_ToolTip.UpdateTipText (IDS_EXPAND, &m_btnMinim);
  142. NewImage = _MAXORZENABLE;
  143. bEnable = TRUE;
  144. }
  146. else {
  147. m_ToolTip.UpdateTipText (IDS_CONTRACT, &m_btnMinim);
  148. NewImage = _NORMORZENABLE;
  149. bEnable = TRUE;
  150. }
  151. }
  153. else if(IsVertDocked())
  154. {
  155. if (m_bUnique) {
  156. m_ToolTip.UpdateTipText (IDS_EXPAND, &m_btnMinim);
  157. NewImage = _MAXVERTDISABLE;
  158. bEnable = FALSE;
  159. }
  161. else if (!m_bMaximized) {
  162. m_ToolTip.UpdateTipText (IDS_EXPAND, &m_btnMinim);
  163. NewImage = _MAXVERTENABLE;
  164. bEnable = TRUE;
  165. }
  167. else {
  168. m_ToolTip.UpdateTipText (IDS_CONTRACT, &m_btnMinim);
  169. NewImage = _NORMVERTENABLE;
  170. bEnable = TRUE;
  171. }
  172. }
  174. if (NewImage != m_iAuxImage) {
  175. m_iAuxImage = NewImage;
  176. m_btnMinim.SetIcon(m_ImageList.ExtractIcon(m_iAuxImage), CSize(10,10));
  177. m_btnMinim.EnableWindow(bEnable);
  178. }
  179. }
  180. }
  182. CSize COAMControlBar::CalcDynamicLayout(int nLength, DWORD nMode)
  183. { CSize sizeResult = m_sizeDesired;
  185. // sizeResult.cx += GetMinExt();
  186. // sizeResult.cy += GetMinExt();
  188. /* if(IsFloating())
  189. {
  190. if (nMode == LM_HORZ) {
  191. if (nLength < 50)
  192. nLength = 50;
  193. m_sizeDesired.cx = nLength;
  194. }
  196. if (nMode == (LM_LENGTHY | LM_HORZ)) {
  197. if (nLength < 50)
  198. nLength = 50;
  199. m_sizeDesired.cy = nLength;
  200. }
  202. sizeResult = m_sizeDesired;
  203. }*/
  205. return sizeResult;
  206. }
  208. /////////////////////////////////////////////////////////////////////////////
  209. // COAMControlBar message handlers
  211. void COAMControlBar::OnNcPaint() 
  212. {
  213. EraseNonClient();
  214. }
  216. void COAMControlBar::OnPaint() 
  217. {
  218. CPaintDC dc(this); // device context for painting
  219. CRect rc;
  220. m_iAuxImage = -1;
  221. GetClientRect(&rc);
  222. CRect rect;
  223. GetChildRect(rect);
  224. dc.ExcludeClipRect(rect);
  225. DrawBorders(&dc,rc);
  226. }
  228. void COAMControlBar::OnMouseMove(UINT nFlags, CPoint point) 
  229. {
  230. HitTest(point);
  231. CRect rectDock;
  232. if( m_bDragging )
  233. {
  234. // ASSERT(GetParent() != NULL);
  236. GetParent()->GetClientRect(&rectDock);
  237. ClientToScreen(&rectDock);
  238. ClientToScreen(&point);
  240. CFrameWnd *pFrame=GetDockingFrame();
  241. // ASSERT(pFrame != NULL);
  243. pFrame -> ScreenToClient(&point);
  244. pFrame->ScreenToClient(&rectDock);
  246. point.x = point.x>rectDock.right ? rectDock.right:point.x;
  247. point.x = point.x<rectDock.left ? rectDock.left:point.x;
  248. point.y = point.y>rectDock.bottom ? rectDock.bottom:point.y;
  249. point.y = point.y<rectDock.top ? rectDock.top:point.y;
  251. OnInvertTracker(m_rcTrack);
  252. int deltaX = point.x-m_ptCurDrag.x;
  253. int deltaY = point.y-m_ptCurDrag.y;
  255. if(IsVertDocked()) {
  256. m_rcTrack.top += deltaY;
  257. m_rcTrack.bottom += deltaY;
  258. }
  260. else if (IsHorzDocked()) {
  261. m_rcTrack.left += deltaX;
  262. m_rcTrack.right += deltaX;
  263. }
  265. OnInvertTracker(m_rcTrack);
  266. m_ptCurDrag = point;
  267. }
  269. CControlBar::OnMouseMove(nFlags, point);
  270. }
  272. BOOL COAMControlBar::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message) 
  273. {
  274. return (!m_bOkToDrag && !m_bDragging)?
  275. CControlBar::OnSetCursor(pWnd, nHitTest, message):FALSE;
  276. }
  278. void COAMControlBar::OnLButtonUp(UINT nFlags, CPoint point) 
  279. {
  280. CRect rectAvail;
  281. GetParent()->GetClientRect(&rectAvail);
  283. if( m_bDragging )
  284. {
  285.     ReleaseCapture();
  286.     OnInvertTracker(m_rcTrack);
  287.     m_bDragging = FALSE;
  289. if(IsVertDocked()) {
  290. int newHeight = m_rcTrack.top-m_ptStartDrag.y;
  291. m_sizeDesired.cy += newHeight;
  292. m_sizeDesired.cy = m_sizeDesired.cy > GetMinExt() ? m_sizeDesired.cy : GetMinExt();
  293. m_sizeDesired.cy = m_sizeDesired.cy > rectAvail.Height() ? rectAvail.Height() : m_sizeDesired.cy;
  294. }
  295.     
  296. else if (IsHorzDocked()) {
  297. int newWidth = m_rcTrack.left-m_ptStartDrag.x;
  298. m_sizeDesired.cx += newWidth;
  299. m_sizeDesired.cx = m_sizeDesired.cx > GetMinExt() ? m_sizeDesired.cx : GetMinExt();
  300.         m_sizeDesired.cx = m_sizeDesired.cx > rectAvail.Width() ? rectAvail.Width() : m_sizeDesired.cx;
  301.     }
  303.    ((COAMSizeDockBar *)GetParent())->CalcSizeBarLayout();
  304. }
  306.     CControlBar::OnLButtonUp(nFlags, point);
  307. }
  309. UINT COAMControlBar::OnNcHitTest(CPoint point) 
  310. {
  311. return HTCLIENT;
  312. }
  314. BOOL COAMControlBar::OnEraseBkgnd(CDC* pDC) 
  315. {
  316. int result;// = CControlBar::OnEraseBkgnd(pDC);
  318. if(hBkBitmap)
  319. {
  320. CRect rectClient;
  321. GetClientRect(rectClient);
  322. CBitmap * bp = CBitmap::FromHandle(hBkBitmap);
  323. pDC->FillRect(rectClient,&CBrush(bp));
  324. result = TRUE;
  325. }
  326. else
  327. {
  328. result = CControlBar::OnEraseBkgnd(pDC);
  329. }
  330. CRect rect;
  331. GetChildRect(rect);
  332. rect.DeflateRect(1,1);
  333. pDC->Draw3dRect(rect, m_clrBtnShadow, m_clrBtnHilite);
  335. UpdateWindow(); // Reduce some of the flickering. Really not convinced this is a good solution.
  337. return result;
  338. }
  340. void COAMControlBar::OnSysColorChange() 
  341. {
  342. CControlBar::OnSysColorChange();
  344. m_clrBtnHilite = ::GetSysColor(COLOR_BTNHILIGHT);
  345. m_clrBtnShadow = ::GetSysColor(COLOR_BTNSHADOW);
  346. m_clrBtnFace   = ::GetSysColor(COLOR_BTNFACE);
  347. }
  349. int COAMControlBar::OnCreate(LPCREATESTRUCT lpCreateStruct) 
  350. {
  351. if (CControlBar::OnCreate(lpCreateStruct) == -1)
  352. return -1;
  354. if (m_bButtons)
  355. {
  356. if(!m_btnClose.Create(NULL, WS_CHILD | WS_VISIBLE | WS_TABSTOP |
  357. BS_NOTIFY | BS_OWNERDRAW | BS_ICON,
  358. CRect(0,0,0,0), this, IDC_BUTTON_HIDE ))
  359. {
  360. TRACE0(_T("Unable to create close buttonn"));
  361. return -1;
  362. }
  365. if(!m_btnMinim.Create(NULL, WS_CHILD | WS_VISIBLE | WS_TABSTOP |
  366. BS_NOTIFY | BS_OWNERDRAW | BS_ICON,
  367. CRect(0,0,0,0), this, IDC_BUTTON_MINI ))
  368. {
  369. TRACE0(_T("Unable to create minimize buttonn"));
  370. return -1;
  371. }
  373. m_btnClose.DisableFlatLook();
  374. m_btnMinim.DisableFlatLook();
  376. m_btnClose.SetIcon(m_ImageList.ExtractIcon(0), CSize(10,10));
  378. // Create the ToolTip control.
  379. m_ToolTip.Create(this);
  380. m_ToolTip.Activate(TRUE);
  382. m_ToolTip.AddTool (&m_btnClose, IDS_HIDE);
  383. m_ToolTip.AddTool (&m_btnMinim, IDS_EXPAND);
  384. }
  386. return 0;
  387. }
  389. void COAMControlBar::OnWindowPosChanged(WINDOWPOS FAR* lpwndpos) 
  390. {
  391. CControlBar::OnWindowPosChanged(lpwndpos);
  393. if (m_bButtons)
  394. {
  395. if (IsFloating())
  396. {
  397. m_btnClose.ShowWindow(SW_HIDE);
  398. m_btnMinim.ShowWindow(SW_HIDE);
  399. }
  401. else
  402. {
  403. m_btnClose.ShowWindow(SW_SHOW);
  404. m_btnMinim.ShowWindow(SW_SHOW);
  406. CRect rcClose(GetButtonRect());
  407. CRect rcMinim(GetButtonRect());
  409. if (IsHorzDocked()) {
  410. rcMinim.OffsetRect(0,14);
  411. }
  413. else {
  414. rcClose.OffsetRect(14,0);
  415. }
  417. m_btnClose.MoveWindow(rcClose);
  418. m_btnMinim.MoveWindow(rcMinim);
  420.             Invalidate();     // Added
  421. }
  422. }
  424. if (m_pChildWnd->GetSafeHwnd()) {
  425. CRect rc;
  426. GetChildRect(rc);
  427. rc.DeflateRect(1,1);
  428. m_pChildWnd->MoveWindow(rc);
  429. m_pChildWnd->Invalidate();
  430. }
  431. }
  433. void COAMControlBar::OnContextMenu(CWnd* pWnd, CPoint point) 
  434. {
  435. // if no menu, just return. 
  436. /* if (m_menuID == -1 )
  437. { 
  438. // Gonzalo Pereyra
  439. DefWindowProc(WM_CONTEXTMENU, LONG(m_hWnd), 
  440. MAKELPARAM(point.x,point.y)); 
  442. TRACE0(_T("Warning: No control bar menu defined.n")); 
  443. return; 
  444. }
  446. if (point.x == -1 && point.y == -1)
  447. {
  448. //keystroke invocation
  449. CRect rect;
  450. GetClientRect(rect);
  451. ClientToScreen(rect);
  453. point = rect.TopLeft();
  454. point.Offset(5, 5);
  455. }
  457. CMenu menu;
  458. VERIFY(menu.LoadMenu(m_menuID));
  460. CMenu* pPopup = menu.GetSubMenu(0);
  461. // ASSERT(pPopup != NULL);
  462. CWnd* pWndPopupOwner = this;
  464. while (pWndPopupOwner->GetStyle() & WS_CHILD)
  465. pWndPopupOwner = pWndPopupOwner->GetParent();
  467. pPopup->TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON, point.x, point.y,
  468. pWndPopupOwner);*/
  469. if (point.x == -1 && point.y == -1){
  470. //keystroke invocation
  471. CRect rect;
  472. GetClientRect(rect);
  473. ClientToScreen(rect);
  475. point = rect.TopLeft();
  476. point.Offset(5, 5);
  477. }
  479. CMenu menu;
  480. VERIFY(menu.LoadMenu(IDR_TREE));
  482. CMenu* pPopup = menu.GetSubMenu(0);
  483. ASSERT(pPopup != NULL);
  484. CWnd* pWndPopupOwner = this;
  486. // while (pWndPopupOwner->GetStyle() & WS_CHILD)
  487. // pWndPopupOwner = pWndPopupOwner->GetParent();
  489. pPopup->TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON, point.x, point.y,
  490. pWndPopupOwner);
  491. }
  493. void COAMControlBar::OnLButtonDown(UINT nFlags, CPoint point) 
  494. {
  495. if (m_bOkToDrag)
  496. {
  497. CFrameWnd *pFrame=GetDockingFrame();
  498. GetClientRect(m_rcTrack);
  500. if (IsVertDocked()) {
  501. m_rcTrack.top = m_rcTrack.bottom-m_iTrackBorderSize-2;
  502. m_rcTrack.bottom-=2;
  503. }
  505. else if (IsHorzDocked()) {
  506. m_rcTrack.left = m_rcTrack.right-m_iTrackBorderSize-2;
  507. m_rcTrack.right-=2;
  508. }
  510. ClientToScreen(&m_rcTrack);
  511. pFrame->ScreenToClient(&m_rcTrack);
  512. ClientToScreen(&point);
  513. pFrame->ScreenToClient(&point);
  515. m_ptStartDrag = point;
  516. m_ptCurDrag = point;
  518. SetCapture();
  519. m_bDragging = TRUE;
  520. OnInvertTracker(m_rcTrack);
  521. }
  523. else if (m_pDockBar) {
  524. if (OnToolHitTest(point, NULL) == -1) {
  525. ClientToScreen(&point);
  526. ((COAMDockContext*)m_pDockContext)->StartDragDockBar(point);
  527. }
  528. }
  530. else {
  531. CControlBar::OnLButtonDown(nFlags, point);
  532. }
  533. }
  535. void COAMControlBar::OnButtonClose()
  536. {
  537. GetDockingFrame()->ShowControlBar(this,FALSE,FALSE);
  538. }
  540. void COAMControlBar::OnUpdateButtonClose(CCmdUI* pCmdUI)
  541. {
  542. pCmdUI->Enable();
  543. }
  545. void COAMControlBar::OnButtonMinimize()
  546. {
  547. if (!m_bMaximized) {
  548. ((COAMSizeDockBar *)GetParent())->Maximize(this);
  549. m_bMaximized = TRUE;
  550. }
  552. else {
  553. ((COAMSizeDockBar *)GetParent())->Normalize(this);
  554. m_bMaximized = FALSE;
  555. }
  556. }
  558. void COAMControlBar::OnUpdateButtonMinimize(CCmdUI* pCmdUI)
  559. {
  560. pCmdUI->Enable();
  561. }
  563. /////////////////////////////////////////////////////////////////////////////
  564. // COAMControlBar operations
  566. UINT COAMControlBar::GetMenuID()
  567. {
  568. return m_menuID;
  569. }
  571. void COAMControlBar::SetMenuID(UINT nID)
  572. {
  573. m_menuID = nID;
  574. }
  576. void COAMControlBar::ShowFrameControls(BOOL bGripper, BOOL bButtons)
  577. {
  578. m_bGripper = bGripper;
  579. m_bButtons = bButtons;
  580. }
  582. void COAMControlBar::EnableDockingOnSizeBar(DWORD dwDockStyle)
  583. {
  584. // ASSERT(m_pDockContext == NULL);
  585. m_dwDockStyle = dwDockStyle;
  587. if (m_pDockContext == NULL)
  588. m_pDockContext = new COAMDockContext(this);
  590. if (m_hWndOwner == NULL)
  591. m_hWndOwner = ::GetParent(m_hWnd);
  592. }
  594. void COAMControlBar::Maximize(int size)
  595. {
  596. m_sizeNormal = m_sizeDesired;
  597. if (IsHorzDocked()) {
  598. m_sizeDesired.cx = size;
  599. }
  601. else if (IsVertDocked()) {
  602. m_sizeDesired.cy = size;
  603. }
  605. m_bMaximized = TRUE;
  606. }
  608. void COAMControlBar::Minimize()
  609. {
  610. m_sizeNormal = m_sizeDesired;
  611. if (IsHorzDocked()) {
  612. m_sizeDesired.cx = GetMinExt();
  613. }
  615. else if (IsVertDocked()) {
  616. m_sizeDesired.cy = GetMinExt();
  617. }
  619. m_bMaximized = FALSE;
  620. }
  622. void COAMControlBar::Normalize()
  623. {
  624. if (IsHorzDocked()) {
  625. m_sizeDesired.cx = m_sizeNormal.cx;
  626. }
  628. else if (IsVertDocked()) {
  629. m_sizeDesired.cy = m_sizeNormal.cy;
  630. }
  632. m_bMaximized = FALSE;
  633. }
  635. void COAMControlBar::SetNormalSize(const CSize &cs)
  636. {
  637. m_sizeDesired = m_sizeNormal = cs;
  638. }
  640. BOOL COAMControlBar::IsVertDocked()
  641. {
  642. return (IsLeftDocked() || IsRightDocked());
  643. }
  645. BOOL COAMControlBar::IsHorzDocked()
  646. {
  647. return (IsTopDocked() || IsBottomDocked());
  648. }
  650. BOOL COAMControlBar::IsBottomDocked()
  651. {
  652. return m_pDockBar?(m_pDockBar->GetDlgCtrlID()
  653. == AFX_IDW_SIZEBAR_BOTTOM):FALSE;
  654. }
  656. BOOL COAMControlBar::IsTopDocked()
  657. {
  658. return m_pDockBar?(m_pDockBar->GetDlgCtrlID()
  659. == AFX_IDW_SIZEBAR_TOP):FALSE;
  660. }
  662. BOOL COAMControlBar::IsRightDocked()
  663. {
  664. return m_pDockBar?(m_pDockBar->GetDlgCtrlID()
  665. == AFX_IDW_SIZEBAR_RIGHT):FALSE;
  666. }
  668. BOOL COAMControlBar::IsLeftDocked()
  669. {
  670. return m_pDockBar?(m_pDockBar->GetDlgCtrlID()
  671. == AFX_IDW_SIZEBAR_LEFT):FALSE;
  672. }
  674. int COAMControlBar::GetMinExt()
  675. {
  676. int nRet = m_iTrackBorderSize;
  678. if (m_bGripper || m_bButtons) {
  679. nRet += GRIP_STARTGRIP;
  680. nRet += GRIP_SIZE*2;
  681. nRet += GRIP_INTRASPACING*3+2;
  682. }
  684. else
  685. nRet += 2;
  687. return nRet;
  688. }
  690. void COAMControlBar::GetChildRect(CRect &rect)
  691. {
  692. GetClientRect(&rect);
  694. if (!IsFloating())
  695. {
  696. if (IsVertDocked()) {
  697. // rect.left += sizeImgBarBorder.cx;//m_cxOffset;
  698. // rect.right -= sizeImgBarBorder.cx;//m_cxOffset;
  699. // rect.top += sizeImgBarBorder.cy;//m_cyOffset;
  700. // rect.bottom -= sizeImgBarBorder.cy;//m_cyOffset;
  701. rect.left += m_cxOffset;
  702. rect.right -= m_cxOffset;
  703. rect.top += (GetMinExt()-5);
  704. rect.bottom -= (m_iTrackBorderSize+4);
  705. }
  707. else if(IsHorzDocked()) {
  708. rect.left += (GetMinExt()-5);
  709. rect.right -= (m_iTrackBorderSize+4);
  710. rect.top += m_cyOffset;
  711. rect.bottom -= m_cyOffset;
  712. }
  714. if( rect.left > rect.right || rect.top > rect.bottom )
  715. rect = CRect(0,0,0,0);
  716. }
  717. }
  719. void COAMControlBar::EraseNonClient()
  720. {
  721. CWindowDC dc(this);
  722. CRect rectClient;
  723. GetClientRect(rectClient);
  724. CRect rectWindow;
  725. GetWindowRect(rectWindow);
  726. ScreenToClient(rectWindow);
  727. rectClient.OffsetRect(-rectWindow.left, -rectWindow.top);
  728. dc.ExcludeClipRect(rectClient);
  729. rectWindow.OffsetRect(-rectWindow.left, -rectWindow.top);
  730. dc.IntersectClipRect(rectWindow);
  731. SendMessage(WM_ERASEBKGND, (WPARAM)dc.m_hDC);
  732. }
  734. void COAMControlBar::DrawBorders(CDC *pDC, CRect &rect)
  735. {
  736. CRect rc;
  737. rc.CopyRect(&rect);
  739. CRect rcTrack;
  740. rcTrack.CopyRect(&rc);
  742. if(IsVertDocked())
  743. {
  744. if (!m_bToFit) {
  745. rcTrack.top = rc.bottom-m_iTrackBorderSize;
  746. rcTrack.top-=2;
  747. rcTrack.bottom-=1;
  748. pDC->FillSolidRect(rcTrack, m_clrBtnFace);
  749. pDC->Draw3dRect(rcTrack, m_clrBtnHilite, m_clrBtnShadow);
  750. }
  751. }
  753. else if (IsHorzDocked())
  754. {
  755. if (!m_bToFit) {
  756. rcTrack.left = rc.right-m_iTrackBorderSize;
  757. rcTrack.left-=2;
  758. rcTrack.right-=1;
  759. pDC->FillSolidRect(rcTrack, m_clrBtnFace);
  760. pDC->Draw3dRect(rcTrack, m_clrBtnHilite, m_clrBtnShadow);
  761. }
  762. }
  768. DrawGripper(pDC);
  769. }
  771. void COAMControlBar::HitTest(CPoint &point)
  772. {
  773. CRect rcWin;
  774. GetClientRect(&rcWin);
  775. HCURSOR hCur;
  776. BOOL bHit = FALSE;
  778. if (IsVertDocked()) {
  779. rcWin.top = rcWin.bottom-m_iTrackBorderSize;
  780. hCur = AfxGetApp()->LoadCursor(IDC_VSPLITBAR);
  781. bHit = rcWin.PtInRect(point) && !m_bToFit;
  782. }
  784. else if (IsHorzDocked()) {
  785. rcWin.left = rcWin.right-m_iTrackBorderSize;
  786. hCur = AfxGetApp()->LoadCursor(IDC_HSPLITBAR);
  787. bHit = rcWin.PtInRect(point) && !m_bToFit;
  788. }
  790. if( bHit )
  791. SetCursor(hCur);
  793. else {
  794. hCur = ::LoadCursor(NULL,IDC_ARROW);
  795. SetCursor(hCur);
  796. }
  798. m_bOkToDrag = bHit;
  799. }
  801. void COAMControlBar::OnInvertTracker(const CRect &rect)
  802. {
  803. ASSERT_VALID(this);
  804. // ASSERT(!rect.IsRectEmpty());
  805. CFrameWnd *pFrame=GetDockingFrame();
  806. CDC* pDC = pFrame->GetDC();
  807. CBrush* pBrush = CDC::GetHalftoneBrush();
  808. HBRUSH hOldBrush = NULL;
  809. if (pBrush != NULL)
  810. hOldBrush = (HBRUSH)SelectObject(pDC->m_hDC, pBrush->m_hObject);
  811. pDC->PatBlt(rect.left, rect.top, rect.Width(), rect.Height(), PATINVERT);
  812. if (hOldBrush != NULL)
  813. SelectObject(pDC->m_hDC, hOldBrush);
  814. pFrame->ReleaseDC(pDC);
  815. }
  817. void COAMControlBar::SetChild(CWnd *pWnd)
  818. {
  819. m_pChildWnd = pWnd;
  820. }
  822. void COAMControlBar::DrawGripper(CDC *pDC)
  823. {
  824. if (!IsFloating() && m_bGripper)
  825. {
  826. // draw the gripper.
  827. CRect pRect(GetGripperRect());
  828. pDC->Draw3dRect( pRect, ::GetSysColor(COLOR_BTNHIGHLIGHT),
  829. ::GetSysColor(COLOR_BTNSHADOW) );
  831. if (IsHorzDocked())
  832. pRect.OffsetRect(4,0);
  833. else
  834. pRect.OffsetRect(0,4);
  836. pDC->Draw3dRect( pRect, ::GetSysColor(COLOR_BTNHIGHLIGHT),
  837. ::GetSysColor(COLOR_BTNSHADOW) );
  839. }
  840. }
  842. CRect COAMControlBar::GetButtonRect()
  843. {
  844. CRect rect;
  845. GetClientRect(&rect);
  846. rect.OffsetRect(-rect.left,-rect.top);
  848. if (IsHorzDocked()) {
  849. rect.top  += 3;
  850. rect.bottom = rect.top+12;
  851. rect.left  += 2;
  852. rect.right  = rect.left+12;
  853. }
  855. else {
  856. rect.right -= 19;
  857. rect.left   = rect.right-12;
  858. rect.top   += 3;
  859. rect.bottom = rect.top+12;
  860. }
  862. return rect;
  863. }
  865. CRect COAMControlBar::GetGripperRect()
  866. {
  867. CRect rect;
  868. GetClientRect(&rect);
  869. rect.OffsetRect(-rect.left,-rect.top);
  871. if (IsHorzDocked()) {
  872. rect.DeflateRect(3,3);
  873. rect.left += 1;
  874. rect.right  = rect.left+3;
  875. rect.bottom -= 1;
  876. rect.top += m_bButtons?30:1;
  877. }
  879. else {
  880. rect.DeflateRect(4,4);
  881. rect.top += 2;
  882. rect.bottom  = rect.top+3;
  883. rect.right -= m_bButtons?30:2;
  884. }
  886. return rect;
  887. }