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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 工具条 > 查看源码
gripdialogbar.cpp
资源名称：VSOMenu.zip　[点击查看]
上传用户：libwxy
上传日期：2007-01-02
资源大小：200k
文件大小：32k
源码类别：

工具条

开发平台：

Visual C++

gripdialogbar.cpp：源码内容
  1. /////////////////////////////////////////////////////////////////////////////
  2. // This is an extension to the MFC C++ library.
  3. // Copyright (C) 1997-1998 ACPSoft
  4. // All rights reserved.
  5. //
  6. // This source code is only intended as a building
  7. // tool to aid your own development.  This code is
  8. // under the license agreement provided with the
  9. // software. By using this code in your own project(s)
  10. // you agree to the terms in that license.
  11. /////////////////////////////////////////////////////////////////////////////
  13. // MFC includes
  14. #include "stdafx.h"
  15. #include <afxpriv.h> 
  16. #include <..srcafximpl.h> 
  18. // Local includes
  19. #include "GripDialogBar.h" 
  21. #ifdef _DEBUG 
  22. #undef THIS_FILE 
  23. static char THIS_FILE[]=__FILE__; 
  24. #define new DEBUG_NEW 
  25. #endif
  27. /////////////////////////////////////////////////////////////////// 
  28. // Class CInitDialogBar 
  29. // 
  30. // Class provides new behavior for OnInitDialogBar() 
  31. // and DDX support for common CDialogBar
  32. //  
  33. /////////////////////////////////////////////////////////////////// 
  35. //////////////////////////////////////////////////////////////////////
  36. // Construction/Destruction
  37. //////////////////////////////////////////////////////////////////////
  39. IMPLEMENT_DYNAMIC(CInitDialogBar, CDialogBar)
  41. CInitDialogBar::CInitDialogBar()
  42. {
  43. // In derived classes set intial
  44. // state of control(s) in the derived
  45. // constructor
  46. }
  48. CInitDialogBar::~CInitDialogBar()
  49. {
  50. }
  52. BEGIN_MESSAGE_MAP(CInitDialogBar, CDialogBar)
  53. //{{AFX_MSG_MAP(CInitDialogBar)
  54. //}}AFX_MSG_MAP
  55. END_MESSAGE_MAP()
  57. BOOL CInitDialogBar::Create(CWnd * pParentWnd, UINT nIDTemplate, UINT nStyle, UINT nID)
  58. {
  59. ASSERT(pParentWnd);
  61. m_dwStyle = nStyle;
  63. //Let MFC Create the control
  64. if(!CDialogBar::Create(pParentWnd,
  65. nIDTemplate,
  66. nStyle,
  67. nID))
  68. return FALSE;
  70. // Since there is no WM_INITDIALOG message we have to call
  71. // our own InitDialog function ourselves after m_hWnd is valid
  72. if(!OnInitDialogBar())
  73. return FALSE;
  74. return TRUE;
  75. }
  77. BOOL CInitDialogBar::Create(CWnd * pParentWnd, LPCTSTR lpszTemplateName, UINT nStyle, UINT nID)
  78. {
  79. ASSERT(pParentWnd);
  81. m_dwStyle = nStyle;
  83. //Let MFC Create the control
  84. if(!CDialogBar::Create(pParentWnd,
  85. lpszTemplateName,
  86. nStyle,
  87. nID))
  88. return 0;
  90. // Since there is no WM_INITDIALOG message we have to call
  91. // our own InitDialog function ourselves after m_hWnd is valid
  92. if(!OnInitDialogBar())
  93. return FALSE;
  94. return TRUE;
  95. }
  97. BOOL CInitDialogBar::OnInitDialogBar()
  98. {
  99. // Support for the MFC DDX model
  100. // If you do not want this do not 
  101. // call the base class from derived 
  102. // classes
  103. UpdateData(FALSE);
  104. return TRUE;
  105. }
  107. void CInitDialogBar::DoDataExchange(CDataExchange* pDX) 
  108. {
  109. //Derived Classes Overide this function
  110. ASSERT(pDX);
  112. // In derived class call the DDX_???
  113. // functions to set retrieve values
  114. // of your controls
  115. // See example derived class for how
  116. // to do this.
  117. CDialogBar::DoDataExchange(pDX);
  118. }
  120. //////////////////////////////////////////////////////////////////////
  121. // Class CGripDialogBar 
  122. // 
  123. // Class provides new behavior for drawing the 
  124. // CDialog Bar make it like a DevStudio workspace
  125. //  
  126. //////////////////////////////////////////////////////////////////////
  128. //////////////////////////////////////////////////////////////////////
  129. // Construction/Destruction 
  130. //////////////////////////////////////////////////////////////////////
  132. IMPLEMENT_DYNAMIC(CGripDialogBar, CInitDialogBar) 
  134. CGripDialogBar::CGripDialogBar()
  135. {
  137. // Default style Gripper bars and
  138. // close button only to add text
  139. // dockbutton or title use the
  140. // GBS_??? flags
  141. m_GripBar = new CGripControl();
  142. m_bActive = -1;
  143. }
  145. CGripDialogBar::CGripDialogBar(UINT nID, DWORD Style, COLORREF clr)
  146. {
  148. // To use color be sure to
  149. // Set the GBS_USECOLOR bit
  151. // GBS_DOCKAPPST - Display App String
  152. // GBS_DOCKBUTTON - Display the dock button
  153. // GBS_DOCKCLOSE - Display the close button
  154. // GBS_DOCKTITLE - Displays window title
  155. // GBS_NOGRADIENT - Use solid color
  156. // GBS_NOGRIPBARS - Do not display grip bars
  157. // GBS_USECOLOR - Use user defined color
  159. m_GripBar = new CGripControl(nID, Style, clr);
  160. m_bActive = -1;
  161. }
  163. CGripDialogBar::~CGripDialogBar() 
  164. { 
  166. // Cleanup
  167. if(m_GripBar)
  168. delete m_GripBar;
  169. }
  171. BEGIN_MESSAGE_MAP(CGripDialogBar, CInitDialogBar) 
  172. //{{AFX_MSG_MAP(CInitDialogBar)
  173. ON_WM_CLOSE()
  174. ON_WM_ERASEBKGND()
  175. ON_WM_NCACTIVATE()
  176. ON_WM_NCPAINT() 
  177. ON_WM_PAINT()
  178. //}}AFX_MSG_MAP 
  179. END_MESSAGE_MAP()
  181. void CGripDialogBar::GetCaptionRect(CRect* rect)
  182. {
  184. // Get the frame size
  185. DWORD style = GetStyle();
  187. CSize frame;
  188. if(style & WS_BORDER)
  189. frame = CSize(GetSystemMetrics(SM_CXFIXEDFRAME),
  190. GetSystemMetrics(SM_CXFIXEDFRAME));
  191. else
  192. frame = CSize(GetSystemMetrics(SM_CXFIXEDFRAME),
  193. GetSystemMetrics(SM_CYFIXEDFRAME));
  195. // Compute caption area
  196. GetWindowRect(rect);
  197. CPoint pt(rect->left, rect->top);
  199. // Our DC has 0,0 as it origin
  200. *rect -= pt;
  202. // Adjust for window frame
  203. rect->left  += frame.cx;
  204. rect->right -= frame.cx;
  205. rect->top   += frame.cy;
  206. rect->bottom = rect->top + GetSystemMetrics(SM_CYCAPTION)
  207. - GetSystemMetrics(SM_CYBORDER);
  208. return;
  209. }
  211. inline
  212. DWORD CGripDialogBar::GetGripStyle()
  213. {
  214. return m_GripBar->m_GBStyle;
  215. }
  217. void CGripDialogBar::ModifyGripStyle(DWORD remove, DWORD add)
  218. {
  219. m_GripBar->m_GBStyle = m_GripBar->m_GBStyle | add;
  220. m_GripBar->m_GBStyle = m_GripBar->m_GBStyle & ~remove;
  221. m_GripBar->Abolish();
  222. }
  224. void CGripDialogBar::SetActiveState(UINT nState)
  225. {
  226. if(!IsWindow(m_hWnd))
  227. return;
  229. WPARAM state;
  231. // Call this function from your main frame
  232. // OnActivate Handler. Example:
  233. // void CMainFrame::OnActivate(UINT nState, CWnd* pWndOther, BOOL bMinimized) 
  234. // {
  235. //      m_YourObject.SetActiveState(nState); <-- Add this line
  236. //      CMDIFrameWnd::OnActivate(nState, pWndOther, bMinimized);
  237. //      return;
  238. // }
  240. if(nState == WA_INACTIVE)
  241. state = FALSE;
  242. else
  243. state = TRUE;
  245. SendMessage(WM_NCACTIVATE, state, 0);
  246. return;
  247. }
  249. void CGripDialogBar::StartDrag(CPoint point)
  250. {
  251. ASSERT(m_pDockContext != NULL);
  253. m_pDockContext->StartDrag(point);
  254. Invalidate(TRUE);
  255. }
  257. void CGripDialogBar::ToggleDocking()
  258. {
  259.  ASSERT(m_pDockContext != NULL); 
  261.      m_pDockContext->ToggleDocking(); 
  262. }
  264. void CGripDialogBar::View(CFrameWnd* fWnd, BOOL state)
  265. {
  266. ASSERT(fWnd);
  268. // Put this function in your handler
  269. // which toggles the view of the control
  270. fWnd->ShowControlBar(this, state, FALSE);
  271. }
  273. BOOL CGripDialogBar::OnInitDialogBar() 
  274. { 
  276. // To display a title modify your resource
  277. // select the title checkbox, the grip bar will
  278. // take the title of the window. Set your
  279. // margin at 16 or more dialog units. See below.
  280. m_GripBar->Fasten(this);
  282. // To avoid MFC bugs with edit controls we need
  283. // to turn off the caption style and provide our
  284. // own caption. This means in your resource you
  285. // need to leave a little space at the top for
  286. // the caption. Set the top margin at 16 DLG Units
  287. // This works well.
  288. ModifyStyle(WS_CAPTION, 0);
  290. // Setup the overidden context for Docking.
  291. // We will use this context to provide our own 
  292. // docking functionality.  By doing this ourselves
  293. // now instead of during Enable docking we are
  294. // able to replace the original member variable
  295. // with our new class. All changes MUST occur
  296. // in virtual functions. 
  297.      if (m_pDockContext == NULL) 
  298.           m_pDockContext = new CExDockContext(this); 
  299.      ASSERT(m_pDockContext); 
  301.      // Call Base Class. You must do this
  302.      CInitDialogBar::OnInitDialogBar(); 
  303.      return TRUE; 
  304. }
  306. void CGripDialogBar::ExcludeCaption(CDC* pDC) 
  307. { 
  309. // Compute caption area
  310. CRect capRect;
  311. CRect rcWin;
  312. GetWindowRect(rcWin);
  313. GetCaptionRect(&capRect);
  315. // There is no need to paint the caption
  316. // area twice so only our provided caption
  317. // paint it. The parent need not paint
  318. // the same area. This helps to prevent
  319. // flicker in drawing.
  320. pDC->ExcludeClipRect(&capRect);
  321. } 
  323. void CGripDialogBar::PaintRect(CDC* pDC, int x, int y, int w, int h, COLORREF color)
  324. {
  325. CBrush brush(color);
  326. CBrush* pOldBrush = pDC->SelectObject(&brush);
  327. pDC->PatBlt(x, y, w, h, PATCOPY);
  328. pDC->SelectObject(pOldBrush);
  329. }
  331. void CGripDialogBar::RecalcLayout() 
  332. { 
  333. // If we are floating we do not want 
  334. // our new caption to be visible, 
  335. // so we move our window up so our 
  336. // caption is underneath the CMiniFrameWnd 
  337. // caption 
  338. if(IsFloating()) 
  339. {
  340. CRect rect; 
  342. GetWindowRect(rect); 
  344. SetWindowPos(NULL, 
  345. 0, 
  346. -(GetSystemMetrics(SM_CYCAPTION) 
  347. + GetSystemMetrics(SM_CYFRAME)), 
  348. rect.Width(), 
  349. rect.Height(), 
  350. NULL); 
  351. } 
  352. } 
  354. void CGripDialogBar::OnClose() 
  355. {
  356. CFrameWnd* wnd;
  358. wnd = (CFrameWnd*) AfxGetMainWnd();
  359. ASSERT(wnd);
  361. // Make sure your main Wnd is really a 
  362. // Frame Wnd Object else we do nothing
  363. // This protects us from apps which do not
  364. // use CFrameWnd for their main window.
  365. // Those apps will need to override to
  366. // provide their own support for close.
  367. if(wnd->IsKindOf(RUNTIME_CLASS(CFrameWnd)))
  368. {
  370. // Close (really hide) our control bar
  371. wnd->ShowControlBar(this, FALSE, FALSE);
  372. }
  373. return;
  374. }
  376. BOOL CGripDialogBar::OnEraseBkgnd(CDC* pDC)
  377. {
  378. ExcludeCaption(pDC);
  379. CInitDialogBar::OnEraseBkgnd(pDC);
  380. return TRUE;
  381. }
  383. BOOL CGripDialogBar::OnNcActivate(BOOL bActive) 
  384. { 
  386. // Tell the control which of our two
  387. // caption bitmaps to paint
  388. m_bActive = bActive;
  390. m_GripBar->Invalidate(TRUE);
  391. return TRUE;
  392. }
  394. void CGripDialogBar::OnPaint() 
  395. { 
  396. // Notice here we break the do not call 
  397. // the base class OnPaint Rule. This is 
  398. // because we do not set up our own DC 
  399. // here so calling the base is OK and
  400. // also required otherwise we need to
  401. // redo what the base already does for us 
  402. RecalcLayout(); 
  403. CDialogBar::OnPaint(); 
  404. } 
  407. /////////////////////////////////////////////////////////////////// 
  408. // Class CGripControl 
  409. // 
  410. // Class provides new behavior for drawing the 
  411. // CDialog Bar make it like a DevStudio workspace
  412. //  
  413. /////////////////////////////////////////////////////////////////// 
  415. // Local defines
  416. #define WHITE RGB(255,255,255)
  417. #define BLACK RGB(0,0,0)
  418. #define GRADBOXWIDTH 80
  419. #define HLSMAX 240
  420. #define RGBMAX 255
  422. // Local functions
  423. // The following function is
  424. /////////////////////////////////////////////////
  425. // Copyright (1997) Microsoft Systems Journal
  426. /////////////////////////////////////////////////
  427. static int GetLuminosity(COLORREF color)
  428. {
  429. int r = GetRValue(color);
  430. int g = GetGValue(color);
  431. int b = GetBValue(color);
  432. int rgbMax = max( max(r,g), b);
  433. int rgbMin = min( min(r,g), b);
  434. return (((rgbMax+rgbMin) * HLSMAX) + RGBMAX ) / (2*RGBMAX);
  435. }
  436. /////////////////////////////////////////////////
  437. // End MSJ code
  438. /////////////////////////////////////////////////
  440. ////////////////////////////////////////////////////////////////////// 
  441. // Construction/Destruction 
  442. ////////////////////////////////////////////////////////////////////// 
  443. IMPLEMENT_DYNCREATE(CGripControl, CEdit)
  445. CGripControl::CGripControl()
  446. {
  447. // Default style
  448. // Gripper bars and close
  449. // button only to add text
  450. // dockbutton or title use
  451. // the GBS flags
  452. m_nID = 0;
  453. m_GBStyle = GBS_DOCKCLOSE;
  454. m_prevHitTest = -1;
  456. // DevStudio Generated String
  457. // for application title
  458. UINT id = AFX_IDS_APP_TITLE;
  459. m_appString.LoadString(id);
  460. }
  462. CGripControl::CGripControl(UINT nID, DWORD Style, COLORREF clr)
  463. {
  464. m_ColorCap = clr;
  465. m_GBStyle = Style;
  466. m_prevHitTest = -1;
  467. m_nID = nID;
  469. // DevStudio Generated String
  470. // for application title
  471. UINT id = AFX_IDS_APP_TITLE;
  472. m_appString.LoadString(id);
  473. }
  475. CGripControl::~CGripControl()
  476. {
  477. }
  480. BEGIN_MESSAGE_MAP(CGripControl, CEdit)
  481. //{{AFX_MSG_MAP(CGripControl)
  482. ON_WM_ERASEBKGND()
  483. ON_WM_PAINT()
  484. ON_WM_LBUTTONDOWN()
  485. ON_WM_SETCURSOR()
  486. ON_WM_LBUTTONDBLCLK()
  487. ON_WM_LBUTTONUP()
  488. ON_WM_MOUSEMOVE()
  489. ON_WM_SETTINGCHANGE()
  490. ON_WM_SYSCOLORCHANGE()
  491. //}}AFX_MSG_MAP
  492. END_MESSAGE_MAP()
  494. /////////////////////////////////////////////////////////////////////////////
  495. // CGripControl message handlers
  497. void CGripControl::Abolish()
  498. {
  499. // Next time we paint use the newly
  500. // seleted settings.
  501. m_fontCap.DeleteObject();
  502. m_fontTitle.DeleteObject();
  503. m_rcCap.SetRectEmpty();
  504. }
  506. void CGripControl::Fasten(CGripDialogBar* pControlBar)
  507. {
  508. ASSERT(pControlBar);
  509. ASSERT(pControlBar->IsKindOf(RUNTIME_CLASS(CGripDialogBar)));
  511. m_pControlBar = pControlBar;
  513. // Setup the Grip Bar Control
  514. // using the parms from the control
  515. // Get the text and rect from control
  516. CString str;
  517. m_pControlBar->GetWindowText(str);
  519. // Dummy Rect for Creation purposes
  520. // The window is moved to the proper
  521. // location during erase background
  522. CRect rc(0,0,10,50);
  523. Create(WS_VISIBLE,
  524. rc,
  525. m_pControlBar,
  526. m_nID);
  527. ASSERT(IsWindow(m_hWnd));
  529. SetWindowText(str);
  530. }
  532. inline
  533. CString CGripControl::GetBarTitle()
  534. {
  535. CString str;
  537. GetWindowText(str);
  538. return str;
  539. }
  541. inline 
  542. void CGripControl::GetCaptionRect(CRect* rect)
  543. {
  544. GetClientRect(rect);
  545. return;
  546. }
  548. void CGripControl::CreateFonts()
  549. {
  550. NONCLIENTMETRICS ncm;
  551. ncm.cbSize = sizeof(ncm);
  552. VERIFY(SystemParametersInfo(SPI_GETNONCLIENTMETRICS,
  553. 0,
  554. &ncm,
  555. 0));
  557. // Derived classes can esily override to provide
  558. // their own font support
  559. m_fontCap.CreateFontIndirect(&ncm.lfCaptionFont);
  560. m_fontTitle.CreateFontIndirect(&ncm.lfCaptionFont);
  561. } 
  563. void CGripControl::OnNcDraw(CDC* pDC)
  564. {
  566. // We will draw on a MemDC then BitBlt
  567. // the bmp to the window DC
  568. CDC memDC;
  569. memDC.CreateCompatibleDC(pDC);
  571. // See if we need a new bitmap
  572. UpdateBitmap(m_pControlBar->m_bActive,
  573. &memDC,
  574. pDC);
  576. // Get paint area 
  577. // It's set by update bitmap
  578. CRect& rc = m_rcCap;
  580. // OK Paint
  581. pDC->BitBlt(rc.left,
  582. rc.top,
  583. rc.Width(),
  584. rc.Height(),
  585. &memDC,
  586. 0,
  587. 0,
  588. SRCCOPY);
  589. return;
  590. }
  592. void CGripControl::DrawOnBitmap(BOOL bActive, CDC* pMemDC, CRect* pRC)
  593. {
  594. int w = pRC->Width();
  595. int cxIcon = GetSystemMetrics(SM_CXSIZE);
  596. int cyIcon = GetSystemMetrics(SM_CYSIZE);
  598. // Paint our inactive bmp
  599. if (!bActive)
  600. {
  602. // Let's not get fancy; when we are inactive
  603. // The window is probably out of view anyway.
  604. // Don't waste CPU cycles on something no one
  605. // may ever see. So we will just fill the caption
  606. // Rect with the default inactive color
  607. PaintRect(pMemDC,
  608. 0,
  609. 0,
  610. pRC->Width(),
  611. pRC->Height(),
  612. GetSysColor(COLOR_INACTIVECAPTION));
  613. }
  614. else
  615. {
  616. // Active : We paint according to
  617. // which flags are set
  618. COLORREF clr;
  620. // Do we use windows default
  621. // or user supplied color
  622. if(m_GBStyle & GBS_USECOLOR)
  623. {
  625. // user supplied
  626. clr = m_ColorCap;
  627. }
  628. else
  629. {
  631. // widnows default
  632. clr = GetSysColor(COLOR_ACTIVECAPTION); 
  633. }
  635. // Do we use quadratic gradient
  636. // or solid Fill
  637. if(m_GBStyle & GBS_NOGRADIENT)
  638. {
  639. // If you prefer not to have a color gradient
  640. // use this flag
  641. PaintRect(pMemDC,
  642. 0,
  643. 0,
  644. pRC->Width(),
  645. pRC->Height(),
  646. clr);
  647. }
  648. else
  649. {
  651. // Use the quadratic gradient
  652. // The following gradient:
  653. /////////////////////////////////////////////////
  654. // Copyright (1997) Microsoft Systems Journal
  655. /////////////////////////////////////////////////
  656. // Note: future version of this code will replace
  657. // this gradient with a new one.
  658. int r = GetRValue(clr);
  659. int g = GetGValue(clr);
  660. int b = GetBValue(clr);
  661. int x = 7 * pRC->right / 8;
  662. int w = x - pRC->left;
  663. int xDelta= max((w / GRADBOXWIDTH),1);
  664. int h = pRC->Height();
  666. PaintRect(pMemDC,
  667. x,
  668. 0,
  669. pRC->right - x,
  670. h,
  671. clr);
  673. int w2  = w*w;
  675. while (x > xDelta)
  676. {
  677. x -= xDelta;
  678. int wmx2 = (w-x)*(w-x);
  680. PaintRect(pMemDC,
  681. x,
  682. 0,
  683. xDelta,
  684. h,
  685. RGB(r-(r*wmx2)/w2,
  686. g-(g*wmx2)/w2,
  687. b-(b*wmx2)/w2));
  688. }
  690. // Remainder paint black
  691. PaintRect(pMemDC,0,0,x,h,BLACK);
  693. /////////////////////////////////////////////////
  694. // End MSJ code
  695. /////////////////////////////////////////////////
  696. }
  697. }
  699. // Draw icon and caption buttons.
  700. // Note if you do not want these
  701. // buttons use the GBS_??? flags
  702. // to turn on/off. See constructor
  703. // comments for more details
  704. CRect rcButn(0,0,cxIcon,cyIcon);
  705. rcButn.DeflateRect(0,2);
  706. rcButn.left += 2;
  708. // Do we want the dock button?
  709. if(m_GBStyle & GBS_DOCKBUTTON)
  710. {
  711. m_rcIcon = rcButn;
  712. pMemDC->DrawFrameControl(&rcButn,
  713. DFC_CAPTION,
  714. DFCS_CAPTIONRESTORE);
  715. }
  716. else
  717. m_rcIcon.SetRect(-1,-1,-1,-1);
  719. rcButn += CPoint(w-cxIcon-2,0);
  721. // Do we want the close button?
  722. if(m_GBStyle & GBS_DOCKCLOSE)
  723. {
  724. m_rcClose = rcButn;
  725. pMemDC->DrawFrameControl(&rcButn,
  726. DFC_CAPTION,
  727. DFCS_CAPTIONCLOSE);
  728. }
  729. else
  730. m_rcClose.SetRect(-1,-1,-1,-1);
  732. CString str;
  734. // Do we want the application string?
  735. if((m_GBStyle & GBS_DOCKAPPST))
  736. {
  737. str = m_appString;
  738. if(m_GBStyle & GBS_DOCKTITLE)
  739. {
  740. str += _T(" - ");
  741. }
  742. }
  743. else
  744. str = _T(" ");
  746. CRect rcText = CRect(pRC->TopLeft(),
  747. pMemDC->GetTextExtent(str));
  749. // Use old fonts or create new if user
  750. // has changed system settings
  751. if (!m_fontCap.m_hObject)
  752. CreateFonts();
  754. CFont* pOldFont = pMemDC->SelectObject(&m_fontTitle);
  756. if(!(m_GBStyle & GBS_DOCKBUTTON))
  757. {
  758. rcText.left += 2;  
  759. rcText.right += 2;
  760. }
  761. else
  762. {
  763. rcText.left += cxIcon+2;  
  764. rcText.right += cxIcon+2;
  765. }
  767. // Set our text color
  768. COLORREF clrText;
  770. if (bActive)
  771. {
  772. clrText = GetSysColor(COLOR_CAPTIONTEXT);
  774. if(m_GBStyle & GBS_NOGRADIENT)
  775. {
  777. // If the current color will not show
  778. // up in the window let's brighten it
  779. // until it will
  780. while(GetLuminosity(clrText) < 90)
  781. {
  782. int r = GetRValue(clrText);
  783. int g = GetGValue(clrText);
  784. int b = GetBValue(clrText);
  786. r+= 20;
  787. g+= 20;
  788. b+= 20;
  789. clrText = RGB(r,
  790. g,
  791. b);
  792. }
  793. }
  794. } else
  795. clrText = GetSysColor(COLOR_INACTIVECAPTIONTEXT);
  797. pMemDC->SetBkMode(TRANSPARENT);
  798. pMemDC->SetTextColor(clrText);
  799. pMemDC->DrawText(str,
  800. &rcText,
  801. DT_LEFT|DT_VCENTER|DT_SINGLELINE|DT_END_ELLIPSIS);
  803. if(m_GBStyle & GBS_DOCKTITLE)
  804. {
  805. pMemDC->SelectObject(&m_fontCap);
  806. rcText.left += pMemDC->GetTextExtent(str).cx;
  807. str = GetBarTitle();
  808. rcText.right += pMemDC->GetTextExtent(str).cx + 4;
  810. if (rcText.right > rcText.left)
  811. {
  812. pMemDC->DrawText(GetBarTitle(),
  813. &rcText,
  814. DT_LEFT|DT_VCENTER|DT_SINGLELINE|DT_END_ELLIPSIS);
  815. } 
  816. }
  818. if(!(m_GBStyle & GBS_NOGRIPBARS))
  819. {
  820. // Draw the docking grippers
  821. CRect rect(5, 6, (5+w) - 30, 9);
  823. if((m_GBStyle & GBS_DOCKTITLE) ||
  824. (m_GBStyle & GBS_DOCKAPPST))
  825. {
  826. rect.left += rcText.right;
  827. }
  828. else
  829. {
  830. if(m_GBStyle & GBS_DOCKBUTTON)
  831. {
  832. rect.left = m_rcIcon.right + 2;
  833. }
  834. else
  835. {
  836. rect.left = 2;
  837. }
  839. }
  840. if(m_GBStyle & GBS_DOCKCLOSE)
  841. {
  842. rect.right = m_rcClose.left - 2;
  843. }
  844. else
  845. {
  846. rect.right = rcButn.right;
  847. }
  848. if (rect.right > rect.left)
  849. {
  850. pMemDC->Draw3dRect(rect,
  851. RGB(255,255,255),
  852. RGB(128,128,128));
  854. rect += CPoint(0, 4);
  855. pMemDC->Draw3dRect(rect,
  856. RGB(255,255,255),
  857. RGB(128,128,128));
  858. }
  859. }
  861. // Restore DC
  862. pMemDC->SelectObject(pOldFont);
  863. return;
  864. }
  866. DWORD CGripControl::HitTest(CPoint pt)
  867. {
  868. if(m_rcClose.PtInRect(pt))
  869. return (DWORD) GHT_CLOSE;
  870. else if(m_rcIcon.PtInRect(pt))
  871. return (DWORD) GHT_DOCKBUT;
  872. else
  873. return (DWORD) GHT_CAPTION;
  874. }
  876. void CGripControl::PaintRect(CDC* pDC, int x, int y, int w, int h, COLORREF color)
  877. {
  878. CBrush brush(color);
  879. CBrush* pOldBrush = pDC->SelectObject(&brush);
  880. pDC->PatBlt(x, y, w, h, PATCOPY);
  881. pDC->SelectObject(pOldBrush);
  882. }
  884. void CGripControl::UpdateBitmap(BOOL bActive, CDC * pMemDC, CDC * pWinDC)
  885. {
  887. // Get our Active or inactive bmp
  888. CBitmap& bmp = m_bmpCap[bActive != 0];
  890. // Get our draw region
  891. CRect rcCap;
  892. GetCaptionRect(&rcCap);
  894. // If we have a new Rect redraw
  895. // bmp otherwise use the old one
  896. if (rcCap != m_rcCap) {
  897. m_bmpCap[0].DeleteObject();
  898. m_bmpCap[1].DeleteObject();
  899. m_rcCap = rcCap;
  900. }
  902. // Make sure there is a valid bmp
  903. if (bmp.m_hObject)
  904. {
  905. pMemDC->SelectObject(&bmp);
  906. return;
  907. }
  909. // Erase old bmp
  910. bmp.DeleteObject();
  912. // Create new bmp
  913. bmp.CreateCompatibleBitmap(pWinDC,
  914. m_rcCap.Width(),
  915. m_rcCap.Height());
  916. pMemDC->SelectObject(&bmp);
  918. DrawOnBitmap(bActive, pMemDC, &m_rcCap);
  919. return;
  920. }
  922. BOOL CGripControl::OnEraseBkgnd(CDC* pDC)
  923. {
  924. CRect rect;
  926. m_pControlBar->GetCaptionRect(&rect);
  927. MoveWindow(rect, TRUE);
  928. return TRUE;
  929. }
  931. void CGripControl::OnLButtonDblClk(UINT nFlags, CPoint point) 
  932. {
  933. DWORD hitTest = HitTest(point);
  935. switch(hitTest)
  936. {
  937. case GHT_CAPTION:
  938. {
  939. m_pControlBar->ToggleDocking();
  940. }
  941. default:
  942. break;
  943. }
  944. }
  946. void CGripControl::OnLButtonDown(UINT nFlags, CPoint point) 
  947. {
  949. // Make sure if parent is app
  950. // when we click on ControlBar
  951. CWnd* Wnd = GetActiveWindow();
  952. CWnd* frm = AfxGetMainWnd();
  954. if(Wnd != frm)
  955. frm->SetActiveWindow();
  957. DWORD hitTest = HitTest(point);
  959. switch(hitTest)
  960. {
  961. case GHT_CAPTION:
  962. {
  963. CPoint pt = point;
  965. ClientToScreen(&point);
  966. m_pControlBar->StartDrag(point);
  967. return;
  968. }
  969. break;
  970. case GHT_CLOSE:
  971. {
  972. CClientDC dc(this);
  974. DrawFrameControl(dc.m_hDC,
  975. m_rcClose,
  976. DFC_CAPTION,
  977. DFCS_CAPTIONCLOSE | DFCS_PUSHED);
  978. }
  979. break;
  980. case GHT_DOCKBUT:
  981. {
  982. CClientDC dc(this);
  984. DrawFrameControl(dc.m_hDC,
  985. m_rcIcon,
  986. DFC_CAPTION,
  987. DFCS_CAPTIONRESTORE | DFCS_PUSHED);
  988. }
  989. break;
  990. default:
  991. break;
  992. }
  993. SetCapture();
  994. }
  996. void CGripControl::OnLButtonUp(UINT nFlags, CPoint point) 
  997. {
  998. if(this != GetCapture())
  999. return;
  1001. DWORD hitTest = HitTest(point);
  1003. switch(hitTest)
  1004. {
  1005. case GHT_CAPTION:
  1006. {
  1007. }
  1008. break;
  1009. case GHT_CLOSE:
  1010. {
  1011. CClientDC dc(this);
  1013. DrawFrameControl(dc.m_hDC,
  1014. m_rcClose,
  1015. DFC_CAPTION,
  1016. DFCS_CAPTIONCLOSE);
  1017. ReleaseCapture();
  1018. m_pControlBar->SendMessage(WM_CLOSE, 0,0);
  1019. }
  1020. break;
  1021. case GHT_DOCKBUT:
  1022. {
  1023. CClientDC dc(this);
  1025. DrawFrameControl(dc.m_hDC,
  1026. m_rcIcon,
  1027. DFC_CAPTION,
  1028. DFCS_CAPTIONRESTORE);
  1029. ReleaseCapture();
  1030. m_pControlBar->ToggleDocking();
  1031. return;
  1032. }
  1033. default:
  1034. break;
  1035. }
  1036. ReleaseCapture();
  1037. }
  1039. void CGripControl::OnMouseMove(UINT nFlags, CPoint point) 
  1040. {
  1041. if(this != GetCapture())
  1042. return;
  1044. DWORD hitTest = HitTest(point);
  1045. if(hitTest == m_prevHitTest)
  1046. return;
  1048. m_prevHitTest = hitTest;
  1050. CClientDC dc(this);
  1052. switch(hitTest)
  1053. {
  1054. case GHT_CAPTION:
  1055. {
  1056. DrawFrameControl(dc.m_hDC,
  1057. m_rcClose,
  1058. DFC_CAPTION,
  1059. DFCS_CAPTIONCLOSE);
  1060. DrawFrameControl(dc.m_hDC,
  1061. m_rcIcon,
  1062. DFC_CAPTION,
  1063. DFCS_CAPTIONRESTORE);
  1064. }
  1065. break;
  1066. case GHT_CLOSE:
  1067. {
  1068. DrawFrameControl(dc.m_hDC,
  1069. m_rcClose,
  1070. DFC_CAPTION,
  1071. DFCS_CAPTIONCLOSE | DFCS_PUSHED);
  1072. }
  1073. break;
  1074. case GHT_DOCKBUT:
  1075. {
  1076. CClientDC dc(this);
  1078. DrawFrameControl(dc.m_hDC,
  1079. m_rcIcon,
  1080. DFC_CAPTION,
  1081. DFCS_CAPTIONRESTORE | DFCS_PUSHED);
  1082. }
  1083. default:
  1084. break;
  1085. }
  1086. }
  1088. void CGripControl::OnPaint() 
  1089. {
  1090. CPaintDC dc(this); // device context for painting
  1091. OnNcDraw(&dc);
  1092. }
  1094. BOOL CGripControl::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message) 
  1095. {
  1096. ::SetCursor((HCURSOR) ::LoadCursor(NULL, IDC_ARROW));
  1097. return TRUE;
  1098. }
  1100. void CGripControl::OnSettingChange(UINT uFlags, LPCTSTR lpszSection) 
  1101. {
  1102. OnSysColorChange();
  1103. return;
  1104. }
  1106. void CGripControl::OnSysColorChange() 
  1107. {
  1108. Abolish();
  1109. }
  1112. /////////////////////////////////////////////////////////////////// 
  1113. // Class CExDocContext 
  1114. // 
  1115. // Class provides new behaviour for drawing the 
  1116. // track frame when floating 
  1117. // Rem out the code inside AdjustWindowForFloat() 
  1118. // to see original behaviour 
  1119. /////////////////////////////////////////////////////////////////// 
  1121. // Local defines
  1122. // Gain Access to MFC private DATA 
  1123. // Could change without warning 
  1124. #undef AFX_DATA 
  1125. #define AFX_DATA AFX_CORE_DATA 
  1127. extern AFX_DATA AUX_DATA afxData; 
  1129. // Macros from orginal DockCont.cpp 
  1130. #define HORZF(dw) (dw & CBRS_ORIENT_HORZ) 
  1131. #define VERTF(dw) (dw & CBRS_ORIENT_VERT) 
  1133. // Local functions
  1134. // Function from original DockCont.cpp 
  1135. static void AdjustRectangle(CRect& rect, CPoint pt) 
  1136. { 
  1137.  int nXOffset = (pt.x < rect.left) ? (pt.x - rect.left) : 
  1138.      (pt.x > rect.right) ? (pt.x - rect.right) : 0; 
  1139.  int nYOffset = (pt.y < rect.top) ? (pt.y - rect.top) : 
  1140.      (pt.y > rect.bottom) ? (pt.y - rect.bottom) : 0; 
  1141.  rect.OffsetRect(nXOffset, nYOffset); 
  1142. } 
  1144. ////////////////////////////////////////////////////////////////////// 
  1145. // Construction/Destruction 
  1146. ////////////////////////////////////////////////////////////////////// 
  1148. CExDockContext::CExDockContext(CControlBar* pBar) : CDockContext(pBar) 
  1149. { 
  1150.      // Default constructor passes control object 
  1151.      // to base class 
  1152. } 
  1154. CExDockContext::~CExDockContext() 
  1155. { 
  1156. } 
  1158. void CExDockContext::StartDrag(CPoint pt) 
  1159. { 
  1160.      ASSERT_VALID(m_pBar); 
  1162.  m_bDragging = TRUE; 
  1163.      InitLoop(); 
  1165.      if (m_pBar->m_dwStyle & CBRS_SIZE_DYNAMIC) 
  1166.      { 
  1167.           // get true bar size (including borders) 
  1168.           CRect rect; 
  1169.           m_pBar->GetWindowRect(rect); 
  1171.           // This is our added funtionality 
  1172.           // This overridable allows you 
  1173.           // to adjust the window rect so that 
  1174.           // you can hide controls like a caption 
  1175.           // bar from view 
  1176.           AdjustWindowForFloat(rect); 
  1178.           m_ptLast = pt; 
  1179.           CSize sizeHorz = m_pBar->CalcDynamicLayout(0, LM_HORZ | LM_HORZDOCK); 
  1180.           CSize sizeVert = m_pBar->CalcDynamicLayout(0, LM_VERTDOCK); 
  1181.           CSize sizeFloat = m_pBar->CalcDynamicLayout(0, LM_HORZ | LM_MRUWIDTH); 
  1183.           m_rectDragHorz = CRect(rect.TopLeft(), sizeHorz); 
  1184.           m_rectDragVert = CRect(rect.TopLeft(), sizeVert); 
  1186.           // calculate frame dragging rectangle 
  1187.           m_rectFrameDragHorz = CRect(rect.TopLeft(), sizeFloat); 
  1188.           m_rectFrameDragVert = CRect(rect.TopLeft(), sizeFloat); 
  1190. #ifdef _MAC 
  1191.           CMiniFrameWnd::CalcBorders(&m_rectFrameDragHorz, 
  1192.                WS_THICKFRAME | WS_CAPTION, WS_EX_FORCESIZEBOX); 
  1193.           CMiniFrameWnd::CalcBorders(&m_rectFrameDragVert, 
  1194.                WS_THICKFRAME | WS_CAPTION, WS_EX_FORCESIZEBOX); 
  1195. #else 
  1196.           CMiniFrameWnd::CalcBorders(&m_rectFrameDragHorz); 
  1197.           CMiniFrameWnd::CalcBorders(&m_rectFrameDragVert); 
  1198. #endif 
  1199.           m_rectFrameDragHorz.InflateRect(-afxData.cxBorder2, -afxData.cyBorder2); 
  1200.           m_rectFrameDragVert.InflateRect(-afxData.cxBorder2, -afxData.cyBorder2); 
  1201.      } 
  1202.      else if (m_pBar->m_dwStyle & CBRS_SIZE_FIXED) 
  1203.      { 
  1204.           // get true bar size (including borders) 
  1205.           CRect rect; 
  1206.           m_pBar->GetWindowRect(rect); 
  1208.           // This is our added funtionality 
  1209.           // This overridable allows you 
  1210.           // to adjust the window rect so that 
  1211.           // you can hide controls like a caption 
  1212.           // bar from view 
  1213.           AdjustWindowForFloat(rect); 
  1215.           m_ptLast = pt; 
  1216.           CSize sizeHorz = m_pBar->CalcDynamicLayout(-1, LM_HORZ | LM_HORZDOCK); 
  1217.           CSize sizeVert = m_pBar->CalcDynamicLayout(-1, LM_VERTDOCK); 
  1219.           // calculate frame dragging rectangle 
  1220.           m_rectFrameDragHorz = m_rectDragHorz = CRect(rect.TopLeft(), sizeHorz); 
  1221.           m_rectFrameDragVert = m_rectDragVert = CRect(rect.TopLeft(), sizeVert); 
  1223.           CMiniFrameWnd::CalcBorders(&m_rectFrameDragHorz); 
  1224.           CMiniFrameWnd::CalcBorders(&m_rectFrameDragVert); 
  1225.           m_rectFrameDragHorz.InflateRect(-afxData.cxBorder2, -afxData.cyBorder2); 
  1226.           m_rectFrameDragVert.InflateRect(-afxData.cxBorder2, -afxData.cyBorder2); 
  1227.      } 
  1228.      else 
  1229.      { 
  1230.           // get true bar size (including borders) 
  1231.           CRect rect; 
  1232.           m_pBar->GetWindowRect(rect); 
  1234.           // This is our added funtionality 
  1235.           // This overridable allows you 
  1236.           // to adjust the window rect so that 
  1237.           // you can hide controls like a caption 
  1238.           // bar from view 
  1239.           AdjustWindowForFloat(rect); 
  1241.           m_ptLast = pt; 
  1242.           BOOL bHorz = HORZF(m_dwStyle); 
  1243.           DWORD dwMode = !bHorz ? (LM_HORZ | LM_HORZDOCK) : LM_VERTDOCK; 
  1244.           CSize size = m_pBar->CalcDynamicLayout(-1, dwMode); 
  1246.           // calculate inverted dragging rect 
  1247.           if (bHorz) 
  1248.           { 
  1249.                m_rectDragHorz = rect; 
  1250.                m_rectDragVert = CRect(CPoint(pt.x - rect.Height()/2, rect.top), size); 
  1251.           } 
  1252.           else // vertical orientation 
  1253.           { 
  1254.                m_rectDragVert = rect; 
  1255.                m_rectDragHorz = CRect(CPoint(rect.left, pt.y - rect.Width()/2), size); 
  1256.           } 
  1258.           // calculate frame dragging rectangle 
  1259.           m_rectFrameDragHorz = m_rectDragHorz; 
  1260.           m_rectFrameDragVert = m_rectDragVert; 
  1262.           CMiniFrameWnd::CalcBorders(&m_rectFrameDragHorz); 
  1263.           CMiniFrameWnd::CalcBorders(&m_rectFrameDragVert); 
  1264.           m_rectFrameDragHorz.InflateRect(-afxData.cxBorder2, -afxData.cyBorder2); 
  1265.           m_rectFrameDragVert.InflateRect(-afxData.cxBorder2, -afxData.cyBorder2); 
  1266.      } 
  1268.      // adjust rectangles so that point is inside 
  1269.      AdjustRectangle(m_rectDragHorz, pt); 
  1270.      AdjustRectangle(m_rectDragVert, pt); 
  1271.      AdjustRectangle(m_rectFrameDragHorz, pt); 
  1272.      AdjustRectangle(m_rectFrameDragVert, pt); 
  1274.      // initialize tracking state and enter tracking loop 
  1275.      m_dwOverDockStyle = CanDock(); 
  1276.      Move(pt);   // call it here to handle special keys 
  1278.  // Here we call our new function Tracking
  1279.      Tracking(); 
  1280. } 
  1281.   
  1283. void CExDockContext::AdjustWindowForFloat(CRect& rect) 
  1284. { 
  1286.      // Overridable to adjust floating frame 
  1287.      // size for added controls you do not 
  1288.      // want to see in the floating state 
  1289.      // Default behavior is to move window 
  1290.      // up enough to hide the caption bar 
  1291.      if(m_pBar->IsFloating()) 
  1292.            rect.top += (GetSystemMetrics(SM_CYCAPTION) 
  1293.                + GetSystemMetrics(SM_CYFRAME)); 
  1294. } 
  1296. BOOL CExDockContext::Tracking()
  1297. {
  1299. // don't handle if capture already set
  1300. if (::GetCapture() != NULL)
  1301. return FALSE;
  1303. // set capture to the window which received this message
  1304. m_pBar->SetCapture();
  1305. ASSERT(m_pBar == CWnd::GetCapture());
  1307. #ifndef _MAC
  1308. // get messages until capture lost or cancelled/accepted
  1309. while (CWnd::GetCapture() == m_pBar)
  1310. {
  1311. MSG msg;
  1312. if (!::GetMessage(&msg, NULL, 0, 0))
  1313. {
  1314. AfxPostQuitMessage(msg.wParam);
  1315. break;
  1316. }
  1318. switch (msg.message)
  1319. {
  1320. case WM_NCLBUTTONUP:
  1321. m_pBar->SendMessage(WM_NCLBUTTONUP,
  1322. msg.wParam,
  1323. msg.lParam);
  1324. return TRUE;
  1325. case WM_LBUTTONUP:
  1326. if (m_bDragging)
  1327. EndDrag();
  1328. else
  1329. EndResize();
  1330. return TRUE;
  1331. case WM_MOUSEMOVE:
  1332. if (m_bDragging)
  1333. Move(msg.pt);
  1334. else
  1335. Stretch(msg.pt);
  1336. break;
  1337. case WM_KEYUP:
  1338. if (m_bDragging)
  1339. OnKey((int)msg.wParam, FALSE);
  1340. break;
  1341. case WM_KEYDOWN:
  1342. if (m_bDragging)
  1343. OnKey((int)msg.wParam, TRUE);
  1344. if (msg.wParam == VK_ESCAPE)
  1345. {
  1346. CancelLoop();
  1347. return FALSE;
  1348. }
  1349. break;
  1350. case WM_RBUTTONDOWN:
  1351. CancelLoop();
  1352. return FALSE;
  1354. // just dispatch rest of the messages
  1355. default:
  1356. DispatchMessage(&msg);
  1357. break;
  1358. }
  1359. }
  1360. #else
  1361. Point   ptCur = {0};
  1363. // get messages until capture lost or cancelled/accepted
  1364. while (CWnd::GetCapture() == m_pBar)
  1365. {
  1366. EventRecord     er;
  1368. if (OSEventAvail(everyEvent, &er))
  1369. {
  1370. GetNextEvent(everyEvent, &er);
  1371. switch (er.what)
  1372. {
  1373. case mouseUp:
  1374. if (m_bDragging)
  1375. EndDrag();
  1376. else
  1377. EndResize();
  1378. return TRUE;
  1380. case keyDown:
  1381. case keyUp:
  1382. case autoKey:
  1383. case app2Evt:
  1384. {
  1385. MSG     msg;
  1387. if (WrapEvent(&er, &msg, PM_REMOVE))
  1388. {
  1389. if (m_bDragging)
  1390. OnKey((int)msg.wParam, msg.message == WM_KEYDOWN);
  1391. if (msg.message == WM_KEYUP && msg.wParam == VK_ESCAPE)
  1392. {
  1393. CancelLoop();
  1394. return FALSE;
  1395. }
  1396. }
  1397. break;
  1398. }
  1400. default:
  1401. break;
  1402. }
  1403. }
  1404. else
  1405. {
  1406. if (!EqualPt(er.where, ptCur))
  1407. {
  1408. POINT pt = {er.where.h, er.where.v};
  1409. if (m_bDragging)
  1410. Move(pt);
  1411. else
  1412. Stretch(pt);
  1413. }
  1414. }
  1415. }
  1416. #endif
  1417. CancelLoop();
  1418. return FALSE;
  1419. }