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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 查看源码
ExtMiniDockFrameWnd.cpp
资源名称：profuis288_freeware.zip　[点击查看]
上传用户：sesekoo
上传日期：2020-07-18
资源大小：21543k
文件大小：60k
源码类别：

界面编程

开发平台：

Visual C++

ExtMiniDockFrameWnd.cpp：源码内容
  1. // This is part of the Professional User Interface Suite library.
  2. // Copyright (C) 2001-2009 FOSS Software, Inc.
  3. // All rights reserved.
  4. //
  5. // http://www.prof-uis.com
  6. // mailto:support@prof-uis.com
  7. //
  8. // This source code can be used, modified and redistributed
  9. // under the terms of the license agreement that is included
  10. // in the Professional User Interface Suite package.
  11. //
  12. // Warranties and Disclaimers:
  13. // THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND
  14. // INCLUDING, BUT NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY,
  15. // FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  16. // IN NO EVENT WILL FOSS SOFTWARE INC. BE LIABLE FOR ANY DIRECT,
  17. // INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES,
  18. // INCLUDING DAMAGES FOR LOSS OF PROFITS, LOSS OR INACCURACY OF DATA,
  19. // INCURRED BY ANY PERSON FROM SUCH PERSON'S USAGE OF THIS SOFTWARE
  20. // EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
  22. #include "stdafx.h"
  24. #if( !defined __EXTMINIDOCKFRAMEWND_H)
  25. #include "ExtMiniDockFrameWnd.h"
  26. #endif
  28. #if (!defined __EXTDOCKBAR_H)
  29. #include "ExtDockBar.h"
  30. #endif
  32. #if (!defined __EXT_MFC_NO_TAB_CONTROLBARS)
  33. #if (!defined __EXT_CONTROLBAR_TABBED_FEATURES_H)
  34. #include "ExtControlBarTabbedFeatures.h"
  35. #endif // __EXT_CONTROLBAR_TABBED_FEATURES_H
  36. #endif // (!defined __EXT_MFC_NO_TAB_CONTROLBARS)
  38. #if (!defined __EXT_MEMORY_DC_H)
  39. #include <../Src/ExtMemoryDC.h>
  40. #endif
  42. #if _MFC_VER < 0x700
  43. #include <../src/AfxImpl.h>
  44. #else
  45. #ifndef __AFXSTATE_H__
  46. #include <../src/mfc/afxstat_.h>
  47. #endif
  48. #include <../src/mfc/AfxImpl.h>
  49. #endif
  51. #ifdef _DEBUG
  52. #define new DEBUG_NEW
  53. #undef THIS_FILE
  54. static char THIS_FILE[] = __FILE__;
  55. #endif
  57. #define __REMOVED_NONFIXMODE_STYLES 
  58. FWS_SNAPTOBARS
  60. #define __REMOVED_STYLES_NORMAL 
  61. (MFS_4THICKFRAME|WS_THICKFRAME|WS_CAPTION|WS_BORDER|WS_DLGFRAME)
  62. //|WS_SYSMENU
  64. #define __REMOVED_STYLES_EXTENDED 
  65. (WS_EX_STATICEDGE|WS_EX_WINDOWEDGE|WS_EX_DLGMODALFRAME)
  66. // (WS_EX_TOOLWINDOW|WS_EX_STATICEDGE|WS_EX_WINDOWEDGE|WS_EX_DLGMODALFRAME)
  68. #define __SWP_FOR_REMOVED_STYLES 
  69. (SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOCOPYBITS|SWP_NOZORDER|SWP_NOOWNERZORDER|SWP_NOSIZE|SWP_NOMOVE|SWP_NOSENDCHANGING|SWP_NOREDRAW)
  71. #define __cSM_CMONITORS            80
  72. #define __cSM_CXVIRTUALSCREEN      78
  73. #define __cSM_CYVIRTUALSCREEN      79
  74. #define __cSM_XVIRTUALSCREEN       76
  75. #define __cSM_YVIRTUALSCREEN       77
  77. /////////////////////////////////////////////////////////////////////////////
  78. // CExtMiniDockFrameWnd
  80. bool CExtMiniDockFrameWnd::g_bOnWndPosChgProcessing = false;
  81. bool CExtMiniDockFrameWnd::g_bAutoMakeTopmostOnMouseEvent = false;
  83. IMPLEMENT_DYNCREATE( CExtMiniDockFrameWnd, CMiniDockFrameWnd );
  84. IMPLEMENT_CExtPmBridge_MEMBERS( CExtMiniDockFrameWnd );
  86. CExtMiniDockFrameWnd::CExtMiniDockFrameWnd()
  87. : m_bMovingLargeBar( false )
  88. , m_bHelperNcActive( false )
  89. {
  90. m_rcBtnHideBar.SetRectEmpty();
  91. m_rcFrameCaption.SetRectEmpty();
  92. m_bBtnHideBar = false;
  93. m_nResizingMode = HTNOWHERE;
  94. m_ptLastResizing.x = m_ptLastResizing.y = -32767;
  95. m_ptResizingShift.x = m_ptResizingShift.y = 0;
  96. RegisterMiniDockFrameWndClass();
  97. PmBridge_Install();
  98. }
  100. CExtMiniDockFrameWnd::~CExtMiniDockFrameWnd()
  101. {
  102. PmBridge_Uninstall();
  103. }
  105. void CExtMiniDockFrameWnd::PmBridge_OnPaintManagerChanged(
  106. CExtPaintManager * pGlobalPM
  107. )
  108. {
  109. CExtPmBridge::PmBridge_OnPaintManagerChanged( pGlobalPM );
  110. if( GetSafeHwnd() == NULL )
  111. return;
  112. ::SetWindowPos(
  113. m_hWnd, NULL, 0, 0, 0, 0,
  114. SWP_FRAMECHANGED
  115. |SWP_NOACTIVATE
  116. |SWP_NOZORDER
  117. |SWP_NOOWNERZORDER
  118. |SWP_NOMOVE
  119. |SWP_NOSIZE
  120. );
  121. ::RedrawWindow(
  122. m_hWnd, NULL, NULL,
  123. RDW_INVALIDATE|RDW_ERASE|RDW_FRAME|RDW_ALLCHILDREN
  124. );
  125. }
  127. BEGIN_MESSAGE_MAP(CExtMiniDockFrameWnd, CMiniDockFrameWnd)
  128.     //{{AFX_MSG_MAP(CExtMiniDockFrameWnd)
  129. ON_WM_NCMOUSEMOVE()
  130. ON_WM_TIMER()
  131. ON_WM_CLOSE()
  132. ON_WM_NCPAINT()
  133. ON_WM_NCACTIVATE()
  134. ON_WM_NCLBUTTONDOWN()
  135. ON_WM_NCLBUTTONUP()
  136. ON_WM_NCRBUTTONDOWN()
  137.     ON_WM_GETMINMAXINFO()
  138. ON_WM_WINDOWPOSCHANGING()
  139. ON_WM_WINDOWPOSCHANGED()
  140. ON_WM_SIZE()
  141. ON_WM_MOUSEMOVE()
  142. ON_WM_CAPTURECHANGED()
  143. ON_WM_LBUTTONUP()
  144. ON_WM_RBUTTONDOWN()
  145. ON_WM_ERASEBKGND()
  146. ON_WM_NCLBUTTONDBLCLK()
  147. ON_WM_CANCELMODE()
  148. ON_WM_PAINT()
  149. ON_WM_NCCALCSIZE()
  150. //}}AFX_MSG_MAP
  151. __EXT_MFC_ON_WM_NCHITTEST()
  152. ON_WM_SYSCOLORCHANGE()
  153. __EXT_MFC_SAFE_ON_WM_SETTINGCHANGE()
  154. ON_MESSAGE(WM_DISPLAYCHANGE, OnDisplayChange)
  155. ON_MESSAGE(__ExtMfc_WM_THEMECHANGED, OnThemeChanged)
  156. END_MESSAGE_MAP()
  158. void CExtMiniDockFrameWnd::OnSysColorChange() 
  159. {
  160. ASSERT_VALID( this );
  161. CMiniDockFrameWnd::OnSysColorChange();
  162. //CExtPaintManager * pPM = PmBridge_GetPM();
  163. // g_PaintManager.OnSysColorChange( this );
  164. // g_CmdManager.OnSysColorChange( pPM, this );
  165. Invalidate();
  166. }
  168. LRESULT CExtMiniDockFrameWnd::OnDisplayChange( WPARAM wParam, LPARAM lParam )
  169. {
  170. LRESULT lResult = CMiniDockFrameWnd::OnDisplayChange( wParam, lParam );
  171. //CExtPaintManager * pPM = PmBridge_GetPM();
  172. // g_PaintManager.OnDisplayChange( this, (INT)wParam, CPoint(lParam) );
  173. // g_CmdManager.OnDisplayChange( pPM, this, (INT)wParam, CPoint(lParam) );
  174. Invalidate();
  175. return lResult;
  176. }
  178. LRESULT CExtMiniDockFrameWnd::OnThemeChanged( WPARAM wParam, LPARAM lParam )
  179. {
  180. LRESULT lResult = Default();
  181. CExtPaintManager * pPM = PmBridge_GetPM();
  182. g_PaintManager.OnThemeChanged( this, wParam, lParam );
  183. g_CmdManager.OnThemeChanged( pPM, this, wParam, lParam );
  184. ::SetWindowPos(
  185. m_hWnd, NULL, 0, 0, 0, 0,
  186. SWP_FRAMECHANGED
  187. |SWP_NOACTIVATE
  188. |SWP_NOZORDER
  189. |SWP_NOOWNERZORDER
  190. |SWP_NOMOVE
  191. |SWP_NOSIZE
  192. );
  193. RecalcLayout();
  194. CExtControlBar * pExtBar = GetControlBarExt();
  195. if( pExtBar != NULL )
  196. {
  197. VERIFY(
  198. PmBridge_GetPM()->Bar_MiniDockFrameCaptionCalcRect(
  199. m_rcFrameCaption,
  200. this,
  201. pExtBar
  202. ) 
  203. );
  204. SetTimer( 1, 1, NULL );
  205. } // if( pExtBar != NULL )
  206. return lResult;
  207. }
  209. void CExtMiniDockFrameWnd::OnSettingChange(UINT uFlags, __EXT_MFC_SAFE_LPCTSTR lpszSection) 
  210. {
  211. ASSERT_VALID( this );
  212. CMiniDockFrameWnd::OnSettingChange(uFlags, lpszSection);
  213. //CExtPaintManager * pPM = PmBridge_GetPM();
  214. // g_PaintManager.OnSettingChange( this, uFlags, lpszSection );
  215. // g_CmdManager.OnSettingChange( pPM, this, uFlags, lpszSection );
  216. ::SetWindowPos(
  217. m_hWnd, NULL, 0, 0, 0, 0,
  218. SWP_FRAMECHANGED
  219. |SWP_NOACTIVATE
  220. |SWP_NOZORDER
  221. |SWP_NOOWNERZORDER
  222. |SWP_NOMOVE
  223. |SWP_NOSIZE
  224. );
  225. RecalcLayout();
  226. CExtControlBar * pExtBar = GetControlBarExt();
  227. if( pExtBar != NULL )
  228. {
  229. VERIFY(
  230. PmBridge_GetPM()->Bar_MiniDockFrameCaptionCalcRect(
  231. m_rcFrameCaption,
  232. this,
  233. pExtBar
  234. ) 
  235. );
  236. SetTimer( 1, 1, NULL );
  237. } // if( pExtBar != NULL )
  238. }
  240. BOOL CExtMiniDockFrameWnd::Create(CWnd* pParent, DWORD dwBarStyle)
  241. {
  242. // if(!MDFW_Create(pParent, dwBarStyle))
  243. // return FALSE;
  244. if( ! CMiniDockFrameWnd::Create(
  245. pParent,
  246. dwBarStyle
  247. )
  248. )
  249. return FALSE;
  251. ModifyStyle( 0, WS_CLIPCHILDREN|WS_CLIPSIBLINGS );
  252. m_wndDockBar.ModifyStyle( 0, WS_CLIPCHILDREN|WS_CLIPSIBLINGS );
  254. if( ( (m_wndDockBar.GetExStyle()&(WS_EX_LAYOUTRTL|WS_EX_RTLREADING)) != 0 ) )
  255. {
  256. m_wndDockBar.ModifyStyleEx(
  257. WS_EX_LAYOUTRTL|WS_EX_RTLREADING,
  258. 0,
  259. SWP_FRAMECHANGED
  260. );
  261. ASSERT( (m_wndDockBar.GetExStyle()&(WS_EX_LAYOUTRTL|WS_EX_RTLREADING)) == 0 );
  262. } // if( ( (m_wndDockBar.GetExStyle()&(WS_EX_LAYOUTRTL|WS_EX_RTLREADING)) != 0 ) )
  264. if( GetStyle() & __REMOVED_STYLES_NORMAL )
  265. ModifyStyle( __REMOVED_STYLES_NORMAL, 0, __SWP_FOR_REMOVED_STYLES );
  266. if( GetExStyle() & __REMOVED_STYLES_EXTENDED )
  267. ModifyStyleEx( __REMOVED_STYLES_EXTENDED, 0, __SWP_FOR_REMOVED_STYLES );
  269. if( ( (CWnd::GetExStyle()&(WS_EX_LAYOUTRTL|WS_EX_RTLREADING)) != 0 ) )
  270. {
  271. CWnd::ModifyStyleEx(
  272. WS_EX_LAYOUTRTL|WS_EX_RTLREADING,
  273. 0,
  274. SWP_FRAMECHANGED
  275. );
  276. ASSERT( (CWnd::GetExStyle()&(WS_EX_LAYOUTRTL|WS_EX_RTLREADING)) == 0 );
  277. } // if( ( (CWnd::GetExStyle()&(WS_EX_LAYOUTRTL|WS_EX_RTLREADING)) != 0 ) )
  279. SetTimer( 1, 1, NULL );
  280. EnableToolTips();
  281. m_wndToolTip.Create( this );
  282. m_wndToolTip.Activate( TRUE );
  284. return TRUE;
  285. }
  287. void CExtMiniDockFrameWnd::OnNcLButtonUp(UINT nHitTest, CPoint point)
  288. {
  289. if( _ResizingIsInProgress() )
  290. {
  291. _ResizingEnd();
  292. return;
  293. }
  295. if( CExtControlBar::_DraggingGetBar() != NULL )
  296. return;
  298. CRect rcBarWnd;
  299. GetWindowRect( &rcBarWnd );
  300. CPoint ptDevOffset = -rcBarWnd.TopLeft();
  301. CPoint ptWnd( point + ptDevOffset );
  303. CExtControlBar * pExtBar = GetControlBarExt();
  304. if( pExtBar != NULL && pExtBar->m_bNcAreaBtnTracking )
  305. {
  306. INT nCountOfNcButtons = pExtBar->NcButtons_GetCount();
  307. for( INT nBtn = 0; nBtn < nCountOfNcButtons; nBtn++ )
  308. {
  309. CExtBarNcAreaButton * pBtn =
  310. pExtBar->NcButtons_GetAt( nBtn );
  311. if( !pBtn->OnQueryVisibility() )
  312. continue;
  313. if( pBtn->OnNcAreaClicked( ptWnd ) )
  314. return;
  315. } // for( INT nBtn = 0; nBtn < nCountOfNcButtons; nBtn++ )
  316. return;
  317. } // if( pExtBar != NULL && pExtBar->m_bNcAreaBtnTracking )
  319. CMiniDockFrameWnd::OnNcLButtonUp(nHitTest, point);
  320. }
  322. void CExtMiniDockFrameWnd::OnNcLButtonDown(UINT nHitTest, CPoint point)
  323. {
  324. #if (!defined __EXT_MFC_NO_CUSTOMIZE)
  325. CExtCustomizeSite * pSite =
  326. CExtCustomizeSite::GetCustomizeSite( m_hWnd );
  327. if( pSite != NULL
  328. && pSite->IsCustomizeMode()
  329. )
  330. pSite->DropTargetPopupCancel();
  331. #endif // (!defined __EXT_MFC_NO_CUSTOMIZE)
  333. CExtControlBar * pExtBar = GetControlBarExt();
  334. CPoint p(point);
  335. CRect rcWnd;
  336. GetWindowRect( &rcWnd );
  337. p.Offset( -rcWnd.left, -rcWnd.top );
  338. if( m_rcBtnHideBar.PtInRect( p ) )
  339. return;
  340. if( nHitTest == HTCAPTION )
  341. {
  342. ActivateTopParent();
  343. if( pExtBar != NULL
  344. && (! pExtBar->_IsDockSiteCustomizeMode() )
  345. )
  346. BringWindowToTop();
  347. if( (m_wndDockBar.m_dwStyle & CBRS_FLOAT_MULTI) == 0 )
  348. {
  349. int nPos = 1;
  350. CControlBar* pBar = NULL;
  351. while(
  352. pBar == NULL
  353. && nPos < m_wndDockBar.m_arrBars.GetSize()
  354. )
  355. pBar =
  356. reinterpret_cast < CExtDockBar & >
  357. (m_wndDockBar). GetDockedControlBar(nPos++);
  358. ASSERT( pBar != NULL );
  359. ASSERT_KINDOF( CControlBar, pBar );
  360. ASSERT( pBar->m_pDockContext != NULL );
  361. if( pExtBar == NULL
  362. || ( pExtBar != NULL
  363. && pExtBar->IsFixedMode()
  364. && !pExtBar->_IsShowContentWhenDragging()
  365. )
  366. )
  367. {
  368. pBar->m_pDockContext->StartDrag(point);
  369. return;
  370. }
  371. CRect rcGrip = pExtBar->_RectGripGet();
  372. int nCyGripper = min( rcGrip.Width(), rcGrip.Height() );
  373. pExtBar->_DraggingStart(
  374. point,
  375. point
  376. - rcWnd.TopLeft()
  377. - CPoint( nCyGripper, nCyGripper/2 )
  378. );
  379. return;
  380. }
  381. }
  382. else if( nHitTest >= HTSIZEFIRST && nHitTest <= HTSIZELAST )
  383. {
  384. ActivateTopParent();
  385. int nPos = 1;
  386. CControlBar * pBar = NULL;
  387. while(
  388. pBar == NULL
  389. && nPos < m_wndDockBar.m_arrBars.GetSize()
  390. )
  391. pBar =
  392. reinterpret_cast < CExtDockBar & >
  393. (m_wndDockBar).GetDockedControlBar(nPos++);
  394. ASSERT( pBar != NULL );
  395. ASSERT_KINDOF( CControlBar, pBar );
  396. ASSERT( pBar->m_pDockContext != NULL );
  397. ASSERT( (m_wndDockBar.m_dwStyle & CBRS_FLOAT_MULTI) == 0 );
  398. if( ! pBar->IsKindOf( RUNTIME_CLASS(CExtControlBar) ) )
  399. CMiniDockFrameWnd::OnNcLButtonDown( nHitTest, point);
  400. else
  401. {
  402. CExtControlBar * pExtBar =
  403. (CExtControlBar *)pBar;
  404. if( !pExtBar->_IsShowContentWhenDragging()
  405. && pExtBar->IsFixedMode()
  406. )
  407. {
  408. pBar->m_pDockContext->StartResize( nHitTest, point );
  409. return;
  410. }
  411. ClientToScreen( &point );
  412. _ResizingStart( nHitTest, point );
  413. }
  414. return;
  415. }
  416. else if( nHitTest == HTMINBUTTON
  417. || nHitTest == HTMAXBUTTON
  418. || nHitTest == HTGROWBOX
  419. )
  420. return;
  422. CMiniFrameWnd::OnNcLButtonDown( nHitTest, point );
  423. }
  425. void CExtMiniDockFrameWnd::OnNcLButtonDblClk(UINT nHitTest, CPoint point) 
  426. {
  427. if( nHitTest == HTCAPTION )
  428. {
  429. CRect rcWnd;
  430. GetWindowRect( &rcWnd );
  431. CPoint ptTestBtnHideBar( point - rcWnd.TopLeft() );
  432. if( m_rcBtnHideBar.PtInRect(ptTestBtnHideBar) )
  433. return;
  434. } // if( nHitTest == HTCAPTION )
  436. CExtControlBar * pExtBar = GetControlBarExt();
  437. if( pExtBar != NULL )
  438. {
  439. ASSERT_VALID( pExtBar );
  440. if( ! pExtBar->_FloatStateChangingIsEnabled( pExtBar ) )
  441. return;
  442. pExtBar->ToggleDocking();
  443. return;
  444. }
  446. CMiniDockFrameWnd::OnNcLButtonDblClk(nHitTest, point);
  447. }
  449. void CExtMiniDockFrameWnd::_ResizingStart(
  450. UINT nHitTest,
  451. const CPoint & point
  452. )
  453. {
  454. ASSERT( m_nResizingMode == HTNOWHERE );
  455. ASSERT( IsWindowVisible() );
  457. CPoint pointCurrentCursorPos = point;
  458. ScreenToClient( &pointCurrentCursorPos );
  460. CExtPopupMenuWnd::CancelMenuTracking();
  461. CWnd::CancelToolTips();
  463. CExtControlBar * pExtBar = GetControlBarExt();
  464. ASSERT_VALID( pExtBar );
  465. if( ! pExtBar->_FloatStateChangingIsEnabled( pExtBar ) )
  466. return;
  468. if( ( ! pExtBar->_IsShowContentWhenDragging() )
  469. && pExtBar->IsFixedMode()
  470. )
  471. {
  472. m_nResizingMode = HTNOWHERE;
  473. pExtBar->m_pDockContext->StartResize(nHitTest, point);
  474. return;
  475. }
  477. switch( nHitTest )
  478. {
  479. case HTLEFT:
  480. case HTRIGHT:
  481. case HTTOP:
  482. case HTTOPLEFT:
  483. case HTTOPRIGHT:
  484. case HTBOTTOM:
  485. case HTBOTTOMLEFT:
  486. case HTBOTTOMRIGHT:
  487. m_nResizingMode = nHitTest;
  488. break;
  489. default:
  490. return;
  491. } // switch( nHitTest )
  493. #ifdef _DEBUG
  494. int nPos = 1;
  495. CControlBar * pDebugDummyBar = NULL;
  496. while(
  497. pDebugDummyBar == NULL
  498. && nPos < m_wndDockBar.m_arrBars.GetSize()
  499. )
  500. pDebugDummyBar =
  501. reinterpret_cast < CExtDockBar & >
  502. ( m_wndDockBar ) . GetDockedControlBar( nPos++ );
  503. ASSERT( pDebugDummyBar != NULL );
  504. ASSERT_KINDOF( CExtControlBar, pDebugDummyBar );
  505. ASSERT( pDebugDummyBar->m_pDockContext != NULL );
  506. // CBRS_SIZE_DYNAMIC toolbars cannot have the CBRS_FLOAT_MULTI style
  507. ASSERT( (m_wndDockBar.m_dwStyle & CBRS_FLOAT_MULTI) == 0 );
  508. #endif // _DEBUG
  510. ASSERT( pExtBar == pDebugDummyBar );
  511. ASSERT( pExtBar->m_pDockContext != NULL );
  513. if( ! pExtBar->IsFixedMode() )
  514. ModifyStyle( __REMOVED_NONFIXMODE_STYLES, 0 );
  515. BringWindowToTop();
  516. CExtMouseCaptureSink::SetCapture( GetSafeHwnd() );
  517. GetWindowRect( &m_rcWndResizingStart );
  519. HWND hWndExtBar = pExtBar->m_hWnd;
  520. pExtBar->OnControlBarPositionChange(
  521. pExtBar,
  522. CExtControlBar::__ECBPC_FLOATING_FRAME_RESIZING,
  523. true,
  524. false
  525. );
  527. _ResizingUpdateState( pointCurrentCursorPos );
  528. pExtBar->OnControlBarPositionChange(
  529. pExtBar,
  530. CExtControlBar::__ECBPC_FLOATING_FRAME_RESIZING,
  531. false,
  532. false
  533. );
  535. while( m_nResizingMode != HTNOWHERE )
  536. {
  537. ::WaitMessage();
  538. MSG msg;
  539. // Process all the messages in the message queue
  540. while( PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE) )
  541. {
  542. bool bStop = false;
  543. switch( msg.message )
  544. {
  545. case WM_ACTIVATEAPP:
  546. case WM_COMMAND:
  547. bStop = true;
  548. break;
  549. default:
  550. if( WM_KEYFIRST <= msg.message
  551. && msg.message <= WM_KEYLAST
  552. )
  553. bStop = true;
  554. break;
  555. case WM_MOUSEMOVE:
  556. if( _ResizingIsInProgress() )
  557. {
  558. PeekMessage(&msg, NULL, WM_MOUSEMOVE, WM_MOUSEMOVE, PM_REMOVE);
  559. for( ; PeekMessage(&msg, NULL, WM_MOUSEMOVE, WM_MOUSEMOVE, PM_NOREMOVE); )
  560. PeekMessage(&msg, NULL, WM_MOUSEMOVE, WM_MOUSEMOVE, PM_REMOVE);
  561. if( ::GetCursorPos( &pointCurrentCursorPos ) )
  562. {
  563. _ResizingUpdateState( pointCurrentCursorPos );
  564. pExtBar->OnControlBarPositionChange(
  565. pExtBar,
  566. CExtControlBar::__ECBPC_FLOATING_FRAME_RESIZING,
  567. false,
  568. false
  569. );
  570. }
  571. continue;
  572. } // if( _ResizingIsInProgress() )
  573. break;
  574. } // switch( msg.message )
  575. if( (!bStop) &&
  576. CExtMouseCaptureSink::GetCapture() != GetSafeHwnd()
  577. )
  578. bStop = true;
  579. if( bStop )
  580. {
  581. _ResizingEnd();
  582. if( ::IsWindow( hWndExtBar ) )
  583. pExtBar->OnControlBarPositionChange(
  584. pExtBar,
  585. CExtControlBar::__ECBPC_FLOATING_FRAME_RESIZING,
  586. false,
  587. true
  588. );
  589. return;
  590. }
  591. if( !AfxGetThread()->PumpMessage() )
  592. {
  593. PostQuitMessage(0);
  594. return; // Signal WM_QUIT received
  595. } // if( !AfxGetThread()->PumpMessage() )
  596. } // while( PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE) )
  598. if( CExtControlBar::g_bEnableOnIdleCalls )
  599. {
  600. for( LONG nIdleCounter = 0L;
  601. ::AfxGetThread()->OnIdle(nIdleCounter);
  602. nIdleCounter ++
  603. );
  604. }
  605. } // while( m_nResizingMode != HTNOWHERE )
  607. if( ::IsWindow( hWndExtBar ) )
  608. pExtBar->OnControlBarPositionChange(
  609. pExtBar,
  610. CExtControlBar::__ECBPC_FLOATING_FRAME_RESIZING,
  611. false,
  612. true
  613. );
  614. }
  616. void CExtMiniDockFrameWnd::_ResizingEnd()
  617. {
  618. m_ptLastResizing.x = m_ptLastResizing.y = -32767;
  619. m_ptResizingShift.x = m_ptResizingShift.y = 0;
  620. //ASSERT( m_nResizingMode != HTNOWHERE );
  621. if( m_nResizingMode == HTNOWHERE )
  622. return;
  623. if( CExtMouseCaptureSink::GetCapture() == GetSafeHwnd() )
  624. CExtMouseCaptureSink::ReleaseCapture();
  625. CExtControlBar * pExtBar = GetControlBarExt();
  626. ASSERT_VALID( pExtBar );
  627. if( !pExtBar->IsFixedMode() )
  628. ModifyStyle( 0, __REMOVED_NONFIXMODE_STYLES );
  629. m_nResizingMode = HTNOWHERE;
  630. }
  632. bool CExtMiniDockFrameWnd::g_bInResizingUpdateState = false;
  634. void CExtMiniDockFrameWnd::_ResizingUpdateState(
  635. const CPoint & point
  636. )
  637. {
  638. if( g_bInResizingUpdateState
  639. || m_ptLastResizing == point
  640. )
  641. return;
  642. CPoint _pt( point );
  643. ASSERT( m_nResizingMode != HTNOWHERE );
  644. CRect rcWnd, rcClient;
  645. GetWindowRect( &rcWnd );
  646. GetClientRect( &rcClient );
  647. CExtControlBar * pExtBar = GetControlBarExt();
  648. ASSERT_VALID( pExtBar );
  649. bool bFixedMode = pExtBar->IsFixedMode();
  651. if( m_ptLastResizing.x == -32767 && m_ptLastResizing.y == -32767 )
  652. { // adjust "point" parameter by border location
  653. CRect rcClientScreen = rcClient;
  654. ClientToScreen( &rcClientScreen );
  655. m_ptResizingShift.x = m_ptResizingShift.y = 0;
  656. bool bAdjustTop = false, bAdjustBottom = false, bAdjustLeft = false, bAdjustRight = false;
  657. switch( m_nResizingMode )
  658. {
  659. case HTTOP:
  660. bAdjustTop = true;
  661. break;
  662. case HTBOTTOM:
  663. bAdjustBottom = true;
  664. break;
  665. case HTLEFT:
  666. bAdjustLeft = true;
  667. break;
  668. case HTRIGHT:
  669. bAdjustRight = true;
  670. break;
  671. case HTTOPLEFT:
  672. bAdjustTop = true;
  673. bAdjustLeft = true;
  674. break;
  675. case HTTOPRIGHT:
  676. bAdjustTop = true;
  677. bAdjustRight = true;
  678. break;
  679. case HTBOTTOMLEFT:
  680. bAdjustBottom = true;
  681. bAdjustLeft = true;
  682. break;
  683. case HTBOTTOMRIGHT:
  684. bAdjustBottom = true;
  685. bAdjustRight = true;
  686. break;
  687. } // switch( m_nResizingMode )
  688. if( bAdjustTop )
  689. {
  690. m_ptResizingShift.y += _pt.y - rcWnd.top;
  691. if( bFixedMode )
  692. m_ptResizingShift.y += rcClientScreen.top - rcWnd.top;
  693. }
  694. if( bAdjustBottom )
  695. {
  696. m_ptResizingShift.y += rcWnd.bottom - _pt.y;
  697. if( bFixedMode )
  698. m_ptResizingShift.y -= rcWnd.bottom - rcClientScreen.bottom;
  699. }
  700. if( bAdjustLeft )
  701. {
  702. m_ptResizingShift.x += _pt.x - rcWnd.left;
  703. if( bFixedMode )
  704. m_ptResizingShift.y += rcClientScreen.left - rcWnd.left;
  705. }
  706. if( bAdjustRight )
  707. {
  708. m_ptResizingShift.x += rcWnd.right - _pt.x;
  709. if( bFixedMode )
  710. m_ptResizingShift.y += rcWnd.right - rcClientScreen.right;
  711. }
  712. } // adjust "point" parameter by border location
  713. _pt += m_ptResizingShift;
  715. //TRACE2( "m_ptResizingShift = %d, %drn", m_ptResizingShift.x, m_ptResizingShift.y );
  717. #ifdef __FREIWALD_ORIGINAL__
  718. m_ptLastResizing = _pt;
  719. #else
  721. // store the coordinates of "point" here,
  722. // because "point is the base value for the above comparation
  724. m_ptLastResizing = point;
  725. #endif 
  727. g_bInResizingUpdateState = true;
  729. CRect rcClientOrg, rcWndOrg;
  730. rcClientOrg = rcClient;
  731. rcWndOrg = rcWnd;
  732. CSize sizeDiff =
  733. rcWnd.Size() - rcClient.Size();
  734. ASSERT( sizeDiff.cx >= 0 && sizeDiff.cy >= 0 );
  735. CSize sizeNcDiff( sizeDiff );
  737. int nCalcMinHW = pExtBar->_CalcDesiredMinHW();
  738. int nCalcMinVH = pExtBar->_CalcDesiredMinVH();
  739. if( sizeDiff.cx < nCalcMinHW )
  740. sizeDiff.cx = nCalcMinHW;
  741. if( sizeDiff.cy < nCalcMinVH )
  742. sizeDiff.cy = nCalcMinVH;
  744. UINT nHit = m_nResizingMode;
  745. bool bLeft = false, bTop = false, bHorz = false,
  746. bInvTop = false, bInvLeft = false;
  747. CPoint ptOffsetWnd( 0, 0 );
  748. if( bFixedMode )
  749. {
  750. switch( nHit )
  751. {
  752. case HTTOPLEFT:
  753. case HTTOPRIGHT:
  754. nHit = HTTOP;
  755. break;
  756. case HTBOTTOMLEFT:
  757. case HTBOTTOMRIGHT:
  758. nHit = HTBOTTOM;
  759. break;
  760. } // switch( nHit )
  761. switch( nHit )
  762. {
  763. case HTTOP:
  764. _pt.y =
  765. rcWndOrg.bottom
  766. + rcWndOrg.top - _pt.y;
  767. nHit = HTBOTTOM;
  768. bInvLeft = true;
  769. bInvTop = true;
  770. break;
  771. case HTLEFT:
  772. _pt.x =
  773. rcWndOrg.right
  774. + rcWndOrg.left - _pt.x;
  775. nHit = HTRIGHT;
  776. bInvLeft = true;
  777. bInvTop = true;
  778. break;
  779. } // switch( nHit )
  780. } // if( bFixedMode )
  781. if( bInvLeft || bInvTop || (! bFixedMode ) )
  782. {
  783. CRect rcWnd( rcWndOrg );
  784. ScreenToClient( & rcWnd );
  785. if( bInvLeft || (! bFixedMode ) )
  786. ptOffsetWnd.x =
  787. abs( rcWnd.left - rcClientOrg.left );
  788. if( bInvTop || (! bFixedMode ) )
  789. ptOffsetWnd.y =
  790. abs( rcWnd.top - rcClientOrg.top );
  791. } // if( bInvLeft || bInvTop )
  793. switch( nHit )
  794. {
  795. case HTLEFT:
  796. bHorz = true;
  797. rcWnd.left = min( _pt.x, rcWnd.right );
  798. bLeft = true;
  799. break;
  800. case HTRIGHT:
  801. bHorz = true;
  802. rcWnd.right = max( _pt.x, rcWnd.left );
  803. break;
  804. case HTTOP:
  805. rcWnd.top = min( _pt.y, rcWnd.bottom );
  806. bTop = true;
  807. break;
  808. case HTTOPLEFT:
  809. rcWnd.left = min( _pt.x, rcWnd.right );
  810. rcWnd.top = min( _pt.y, rcWnd.bottom );
  811. bLeft = true;
  812. bTop = true;
  813. break;
  814. case HTTOPRIGHT:
  815. rcWnd.right = max( _pt.x, rcWnd.left );
  816. rcWnd.top = min( _pt.y, rcWnd.bottom );
  817. bTop = true;
  818. break;
  819. case HTBOTTOM:
  820. rcWnd.bottom = max( _pt.y, rcWnd.top );
  821. break;
  822. case HTBOTTOMLEFT:
  823. rcWnd.left = min( _pt.x, rcWnd.right );
  824. rcWnd.bottom = max( _pt.y, rcWnd.top );
  825. bLeft = true;
  826. break;
  827. case HTBOTTOMRIGHT:
  828. rcWnd.right = max( _pt.x, rcWnd.left );
  829. rcWnd.bottom = max( _pt.y, rcWnd.top );
  830. break;
  831. default:
  832. ASSERT( FALSE );
  833. g_bInResizingUpdateState = false;
  834. return;
  835. } // switch( nHit )
  837. if( rcWnd.Width() < sizeDiff.cx )
  838. rcWnd.right = rcWnd.left + sizeDiff.cx;
  839. if( rcWnd.Height() < sizeDiff.cy )
  840. rcWnd.bottom = rcWnd.top + sizeDiff.cy;
  841. if( rcWnd.right > rcWndOrg.right
  842. && bLeft
  843. )
  844. rcWnd.OffsetRect(
  845. rcWndOrg.right - rcWnd.right,
  846. 0
  847. );
  848. if( rcWnd.bottom > rcWndOrg.bottom
  849. && bTop
  850. )
  851. rcWnd.OffsetRect(
  852. 0,
  853. rcWndOrg.bottom - rcWnd.bottom
  854. );
  855. rcClient.SetRect(
  856. rcWnd.left - (rcClient.left-rcWndOrg.left),
  857. rcWnd.top - (rcClient.top-rcWndOrg.top),
  858. rcWnd.right - (rcClient.right-rcWndOrg.right),
  859. rcWnd.bottom - (rcClient.bottom-rcWndOrg.bottom)
  860. );
  862. if( ! bFixedMode )
  863. {
  864. ASSERT( (GetStyle() & __REMOVED_NONFIXMODE_STYLES) == 0 );
  865. CSize _sizeMinFloated =
  866. pExtBar->_CalcDesiredMinFloatedSize();
  867. CSize _size = rcWnd.Size();
  868. if( _size.cx < _sizeMinFloated.cx )
  869. _size.cx = _sizeMinFloated.cx;
  870. if( _size.cy < _sizeMinFloated.cy )
  871. _size.cy = _sizeMinFloated.cy;
  872. CExtPaintManager::monitor_parms_t _mp;
  873. CExtPaintManager::stat_GetMonitorParms( _mp, this );
  874. CSize _sizeMaxFloated = _mp.m_rcWorkArea.Size();
  876. #ifdef __FREIWALD_ORIGINAL__
  877. #else
  879. // It should be possible to enlarge the size of a floating frame to cover two or more monitors
  880. // in a multiple monitor configuration.
  882. // The original implementation, however, adjusted the dimensions of the floating frame according to the
  883. // dimensions of the primary monitor.
  885. // This does not only prevent the floating frame from being enlarged to more than one monitor,
  886. // but may also cause wrong calculations, when the frame is resized on the non-primary monitor and
  887. // the dimensions / screen resolution of this non-primary monitor are different to those of the primary monitor.
  889. // This has been adjusted with the following change:
  891. if (GetSystemMetrics(__cSM_CMONITORS) > 1)
  892. {
  893. _sizeMaxFloated = CSize(GetSystemMetrics(__cSM_CXVIRTUALSCREEN), GetSystemMetrics(__cSM_CYVIRTUALSCREEN));
  894. }
  896. #endif
  898. if( _size.cx > _sizeMaxFloated.cx )
  899. _size.cx = _sizeMaxFloated.cx;
  900. if( _size.cy > _sizeMaxFloated.cy )
  901. _size.cy = _sizeMaxFloated.cy;
  902. //CRect rc1, rc2;
  903. //GetClientRect( &rc1 );
  904. //pExtBar->GetClientRect( &rc2 );
  905. //CSize sizeDiff2 = rc1.Size() - rc2.Size();
  906. //_size += sizeDiff2;
  908. #ifdef __FREIWALD_ORIGINAL__
  909. pExtBar->m_sizeFloated = _size - ptOffsetWnd;
  910. #else
  912. // The original code caused the control bar to change its size, 
  913. // even if the right border was only clicked without moving the mouse
  915. // The following change fixes this:
  917. pExtBar->m_sizeFloated += (_size - rcWndOrg.Size());
  919. #endif
  921. //pExtBar->m_pDockContext->m_sizeLast = pExtBar->m_sizeFloated;
  922. CRect rcWndValidated( rcWnd.TopLeft(), _size );
  923. //pExtBar->m_pDockContext->m_rectDragHorz
  924. // = pExtBar->m_pDockContext->m_rectDragVert
  925. // = pExtBar->m_pDockContext->m_rectFrameDragHorz
  926. // = pExtBar->m_pDockContext->m_rectFrameDragVert
  927. // = rcWndValidated;
  928. MoveWindow( &rcWndValidated );
  929. RecalcLayout();
  930. SetTimer( 1, 1, NULL );
  931. g_bInResizingUpdateState = false;
  932. return;
  933. } // if( ! bFixedMode )
  935. INT nResizingFrameDX = 0;
  936. INT nResizingFrameDY = 0;
  937. INT nCaptionDY = 0;
  938. OnQueryNcMetrics(
  939. nResizingFrameDX,
  940. nResizingFrameDY,
  941. nCaptionDY
  942. );
  944. DWORD dwMode = LM_HORZ|LM_COMMIT;
  945. LONG nLendth = 0;
  946. if( bHorz )
  947. nLendth = rcClient.Width();
  948. else
  949. {
  950. dwMode |= LM_LENGTHY;
  951. nLendth =
  952. rcClient.Height()
  953. - nResizingFrameDY;
  954. } // else from if( bHorz )
  955. CSize _sizeFloatedPrev = pExtBar->m_sizeFloated;
  956. CSize _size =
  957. pExtBar->CalcDynamicLayout( nLendth, dwMode );
  958. if( _sizeFloatedPrev == _size )
  959. {
  960. g_bInResizingUpdateState = false;
  961. return;
  962. }
  964. // if( _size.cx < _sizeMinFloated.cx )
  965. // _size.cx = _sizeMinFloated.cx;
  966. // if( _size.cy < _sizeMinFloated.cy )
  967. // _size.cy = _sizeMinFloated.cy;
  969. pExtBar->m_sizeFloated = _size;
  971. if( bInvTop )
  972. {
  973. ASSERT( rcWnd.top == rcWndOrg.top );
  974. rcWnd.bottom = m_rcWndResizingStart.bottom;
  975. rcWnd.top =
  976. rcWnd.bottom - _size.cy - ptOffsetWnd.y;
  977. }
  978. if( bInvLeft )
  979. {
  980. ASSERT( rcWnd.left == rcWndOrg.left );
  981. rcWnd.right = m_rcWndResizingStart.right;
  982. rcWnd.left =
  983. rcWnd.right - _size.cx - ptOffsetWnd.x;
  984. }
  986. ASSERT( pExtBar->m_pDockSite != NULL );
  987. ASSERT( pExtBar->m_pDockBar != NULL );
  988. pExtBar->m_ptFloatHelper = rcWnd.TopLeft();
  990. _size += sizeNcDiff;
  991. _size.cx -= nResizingFrameDX; // (+ v.2.22)
  992. _size.cy -= nResizingFrameDY;
  993. CRect rcToMoveMinFrame(
  994. pExtBar->m_ptFloatHelper,
  995. _size
  996. );
  998. MoveWindow( &rcToMoveMinFrame);
  999. // SendMessage( WM_NCPAINT );
  1000. PostMessage( WM_NCPAINT );
  1001. RecalcLayout();
  1002. pExtBar->RedrawWindow(
  1003. NULL,
  1004. NULL,
  1005. RDW_INVALIDATE|RDW_UPDATENOW
  1006. |RDW_ERASE|RDW_ERASENOW
  1007. |RDW_ALLCHILDREN
  1008. );
  1009. g_bInResizingUpdateState = false;
  1010. }
  1012. CControlBar * CExtMiniDockFrameWnd::GetControlBar()
  1013. {
  1014. CWnd* pTempWnd = GetWindow( GW_CHILD );
  1015.     if( pTempWnd == NULL )
  1016.         return NULL;
  1017. pTempWnd = pTempWnd->GetWindow( GW_CHILD );
  1018.     if( pTempWnd == NULL )
  1019.         return NULL;
  1020.     if( !pTempWnd->IsKindOf( RUNTIME_CLASS(CControlBar) ) )
  1021.         return NULL;
  1022.     return reinterpret_cast < CControlBar * > ( pTempWnd );
  1023. }
  1025. const CControlBar * CExtMiniDockFrameWnd::GetControlBar() const
  1026. {
  1027. CControlBar * pBar =
  1028. ( const_cast < CExtMiniDockFrameWnd * > ( this ) ) ->
  1029. GetControlBar();
  1030. return pBar;
  1031. }
  1033. CExtControlBar * CExtMiniDockFrameWnd::GetControlBarExt()
  1034. {
  1035. CControlBar * pTempWnd = GetControlBar();
  1036.     if( pTempWnd == NULL )
  1037.         return NULL;
  1038. // ASSERT_KINDOF( CExtControlBar, pTempWnd );
  1039.     if( !pTempWnd->IsKindOf( RUNTIME_CLASS(CExtControlBar) ) )
  1040.         return NULL;
  1041.     return reinterpret_cast < CExtControlBar * > ( pTempWnd );
  1042. }
  1044. const CExtControlBar * CExtMiniDockFrameWnd::GetControlBarExt() const
  1045. {
  1046. CExtControlBar * pExtBar =
  1047. ( const_cast < CExtMiniDockFrameWnd * > ( this ) ) ->
  1048. GetControlBarExt();
  1049. return pExtBar;
  1050. }
  1052. void CExtMiniDockFrameWnd::OnNcRButtonDown(UINT nHitTest, CPoint point)
  1053. {
  1054. if( _ResizingIsInProgress() )
  1055. {
  1056. _ResizingEnd();
  1057. return;
  1058. }
  1059. if( nHitTest == HTCAPTION )
  1060. {
  1061. #if (!defined __EXT_MFC_NO_CUSTOMIZE)
  1062. CExtCustomizeSite * pSite =
  1063. CExtCustomizeSite::GetCustomizeSite( m_hWnd );
  1064. if( pSite != NULL
  1065. && pSite->IsCustomizeMode()
  1066. )
  1067. return;
  1068. #endif // (!defined __EXT_MFC_NO_CUSTOMIZE)
  1069. if( CExtControlBar::FindHelpMode(this) )
  1070. return;
  1071. CExtControlBar * pExtBar =
  1072. GetControlBarExt();
  1073. if( pExtBar != NULL )
  1074. {
  1075. ASSERT_VALID( pExtBar );
  1077. CFrameWnd * pFrame = pExtBar->_GetDockingFrameImpl();
  1078. ASSERT_VALID( pFrame );
  1080. CPoint point;
  1081. if( ! ::GetCursorPos(&point) )
  1082. return;
  1083. HWND hWndTrack = pFrame->GetSafeHwnd();
  1084. ASSERT( hWndTrack != NULL && ::IsWindow(hWndTrack) );
  1085. CExtPopupMenuWnd * pPopup =
  1086. CExtPopupMenuWnd::InstantiatePopupMenu(
  1087. hWndTrack,
  1088. RUNTIME_CLASS(CExtPopupMenuWnd),
  1089. this
  1090. );
  1091. VERIFY( pPopup->CreatePopupMenu(hWndTrack) );
  1092. if( ! CExtDockBar::_ConstructDockSiteControlBarPopupMenu(
  1093. pFrame,
  1094. pPopup,
  1095. CExtControlBar::POPUP_MENU_EVENT_DATA::__PMED_MINIFRAME_NC_CTX,
  1096. pExtBar,
  1097. WM_NCRBUTTONDOWN,
  1098. NULL
  1099. )
  1100. )
  1101. {
  1102. delete pPopup;
  1103. return;
  1104. }
  1105. if( pPopup->ItemGetCount() == 0 )
  1106. {
  1107. delete pPopup;
  1108. return;
  1109. }
  1110. //::SetFocus( hWndTrack );
  1111. if( ! pPopup->TrackPopupMenu(
  1112. TPMX_OWNERDRAW_FIXED,
  1113. point.x,
  1114. point.y,
  1115. NULL,
  1116. this,
  1117. NULL,
  1118. NULL,
  1119. true
  1120. )
  1121. )
  1122. {
  1123. //delete pPopup;
  1124. }
  1125. return;
  1126. } // if( pExtBar != NULL )
  1127. } // if( nHitTest == HTCAPTION )
  1128. CMiniDockFrameWnd::OnNcRButtonDown(nHitTest,point);
  1129. }
  1131. void CExtMiniDockFrameWnd::OnNcCalcSize(BOOL bCalcValidRects, NCCALCSIZE_PARAMS FAR* lpncsp) 
  1132. {
  1133. // CMiniDockFrameWnd::OnNcCalcSize(bCalcValidRects, lpncsp);
  1134. bCalcValidRects;
  1135. if( PmBridge_GetPM()->Bar_MiniDockFrameNcCalcSize(
  1136. lpncsp->rgrc[0],
  1137. this,
  1138. GetControlBarExt()
  1139. )
  1140. )
  1141. return;
  1143. INT nResizingFrameDX = 0;
  1144. INT nResizingFrameDY = 0;
  1145. INT nCaptionDY = 0;
  1146. OnQueryNcMetrics(
  1147. nResizingFrameDX,
  1148. nResizingFrameDY,
  1149. nCaptionDY
  1150. );
  1152. ::InflateRect(
  1153. &lpncsp->rgrc[0],
  1154. - nResizingFrameDX,
  1155. - nResizingFrameDY
  1156. );
  1157. lpncsp->rgrc[0].top += nCaptionDY;
  1158. }
  1160. void CExtMiniDockFrameWnd::CalcWindowRect(
  1161. LPRECT lpClientRect,
  1162. UINT nAdjustType // = CWnd::AdjustType::adjustBorder
  1163. )
  1164. {
  1165. ASSERT_VALID( this );
  1166. ASSERT( lpClientRect != NULL );
  1167. nAdjustType;
  1169. INT nResizingFrameDX = 0;
  1170. INT nResizingFrameDY = 0;
  1171. INT nCaptionDY = 0;
  1172. OnQueryNcMetrics(
  1173. nResizingFrameDX,
  1174. nResizingFrameDY,
  1175. nCaptionDY
  1176. );
  1178. ::InflateRect(
  1179. lpClientRect,
  1180. nResizingFrameDX,
  1181. nResizingFrameDY
  1182. );
  1183. lpClientRect->top -= nCaptionDY;
  1184. }
  1186. void CExtMiniDockFrameWnd::OnNcPaint() 
  1187. {
  1188. CRect rcClient, rcBar;
  1189. GetClientRect(rcClient);
  1190. ClientToScreen(rcClient);
  1191. GetWindowRect(rcBar);
  1192. rcClient.OffsetRect(-rcBar.TopLeft());
  1193. rcBar.OffsetRect(-rcBar.TopLeft());
  1194. CWindowDC dcSrc( this );
  1195. dcSrc.ExcludeClipRect( &rcClient );
  1196. CExtMemoryDC dcWin( &dcSrc, &rcBar );
  1197. RenderNC( dcWin );
  1198. PmBridge_GetPM()->OnPaintSessionComplete( this );
  1199. }
  1201. CExtControlBar * CExtMiniDockFrameWnd::FindSingleVisbleFlatingBar()
  1202. {
  1203. ASSERT_VALID( this );
  1204. if( GetSafeHwnd() == NULL )
  1205. return false;
  1206. CWnd * pWnd = GetWindow( GW_CHILD );
  1207. if( pWnd == NULL )
  1208. return NULL;
  1209. CDockBar * pDockBar = DYNAMIC_DOWNCAST( CDockBar, pWnd );
  1210. if( pDockBar == NULL )
  1211. return NULL;
  1212. if( pDockBar->GetDlgCtrlID() != AFX_IDW_DOCKBAR_FLOAT )
  1213. return NULL;
  1214. CExtControlBar * pFoundBar = NULL;
  1215. if( ! CExtControlBar::stat_FindSingleVisbleBarNested( pDockBar, &pFoundBar ) )
  1216. return NULL;
  1217. ASSERT_VALID( pFoundBar );
  1218. ASSERT( pFoundBar->GetSafeHwnd() != NULL );
  1219. ASSERT( ((CControlBar*)pFoundBar) != ((CControlBar*)pDockBar) );
  1220. return pFoundBar;
  1221. }
  1223. void CExtMiniDockFrameWnd::RenderNC( CDC & dc )
  1224. {
  1225. ASSERT_VALID( this );
  1226. ASSERT( dc.GetSafeHdc() != NULL );
  1228. CExtControlBar * pExtBar = GetControlBarExt();
  1229. bool bExtBar = false;
  1230. if( pExtBar != NULL
  1231. && (! pExtBar->IsFixedMode() )
  1232. )
  1233. bExtBar = true;
  1234. CRect rcClient, rcBar;
  1235. GetClientRect(rcClient);
  1236. ClientToScreen(rcClient);
  1237. GetWindowRect(rcBar);
  1238. rcClient.OffsetRect(-rcBar.TopLeft());
  1239. rcBar.OffsetRect(-rcBar.TopLeft());
  1241. #ifdef __FREIWALD_ORIGINAL__
  1242. bool bActive =
  1243. ( m_bHelperNcActive
  1244. //|| ( pExtBar != NULL && pExtBar->IsBarWindowActive() )
  1245. ) ? true : false;
  1246. #else
  1248. bool bActive = false;
  1250. HWND hTmpWndFocus = ::GetFocus();
  1251. if( hTmpWndFocus != NULL
  1252. && ( GetSafeHwnd() == hTmpWndFocus
  1253. || ::IsChild( GetSafeHwnd(), hTmpWndFocus )
  1254. )
  1255. )
  1256. bActive = true;
  1258. #endif
  1260. CExtPaintManager::PAINTDOCKINGFRAMEDATA _pdfd(
  1261. this,
  1262. rcBar,
  1263. rcClient,
  1264. bActive,
  1265. true,
  1266. bExtBar
  1267. );
  1268. PmBridge_GetPM()->PaintDockingFrame( dc, _pdfd );
  1269. bool bEnableCaptionText = true;
  1270. CExtSafeString sCaption;
  1271. if( pExtBar != NULL )
  1272. {
  1273. if( pExtBar->IsKindOf(RUNTIME_CLASS(CExtDynControlBar))
  1274. #if (!defined __EXT_MFC_NO_TAB_CONTROLBARS)
  1275. && ( !pExtBar->IsKindOf(RUNTIME_CLASS(CExtDynTabControlBar)) )
  1276. #endif // (!defined __EXT_MFC_NO_TAB_CONTROLBARS)
  1277. )
  1278. bEnableCaptionText = false;
  1279. else
  1280. {
  1281. pExtBar->OnGetBarCaptionText(
  1282. CExtControlBar::__EBCT_SINGLE_CAPTION_FLOATING,
  1283. sCaption
  1284. );
  1285. }
  1286. }
  1287. if( ! bEnableCaptionText )
  1288. {
  1289. if( pExtBar != NULL
  1290. && pExtBar->IsKindOf(RUNTIME_CLASS(CExtDynControlBar))
  1291. )
  1292. bEnableCaptionText =
  1293. _GetSingleVisibleCaptionText(
  1294. sCaption
  1295. );
  1296. }
  1297. else
  1298. if( bEnableCaptionText && sCaption.IsEmpty() )
  1299. {
  1300. if( pExtBar != NULL )
  1301. {
  1302. pExtBar->OnGetBarCaptionText(
  1303. CExtControlBar::__EBCT_SINGLE_CAPTION_FLOATING,
  1304. sCaption
  1305. );
  1306. } // if( pExtBar != NULL )
  1307. else
  1308. {
  1309. int nTextLen = GetWindowTextLength();
  1310. if( nTextLen > 0 )
  1311. {
  1312. GetWindowText( sCaption.GetBuffer( nTextLen+2 ), nTextLen+1 );
  1313. sCaption.ReleaseBuffer();
  1314. } // if( nTextLen > 0 )
  1315. } // else from if( pExtBar != NULL )
  1316. }
  1318. CRect rcCapt( m_rcFrameCaption );
  1319. CRect rcText( m_rcFrameCaption );
  1320. if( pExtBar == NULL )
  1321. rcText.right = m_rcBtnHideBar.left;
  1323. if( pExtBar != NULL )
  1324. pExtBar->NcButtons_CalcGripperTextLocation( rcText );
  1326. if( ! bActive )
  1327. {
  1328. HWND hTmpWndFocus = ::GetFocus();
  1329. if( hTmpWndFocus != NULL
  1330. && ( GetSafeHwnd() == hTmpWndFocus
  1331. || ::IsChild( GetSafeHwnd(), hTmpWndFocus )
  1332. )
  1333. )
  1334. bActive = true;
  1335. }
  1337. rcText.DeflateRect(2,0);
  1339. CExtControlBar * pSingleVisbleFlatingBar = FindSingleVisbleFlatingBar();
  1340. if( pSingleVisbleFlatingBar != NULL )
  1341. {
  1342. CExtControlBar * pFlashingBar = pSingleVisbleFlatingBar;
  1343. #if (!defined __EXT_MFC_NO_TAB_CONTROLBARS)
  1344. CExtDynTabControlBar * pTabbedBar = DYNAMIC_DOWNCAST( CExtDynTabControlBar, pSingleVisbleFlatingBar );
  1345. if( pTabbedBar != NULL )
  1346. {
  1347. LONG nSel = pTabbedBar->GetSwitcherSelection();
  1348. if( nSel >= 0 )
  1349. {
  1350. CExtControlBar * pBar = pTabbedBar->GetBarAt( nSel, true );
  1351. if( pBar != NULL )
  1352. {
  1353. ASSERT_VALID( pBar );
  1354. ASSERT( pBar->GetSafeHwnd() != NULL );
  1355. pFlashingBar = pBar;
  1356. } // if( pBar != NULL )
  1357. } // if( nSel >= 0 )
  1358. } // if( pTabbedBar != NULL )
  1359. #endif // (!defined __EXT_MFC_NO_TAB_CONTROLBARS)
  1360. CExtPaintManager::PAINTGRIPPERDATA _pgd(
  1361. pFlashingBar, // pSingleVisbleFlatingBar
  1362. rcCapt,
  1363. rcText,
  1364. bActive,
  1365. true,
  1366. false,
  1367. bExtBar,
  1368. sCaption.IsEmpty() ? LPCTSTR( NULL ) : sCaption,
  1369. ( (g_ResourceManager->OnQueryLangLayout()&LAYOUT_RTL) != 0 ) ? true : false
  1370. );
  1371. bool bDrawDefaultCaption = true, bFlashCaptionHighlightedState = false;
  1372. if( pFlashingBar->FlashCaptionIsInProgress( &bFlashCaptionHighlightedState ) )
  1373. {
  1374. _pgd.m_bFlashCaptionHighlightedState = bFlashCaptionHighlightedState;
  1375. _pgd.m_clrFlashCaptionText = pFlashingBar->m_clrFlashCaptionText;
  1376. _pgd.m_clrFlashCaptionBackground = pFlashingBar->m_clrFlashCaptionBackground;
  1377. if( pFlashingBar->FlashCaption_DoPaintNC(
  1378. dc,
  1379. (LPVOID)(&_pgd)
  1380. )
  1381. )
  1382. bDrawDefaultCaption = false;
  1383. } // if( pFlashingBar->FlashCaptionIsInProgress( &bFlashCaptionHighlightedState ) )
  1384. if( bDrawDefaultCaption )
  1385. {
  1386. PmBridge_GetPM()->PaintGripper( dc, _pgd );
  1387. if( pExtBar != NULL )
  1388. pExtBar->NcButtons_Paint( dc );
  1389. } // if( bDrawDefaultCaption )
  1390. } // if( pSingleVisbleFlatingBar != NULL )
  1391. else
  1392. {
  1393. CExtPaintManager::PAINTGRIPPERDATA _pgd(
  1394. this,
  1395. rcCapt,
  1396. rcText,
  1397. bActive,
  1398. true,
  1399. false,
  1400. bExtBar,
  1401. sCaption.IsEmpty() ? LPCTSTR( NULL ) : sCaption,
  1402. ( (g_ResourceManager->OnQueryLangLayout()&LAYOUT_RTL) != 0 ) ? true : false
  1403. );
  1404. PmBridge_GetPM()->PaintGripper( dc, _pgd );
  1405. }
  1407. if( pExtBar != NULL )
  1408. pExtBar->NcButtons_Paint( dc );
  1409. }
  1411. bool CExtMiniDockFrameWnd::_GetSingleVisibleCaptionText( CExtSafeString & sCaption )
  1412. {
  1413. sCaption = _T("");
  1414. CFrameWnd * pDockSite = GetParentFrame();
  1415. if( pDockSite == NULL )
  1416. return false;
  1417. ASSERT( ! pDockSite->IsKindOf( RUNTIME_CLASS(CMiniFrameWnd) ) );
  1418. POSITION pos = pDockSite->m_listControlBars.GetHeadPosition();
  1419. for( ; pos != NULL; )
  1420. {
  1421. CExtControlBar * pBar =
  1422. DYNAMIC_DOWNCAST(
  1423. CExtControlBar,
  1424. ((CControlBar *)(pDockSite->m_listControlBars.GetNext(pos)))
  1425. );
  1426. if( pBar == NULL
  1427. || pBar->m_pDockSite == NULL
  1428. || pBar->IsFixedMode()
  1429. || ( pBar->IsKindOf(RUNTIME_CLASS(CExtDynControlBar))
  1430. #if (!defined __EXT_MFC_NO_TAB_CONTROLBARS)
  1431. && !pBar->IsKindOf(RUNTIME_CLASS(CExtDynTabControlBar))
  1432. #endif // (!defined __EXT_MFC_NO_TAB_CONTROLBARS)
  1433. )
  1434. || pBar->GetParentFrame() != this
  1435. || pBar->IsFloating()
  1436. || !pBar->IsVisible()
  1437. )
  1438. continue;
  1439. ASSERT( pBar->m_pDockBar != NULL );
  1440. if(
  1441. #if (!defined __EXT_MFC_NO_TAB_CONTROLBARS)
  1442. pBar->m_pDockBar->IsKindOf(RUNTIME_CLASS(CExtDockDynTabBar))
  1443. ||
  1444. #endif // (!defined __EXT_MFC_NO_TAB_CONTROLBARS)
  1445. !pBar->m_pDockBar->IsKindOf(RUNTIME_CLASS(CExtDockBar))
  1446. )
  1447. continue;
  1448. if( ! pBar->_IsSingleVisibleInFloatingPalette() )
  1449. return false;
  1450. pBar->OnGetBarCaptionText(
  1451. CExtControlBar::__EBCT_SINGLE_CAPTION_FLOATING,
  1452. sCaption
  1453. );
  1454. return sCaption.IsEmpty() ? false : true;
  1455. }
  1456. return false;
  1457. }
  1459. BOOL CExtMiniDockFrameWnd::OnNcActivate(BOOL bActive) 
  1460. {
  1461. ASSERT_VALID( this );
  1462. m_bHelperNcActive = bActive ? true : false;
  1463. BOOL rc = CMiniDockFrameWnd::OnNcActivate( bActive );
  1464. CExtControlBar * pExtBar = GetControlBarExt();
  1465. if( pExtBar != NULL )
  1466. {
  1467. ASSERT_VALID( pExtBar );
  1468. pExtBar->_OnNcMiniFrameActivate( bActive ? true : false );
  1469. }
  1470. if( ( GetStyle() & WS_VISIBLE ) != 0 )
  1471. {
  1472. // SendMessage( WM_NCPAINT );
  1473. PostMessage( WM_NCPAINT );
  1474. if( bActive )
  1475. {
  1476. if( pExtBar != NULL )
  1477. {
  1478. ASSERT_VALID( pExtBar );
  1479. pExtBar->RedrawWindow(
  1480. NULL,
  1481. NULL,
  1482. RDW_INVALIDATE|RDW_UPDATENOW
  1483. |RDW_ERASE|RDW_ALLCHILDREN
  1484. );
  1485. }
  1486. }
  1487. } // if( ( GetStyle() & WS_VISIBLE ) != 0 )
  1488. return rc;
  1489. }
  1491. void CExtMiniDockFrameWnd::OnSize(UINT nType, int cx, int cy) 
  1492. {
  1493. // if( _ResizingIsInProgress() )
  1494. // return;
  1496. ASSERT( cx >= 0 && cy >= 0 );
  1497. CExtPaintManager::monitor_parms_t _mp;
  1498. CExtPaintManager::stat_GetMonitorParms( _mp, this );
  1500. CRect rcWnd;
  1501. GetWindowRect( &rcWnd );
  1503. #ifdef __FREIWALD_ORIGINAL__
  1505. if( ( cx > _mp.m_rcWorkArea.Width() && _mp.m_rcWorkArea.Width() > 0 )
  1506. || ( cy > _mp.m_rcWorkArea.Height() && _mp.m_rcWorkArea.Height() > 0 )
  1507. || rcWnd.right < _mp.m_rcWorkArea.left
  1508. || rcWnd.bottom < _mp.m_rcWorkArea.top
  1509. || rcWnd.left > _mp.m_rcWorkArea.right
  1510. || rcWnd.top > _mp.m_rcWorkArea.bottom
  1511. )
  1513. #else
  1515. // It should be possible to enlarge the size of a floating frame to cover two or more monitors
  1516. // in a multiple monitor configuration.
  1518. // The original implementation, however, adjusted the dimensions of the floating frame according to the
  1519. // dimensions of the primary monitor.
  1521. // This does not only prevent the floating frame from being enlarged to more than one monitor,
  1522. // but may also cause wrong calculations, when the frame is resized on the non-primary monitor and
  1523. // the dimensions / screen resolution of this non-primary monitor are different to those of the primary monitor.
  1525. // This has been adjusted with the following change:
  1527. CRect rcWorkArea = _mp.m_rcWorkArea;
  1529. if (GetSystemMetrics(__cSM_CMONITORS) > 1)
  1530. {
  1531. rcWorkArea = CRect(CPoint(GetSystemMetrics(__cSM_XVIRTUALSCREEN), GetSystemMetrics(__cSM_YVIRTUALSCREEN)), 
  1532.  CSize(GetSystemMetrics(__cSM_CXVIRTUALSCREEN), GetSystemMetrics(__cSM_CYVIRTUALSCREEN)));
  1534. }
  1536. if( ( cx > rcWorkArea.Width() && rcWorkArea.Width() > 0 )
  1537. || ( cy > rcWorkArea.Height() && rcWorkArea.Height() > 0 )
  1538. || rcWnd.right < rcWorkArea.left
  1539. || rcWnd.bottom < rcWorkArea.top
  1540. || rcWnd.left > rcWorkArea.right
  1541. || rcWnd.top > rcWorkArea.bottom
  1542. )
  1544. #endif
  1545. {
  1546. if( ! m_bMovingLargeBar )
  1547. SetTimer( 5, 1, NULL );
  1548. return;
  1549. }
  1551. CMiniDockFrameWnd::OnSize(nType, cx, cy);
  1553. VERIFY(
  1554. PmBridge_GetPM()->Bar_MiniDockFrameCaptionCalcRect(
  1555. m_rcFrameCaption,
  1556. this,
  1557. GetControlBarExt()
  1558. ) 
  1559. );
  1560. int nDummyMetric = ::GetSystemMetrics( SM_CXSMSIZE ) - 1;
  1561. int nRight =
  1562. m_rcFrameCaption.right - nDummyMetric - 1;
  1563. m_rcBtnHideBar.SetRect(
  1564. nRight,
  1565. m_rcFrameCaption.top + 2,
  1566. nRight + nDummyMetric - 2,
  1567. m_rcFrameCaption.bottom - 2
  1568. );
  1570. CExtControlBar * pExtBar = GetControlBarExt();
  1571. if( pExtBar != NULL )
  1572. {
  1573. pExtBar->OnNcAreaButtonsReinitialize();
  1574. pExtBar->OnNcAreaButtonsReposition();
  1575. } // if( pExtBar != NULL )
  1576. if( ::GetCapture() == m_hWnd )
  1577. SendMessage( WM_NCPAINT );
  1578. CExtPaintManager::stat_PassPaintMessages();
  1579. }
  1581. void CExtMiniDockFrameWnd::OnWindowPosChanged(WINDOWPOS FAR* lpwndpos) 
  1582. {
  1583. CMiniDockFrameWnd::OnWindowPosChanged(lpwndpos);
  1584. CExtControlBar * pExtBar = GetControlBarExt();
  1585. if( _ResizingIsInProgress()
  1586. || g_bOnWndPosChgProcessing
  1587. || (lpwndpos->flags & SWP_NOMOVE) != 0
  1588. )
  1589. {
  1590. return;
  1591. }
  1592. if( pExtBar == NULL || (! pExtBar->IsFloating()) )
  1593. return;
  1594. CRect rcWnd;
  1595. GetWindowRect( &rcWnd );
  1597. INT nResizingFrameDX = 0;
  1598. INT nResizingFrameDY = 0;
  1599. INT nCaptionDY = 0;
  1600. OnQueryNcMetrics(
  1601. nResizingFrameDX,
  1602. nResizingFrameDY,
  1603. nCaptionDY
  1604. );
  1605. CExtPaintManager::monitor_parms_t _mp;
  1606. CExtPaintManager::stat_GetMonitorParms( _mp, this );
  1607. ASSERT( ! g_bOnWndPosChgProcessing );
  1608. //if( rcWnd.top < _mp.m_rcWorkArea.top )
  1609. if( rcWnd.bottom < _mp.m_rcWorkArea.top )
  1610. {
  1611. rcWnd.top = _mp.m_rcWorkArea.top;
  1612. g_bOnWndPosChgProcessing = true;
  1613. }
  1614. else if( rcWnd.top + nCaptionDY > _mp.m_rcWorkArea.bottom )
  1615. {
  1616. rcWnd.top =
  1617. max(
  1618. _mp.m_rcWorkArea.top, 
  1619. _mp.m_rcWorkArea.bottom
  1620. - nCaptionDY
  1621. );
  1622. g_bOnWndPosChgProcessing = true;
  1623. }
  1624. if( ! g_bOnWndPosChgProcessing )
  1625. {
  1626. return;
  1627. }
  1628. SetWindowPos(
  1629. NULL,
  1630. rcWnd.left, rcWnd.top, -1, -1,
  1631. SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOSIZE
  1632. );
  1634. pExtBar->OnNcAreaButtonsReposition();
  1635. PostMessage( WM_NCPAINT );
  1636. CExtPaintManager::stat_PassPaintMessages();
  1637. g_bOnWndPosChgProcessing = false;
  1638. }
  1640. void CExtMiniDockFrameWnd::OnWindowPosChanging( WINDOWPOS* lpwndpos )
  1641. {
  1642. CMiniDockFrameWnd::OnWindowPosChanging( lpwndpos );
  1643. if( GetStyle() & __REMOVED_STYLES_NORMAL )
  1644. ModifyStyle( __REMOVED_STYLES_NORMAL, 0, __SWP_FOR_REMOVED_STYLES );
  1645. if( GetExStyle() & __REMOVED_STYLES_EXTENDED )
  1646. ModifyStyleEx( __REMOVED_STYLES_EXTENDED, 0, __SWP_FOR_REMOVED_STYLES );
  1647. }
  1649. void CExtMiniDockFrameWnd::_AnalyzeButtonsHover(
  1650. bool bAllowShowAdvacedTip // = false
  1651. )
  1652. {
  1653. ASSERT_VALID( this );
  1654. CPoint point;
  1655. if( ::GetCursorPos( &point ) )
  1656. _AnalyzeButtonsHover(
  1657. point,
  1658. bAllowShowAdvacedTip
  1659. );
  1660. }
  1662. void CExtMiniDockFrameWnd::_AnalyzeButtonsHover(
  1663. CPoint point,
  1664. bool bAllowShowAdvacedTip // = false
  1665. )
  1666. {
  1667. ASSERT_VALID( this );
  1668. CExtControlBar * pExtBar = GetControlBarExt();
  1669. if( pExtBar != NULL )
  1670. {
  1671. CExtPopupMenuTipWnd * pATTW =
  1672. pExtBar->OnAdvancedPopupMenuTipWndGet();
  1673. if( pATTW == NULL )
  1674. bAllowShowAdvacedTip = false;
  1675. CExtBarNcAreaButton * pBtn = NULL;
  1676. pExtBar->NcButtons_HitTest( point, &pBtn );
  1677. if( bAllowShowAdvacedTip && pBtn != NULL )
  1678. {
  1679. TOOLINFO _ti;
  1680. ::memset( &_ti, 0, sizeof(AFX_OLDTOOLINFO) );
  1681. _ti.cbSize = sizeof( TOOLINFO );
  1682. _ti.hinst = ::AfxGetInstanceHandle();
  1683. if( pBtn->OnToolHitTest( point, &_ti ) > 0 )
  1684. {
  1685. if( _ti.lpszText != NULL
  1686. && _ti.lpszText != LPSTR_TEXTCALLBACK
  1687. && _tcslen( _ti.lpszText ) > 0
  1688. )
  1689. {
  1690. CRect rcArea = *pBtn;
  1691. CRect rcDefOffsetWnd;
  1692. GetWindowRect( &rcDefOffsetWnd );
  1693. rcArea.OffsetRect( rcDefOffsetWnd.TopLeft() );
  1694. pExtBar->OnAdvancedPopupMenuTipWndDisplay(
  1695. *pATTW,
  1696. rcArea,
  1697. _ti.lpszText
  1698. );
  1699. }
  1700. }
  1701. if( _ti.lpszText != NULL
  1702. && _ti.lpszText != LPSTR_TEXTCALLBACK
  1703. )
  1704. ::free( _ti.lpszText );
  1705. } // if( bAllowShowAdvacedTip && pBtn != NULL )
  1706. return;
  1707. }
  1708. CRect rcClient, rcBar;
  1709. GetClientRect( &rcClient );
  1710. ClientToScreen( &rcClient );
  1711. GetWindowRect( &rcBar );
  1712. rcClient.OffsetRect( -rcBar.TopLeft() );
  1713. rcBar.OffsetRect (-rcBar.TopLeft() );
  1714. ScreenToClient( &point );
  1715. point.y -= rcBar.top - rcClient.top;
  1716. bool bBtnHideBarHover = false;
  1717. if( m_rcBtnHideBar.PtInRect(point) )
  1718. bBtnHideBarHover = true;
  1719. if( m_bBtnHideBar != bBtnHideBarHover )
  1720. {
  1721. m_bBtnHideBar = bBtnHideBarHover;
  1722. // SendMessage( WM_NCPAINT );
  1723. PostMessage( WM_NCPAINT );
  1724. }
  1725. if( m_bBtnHideBar || bBtnHideBarHover )
  1726. SetTimer( 2, 20, NULL );
  1727. else
  1728. KillTimer( 2 );
  1729. }
  1731. void CExtMiniDockFrameWnd::OnNcMouseMove( UINT nHitTest, CPoint point )
  1732. {
  1733. if( g_bAutoMakeTopmostOnMouseEvent
  1734. && (!CExtPopupMenuWnd::IsMenuTracking())
  1735. && (CExtControlBar::_DraggingGetBar() == NULL)
  1736. )
  1737. BringWindowToTop();
  1739. if( _ResizingIsInProgress() )
  1740. {
  1741. return;
  1742. }
  1743. CMiniDockFrameWnd::OnNcMouseMove( nHitTest, point );
  1744. _AnalyzeButtonsHover( point, true );
  1745. }
  1747. void CExtMiniDockFrameWnd::OnTimer( __EXT_MFC_UINT_PTR nIDEvent )
  1748. {
  1749. CExtControlBar * pExtBar = GetControlBarExt();
  1750. if( nIDEvent == 1 )
  1751. {
  1752. if( pExtBar == NULL )
  1753. return;
  1754. KillTimer( 1 );
  1755. if( pExtBar->IsFixedMode() )
  1756. {
  1757. CRect rcWnd;
  1758. GetWindowRect( &rcWnd );
  1759. pExtBar->SetInitDesiredSizeFloating( rcWnd.Size() );
  1760. }
  1761. pExtBar->OnNcAreaButtonsReposition();
  1762.   if( IsWindowVisible() )
  1763. //  SendMessage( WM_NCPAINT );
  1764. PostMessage( WM_NCPAINT );
  1765. return;
  1766. }
  1767. if( nIDEvent == 2 )
  1768. {
  1769. _AnalyzeButtonsHover();
  1770. return;
  1771. }
  1772. if( nIDEvent == 4 )
  1773. {
  1774. if( CExtControlBar::_DraggingGetBar() != NULL )
  1775. {
  1776. KillTimer( 4 );
  1777. return;
  1778. } // if( CExtControlBar::_DraggingGetBar() != NULL )
  1779. if( pExtBar != NULL )
  1780. {
  1781. ASSERT_VALID( pExtBar );
  1782. CPoint point;
  1783. if( ! ::GetCursorPos(&point) )
  1784. return;
  1785. UINT nHT = pExtBar->NcButtons_HitTest( point );
  1786. if( nHT == HTCLIENT )
  1787. {
  1788. PostMessage( WM_NCPAINT );
  1789. pExtBar->m_bNcAreaBtnTracking = false;
  1790. }
  1791. }
  1792. if( !pExtBar->m_bNcAreaBtnTracking )
  1793. KillTimer( 4 );
  1794. return;
  1795. }
  1796. if( nIDEvent == 5 )
  1797. {
  1798. KillTimer( 5 );
  1799. CExtPaintManager::monitor_parms_t _mp;
  1800. CExtPaintManager::stat_GetMonitorParms( _mp, this );
  1801. CRect rcWnd;
  1802. GetWindowRect( &rcWnd );
  1804. #ifdef __FREIWALD_ORIGINAL__
  1806. if( ( rcWnd.Width() > _mp.m_rcWorkArea.Width() && _mp.m_rcWorkArea.Width() > 0 )
  1807. || ( rcWnd.Height() > _mp.m_rcWorkArea.Height() && _mp.m_rcWorkArea.Height() > 0 )
  1808. )
  1810. {
  1811. rcWnd.right =
  1812. rcWnd.left
  1813. + ( min( rcWnd.Width(), _mp.m_rcWorkArea.Width() ) )
  1814. ;
  1815. rcWnd.bottom =
  1816. rcWnd.top
  1817. + ( min( rcWnd.Height(), _mp.m_rcWorkArea.Height() ) )
  1818. ;
  1820. #else
  1822. // It should be possible to enlarge the size of a floating frame to cover two or more monitors
  1823. // in a multiple monitor configuration.
  1825. // The original implementation, however, adjusted the dimensions of the floating frame according to the
  1826. // dimensions of the primary monitor.
  1828. // This does not only prevent the floating frame from being enlarged to more than one monitor,
  1829. // but may also cause wrong calculations, when the frame is resized on the non-primary monitor and
  1830. // the dimensions / screen resolution of this non-primary monitor are different to those of the primary monitor.
  1832. // This has been adjusted with the following change:
  1834. CRect rcWorkArea = _mp.m_rcWorkArea;
  1836. if (GetSystemMetrics(__cSM_CMONITORS) > 1)
  1837. {
  1838. rcWorkArea = CRect(CPoint(GetSystemMetrics(__cSM_XVIRTUALSCREEN), GetSystemMetrics(__cSM_YVIRTUALSCREEN)), 
  1839.  CSize(GetSystemMetrics(__cSM_CXVIRTUALSCREEN), GetSystemMetrics(__cSM_CYVIRTUALSCREEN)));
  1841. }
  1843. if( ( rcWnd.Width() > rcWorkArea.Width() && rcWorkArea.Width() > 0 )
  1844. || ( rcWnd.Height() > rcWorkArea.Height() && rcWorkArea.Height() > 0 )
  1845. )
  1846. {
  1847. rcWnd.right =
  1848. rcWnd.left
  1849. + ( min( rcWnd.Width(), rcWorkArea.Width() ) )
  1850. ;
  1851. rcWnd.bottom =
  1852. rcWnd.top
  1853. + ( min( rcWnd.Height(), rcWorkArea.Height() ) )
  1854. ;
  1855. #endif
  1857. m_bMovingLargeBar = true;
  1858. MoveWindow( &rcWnd );
  1859. // SendMessage( WM_NCPAINT );
  1860. PostMessage( WM_NCPAINT );
  1861. m_bMovingLargeBar = false;
  1862. }
  1864. CRect rcWndAdjusted( 0, 0, 0, 0 );
  1865. if( rcWnd.right < _mp.m_rcWorkArea.left )
  1866. {
  1867. rcWndAdjusted = rcWnd;
  1868. rcWndAdjusted.OffsetRect(
  1869. _mp.m_rcWorkArea.left - rcWnd.left,
  1870. 0
  1871. );
  1872. }
  1873. if( rcWnd.bottom < _mp.m_rcWorkArea.top )
  1874. {
  1875. rcWndAdjusted = rcWnd;
  1876. rcWndAdjusted.OffsetRect(
  1877. 0,
  1878. _mp.m_rcWorkArea.top - rcWnd.top
  1879. );
  1880. }
  1881. if( rcWnd.left > _mp.m_rcWorkArea.right )
  1882. {
  1883. rcWndAdjusted = rcWnd;
  1884. rcWndAdjusted.OffsetRect(
  1885. _mp.m_rcWorkArea.right - rcWnd.right,
  1886. 0
  1887. );
  1888. }
  1889. if( rcWnd.top > _mp.m_rcWorkArea.bottom )
  1890. {
  1891. rcWndAdjusted = rcWnd;
  1892. rcWndAdjusted.OffsetRect(
  1893. 0,
  1894. _mp.m_rcWorkArea.bottom - rcWnd.bottom
  1895. );
  1896. }
  1897. if( ! rcWndAdjusted.IsRectEmpty() )
  1898. {
  1899. m_bMovingLargeBar = true;
  1900. MoveWindow( &rcWndAdjusted );
  1901. // SendMessage( WM_NCPAINT );
  1902. PostMessage( WM_NCPAINT );
  1903. m_bMovingLargeBar = false;
  1904. }
  1905. return;
  1906. }
  1908. if( pExtBar == NULL )
  1909. return;
  1910. ASSERT_VALID( pExtBar );
  1911. if( nIDEvent == (UINT)pExtBar->GetDlgCtrlID() )
  1912. {
  1913. if( _ResizingIsInProgress() )
  1914. return;
  1915. CPoint pt;
  1916. if( ! ::GetCursorPos( &pt ) )
  1917. return;
  1918. CWnd * pTempWnd = WindowFromPoint( pt );
  1919. int IsMouseInsideTheWindow =
  1920. IsChild( pTempWnd ) || pTempWnd->m_hWnd == m_hWnd;
  1922. if( IsMouseInsideTheWindow
  1923. || IsChild(GetFocus())  
  1924. || (CExtMouseCaptureSink::GetCapture() && pExtBar->m_hWnd == CExtMouseCaptureSink::GetCapture()) 
  1925. || CExtPopupMenuWnd::IsMenuTracking()
  1926. ) 
  1927. {
  1929. if( IsMouseInsideTheWindow 
  1930. && !CExtPopupMenuWnd::IsMenuTracking()
  1931. && IsWindowEnabled()
  1932. && GetFocus()
  1933. ) 
  1934. BringWindowToTop();
  1935. }
  1936. } // if( nIDEvent == (UINT)pExtBar->GetDlgCtrlID() )
  1937. }
  1939. void CExtMiniDockFrameWnd::OnClose() 
  1940. {
  1941. CMiniDockFrameWnd::OnClose();
  1942. }
  1944. void CExtMiniDockFrameWnd::OnGetMinMaxInfo(MINMAXINFO FAR* lpMMI)
  1945. {
  1946.     CMiniDockFrameWnd::OnGetMinMaxInfo( lpMMI );
  1947. CExtPaintManager::monitor_parms_t _mp;
  1948. CExtPaintManager::stat_GetMonitorParms( _mp, this );
  1949. if( lpMMI->ptMaxTrackSize.x > _mp.m_rcWorkArea.Width() )
  1950. lpMMI->ptMaxTrackSize.x = _mp.m_rcWorkArea.Width();
  1951. if( lpMMI->ptMaxTrackSize.y > _mp.m_rcWorkArea.Height() ) 
  1952. lpMMI->ptMaxTrackSize.y = _mp.m_rcWorkArea.Height();
  1953. }
  1955. void CExtMiniDockFrameWnd::OnMouseMove(UINT nFlags, CPoint point) 
  1956. {
  1957. if( g_bAutoMakeTopmostOnMouseEvent
  1958. && (!CExtPopupMenuWnd::IsMenuTracking())
  1959. )
  1960. BringWindowToTop();
  1961. if( _ResizingIsInProgress() )
  1962. {
  1963. ClientToScreen( &point );
  1964. _ResizingUpdateState( point );
  1965. return;
  1966. }
  1967. CMiniDockFrameWnd::OnMouseMove(nFlags, point);
  1968. }
  1970. void CExtMiniDockFrameWnd::OnCaptureChanged(CWnd *pWnd) 
  1971. {
  1972. if( _ResizingIsInProgress()
  1973. && pWnd != this
  1974. )
  1975. {
  1976. _ResizingEnd();
  1977. return;
  1978. }
  1979. CMiniDockFrameWnd::OnCaptureChanged(pWnd);
  1980. }
  1982. void CExtMiniDockFrameWnd::OnLButtonUp(UINT nFlags, CPoint point) 
  1983. {
  1984. if( _ResizingIsInProgress() )
  1985. {
  1986. _ResizingEnd();
  1987. return;
  1988. }
  1989. CMiniDockFrameWnd::OnLButtonUp(nFlags, point);
  1990. }
  1992. void CExtMiniDockFrameWnd::OnRButtonDown(UINT nFlags, CPoint point) 
  1993. {
  1994. if( _ResizingIsInProgress() )
  1995. {
  1996. _ResizingEnd();
  1997. return;
  1998. }
  1999. CMiniDockFrameWnd::OnRButtonDown(nFlags, point);
  2000. }
  2002. BOOL CExtMiniDockFrameWnd::OnEraseBkgnd(CDC* pDC) 
  2003. {
  2004. pDC;
  2005. return TRUE;
  2006. }
  2008. UINT CExtMiniDockFrameWnd::OnNcHitTest(CPoint point) 
  2009. {
  2010. if( CExtControlBar::_DraggingGetBar() != NULL )
  2011. return HTNOWHERE;
  2013. CExtControlBar * pExtBar = GetControlBarExt();
  2014. if( pExtBar != NULL )
  2015. {
  2016. ASSERT_VALID( pExtBar );
  2017. if( ! pExtBar->_FloatStateChangingIsEnabled( pExtBar ) )
  2018. return HTNOWHERE;
  2019. }
  2021. if( GetStyle() & MFS_MOVEFRAME )
  2022. ModifyStyle( MFS_MOVEFRAME, 0 );
  2023. //UINT nHit = CMiniDockFrameWnd::OnNcHitTest(point);
  2024. CRect rcBar;
  2025. GetWindowRect( &rcBar );
  2026. if( !rcBar.PtInRect( point ) )
  2027. return HTNOWHERE;
  2028. UINT nHit = HTCLIENT;
  2031. INT nResizingFrameDX = 0;
  2032. INT nResizingFrameDY = 0;
  2033. INT nCaptionDY = 0;
  2034. OnQueryNcMetrics(
  2035. nResizingFrameDX,
  2036. nResizingFrameDY,
  2037. nCaptionDY
  2038. );
  2040. CRect rcTest(
  2041. rcBar.left,
  2042. rcBar.top,
  2043. rcBar.right,
  2044. rcBar.top + nResizingFrameDY
  2045. );
  2046. if( rcTest.PtInRect( point ) )
  2047. nHit = HTTOP;
  2048. else
  2049. {
  2050. rcTest.SetRect(
  2051. rcBar.left,
  2052. rcBar.bottom - nResizingFrameDY,
  2053. rcBar.right,
  2054. rcBar.bottom
  2055. );
  2056. if( rcTest.PtInRect( point ) )
  2057. nHit = HTBOTTOM;
  2058. else
  2059. {
  2060. rcTest.SetRect(
  2061. rcBar.left,
  2062. rcBar.top,
  2063. rcBar.left + nResizingFrameDX,
  2064. rcBar.bottom
  2065. );
  2066. if( rcTest.PtInRect( point ) )
  2067. nHit = HTLEFT;
  2068. else
  2069. {
  2070. rcTest.SetRect(
  2071. rcBar.right - nResizingFrameDX,
  2072. rcBar.top,
  2073. rcBar.right,
  2074. rcBar.bottom
  2075. );
  2076. if( rcTest.PtInRect( point ) )
  2077. nHit = HTRIGHT;
  2078. else
  2079. {
  2080. rcTest.SetRect(
  2081. rcBar.left,
  2082. rcBar.top + nResizingFrameDY,
  2083. rcBar.right,
  2084. rcBar.top + nResizingFrameDY + nCaptionDY
  2085. );
  2086. if( rcTest.PtInRect( point ) )
  2087. nHit = HTCAPTION;
  2088. }
  2089. }
  2090. }
  2091. }
  2092. switch( nHit )
  2093. {
  2094. case HTTOP:
  2095. {
  2096. rcTest.SetRect(
  2097. rcBar.left,
  2098. rcBar.top,
  2099. rcBar.left + nCaptionDY,
  2100. rcBar.top + nResizingFrameDY
  2101. );
  2102. if( rcTest.PtInRect(point) )
  2103. nHit = HTTOPLEFT;
  2104. else
  2105. {
  2106. rcTest.SetRect(
  2107. rcBar.right - nResizingFrameDY,
  2108. rcBar.top,
  2109. rcBar.right,
  2110. rcBar.top + nResizingFrameDY
  2111. );
  2112. if( rcTest.PtInRect(point) )
  2113. nHit = HTTOPRIGHT;
  2114. }
  2115. }
  2116. break;
  2117. case HTBOTTOM:
  2118. {
  2119. rcTest.SetRect(
  2120. rcBar.left,
  2121. rcBar.bottom - nResizingFrameDY,
  2122. rcBar.left + nCaptionDY,
  2123. rcBar.bottom
  2124. );
  2125. if( rcTest.PtInRect(point) )
  2126. nHit = HTBOTTOMLEFT;
  2127. else
  2128. {
  2129. rcTest.SetRect(
  2130. rcBar.right - nResizingFrameDY,
  2131. rcBar.bottom - nResizingFrameDY,
  2132. rcBar.right,
  2133. rcBar.bottom
  2134. );
  2135. if( rcTest.PtInRect(point) )
  2136. nHit = HTBOTTOMRIGHT;
  2137. }
  2138. }
  2139. break;
  2140. case HTLEFT:
  2141. {
  2142. rcTest.SetRect(
  2143. rcBar.left,
  2144. rcBar.top,
  2145. rcBar.left + nResizingFrameDX,
  2146. rcBar.top + nCaptionDY
  2147. );
  2148. if( rcTest.PtInRect(point) )
  2149. nHit = HTTOPLEFT;
  2150. else
  2151. {
  2152. rcTest.SetRect(
  2153. rcBar.left,
  2154. rcBar.bottom - nCaptionDY,
  2155. rcBar.left + nResizingFrameDX,
  2156. rcBar.bottom
  2157. );
  2158. if( rcTest.PtInRect(point) )
  2159. nHit = HTBOTTOMLEFT;
  2160. }
  2161. }
  2162. break;
  2163. case HTRIGHT:
  2164. {
  2165. rcTest.SetRect(
  2166. rcBar.right - nResizingFrameDX,
  2167. rcBar.top,
  2168. rcBar.right,
  2169. rcBar.top + nCaptionDY
  2170. );
  2171. if( rcTest.PtInRect(point) )
  2172. nHit = HTTOPRIGHT;
  2173. else
  2174. {
  2175. rcTest.SetRect(
  2176. rcBar.right - nResizingFrameDX,
  2177. rcBar.bottom - nCaptionDY,
  2178. rcBar.right,
  2179. rcBar.bottom
  2180. );
  2181. if( rcTest.PtInRect(point) )
  2182. nHit = HTBOTTOMRIGHT;
  2183. }
  2184. }
  2185. break;
  2186. } // switch( nHit )
  2188. bool bNcRepaint = false;
  2189. if( pExtBar != NULL )
  2190. {
  2191. ASSERT_VALID( pExtBar );
  2192. UINT nHT = pExtBar->NcButtons_HitTest( point );
  2193. if( nHT != HTCLIENT )
  2194. {
  2195. pExtBar->m_bNcAreaBtnTracking = true;
  2196. if( pExtBar->_IsDockSiteCustomizeMode() )
  2197. SetTimer( 4, 20, NULL );
  2198. return nHT;
  2199. }
  2200. else
  2201. {
  2202. bNcRepaint = true;
  2203. pExtBar->m_bNcAreaBtnTracking = false;
  2204. }
  2205. if( pExtBar->IsFixedMode() )
  2206. {
  2207. bool bPaletteMode = false;
  2208. CExtToolControlBar * pToolBar =
  2209. DYNAMIC_DOWNCAST(
  2210. CExtToolControlBar,
  2211. pExtBar
  2212. );
  2213. if( pToolBar != NULL )
  2214. {
  2215. ASSERT_VALID( pToolBar );
  2216. bPaletteMode = pToolBar->m_bPaletteMode;
  2217. } // if( pToolBar != NULL )
  2218. switch( nHit )
  2219. {
  2220. case HTTOP:
  2221. case HTBOTTOM:
  2222. case HTLEFT:
  2223. case HTRIGHT:
  2224. if( bPaletteMode )
  2225. nHit = HTCAPTION;
  2226. break;
  2227. case HTTOPLEFT:
  2228. case HTTOPRIGHT:
  2229. nHit = bPaletteMode ? HTCAPTION : HTTOP;
  2230. break;
  2231. case HTBOTTOMLEFT:
  2232. case HTBOTTOMRIGHT:
  2233. nHit = bPaletteMode ? HTCAPTION : HTBOTTOM;
  2234. break;
  2235. } // switch( nHit )
  2236. } // if( pExtBar->IsFixedMode() )
  2237. } // if( pExtBar != NULL )
  2238. if( bNcRepaint )
  2239. // SendMessage( WM_NCPAINT );
  2240. PostMessage( WM_NCPAINT );
  2241. return nHit;
  2242. }
  2244. void CExtMiniDockFrameWnd::OnCancelMode() 
  2245. {
  2246. CMiniDockFrameWnd::OnCancelMode();
  2247. CExtPopupMenuWnd::CancelMenuTracking();
  2248. CWnd::CancelToolTips();
  2249. // ASSERT( ! CExtPopupMenuWnd::IsMenuTracking() );
  2250. if( _ResizingIsInProgress() )
  2251. _ResizingEnd();
  2252. }
  2254. void CExtMiniDockFrameWnd::OnPaint() 
  2255. {
  2256. CPaintDC dcPaint( this );
  2257. // return;
  2258. CRect rcClient;
  2259. GetClientRect( &rcClient );
  2260. if( rcClient.IsRectEmpty()
  2261. || (! dcPaint.RectVisible( &rcClient ) )
  2262. )
  2263. return;
  2264. CExtMemoryDC dc( &dcPaint, &rcClient );
  2265. CExtPaintManager::stat_ExcludeChildAreas(
  2266. dcPaint.GetSafeHdc(),
  2267. GetSafeHwnd()
  2268. );
  2269. if( (! PmBridge_GetPM()->GetCb2DbTransparentMode(this) )
  2270. || (! PmBridge_GetPM()->PaintDockerBkgnd( true, dc, this ) )
  2271. )
  2272. dc.FillSolidRect(
  2273. &rcClient,
  2274. PmBridge_GetPM()->GetColor(
  2275. CExtPaintManager::CLR_3DFACE_OUT,
  2276. this
  2277. )
  2278. );
  2279. }
  2281. __EXT_MFC_INT_PTR CExtMiniDockFrameWnd::OnToolHitTest(
  2282. CPoint point,
  2283. TOOLINFO * pTI
  2284. ) const
  2285. {
  2286. ASSERT_VALID( this );
  2288. if( pTI == NULL || m_wndToolTip.GetSafeHwnd() == NULL )
  2289. return -1;
  2291. const CControlBar * pBar = GetControlBar();
  2292. if( pBar == NULL )
  2293. return -1;
  2294. ASSERT_VALID( pBar );
  2295. if( (pBar->m_dwStyle & CBRS_TOOLTIPS) == NULL )
  2296. return -1;
  2298. __EXT_MFC_INT_PTR nRet = pBar->OnToolHitTest( point, pTI );
  2299. if( nRet < 0 )
  2300. return -1;
  2302. if( pTI->lpszText != NULL )
  2303. {
  2304. CExtMiniDockFrameWnd * pNCT = (CExtMiniDockFrameWnd *)this;
  2305. VERIFY(
  2306. pNCT->m_wndToolTip.AddTool(
  2307. pNCT,
  2308. pTI->lpszText,
  2309. &pTI->rect,
  2310. 1
  2311. )
  2312. );
  2313. }
  2315. return -1;
  2316. }
  2318. LRESULT CExtMiniDockFrameWnd::WindowProc( UINT message, WPARAM wParam, LPARAM lParam )
  2319. {
  2320. switch( message)
  2321. {
  2322. case WM_DESTROY:
  2323. m_bHelperNcActive = false;
  2324. break;
  2325. case WM_PRINT:
  2326. case WM_PRINTCLIENT:
  2327. {
  2328. CDC * pDC = CDC::FromHandle( (HDC) wParam );
  2329. if( (lParam&PRF_NONCLIENT) != 0 )
  2330. RenderNC( *pDC );
  2331. if( (lParam&PRF_CHILDREN) != 0 )
  2332. CExtPaintManager::stat_PrintChildren(
  2333. m_hWnd,
  2334. message,
  2335. pDC->GetSafeHdc(),
  2336. lParam
  2337. );
  2338. }
  2339. return (!0);
  2340. } // switch( message)
  2341. LRESULT lResult = CMiniDockFrameWnd::WindowProc( message, wParam, lParam );
  2342. return lResult;
  2343. }
  2345. BOOL CExtMiniDockFrameWnd::PreTranslateMessage( MSG* pMsg ) 
  2346. {
  2347. if( m_wndToolTip.GetSafeHwnd() != NULL )
  2348. m_wndToolTip.RelayEvent( pMsg );
  2349. return CMiniDockFrameWnd::PreTranslateMessage( pMsg );
  2350. }
  2352. BOOL CExtMiniDockFrameWnd::PreCreateWindow(CREATESTRUCT& cs) 
  2353. {
  2354. if( ! RegisterMiniDockFrameWndClass() )
  2355. {
  2356. ASSERT( FALSE );
  2357. return FALSE;
  2358. }
  2360. cs.lpszClass = __EXT_MINIDOCKFRAMEWND_CLASS_NAME;
  2362. if( ! CMiniDockFrameWnd::PreCreateWindow( cs ) )
  2363. {
  2364. ASSERT( FALSE );
  2365. return FALSE;
  2366. }
  2367. cs.dwExStyle |= WS_EX_TOOLWINDOW;
  2368. cs.dwExStyle &= ~(WS_EX_LAYOUTRTL|WS_EX_RTLREADING);
  2369. return TRUE;
  2370. }
  2372. void CExtMiniDockFrameWnd::RecalcLayout(BOOL bNotify /* = TRUE */ )
  2373. {
  2374. if( GetSafeHwnd() == NULL || m_bInRecalcLayout )
  2375. return;
  2376. //CExtControlBar * pExtBar = GetControlBarExt();
  2377. // if( pExtBar != NULL
  2378. // && (! pExtBar->IsFixedMode() )
  2379. // )
  2380. // {
  2381. // if( (GetStyle() & __REMOVED_NONFIXMODE_STYLES) != 0 )
  2382. // ModifyStyle( __REMOVED_NONFIXMODE_STYLES, 0 );
  2383. // }
  2384. CMiniDockFrameWnd::RecalcLayout( bNotify );
  2385. if( GetSafeHwnd() != NULL )
  2386. SendMessage( WM_NCPAINT );
  2387. }
  2389. void CExtMiniDockFrameWnd::OnQueryNcMetrics(
  2390. INT & nResizingFrameDX,
  2391. INT & nResizingFrameDY,
  2392. INT & nCaptionDY
  2393. )
  2394. {
  2395. PmBridge_GetPM()->Bar_MiniDockFrameGetNcMetrics(
  2396. nResizingFrameDX,
  2397. nResizingFrameDY,
  2398. nCaptionDY,
  2399. this,
  2400. GetControlBarExt()
  2401. );
  2402. }
  2404. bool CExtMiniDockFrameWnd::g_bMiniDockFrameWndClassRegistered = false;
  2406. bool CExtMiniDockFrameWnd::RegisterMiniDockFrameWndClass()
  2407. {
  2408. if( g_bMiniDockFrameWndClassRegistered )
  2409. return true;
  2410. WNDCLASS _wndClassInfo;
  2411. HINSTANCE hInst = ::AfxGetInstanceHandle();
  2412. if( ! ::GetClassInfo( hInst, __EXT_MINIDOCKFRAMEWND_CLASS_NAME, &_wndClassInfo ) )
  2413. {
  2414. _wndClassInfo.style = CS_GLOBALCLASS|CS_DBLCLKS;
  2415. _wndClassInfo.lpfnWndProc = ::DefWindowProc;
  2416. _wndClassInfo.cbClsExtra = _wndClassInfo.cbWndExtra = 0;
  2417. _wndClassInfo.hInstance = hInst;
  2418. _wndClassInfo.hIcon = NULL;
  2419. _wndClassInfo.hCursor = ::LoadCursor( NULL, IDC_ARROW );
  2420. ASSERT( _wndClassInfo.hCursor != NULL );
  2421. _wndClassInfo.hbrBackground = NULL; 
  2422. _wndClassInfo.lpszMenuName = NULL;
  2423. _wndClassInfo.lpszClassName = __EXT_MINIDOCKFRAMEWND_CLASS_NAME;
  2424. if( ! ::AfxRegisterClass( &_wndClassInfo ) )
  2425. {
  2426. ASSERT( FALSE );
  2427. //AfxThrowResourceException();
  2428. return false;
  2429. }
  2430. }
  2431. g_bMiniDockFrameWndClassRegistered = true;
  2432. return true;
  2433. }