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

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

界面编程

开发平台：

Visual C++

ExtScrollWnd.h：源码内容
  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. #if (!defined __EXT_SCROLLWND_H)
  23. #define __EXT_SCROLLWND_H
  25. #if _MSC_VER > 1000
  26. #pragma once
  27. #endif // _MSC_VER > 1000
  29. #if (!defined __EXT_MFC_DEF_H)
  30. #include <ExtMfcDef.h>
  31. #endif // __EXT_MFC_DEF_H
  33. #if (!defined __AFXTEMPL_H__)
  34. #include <AfxTempl.h>
  35. #endif
  37. #if (!defined __EXT_MOUSECAPTURESINK_H)
  38. #include <../Src/ExtMouseCaptureSink.h>
  39. #endif
  41. #if (!defined __EXT_CONTROLBAR_H)
  42. #include <ExtControlBar.h>
  43. #endif
  45. #if (!defined __EXT_HOOK_H)
  46. #include "../Src/ExtHook.h"
  47. #endif
  49. #if (!defined __EXT_PAINT_MANAGER_H)
  50. #include <ExtPaintManager.h>
  51. #endif
  53. #if (!defined __EXT_MEMORY_DC_H)
  54. #include <../Src/ExtMemoryDC.h>
  55. #endif
  57. #if (!defined __EXT_MFC_NO_SCROLLCONAINERWND)
  58. #if (!defined __EXT_LABEL_H)
  59. #include <ExtLabel.h>
  60. #endif
  61. #endif // (!defined __EXT_MFC_NO_SCROLLCONAINERWND)
  63. #define __EXT_SCROLL_NUMERIC_MAX INT_MAX
  65. /////////////////////////////////////////////////////////////////////////////
  66. // CExtScrollBar window
  68. class CExtNCSB_ScrollContainer;
  70. #define __EXT_ID_SCROLL_HERE 0x100
  71. #define __EXT_ID_SCROLL_EDGE_LOWER 0x101
  72. #define __EXT_ID_SCROLL_EDGE_UPPER 0x102
  73. #define __EXT_ID_SCROLL_PAGE_LOWER 0x103
  74. #define __EXT_ID_SCROLL_PAGE_UPPER 0x104
  75. #define __EXT_ID_SCROLL_LINE_LOWER 0x105
  76. #define __EXT_ID_SCROLL_LINE_UPPER 0x106
  78. class __PROF_UIS_API CExtScrollBar
  79. : public CScrollBar
  80. , public CExtAnimationSingleton
  81. , public CExtHookSpy
  82. {
  83. public:
  84. DECLARE_DYNCREATE( CExtScrollBar );
  85. CExtScrollBar();
  87. public:
  88. INT m_nStepSize;
  89. virtual INT GetStepSize() const;
  90. /*
  91. SCROLLINFO m_scrollInfo;
  92. */
  93. enum eScrollerOrientation_t
  94. {
  95. __ESO_TOP = 0,
  96. __ESO_BOTTOM = 1,
  97. __ESO_LEFT = 2,
  98. __ESO_RIGHT = 3,
  99. __ESO_AUTO = 4,
  100. __ESO_NONE = 5,
  101. __ESO_MIN_VALUE = 0,
  102. __ESO_MAX_VALUE = 5,
  103. };
  104. eScrollerOrientation_t m_eSO;
  105. bool m_bAutoDeleteOnPostNcDestroy:1, m_bReflectParentSizing:1,
  106. m_bDisableAutoReserveSpace:1, m_bHelperLightAccent:1,
  107. m_bAutoReserveSpaceBefore:1, m_bAutoReserveSpaceAfter:1,
  108. m_bCompleteRepaint:1, m_bSmoothPainting:1,
  109. m_bHideHwndBefore:1, m_bHideHwndAfter:1,
  110. m_bEnabledToolTips:1, m_bEnabledTrackingToolTips:1,
  111. m_bEnableHookSpy:1, m_bHookCapturedState:1,
  112. m_bSendActionNotifications:1, m_bPopupInactiveLightMode:1,
  113. m_bSendEqualNotifications:1;
  114. HWND m_hWndBefore, m_hWndAfter;
  115. CExtSafeString
  116. m_strTipTextForUpButton, m_strTipTextForDownButton,
  117. m_strTipTextForPageUpArea, m_strTipTextForPageDownArea,
  118. m_strTipTextForThumbButton;
  119. int m_nMouseActivateCode;
  121. virtual void SyncReservedSpace( CExtScrollBar * pOtherBar );
  122. virtual eScrollerOrientation_t GetScrollerOrientation() const;
  124. public:
  126. //{{AFX_VIRTUAL(CExtScrollBar)
  127. protected:
  128. virtual void PreSubclassWindow();
  129. virtual LRESULT DefWindowProc(UINT message, WPARAM wParam, LPARAM lParam);
  130. virtual LRESULT WindowProc(UINT message, WPARAM wParam, LPARAM lParam);
  131. //}}AFX_VIRTUAL
  133. public:
  134. virtual bool OnHookSpyPreTranslateMessage(
  135. MSG * pMSG
  136. );
  137. virtual bool OnHookSpyMouseMoveMsg(
  138. MSG * pMSG
  139. );
  140. virtual bool OnHookSpyMouseClickMsg(
  141. MSG * pMSG
  142. );
  143. bool ScrollBar_OnMouseMoveMsg(
  144. MSG * pMSG
  145. );
  146. bool ScrollBar_OnMouseClickMsg(
  147. MSG * pMSG
  148. );
  149. virtual HWND ScrollBar_CaptureGet() const;
  150. virtual void ScrollBar_CaptureSet();
  151. virtual void ScrollBar_CaptureRelease();
  152. virtual void ScrollBar_TrackMouseLButtonDown(
  153. MSG * pMSG
  154. );
  156. virtual void OnSbPaint( CDC & dc );
  158. virtual bool _IsLockAbleMessage( UINT message ) const;
  159. virtual INT _GetScrollPos(
  160. bool bTrackPos = false
  161. ) const;
  162. virtual void _SetScrollPos(
  163. INT nPos,
  164. bool bTrackPos = false,
  165. bool bRedraw = true,
  166. bool bSendScrollingNotification = true
  167. );
  168. virtual ~CExtScrollBar();
  169. CExtNCSB_ScrollContainer * _GetParentScrollContainer();
  170. virtual CExtPopupMenuTipWnd * OnAdvancedPopupMenuTipWndGet() const;
  171. virtual bool OnAdvancedPopupMenuTipWndGetInfo(
  172. CExtPopupMenuTipWnd & _ATTW,
  173. INT nSBMHT,
  174. bool bTrackingTip,
  175. CRect & rcExcludeArea,
  176. CExtSafeString & strTipText
  177. ) const;
  178. virtual void OnAdvancedPopupMenuTipWndDisplay(
  179. CExtPopupMenuTipWnd & _ATTW,
  180. INT nSBMHT,
  181. bool bTrackingTip
  182. ) const;
  183. virtual void OnAdvancedPopupMenuTipWndDisplay(
  184. CExtPopupMenuTipWnd & _ATTW,
  185. const RECT & rcExcludeArea,
  186. __EXT_MFC_SAFE_LPCTSTR strTipText,
  187. bool bTrackingTip
  188. ) const;
  189. virtual void PostNcDestroy();
  190. virtual bool AnimationClient_EnabledGet() const;
  191. virtual bool AnimationSite_EnabledGet() const;
  192. virtual void AnimationSite_OnProgressShutdownTimer( UINT nTimerID );
  193. virtual HWND AnimationSite_GetSafeHWND() const;
  194. virtual const CExtAnimationParameters *
  195. AnimationClient_OnQueryAnimationParameters(
  196. INT eAPT // __EAPT_*** animation type
  197. ) const;
  198. virtual bool AnimationClient_CacheNextState(
  199. CDC & dc,
  200. const RECT & rcAcAnimationTarget,
  201. bool bAnimate,
  202. INT eAPT // __EAPT_*** animation type
  203. );
  204. virtual void PmBridge_OnPaintManagerChanged(
  205. CExtPaintManager * pGlobalPM
  206. );
  207. INT m_nHorzBarHeight, m_nVertBarWidth,
  208. m_nHorzButtonWidth, m_nVertButtonHeight,
  209. m_nHorzThumbMinWidth, m_nVertThumbMinHeight;
  210. protected:
  211. virtual void _ScanSysMertics();
  212. bool m_bProcessingClick:1, m_bProcessingOutClick:1,
  213. m_bProcessingHover:1, m_bProcessingCancelMode:1,
  214. m_bHelperHaveTrackPos:1;
  215. INT m_nSBMHT, m_nHelperTrackPos;
  216. CPoint m_ptCtxMenuCache;
  217. public:
  218. bool m_bAlwaysSendThumbButtonNotifications:1, m_bEnableCtxMenu:1;
  220. protected:
  221. //{{AFX_MSG(CExtScrollBar)
  222. afx_msg BOOL OnEraseBkgnd(CDC* pDC);
  223. afx_msg void OnPaint();
  224.     afx_msg void OnWindowPosChanging(WINDOWPOS FAR* lpwndpos);
  225. afx_msg void OnWindowPosChanged(WINDOWPOS FAR* lpwndpos);
  226.     afx_msg void OnSize(UINT nType, int cx, int cy);
  227. afx_msg void OnNcCalcSize(BOOL bCalcValidRects, NCCALCSIZE_PARAMS FAR* lpncsp);
  228. afx_msg void OnContextMenu(CWnd* pWnd, CPoint point);
  229. afx_msg int OnMouseActivate(CWnd* pDesktopWnd, UINT nHitTest, UINT message);
  230. afx_msg void OnShowWindow(BOOL bShow, UINT nStatus);
  231. afx_msg void OnEnable(BOOL bEnable);
  232. afx_msg void OnCancelMode();
  233. afx_msg void OnCaptureChanged(CWnd *pWnd);
  234. afx_msg BOOL OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message);
  235. afx_msg void OnMouseMove(UINT nFlags, CPoint point);
  236. afx_msg void OnLButtonDown(UINT nFlags, CPoint point);
  237. afx_msg void OnLButtonUp(UINT nFlags, CPoint point);
  238. afx_msg void OnLButtonDblClk(UINT nFlags, CPoint point);
  239. afx_msg void OnMButtonDown(UINT nFlags, CPoint point);
  240. afx_msg void OnMButtonUp(UINT nFlags, CPoint point);
  241. afx_msg void OnMButtonDblClk(UINT nFlags, CPoint point);
  242. afx_msg void OnRButtonDown(UINT nFlags, CPoint point);
  243. afx_msg void OnRButtonUp(UINT nFlags, CPoint point);
  244. afx_msg void OnRButtonDblClk(UINT nFlags, CPoint point);
  245. //}}AFX_MSG
  246. afx_msg UINT OnNcHitTest(CPoint point);
  247. afx_msg void OnTimer(__EXT_MFC_UINT_PTR nIDEvent);
  248. afx_msg void OnSettingChange(UINT uFlags, __EXT_MFC_SAFE_LPCTSTR lpszSection);
  249. afx_msg LRESULT OnSizeParent( WPARAM wParam, LPARAM lParam );
  250. afx_msg void OnScrollHere();
  251. afx_msg void OnScrollEdgeLower();
  252. afx_msg void OnScrollEdgeUpper();
  253. afx_msg void OnScrollPageLower();
  254. afx_msg void OnScrollPageUpper();
  255. afx_msg void OnScrollLineLower();
  256. afx_msg void OnScrollLineUpper();
  257. DECLARE_MESSAGE_MAP()
  258. }; // class CExtScrollBar
  260. /////////////////////////////////////////////////////////////////////////////
  261. // CExtNSB template
  262. // Provides any CWnd with Prof-UIS CExtScrollBar nicer scroll bars.
  263. // CWnd should use RepositionBars for docking Prof-UIS scroll bars to its borders.
  265. template < class _BT >
  266. class CExtNSB : public _BT
  267. {
  268. public:
  269. mutable CExtScrollBar m_wndScrollBarH, m_wndScrollBarV;
  270. virtual bool NSB_EnsureScrollBarsCreated() const
  271. {
  272. if( m_wndScrollBarH.GetSafeHwnd() != NULL
  273. && m_wndScrollBarV.GetSafeHwnd() != NULL
  274. )
  275. return true;
  276. m_wndScrollBarH.m_eSO = CExtScrollBar::__ESO_BOTTOM;
  277. m_wndScrollBarV.m_eSO = CExtScrollBar::__ESO_RIGHT;
  278. if( m_wndScrollBarV.GetSafeHwnd() == NULL )
  279. {
  280. if( ! m_wndScrollBarV.Create(
  281. WS_CHILD|WS_VISIBLE|WS_CLIPSIBLINGS|WS_CLIPCHILDREN|SBS_VERT|SBS_RIGHTALIGN,
  282. CRect(0,0,0,0),
  283. ((CWnd*)this),
  284. 1
  285. )
  286. )
  287. {
  288. ASSERT( FALSE );
  289. return false;
  290. }
  291. }
  292. if( m_wndScrollBarH.GetSafeHwnd() == NULL )
  293. {
  294. if( ! m_wndScrollBarH.Create(
  295. WS_CHILD|WS_VISIBLE|WS_CLIPSIBLINGS|WS_CLIPCHILDREN|SBS_HORZ|SBS_BOTTOMALIGN,
  296. CRect(0,0,0,0),
  297. ((CWnd*)this),
  298. 2
  299. )
  300. )
  301. {
  302. ASSERT( FALSE );
  303. return false;
  304. }
  305. }
  306. m_wndScrollBarH.SyncReservedSpace( &m_wndScrollBarV );
  307. m_wndScrollBarV.SyncReservedSpace( &m_wndScrollBarH );
  308. return true;
  309. }
  310. virtual CScrollBar * GetScrollBarCtrl( int nBar ) const
  311. {
  312. ASSERT_VALID( this );
  313. switch( nBar )
  314. {
  315. case SB_HORZ:
  316. case SB_VERT:
  317. if( NSB_EnsureScrollBarsCreated() )
  318. {
  319. CExtScrollBar * pExtScrollBar = ( nBar == SB_HORZ ) ? (&m_wndScrollBarH) : (&m_wndScrollBarV);
  320. ASSERT_VALID( pExtScrollBar );
  321. ASSERT( pExtScrollBar->GetSafeHwnd() != NULL );
  322. //pExtScrollBar->m_bSendActionNotifications = false;
  323. return pExtScrollBar;
  324. }
  325. break;
  326. }
  327. return NULL;
  328. }
  329. }; // class CExtNSB
  331. /////////////////////////////////////////////////////////////////////////////
  332. // CExtZoomScrollBar window
  334. class __PROF_UIS_API CExtZoomScrollBar : public CExtScrollBar
  335. {
  336. // Construction
  337. public:
  339. DECLARE_DYNCREATE( CExtZoomScrollBar );
  340. CExtZoomScrollBar();
  342. public:
  344. //{{AFX_VIRTUAL(CExtZoomScrollBar)
  345. //}}AFX_VIRTUAL
  347. public:
  348. virtual ~CExtZoomScrollBar();
  350. protected:
  351. //{{AFX_MSG(CExtZoomScrollBar)
  352. //}}AFX_MSG
  353. DECLARE_MESSAGE_MAP()
  354. }; // class CExtZoomScrollBar
  356. /////////////////////////////////////////////////////////////////////////////
  357. // class CExtNCSB_ScrollContainer
  359. #define __EXT_NCSB_SCROLL_CONTAINER_CLASS_NAME _T("ProfUIS-NCSB_ScrollContainer")
  361. class __PROF_UIS_API CExtNCSB_ScrollContainer : public CWnd
  362. {
  363. public:
  364. enum e_mode_t
  365. {
  366. __EM_MIDDLE_CONTAINER = 0,
  367. __EM_CORNER_AREA = 1,
  368. __EM_HORIZONTAL_SCROLL_BAR = 2,
  369. __EM_VERTICAL_SCROLL_BAR = 3,
  370. __EM_MIN_VALUE = 0,
  371. __EM_MAX_VALUE = 3,
  372. };
  373. protected:
  374. mutable HWND m_hWndScrollingTaget;
  375. e_mode_t m_eMode;
  376. mutable CExtScrollBar * m_pWndScrollBar;
  377. public:
  378. DECLARE_DYNAMIC( CExtNCSB_ScrollContainer );
  379. CExtNCSB_ScrollContainer(
  380. HWND hWndScrollingTaget,
  381. e_mode_t eMode
  382. );
  383. virtual ~CExtNCSB_ScrollContainer();
  384. HWND GetSafeScrollingTargetHWND() const;
  385. CExtScrollBar * GetScrollBarInContainer() const;
  386. e_mode_t GetMode() const;
  387. virtual CExtScrollBar * OnInstantiateAndCreateScrollBar( bool bChildMode );
  388. virtual bool Create( CWnd * pWndParent );
  389. protected:
  390. virtual void PreSubclassWindow();
  391. virtual void PostNcDestroy();
  392. virtual LRESULT WindowProc( UINT message, WPARAM wParam, LPARAM lParam );
  393. }; /// class CExtNCSB_ScrollContainer
  395. /////////////////////////////////////////////////////////////////////////////
  396. // template class CExtNCSB_Impl
  397. // skin scroll bars of any window with non-client area scroll bars
  399. template < class _BTNCSBimpl >
  400. class CExtNCSB_Impl : public _BTNCSBimpl
  401. {
  402. protected:
  403. mutable HWND m_hWndNcsbContainerHorizontal, m_hWndNcsbContainerVertical, m_hWndNcsbContainerCorner, m_hWndNcsbContainerMiddle;
  404. mutable CExtNCSB_ScrollContainer * m_pNcsbContainerHorizontal, * m_pNcsbContainerVertical, * m_pNcsbContainerCorner, * m_pNcsbContainerMiddle;
  405. bool m_bNcsbHelperDestructionMode:1, m_bNcsbFirstPaintMessagePassed:1;
  406. public:
  407. CPoint m_ptNcsbProtectMouseMoveLast;
  408. bool m_bNcsbUse32BitScrollInfo:1, m_bNcsbForceMiddleContainerMode:1,
  409. m_bNcsbProtectMessageLoopFromMfcToolHitTesting:1, m_bNcsbDelayedInitialization:1,
  410. m_bNcsbForceRedrawOnMouseWheel:1, m_bNcsbCreatingContainers:1,
  411. m_bNcsbUpdateTargetWindowScrollInfoH:1, m_bNcsbUpdateTargetWindowScrollInfoV:1,
  412. m_bNcsbUpdateTargetWindowScrollPosH:1, m_bNcsbUpdateTargetWindowScrollPosV:1;
  413. CRect m_rcNcsbCustomNcAreaSizes;
  414. COLORREF m_clrNcsbCustomNcAreaFill;
  415. CExtNCSB_Impl(
  416. bool bNcsbDelayedInitialization = false,
  417. bool bNcsbForceMiddleContainerMode = false
  418. )
  419. : m_pNcsbContainerHorizontal( NULL )
  420. , m_pNcsbContainerVertical( NULL )
  421. , m_pNcsbContainerCorner( NULL )
  422. , m_pNcsbContainerMiddle( NULL )
  423. , m_hWndNcsbContainerHorizontal( NULL )
  424. , m_hWndNcsbContainerVertical( NULL )
  425. , m_hWndNcsbContainerCorner( NULL )
  426. , m_hWndNcsbContainerMiddle( NULL )
  427. , m_bNcsbUse32BitScrollInfo( true )
  428. , m_bNcsbHelperDestructionMode( false )
  429. , m_bNcsbDelayedInitialization( bNcsbDelayedInitialization )
  430. , m_bNcsbForceMiddleContainerMode( bNcsbForceMiddleContainerMode )
  431. , m_bNcsbProtectMessageLoopFromMfcToolHitTesting( true )
  432. , m_ptNcsbProtectMouseMoveLast( -32767, -32767 )
  433. , m_rcNcsbCustomNcAreaSizes( -1, -1, -1, -1 )
  434. , m_clrNcsbCustomNcAreaFill( COLORREF(-1L) )
  435. , m_bNcsbFirstPaintMessagePassed( false )
  436. , m_bNcsbForceRedrawOnMouseWheel( false )
  437. , m_bNcsbCreatingContainers( false )
  438. , m_bNcsbUpdateTargetWindowScrollInfoH( false )
  439. , m_bNcsbUpdateTargetWindowScrollInfoV( false )
  440. , m_bNcsbUpdateTargetWindowScrollPosH( false )
  441. , m_bNcsbUpdateTargetWindowScrollPosV( false )
  442. {
  443. }
  444. CExtNCSB_Impl(
  445. UINT nIDTemplate,
  446. CWnd * pParentWnd,
  447. bool bNcsbDelayedInitialization = false,
  448. bool bNcsbForceMiddleContainerMode = false
  449. )
  450. : _BTNCSBimpl( nIDTemplate, pParentWnd )
  451. , m_pNcsbContainerHorizontal( NULL )
  452. , m_pNcsbContainerVertical( NULL )
  453. , m_pNcsbContainerCorner( NULL )
  454. , m_pNcsbContainerMiddle( NULL )
  455. , m_hWndNcsbContainerHorizontal( NULL )
  456. , m_hWndNcsbContainerVertical( NULL )
  457. , m_hWndNcsbContainerCorner( NULL )
  458. , m_hWndNcsbContainerMiddle( NULL )
  459. , m_bNcsbUse32BitScrollInfo( true )
  460. , m_bNcsbHelperDestructionMode( false )
  461. , m_bNcsbDelayedInitialization( bNcsbDelayedInitialization )
  462. , m_bNcsbForceMiddleContainerMode( bNcsbForceMiddleContainerMode )
  463. , m_bNcsbProtectMessageLoopFromMfcToolHitTesting( true )
  464. , m_ptNcsbProtectMouseMoveLast( -32767, -32767 )
  465. , m_rcNcsbCustomNcAreaSizes( -1, -1, -1, -1 )
  466. , m_clrNcsbCustomNcAreaFill( COLORREF(-1L) )
  467. , m_bNcsbFirstPaintMessagePassed( false )
  468. , m_bNcsbForceRedrawOnMouseWheel( false )
  469. , m_bNcsbCreatingContainers( false )
  470. {
  471. }
  472. CExtNCSB_Impl(
  473. __EXT_MFC_SAFE_LPCTSTR lpszTemplateName,
  474. CWnd * pParentWnd,
  475. bool bNcsbDelayedInitialization = false,
  476. bool bNcsbForceMiddleContainerMode = false
  477. )
  478. : _BTNCSBimpl( lpszTemplateName, pParentWnd )
  479. , m_pNcsbContainerHorizontal( NULL )
  480. , m_pNcsbContainerVertical( NULL )
  481. , m_pNcsbContainerCorner( NULL )
  482. , m_pNcsbContainerMiddle( NULL )
  483. , m_hWndNcsbContainerHorizontal( NULL )
  484. , m_hWndNcsbContainerVertical( NULL )
  485. , m_hWndNcsbContainerCorner( NULL )
  486. , m_hWndNcsbContainerMiddle( NULL )
  487. , m_bNcsbUse32BitScrollInfo( true )
  488. , m_bNcsbHelperDestructionMode( false )
  489. , m_bNcsbDelayedInitialization( bNcsbDelayedInitialization )
  490. , m_bNcsbForceMiddleContainerMode( bNcsbForceMiddleContainerMode )
  491. , m_bNcsbProtectMessageLoopFromMfcToolHitTesting( true )
  492. , m_ptNcsbProtectMouseMoveLast( -32767, -32767 )
  493. , m_rcNcsbCustomNcAreaSizes( -1, -1, -1, -1 )
  494. , m_clrNcsbCustomNcAreaFill( COLORREF(-1L) )
  495. , m_bNcsbFirstPaintMessagePassed( false )
  496. , m_bNcsbForceRedrawOnMouseWheel( false )
  497. , m_bNcsbCreatingContainers( false )
  498. {
  499. }
  500. virtual ~CExtNCSB_Impl()
  501. {
  502. NCSB_EnsureContainersDestroyed();
  503. }
  504. virtual bool NCSB_IsDestructionMode() const
  505. {
  506. ASSERT_VALID( this );
  507. return m_bNcsbHelperDestructionMode;
  508. }
  509. virtual bool NCSB_IsMiddleContainerRequired() const
  510. {
  511. ASSERT_VALID( this );
  512. if( m_bNcsbForceMiddleContainerMode )
  513. return true;
  514. return false;
  515. }
  516. virtual CWnd * NCSB_GetParentWindow()
  517. {
  518. ASSERT_VALID( this );
  519. if( GetSafeHwnd() == NULL )
  520. return NULL;
  521. DWORD dwStyle = GetStyle();
  522. if( (dwStyle&WS_CHILD) == 0 )
  523. return this;
  524. CWnd * pWndParent = GetParent();
  525. if( pWndParent->GetSafeHwnd() == ::GetDesktopWindow() )
  526. return this;
  527. return pWndParent;
  528. }
  529. virtual bool NSCB_IsLeftScrollBarMode() const
  530. {
  531. ASSERT_VALID( this );
  532. DWORD dwStyleEx = GetExStyle();
  533. if( (dwStyleEx&WS_EX_LEFTSCROLLBAR) != 0 )
  534. return true;
  535. else
  536. return false;
  537. }
  538. virtual CExtNCSB_ScrollContainer * NCSB_GetContainer( CExtNCSB_ScrollContainer::e_mode_t eMode ) const
  539. {
  540. ASSERT_VALID( this );
  541. ASSERT( INT(CExtNCSB_ScrollContainer::__EM_MIN_VALUE) <= INT(eMode) && INT(eMode) <= INT(CExtNCSB_ScrollContainer::__EM_MAX_VALUE) );
  542. CExtNCSB_ScrollContainer * pWnd = NULL;
  543. HWND hWnd = NULL;
  544. switch( eMode )
  545. {
  546. case CExtNCSB_ScrollContainer::__EM_MIDDLE_CONTAINER:
  547. pWnd = m_pNcsbContainerMiddle;
  548. hWnd = m_hWndNcsbContainerMiddle;
  549. break;
  550. case CExtNCSB_ScrollContainer::__EM_CORNER_AREA:
  551. pWnd = m_pNcsbContainerCorner;
  552. hWnd = m_hWndNcsbContainerCorner;
  553. break;
  554. case CExtNCSB_ScrollContainer::__EM_HORIZONTAL_SCROLL_BAR:
  555. pWnd = m_pNcsbContainerHorizontal;
  556. hWnd = m_hWndNcsbContainerHorizontal;
  557. break;
  558. case CExtNCSB_ScrollContainer::__EM_VERTICAL_SCROLL_BAR:
  559. pWnd = m_pNcsbContainerVertical;
  560. hWnd = m_hWndNcsbContainerVertical;
  561. break;
  562. }
  563. if( pWnd == NULL
  564. || hWnd == NULL
  565. || (! ::IsWindow( hWnd ) )
  566. || LPVOID( CWnd::FromHandlePermanent( hWnd ) ) != LPVOID( pWnd )
  567. )
  568. return NULL;
  569. return pWnd;
  570. }
  571. virtual CExtNCSB_ScrollContainer * NCSB_InstantiateAndCreateContainer(
  572. CExtNCSB_ScrollContainer::e_mode_t eMode,
  573. CWnd * pWndParent
  574. )
  575. {
  576. ASSERT_VALID( this );
  577. if( NCSB_IsDestructionMode() || GetSafeHwnd() == NULL || pWndParent->GetSafeHwnd() == NULL )
  578. return NULL;
  579. ASSERT_VALID( pWndParent );
  580. CExtNCSB_ScrollContainer * pWnd =
  581. new CExtNCSB_ScrollContainer(
  582. m_hWnd,
  583. eMode
  584. );
  585. if( ! pWnd->Create( pWndParent ) )
  586. return NULL;
  587. return pWnd;
  588. }
  589. virtual bool NCSB_EnsureContainersCreated()
  590. {
  591. ASSERT_VALID( this );
  592. if( ! g_PaintManager.m_bAutoSkinScrollBars )
  593. return false;
  594. if( NCSB_IsDestructionMode() || GetSafeHwnd() == NULL )
  595. return false;
  596. if( m_pNcsbContainerHorizontal != NULL || m_pNcsbContainerVertical != NULL || m_pNcsbContainerCorner != NULL )
  597. {
  598. ASSERT( m_pNcsbContainerHorizontal != NULL && m_pNcsbContainerVertical != NULL && m_pNcsbContainerCorner != NULL );
  599. ASSERT( m_hWndNcsbContainerHorizontal != NULL && m_hWndNcsbContainerVertical != NULL && m_hWndNcsbContainerCorner != NULL );
  600. return true;
  601. }
  602. CWnd * pWndParent = NCSB_GetParentWindow();
  603. if( pWndParent == NULL )
  604. return false;
  605. ASSERT_VALID( pWndParent );
  606. ASSERT( pWndParent->GetSafeHwnd() != NULL );
  607. if( m_bNcsbCreatingContainers )
  608. return false;
  609. m_bNcsbCreatingContainers = true;
  610. if( NCSB_IsMiddleContainerRequired() )
  611. {
  612. ASSERT( (GetStyle()&WS_CHILD) != 0 );
  613. if( m_pNcsbContainerMiddle == NULL )
  614. {
  615. m_pNcsbContainerMiddle = NCSB_InstantiateAndCreateContainer( CExtNCSB_ScrollContainer::__EM_MIDDLE_CONTAINER, pWndParent );
  616. m_hWndNcsbContainerMiddle = m_pNcsbContainerMiddle->GetSafeHwnd();
  617. if( m_pNcsbContainerMiddle == NULL )
  618. {
  619. m_bNcsbCreatingContainers = false;
  620. return false;
  621. }
  622. }
  623. pWndParent = m_pNcsbContainerMiddle;
  624. ASSERT( LPVOID(pWndParent) == LPVOID(NCSB_GetParentWindow()) );
  625. }
  626. m_pNcsbContainerHorizontal = NCSB_InstantiateAndCreateContainer( CExtNCSB_ScrollContainer::__EM_HORIZONTAL_SCROLL_BAR, pWndParent );
  627. m_hWndNcsbContainerHorizontal = m_pNcsbContainerHorizontal->GetSafeHwnd();
  628. if( m_pNcsbContainerHorizontal == NULL )
  629. {
  630. NCSB_EnsureContainersDestroyed();
  631. m_pNcsbContainerHorizontal = m_pNcsbContainerVertical = m_pNcsbContainerCorner = m_pNcsbContainerMiddle = NULL;
  632. m_hWndNcsbContainerHorizontal = m_hWndNcsbContainerVertical = m_hWndNcsbContainerCorner = m_hWndNcsbContainerMiddle = NULL;
  633. m_bNcsbCreatingContainers = false;
  634. return false;
  635. }
  636. m_pNcsbContainerVertical = NCSB_InstantiateAndCreateContainer( CExtNCSB_ScrollContainer::__EM_VERTICAL_SCROLL_BAR, pWndParent );
  637. m_hWndNcsbContainerVertical = m_pNcsbContainerVertical->GetSafeHwnd();
  638. if( m_pNcsbContainerVertical == NULL )
  639. {
  640. NCSB_EnsureContainersDestroyed();
  641. m_pNcsbContainerHorizontal = m_pNcsbContainerVertical = m_pNcsbContainerCorner = m_pNcsbContainerMiddle = NULL;
  642. m_hWndNcsbContainerHorizontal = m_hWndNcsbContainerVertical = m_hWndNcsbContainerCorner = m_hWndNcsbContainerMiddle = NULL;
  643. m_bNcsbCreatingContainers = false;
  644. return false;
  645. }
  646. m_pNcsbContainerCorner = NCSB_InstantiateAndCreateContainer( CExtNCSB_ScrollContainer::__EM_CORNER_AREA, pWndParent );
  647. m_hWndNcsbContainerCorner = m_pNcsbContainerCorner->GetSafeHwnd();
  648. if( m_pNcsbContainerCorner == NULL )
  649. {
  650. NCSB_EnsureContainersDestroyed();
  651. m_pNcsbContainerHorizontal = m_pNcsbContainerVertical = m_pNcsbContainerCorner =  m_pNcsbContainerMiddle = NULL;
  652. m_hWndNcsbContainerHorizontal = m_hWndNcsbContainerVertical = m_hWndNcsbContainerCorner = m_hWndNcsbContainerMiddle = NULL;
  653. m_bNcsbCreatingContainers = false;
  654. return false;
  655. }
  656. m_bNcsbCreatingContainers = false;
  657. return true;
  658. }
  659. virtual void NCSB_EnsureContainersDestroyed()
  660. {
  661. ASSERT_VALID( this );
  662. CExtNCSB_ScrollContainer * pWnd;
  663. pWnd = NCSB_GetContainer( CExtNCSB_ScrollContainer::__EM_HORIZONTAL_SCROLL_BAR );
  664. if( pWnd->GetSafeHwnd() != NULL )
  665. pWnd->DestroyWindow();
  666. pWnd = NCSB_GetContainer( CExtNCSB_ScrollContainer::__EM_VERTICAL_SCROLL_BAR );
  667. if( pWnd->GetSafeHwnd() != NULL )
  668. pWnd->DestroyWindow();
  669. pWnd = NCSB_GetContainer( CExtNCSB_ScrollContainer::__EM_CORNER_AREA );
  670. if( pWnd->GetSafeHwnd() != NULL )
  671. pWnd->DestroyWindow();
  672. pWnd = NCSB_GetContainer( CExtNCSB_ScrollContainer::__EM_MIDDLE_CONTAINER );
  673. if( pWnd->GetSafeHwnd() != NULL )
  674. pWnd->PostMessage( WM_CLOSE );
  675. }
  676. virtual INT NCSB_GetScrollBarExtent( bool bHorizontal )
  677. {
  678. ASSERT_VALID( this );
  679. INT nExtent = (INT)::GetSystemMetrics( bHorizontal ? SM_CYHSCROLL : SM_CXVSCROLL );
  680. return nExtent;
  681. }
  682. virtual void NCSB_GetScrollInfoWindow( bool bHorizontal, SCROLLINFO & _scroll_info )
  683. {
  684. ASSERT_VALID( this );
  685. ::memset( &_scroll_info, 0, sizeof(SCROLLINFO) );
  686. _scroll_info.cbSize = sizeof(SCROLLINFO);
  687. if( NCSB_IsDestructionMode() || GetSafeHwnd() == NULL )
  688. return;
  689. int nBar = bHorizontal ? SB_HORZ : SB_VERT;
  690. if( m_bNcsbUse32BitScrollInfo )
  691. {
  692. if( ((CWnd*)(this)) ->
  693. CWnd::GetScrollInfo(
  694. nBar,
  695. &_scroll_info,
  696. SIF_RANGE|SIF_PAGE|SIF_POS|SIF_TRACKPOS
  697. )
  698. )
  699. return;
  700. } // if( m_bNcsbUse32BitScrollInfo )
  701. INT nMin = 0, nMax = 0;
  702. CWnd::GetScrollRange( nBar, &nMin, &nMax );
  703. _scroll_info.nMin = nMin;
  704. _scroll_info.nMax = nMax;
  705. _scroll_info.nPos = _scroll_info.nTrackPos = CWnd::GetScrollPos( nBar );
  706. }
  707. virtual void NCSB_SetScrollInfoWindow( bool bHorizontal, SCROLLINFO & _scroll_info )
  708. {
  709. ASSERT_VALID( this );
  710. ::memset( &_scroll_info, 0, sizeof(SCROLLINFO) );
  711. _scroll_info.cbSize = sizeof(SCROLLINFO);
  712. if( NCSB_IsDestructionMode() || GetSafeHwnd() == NULL )
  713. return;
  714. int nBar = bHorizontal ? SB_HORZ : SB_VERT;
  715. if( m_bNcsbUse32BitScrollInfo )
  716. {
  717. if( ((CWnd*)(this)) ->
  718. CWnd::SetScrollInfo(
  719. nBar,
  720. &_scroll_info
  721. )
  722. )
  723. return;
  724. } // if( m_bNcsbUse32BitScrollInfo )
  725. if( ( _scroll_info.fMask & SIF_RANGE ) != 0 )
  726. CWnd::SetScrollRange( nBar, _scroll_info.nMin, _scroll_info.nMax );
  727. if( ( _scroll_info.fMask & SIF_POS ) != 0 )
  728. CWnd::SetScrollPos( nBar, _scroll_info.nPos );
  729. }
  730. virtual void NCSB_GetScrollInfoBar( CExtScrollBar * pScrollBar, SCROLLINFO & _scroll_info )
  731. {
  732. ASSERT_VALID( this );
  733. ::memset( &_scroll_info, 0, sizeof(SCROLLINFO) );
  734. _scroll_info.cbSize = sizeof(SCROLLINFO);
  735. if( NCSB_IsDestructionMode() || GetSafeHwnd() == NULL )
  736. return;
  737. ASSERT_VALID( pScrollBar );
  738. ASSERT( pScrollBar->GetSafeHwnd() != NULL );
  739. if( m_bNcsbUse32BitScrollInfo )
  740. {
  741. if( pScrollBar->GetScrollInfo(
  742. &_scroll_info,
  743. SIF_RANGE|SIF_PAGE|SIF_POS|SIF_TRACKPOS
  744. )
  745. )
  746. return;
  747. } // if( m_bNcsbUse32BitScrollInfo )
  748. INT nMin = 0, nMax = 0;
  749. pScrollBar->GetScrollRange( &nMin, &nMax );
  750. _scroll_info.nMin = nMin;
  751. _scroll_info.nMax = nMax;
  752. _scroll_info.nPos = _scroll_info.nTrackPos = pScrollBar->GetScrollPos();
  753. }
  754. virtual void NCSB_UpdateChannelPos( bool bHorizontal, bool bTrackPos )
  755. {
  756. ASSERT_VALID( this );
  757. if( NCSB_IsDestructionMode() || GetSafeHwnd() == NULL )
  758. return;
  759. CExtNCSB_ScrollContainer * pWnd =
  760. NCSB_GetContainer(
  761. bHorizontal
  762. ? CExtNCSB_ScrollContainer::__EM_HORIZONTAL_SCROLL_BAR
  763. : CExtNCSB_ScrollContainer::__EM_VERTICAL_SCROLL_BAR
  764. );
  765. if( pWnd == NULL )
  766. return;
  767. ASSERT( pWnd->GetSafeHwnd() != NULL );
  768. CExtScrollBar * pScrollBar = pWnd->GetScrollBarInContainer();
  769. if( pScrollBar == NULL )
  770. return;
  771. ASSERT( pScrollBar->GetSafeHwnd() != NULL );
  772. int nBar = bHorizontal ? SB_HORZ : SB_VERT;
  773. INT nPos = (INT)pScrollBar->_GetScrollPos( bTrackPos );
  774. CWnd::SetScrollPos( nBar, nPos );
  775. }
  776. virtual void NCSB_UpdateChannel( bool bHorizontal )
  777. {
  778. ASSERT_VALID( this );
  779. if( NCSB_IsDestructionMode() || GetSafeHwnd() == NULL )
  780. return;
  781. CExtNCSB_ScrollContainer * pWnd =
  782. NCSB_GetContainer(
  783. bHorizontal
  784. ? CExtNCSB_ScrollContainer::__EM_HORIZONTAL_SCROLL_BAR
  785. : CExtNCSB_ScrollContainer::__EM_VERTICAL_SCROLL_BAR
  786. );
  787. if( pWnd == NULL )
  788. return;
  789. ASSERT( pWnd->GetSafeHwnd() != NULL );
  790. CExtScrollBar * pScrollBar = pWnd->GetScrollBarInContainer();
  791. if( pScrollBar == NULL )
  792. return;
  793. ASSERT( pScrollBar->GetSafeHwnd() != NULL );
  794. BOOL bWindowEnabled = IsWindowEnabled();
  795. pWnd->EnableWindow( bWindowEnabled );
  796. SCROLLINFO _scroll_info_window, _scroll_info_bar;
  797. ::memset( &_scroll_info_window, 0, sizeof(SCROLLINFO) );
  798. ::memset( &_scroll_info_bar, 0, sizeof(SCROLLINFO) );
  799. _scroll_info_window.cbSize = sizeof(SCROLLINFO);
  800. _scroll_info_bar.cbSize = sizeof(SCROLLINFO);
  801. if( bWindowEnabled )
  802. {
  803. NCSB_GetScrollInfoWindow( bHorizontal, _scroll_info_window );
  804. NCSB_GetScrollInfoBar( pScrollBar, _scroll_info_bar );
  805. }
  806. //_scroll_info_window.fMask = _scroll_info_bar.fMask = SIF_POS|SIF_TRACKPOS;
  807. //_scroll_info_window.nMin = _scroll_info_window.nMax = _scroll_info_window.nPage
  808. // = _scroll_info_bar.nMin = _scroll_info_bar.nMax = _scroll_info_bar.nPage
  809. // = 0;
  810. if( ::memcmp( &_scroll_info_window, &_scroll_info_bar, sizeof(SCROLLINFO) ) != 0 )
  811. NCSB_SetScrollInfoWindow( bHorizontal, _scroll_info_bar );
  812. }
  813. virtual void NCSB_RescanChannel( bool bHorizontal )
  814. {
  815. ASSERT_VALID( this );
  816. if( NCSB_IsDestructionMode() || GetSafeHwnd() == NULL )
  817. return;
  818. CExtNCSB_ScrollContainer * pWnd =
  819. NCSB_GetContainer(
  820. bHorizontal
  821. ? CExtNCSB_ScrollContainer::__EM_HORIZONTAL_SCROLL_BAR
  822. : CExtNCSB_ScrollContainer::__EM_VERTICAL_SCROLL_BAR
  823. );
  824. if( pWnd == NULL )
  825. return;
  826. ASSERT( pWnd->GetSafeHwnd() != NULL );
  827. CExtScrollBar * pScrollBar = pWnd->GetScrollBarInContainer();
  828. if( pScrollBar == NULL )
  829. return;
  830. ASSERT( pScrollBar->GetSafeHwnd() != NULL );
  831. BOOL bWindowEnabled = IsWindowEnabled();
  832. pWnd->EnableWindow( bWindowEnabled );
  833. SCROLLINFO _scroll_info_window, _scroll_info_bar;
  834. ::memset( &_scroll_info_window, 0, sizeof(SCROLLINFO) );
  835. ::memset( &_scroll_info_bar, 0, sizeof(SCROLLINFO) );
  836. _scroll_info_window.cbSize = sizeof(SCROLLINFO);
  837. _scroll_info_bar.cbSize = sizeof(SCROLLINFO);
  838. if( bWindowEnabled )
  839. {
  840. NCSB_GetScrollInfoWindow( bHorizontal, _scroll_info_window );
  841. NCSB_GetScrollInfoBar( pScrollBar, _scroll_info_bar );
  842. }
  843. if( ::memcmp( &_scroll_info_window, &_scroll_info_bar, sizeof(SCROLLINFO) ) != 0 )
  844. {
  845. if( m_bNcsbUse32BitScrollInfo )
  846. pScrollBar->SetScrollInfo( &_scroll_info_window, FALSE );
  847. else
  848. {
  849. pScrollBar->SetScrollRange( _scroll_info_window.nMin, _scroll_info_window.nMax, FALSE );
  850. pScrollBar->SetScrollPos( _scroll_info_window.nPos, FALSE );
  851. }
  852. }
  853. BOOL bEnable =
  854. ( bWindowEnabled
  855. && ( _scroll_info_window.nMin < _scroll_info_window.nMax )
  856. && ( _scroll_info_window.nPage == 0
  857. || INT( _scroll_info_window.nMax - _scroll_info_window.nMin + 1 ) > INT(_scroll_info_window.nPage)
  858. )
  859. ) ? TRUE : FALSE;
  860. pScrollBar->EnableWindow( bEnable );
  861. pScrollBar->Invalidate();
  862. pScrollBar->UpdateWindow();
  863. }
  864. virtual void NCSB_RescanContainers()
  865. {
  866. ASSERT_VALID( this );
  867. if( NCSB_IsDestructionMode() || GetSafeHwnd() == NULL )
  868. return;
  869. NCSB_RescanChannel( true );
  870. NCSB_RescanChannel( false );
  871. CExtNCSB_ScrollContainer * pWndC = NCSB_GetContainer( CExtNCSB_ScrollContainer::__EM_CORNER_AREA );
  872. if( pWndC != NULL )
  873. {
  874. ASSERT( pWndC->GetSafeHwnd() != NULL );
  875. pWndC->Invalidate();
  876. pWndC->UpdateWindow();
  877. }
  878. }
  879. virtual bool NCSB_RepositionContainers( bool bRescanScrollPositions = true )
  880. {
  881. ASSERT_VALID( this );
  882. if( NCSB_IsDestructionMode() || GetSafeHwnd() == NULL )
  883. return false;
  884. CWnd * pWndParent = NCSB_GetParentWindow();
  885. if( pWndParent == NULL )
  886. {
  887. NCSB_EnsureContainersDestroyed();
  888. m_pNcsbContainerHorizontal = m_pNcsbContainerVertical = m_pNcsbContainerCorner =  m_pNcsbContainerMiddle = NULL;
  889. m_hWndNcsbContainerHorizontal = m_hWndNcsbContainerVertical = m_hWndNcsbContainerCorner = m_hWndNcsbContainerMiddle = NULL;
  890. return false;
  891. }
  892. ASSERT( pWndParent->GetSafeHwnd() != NULL );
  893. if( ! NCSB_EnsureContainersCreated() )
  894. return false;
  895. CExtNCSB_ScrollContainer * pWndH = NCSB_GetContainer( CExtNCSB_ScrollContainer::__EM_HORIZONTAL_SCROLL_BAR );
  896. CExtNCSB_ScrollContainer * pWndV = NCSB_GetContainer( CExtNCSB_ScrollContainer::__EM_VERTICAL_SCROLL_BAR );
  897. CExtNCSB_ScrollContainer * pWndC = NCSB_GetContainer( CExtNCSB_ScrollContainer::__EM_CORNER_AREA );
  898. CRect rcClient, rcLarger;
  899. GetClientRect( &rcClient );
  900. rcLarger = rcClient;
  901. bool bShowH = false, bShowV = false;
  902. DWORD dwStyle = GetStyle();
  903. bool bLeftScrollBarMode = NSCB_IsLeftScrollBarMode();
  904. if( (dwStyle&WS_HSCROLL) != 0 )
  905. {
  906. if( (dwStyle&WS_VISIBLE) != 0 )
  907. bShowH = true;
  908. rcLarger.bottom += NCSB_GetScrollBarExtent( true );
  909. }
  910. if( (dwStyle&WS_VSCROLL) != 0 )
  911. {
  912. if( (dwStyle&WS_VISIBLE) != 0 )
  913. bShowV = true;
  914. if( bLeftScrollBarMode )
  915. rcLarger.left -= NCSB_GetScrollBarExtent( false );
  916. else
  917. rcLarger.right += NCSB_GetScrollBarExtent( false );
  918. }
  919. const CWnd * pWndInsertAfter = &CWnd::wndTop;
  920. bool bChildMode = ( (dwStyle&WS_CHILD) != 0 ) ? true : false;
  921. if( bChildMode && ::GetParent(m_hWnd) == ::GetDesktopWindow() )
  922. bChildMode = false;
  923. UINT nBasecSetWindowPosFlags = SWP_NOCOPYBITS|SWP_NOOWNERZORDER;
  924. if( ! bChildMode )
  925. {
  926. pWndInsertAfter = &wndTopMost; // pWndParent;
  927. nBasecSetWindowPosFlags |= SWP_NOACTIVATE;
  928. }
  929. bool bShowC = ( bShowH && bShowV ) ? true : false;
  930. bool bVisibleH = false, bVisibleV = false, bVisibleC = false;
  931. if( pWndH != NULL )
  932. {
  933. ASSERT( pWndH->GetSafeHwnd() != NULL );
  934. if( (pWndH->GetStyle()&WS_VISIBLE) != 0 )
  935. bVisibleH = true;
  936. }
  937. if( pWndV != NULL )
  938. {
  939. ASSERT( pWndV->GetSafeHwnd() != NULL );
  940. if( (pWndV->GetStyle()&WS_VISIBLE) != 0 )
  941. bVisibleV = true;
  942. }
  943. if( pWndC != NULL )
  944. {
  945. ASSERT( pWndC->GetSafeHwnd() != NULL );
  946. if( (pWndC->GetStyle()&WS_VISIBLE) != 0 )
  947. bVisibleC = true;
  948. }
  949. bool bAnyMoved = false;
  950. if( pWndH != NULL )
  951. {
  952. ASSERT( pWndH->GetSafeHwnd() != NULL );
  953. CRect rcReal, rc(
  954. rcClient.left,
  955. rcClient.bottom,
  956. rcClient.right,
  957. rcLarger.bottom
  958. );
  959. ClientToScreen( &rc );
  960. pWndH->GetWindowRect( &rcReal );
  961. if( bVisibleH != bShowH || rcReal != rc )
  962. {
  963. bAnyMoved = true;
  964. if( bChildMode )
  965. pWndParent->ScreenToClient( &rc );
  966. pWndH->SetWindowPos(
  967. pWndInsertAfter, rc.left, rc.top, rc.Width(), rc.Height(),
  968. nBasecSetWindowPosFlags | ( bShowH ? SWP_SHOWWINDOW : SWP_HIDEWINDOW )
  969. );
  970. } // if( rcReal != rc )
  971. }
  972. if( pWndV != NULL )
  973. {
  974. ASSERT( pWndV->GetSafeHwnd() != NULL );
  975. CRect rcReal, rc(
  976. bLeftScrollBarMode ? rcLarger.left : rcClient.right,
  977. rcClient.top,
  978. bLeftScrollBarMode ? rcClient.left : rcLarger.right,
  979. rcClient.bottom
  980. );
  981. ClientToScreen( &rc );
  982. pWndV->GetWindowRect( &rcReal );
  983. if( bVisibleV != bShowV || rcReal != rc )
  984. {
  985. bAnyMoved = true;
  986. if( bChildMode )
  987. pWndParent->ScreenToClient( &rc );
  988. pWndV->SetWindowPos(
  989. pWndInsertAfter, rc.left, rc.top, rc.Width(), rc.Height(),
  990. nBasecSetWindowPosFlags | ( bShowV ? SWP_SHOWWINDOW : SWP_HIDEWINDOW )
  991. );
  992. } // if( rcReal != rc )
  993. }
  994. if( pWndC != NULL )
  995. {
  996. ASSERT( pWndC->GetSafeHwnd() != NULL );
  997. CRect rcReal, rc(
  998. bLeftScrollBarMode ? rcLarger.left : rcClient.right,
  999. rcClient.bottom,
  1000. bLeftScrollBarMode ? rcClient.left : rcLarger.right,
  1001. rcLarger.bottom
  1002. );
  1003. ClientToScreen( &rc );
  1004. pWndC->GetWindowRect( &rcReal );
  1005. if( bVisibleC != bShowC || rcReal != rc )
  1006. {
  1007. bAnyMoved = true;
  1008. if( bChildMode )
  1009. pWndParent->ScreenToClient( &rc );
  1010. pWndC->SetWindowPos(
  1011. pWndInsertAfter, rc.left, rc.top, rc.Width(), rc.Height(),
  1012. nBasecSetWindowPosFlags | ( bShowC ? SWP_SHOWWINDOW : SWP_HIDEWINDOW )
  1013. );
  1014. } // if( rcReal != rc )
  1015. }
  1016. if( bRescanScrollPositions )
  1017. NCSB_RescanContainers();
  1018. return bAnyMoved;
  1019. }
  1020. virtual bool NSCB_MessageCanAffectScrollBars( UINT message ) const
  1021. {
  1022. ASSERT_VALID( this );
  1023. if( ( __EXT_MFC_WM_MOUSEFIRST <= message && message <= __EXT_MFC_WM_MOUSELAST )
  1024. || ( WM_KEYFIRST <= message && message <= WM_KEYLAST )
  1025. )
  1026. return true;
  1027. return false;
  1028. }
  1029. protected:
  1030. virtual void PreSubclassWindow()
  1031. {
  1032. m_bNcsbHelperDestructionMode = false;
  1033. _BTNCSBimpl::PreSubclassWindow();
  1034. TCHAR szCompare[512] = _T("");
  1035. ::GetClassName(
  1036. m_hWnd,
  1037. szCompare,
  1038. sizeof( szCompare )/sizeof( szCompare[0] )
  1039. );
  1040. if( ! m_bNcsbForceRedrawOnMouseWheel )
  1041. {
  1042. if( _tcsicmp( szCompare, _T("LISTBOX") ) == 0
  1043. || _tcsicmp( szCompare, _T("COMBOLBOX") ) == 0
  1044. )
  1045. m_bNcsbForceRedrawOnMouseWheel = true;
  1046. }
  1047. if( g_PaintManager.m_bIsWinVistaOrLater
  1048. && _tcsicmp( szCompare, _T("SysTreeView32") ) == 0
  1049. )
  1050. m_bNcsbUpdateTargetWindowScrollPosH = m_bNcsbUpdateTargetWindowScrollPosV = true;
  1051. if( ( GetStyle() & (WS_CLIPCHILDREN|WS_CLIPSIBLINGS) ) != (WS_CLIPCHILDREN|WS_CLIPSIBLINGS) )
  1052. ModifyStyle( 0, WS_CLIPCHILDREN|WS_CLIPSIBLINGS );
  1053. if( ! m_bNcsbDelayedInitialization )
  1054. NCSB_RepositionContainers();
  1055. }
  1056. virtual void PostNcDestroy()
  1057. {
  1058. m_bNcsbHelperDestructionMode = true;
  1059. m_bNcsbFirstPaintMessagePassed = true;
  1060. //NCSB_EnsureContainersDestroyed();
  1061. m_pNcsbContainerHorizontal = m_pNcsbContainerVertical = m_pNcsbContainerCorner = m_pNcsbContainerMiddle = NULL;
  1062. m_hWndNcsbContainerHorizontal = m_hWndNcsbContainerVertical = m_hWndNcsbContainerCorner = m_hWndNcsbContainerMiddle = NULL;
  1063. m_ptNcsbProtectMouseMoveLast.x = m_ptNcsbProtectMouseMoveLast.y = -32767;
  1064. _BTNCSBimpl::PostNcDestroy();
  1065. }
  1066. virtual LRESULT WindowProc( UINT message, WPARAM wParam, LPARAM lParam )
  1067. {
  1068. if( ( ! g_PaintManager.m_bAutoSkinScrollBars )
  1069. || ( (! m_bNcsbFirstPaintMessagePassed)
  1070. && message != WM_ERASEBKGND
  1071. && message != WM_PAINT
  1072. && message != WM_NCPAINT
  1073. )
  1074. )
  1075. return _BTNCSBimpl::WindowProc( message, wParam, lParam );;
  1076. switch( message )
  1077. {
  1078. case WM_NCCALCSIZE:
  1079. if( m_rcNcsbCustomNcAreaSizes.left >= 0
  1080. && m_rcNcsbCustomNcAreaSizes.top >= 0
  1081. && m_rcNcsbCustomNcAreaSizes.right >= 0
  1082. && m_rcNcsbCustomNcAreaSizes.bottom >= 0
  1083. )
  1084. {
  1085. NCCALCSIZE_PARAMS * pNCCSP =
  1086. reinterpret_cast < NCCALCSIZE_PARAMS * > ( lParam );
  1087. ASSERT( pNCCSP != NULL );
  1088. CRect rcCalcClient( pNCCSP->rgrc[0] );
  1089. rcCalcClient.DeflateRect( &m_rcNcsbCustomNcAreaSizes );
  1090. DWORD dwStyle = GetStyle();
  1091. bool bLeftScrollBarMode = NSCB_IsLeftScrollBarMode();
  1092. if( (dwStyle&WS_HSCROLL) != 0 )
  1093. rcCalcClient.bottom -= NCSB_GetScrollBarExtent( true );
  1094. if( (dwStyle&WS_VSCROLL) != 0 )
  1095. {
  1096. if( bLeftScrollBarMode )
  1097. rcCalcClient.left += NCSB_GetScrollBarExtent( false );
  1098. else
  1099. rcCalcClient.right -= NCSB_GetScrollBarExtent( false );
  1100. }
  1101. ::CopyRect( &(pNCCSP->rgrc[0]), rcCalcClient );
  1102. return 0L;
  1103. }
  1104. break;
  1105. case WM_NCPAINT:
  1106. m_bNcsbFirstPaintMessagePassed = true;
  1107. if( m_rcNcsbCustomNcAreaSizes.left >= 0
  1108. && m_rcNcsbCustomNcAreaSizes.top >= 0
  1109. && m_rcNcsbCustomNcAreaSizes.right >= 0
  1110. && m_rcNcsbCustomNcAreaSizes.bottom >= 0
  1111. )
  1112. {
  1113. CRect rcInBarWnd, rcInBarClient;
  1114. GetWindowRect( &rcInBarWnd );
  1115. GetClientRect( &rcInBarClient );
  1116. ClientToScreen( &rcInBarClient );
  1117. if( rcInBarWnd == rcInBarClient )
  1118. return 0;
  1119. CPoint ptDevOffset = -rcInBarWnd.TopLeft();
  1120. rcInBarWnd.OffsetRect( ptDevOffset );
  1121. rcInBarClient.OffsetRect( ptDevOffset );
  1122. CWindowDC dcWindow( this );
  1123. dcWindow.ExcludeClipRect( &rcInBarClient );
  1124. CExtMemoryDC dc( &dcWindow );
  1125. if( m_clrNcsbCustomNcAreaFill != COLORREF(-1L) )
  1126. dc.FillSolidRect( &rcInBarWnd, m_clrNcsbCustomNcAreaFill );
  1127. else if( ! g_PaintManager->PaintDockerBkgnd( true, dc, this ) )
  1128. dc.FillSolidRect( &rcInBarWnd, g_PaintManager->GetColor( COLOR_3DDKSHADOW ) );
  1129. dc.__Flush();
  1130. NCSB_RepositionContainers();
  1131. return 0;
  1132. }
  1133. NCSB_RepositionContainers();
  1134. break;
  1135. case WM_MOUSEMOVE:
  1136. if( m_bNcsbProtectMessageLoopFromMfcToolHitTesting )
  1137. {
  1138. CPoint point( short(LOWORD(DWORD(lParam))), short(HIWORD(DWORD(lParam))) );
  1139. if( m_ptNcsbProtectMouseMoveLast == point )
  1140. return 0;
  1141. m_ptNcsbProtectMouseMoveLast = point;
  1142. }
  1143. break;
  1144. case WM_WINDOWPOSCHANGED:
  1145. case WM_SHOWWINDOW:
  1146. case WM_SIZE:
  1147. case WM_ENABLE:
  1148. NCSB_RepositionContainers();
  1149. break;
  1150. case WM_DESTROY:
  1151. m_bNcsbHelperDestructionMode = true;
  1152. NCSB_EnsureContainersDestroyed();
  1153. m_pNcsbContainerHorizontal = m_pNcsbContainerVertical = m_pNcsbContainerCorner = m_pNcsbContainerMiddle = NULL;
  1154. m_hWndNcsbContainerHorizontal = m_hWndNcsbContainerVertical = m_hWndNcsbContainerCorner = m_hWndNcsbContainerMiddle = NULL;
  1155. break;
  1156. default:
  1157. if( NSCB_MessageCanAffectScrollBars( message ) )
  1158. {
  1159. if( NCSB_RepositionContainers() )
  1160. Invalidate();
  1161. }
  1162. break;
  1163. case WM_PAINT:
  1164. case WM_ERASEBKGND:
  1165. m_bNcsbFirstPaintMessagePassed = true;
  1166. break;
  1167. } // switch( message )
  1168. LRESULT lResult = _BTNCSBimpl::WindowProc( message, wParam, lParam );
  1169. switch( message )
  1170. {
  1171. case WM_HSCROLL:
  1172. NCSB_RescanContainers();
  1173. if( m_bNcsbUpdateTargetWindowScrollInfoH )
  1174. NCSB_UpdateChannel( true );
  1175. else if( m_bNcsbUpdateTargetWindowScrollPosH )
  1176. NCSB_UpdateChannelPos( true, true );
  1177. break;
  1178. case WM_VSCROLL:
  1179. NCSB_RescanContainers();
  1180. if( m_bNcsbUpdateTargetWindowScrollInfoV )
  1181. NCSB_UpdateChannel( false );
  1182. else if( m_bNcsbUpdateTargetWindowScrollPosV )
  1183. NCSB_UpdateChannelPos( false, true );
  1184. break;
  1185. case WM_PAINT:
  1186. NCSB_RescanContainers();
  1187. break;
  1188. case WM_MOUSEWHEEL:
  1189. if( m_bNcsbForceRedrawOnMouseWheel )
  1190. {
  1191. Invalidate();
  1192. UpdateWindow();
  1193. }
  1194. break;
  1195. } // switch( message )
  1196. return lResult;
  1197. }
  1198. }; /// template class CExtNCSB_Impl
  1200. template < class _BTNCSB >
  1201. class CExtNCSB : public CExtNCSB_Impl < _BTNCSB >
  1202. {
  1203. public:
  1204. CExtNCSB(
  1205. bool bNcsbDelayedInitialization = false,
  1206. bool bNcsbForceMiddleContainerMode = false
  1207. )
  1208. : CExtNCSB_Impl < _BTNCSB > (
  1209. bNcsbDelayedInitialization,
  1210. bNcsbForceMiddleContainerMode
  1211. )
  1212. {
  1213. }
  1214. CExtNCSB(
  1215. UINT nIDTemplate,
  1216. CWnd * pParentWnd,
  1217. bool bNcsbDelayedInitialization = false,
  1218. bool bNcsbForceMiddleContainerMode = false
  1219. )
  1220. : CExtNCSB_Impl < _BTNCSB > ( nIDTemplate, pParentWnd, bNcsbDelayedInitialization, bNcsbForceMiddleContainerMode )
  1221. {
  1222. }
  1223. CExtNCSB(
  1224. __EXT_MFC_SAFE_LPCTSTR lpszTemplateName,
  1225. CWnd * pParentWnd,
  1226. bool bNcsbDelayedInitialization = false,
  1227. bool bNcsbForceMiddleContainerMode = false
  1228. )
  1229. : CExtNCSB_Impl < _BTNCSB > ( lpszTemplateName, pParentWnd, bNcsbDelayedInitialization, bNcsbForceMiddleContainerMode )
  1230. {
  1231. }
  1232. virtual ~CExtNCSB()
  1233. {
  1234. }
  1235. }; /// template class CExtNCSB
  1237. template < class _BA > class CExtANCSB : public _BA
  1238. {
  1239. public:
  1240. CExtANCSB(
  1241. bool bNcsbDelayedInitialization = false,
  1242. bool bNcsbForceMiddleContainerMode = false
  1243. )
  1244. {
  1245. bNcsbDelayedInitialization;
  1246. bNcsbForceMiddleContainerMode;
  1247. }
  1248. CExtANCSB(
  1249. UINT nIDTemplate,
  1250. CWnd * pParentWnd,
  1251. bool bNcsbDelayedInitialization = false,
  1252. bool bNcsbForceMiddleContainerMode = false
  1253. )
  1254. {
  1255. nIDTemplate;
  1256. pParentWnd;
  1257. bNcsbDelayedInitialization;
  1258. bNcsbForceMiddleContainerMode;
  1259. }
  1260. CExtANCSB(
  1261. __EXT_MFC_SAFE_LPCTSTR lpszTemplateName,
  1262. CWnd * pParentWnd,
  1263. bool bNcsbDelayedInitialization = false,
  1264. bool bNcsbForceMiddleContainerMode = false
  1265. )
  1266. {
  1267. lpszTemplateName;
  1268. pParentWnd;
  1269. bNcsbDelayedInitialization;
  1270. bNcsbForceMiddleContainerMode;
  1271. }
  1272. virtual ~CExtANCSB()
  1273. {
  1274. }
  1275. }; // template < class _BA > class CExtANCSB
  1277. #if _MFC_VER >= 0x700
  1278. #ifndef __EXT_PROFUIS_STATIC_LINK
  1279. template class __PROF_UIS_API CExtNCSB_Impl < CExtANCSB < CScrollView > >;
  1280. #endif  // #ifndef __EXT_PROFUIS_STATIC_LINK
  1281. #endif // _MFC_VER >= 0x700
  1283. template < > class __PROF_UIS_API CExtNCSB < CScrollView > : public CExtNCSB_Impl < CExtANCSB < CScrollView > >
  1284. {
  1285. public:
  1286. CExtNCSB(
  1287. bool bNcsbDelayedInitialization = false,
  1288. bool bNcsbForceMiddleContainerMode = false
  1289. )
  1290. {
  1291. m_bNcsbDelayedInitialization = bNcsbDelayedInitialization;
  1292. m_bNcsbForceMiddleContainerMode = bNcsbForceMiddleContainerMode;
  1293. }
  1294. virtual ~CExtNCSB()
  1295. {
  1296. }
  1297. }; // template < > class CExtNCSB < CScrollView >
  1299. #if _MFC_VER >= 0x700
  1300. #ifndef __EXT_PROFUIS_STATIC_LINK
  1301. template class __PROF_UIS_API CExtNCSB_Impl < CExtANCSB < CListCtrl > >;
  1302. #endif  // #ifndef __EXT_PROFUIS_STATIC_LINK
  1303. #endif // _MFC_VER >= 0x700
  1305. template < > class __PROF_UIS_API CExtNCSB < CListCtrl > : public CExtNCSB_Impl < CExtANCSB < CListCtrl > >
  1306. {
  1307. public:
  1308. CExtNCSB(
  1309. bool bNcsbDelayedInitialization = false,
  1310. bool bNcsbForceMiddleContainerMode = false
  1311. );
  1312. virtual ~CExtNCSB();
  1313. virtual void AdjustScrollMetrics();
  1314. protected:
  1315. virtual LRESULT WindowProc( UINT message, WPARAM wParam, LPARAM lParam );
  1316. }; // template < > class CExtNCSB < CListCtrl >
  1318. #if (!defined __EXT_MFC_NO_SCROLLWND)
  1320. /////////////////////////////////////////////////////////////////////////////
  1321. // CExtScrollWnd window
  1323. // based on MFC source code in viewscrl.cpp
  1324. class __PROF_UIS_API CExtScrollWnd
  1325. : public CWnd
  1326. , public CExtMouseCaptureSink
  1327. , public CExtPmBridge
  1328. {
  1329. public:
  1330. class __PROF_UIS_API CRectWH : public CRect
  1331. {
  1332. public:
  1333. CRectWH( LONG x, LONG y, LONG w, LONG h )
  1334. : CRect( x, y, ( x + w ), ( y + h ) )
  1335. {
  1336. }
  1337. };
  1339. DECLARE_DYNCREATE( CExtScrollWnd );
  1340. DECLARE_CExtPmBridge_MEMBERS( CExtScrollWnd );
  1341. CExtScrollWnd();
  1342. virtual ~CExtScrollWnd();
  1343. public:
  1344. bool m_bScrollPhysical:1, m_bEatErasing:1,
  1345. m_bClientCB:1, m_bBufferedPainting:1,
  1346. m_bScrollInvalidate:1, m_bScrollErase:1,
  1347. m_bScrollUpdateWindow:1, m_bRedrawUpdateWindow:1,
  1348. m_bRedrawInvalidate:1, m_bRedrawErase:1,
  1349. m_bUse32BitScrollInfo:1;
  1350. protected:
  1351. HFONT m_hFont;
  1352. int m_nUpdateScrollBars;
  1353. public:
  1354. //{{AFX_VIRTUAL(CExtScrollWnd)
  1355. public:
  1356. virtual BOOL PreTranslateMessage(MSG* pMsg);
  1357. protected:
  1358. virtual LRESULT WindowProc(UINT message, WPARAM wParam, LPARAM lParam);
  1359. //}}AFX_VIRTUAL
  1360. public:
  1361. virtual void PmBridge_OnPaintManagerChanged(
  1362. CExtPaintManager * pGlobalPM
  1363. );
  1364. virtual CSize OnSwGetTotalSize() const;
  1365. virtual CSize OnSwGetPageSize( int nDirection ) const;
  1366. virtual CSize OnSwGetLineSize( int nDirection ) const;
  1367. virtual CRect OnSwRecalcLayout(
  1368. bool bDoLayout,
  1369. LPCRECT pRectClientSrc = NULL
  1370. );
  1371. virtual CRect OnSwGetClientRect() const;
  1373. virtual bool OnSwCanAutoHideScrollBar( bool bHorz ) const;
  1374. virtual bool OnSwHasScrollBar( bool bHorz ) const;
  1375. virtual void OnSwEnableScrollBarCtrl( int nBar, bool bEnable );
  1376. virtual bool OnSwScrollInfoAdjust(
  1377. int nBar,
  1378. SCROLLINFO & si,
  1379. bool bRedraw = true
  1380. );
  1381. virtual void OnSwSetScrollRange(
  1382. int nBar,
  1383. LONG nMinPos,
  1384. LONG nMaxPos,
  1385. bool bRedraw = true
  1386. );
  1387. virtual bool OnSwQueryThumbTrackEnabled( bool bHorz ) const;
  1389. virtual LONG ScrollLimit32Get( int nBar ) const;
  1390. virtual void ScrollInfo32Get(
  1391. int nBar,
  1392. LONG * p_nMinPos,
  1393. LONG * p_nMaxPos,
  1394. LONG * p_nPageSize,
  1395. LONG * p_nCurrPos,
  1396. LONG * p_nTrackPos
  1397. ) const;
  1398. virtual LONG ScrollPos32Get(
  1399. int nBar,
  1400. bool bTrackPos = false
  1401. ) const;
  1402. virtual void ScrollPos32Set(
  1403. int nBar,
  1404. LONG nPos,
  1405. bool bRedraw = true
  1406. );
  1408. virtual CPoint OnSwGetScrollPos() const;
  1409. virtual CPoint OnSwGetScrollPaintPos() const;
  1410. virtual void OnSwSetScrollPos( POINT pt );
  1412. virtual void OnSwGetScrollBarState(
  1413. CSize sizeClient,
  1414. CSize & sizeNeedSB,
  1415. CSize & sizeRange,
  1416. CPoint & ptMove,
  1417. bool bInsideClient
  1418. ) const;
  1419. virtual CSize OnSwGetScrollBarSizes() const;
  1420. virtual bool OnSwCalcClientSizes(
  1421. CSize & size,
  1422. CSize & sizeSb
  1423. );
  1425. virtual UINT OnSwCalcMouseScrollLines(
  1426. UINT fFlags,
  1427. short zDelta,
  1428. CPoint point
  1429. );
  1430. virtual bool OnSwDoMouseWheel(
  1431. UINT fFlags,
  1432. short zDelta,
  1433. CPoint point
  1434. );
  1436. virtual bool OnSwDoScroll(
  1437. UINT nScrollCode,
  1438. UINT nPos,
  1439. bool bDoScroll = true
  1440. );
  1441. virtual bool OnSwDoScrollBy(
  1442. CSize sizeScroll,
  1443. bool bDoScroll = true
  1444. );
  1445. virtual void OnSwUpdateScrollBars();
  1447. virtual void OnSwDoScrollWindow(
  1448. int xAmount,
  1449. int yAmount,
  1450. LPCRECT lpRect = NULL,
  1451. LPCRECT lpClipRect = NULL
  1452. );
  1454. virtual void OnSwEnsurePointAvail( CPoint point );
  1456. virtual void OnSwInvalidate( bool bErase );
  1457. virtual void OnSwUpdateWindow();
  1458. virtual void OnSwDoRedraw();
  1459. virtual void OnSwPaint( CDC & dc );
  1460. virtual void OnSwPaintAreaBetweenScrollBarWindows(
  1461. CDC & dc,
  1462. const RECT & rcAreaBetweenScrollBarWindows
  1463. );
  1465. // Generated message map functions
  1466. protected:
  1467. //{{AFX_MSG(CExtScrollWnd)
  1468. afx_msg void OnSize(UINT nType, int cx, int cy);
  1469. afx_msg void OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar);
  1470. afx_msg void OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar);
  1471. afx_msg BOOL OnMouseWheel(UINT fFlags, short zDelta, CPoint point);
  1472. afx_msg BOOL OnEraseBkgnd(CDC* pDC);
  1473. afx_msg void OnPaint();
  1474. afx_msg void OnEnable( BOOL bEnable );
  1475. afx_msg LRESULT OnSetFont( WPARAM wParam, LPARAM lParam );
  1476. afx_msg LRESULT OnGetFont( WPARAM, LPARAM );
  1477. //}}AFX_MSG
  1478. afx_msg void OnSysColorChange();
  1479. afx_msg void OnSettingChange(UINT uFlags, __EXT_MFC_SAFE_LPCTSTR lpszSection);
  1480. afx_msg LRESULT OnDisplayChange( WPARAM wParam, LPARAM lParam );
  1481. afx_msg LRESULT OnThemeChanged( WPARAM wParam, LPARAM lParam );
  1482. DECLARE_MESSAGE_MAP()
  1483. }; // class CExtScrollWnd
  1485. #if (!defined __EXT_MFC_NO_SCROLLITEMWND)
  1487. /////////////////////////////////////////////////////////////////////////////
  1488. // CExtScrollItemWnd window & CExtScrollItemCacheInfo helper
  1490. // item scrolling type
  1491. #define __ESIW_ST_NONE 0x00000000L
  1492. #define __ESIW_ST_PIXEL 0x00000001L
  1493. #define __ESIW_ST_ITEM 0x00000002L
  1494. #define __ESIW_ST_VIRTUAL 0x00000003L
  1495. #define __ESIW_ST_MASK 0x00000003L
  1496. #define __ESIW_ST_BIT_COUNT 2L
  1498. // item scroll window styles
  1499. #define __ESIS_STH_NONE __ESIW_ST_NONE
  1500. #define __ESIS_STH_PIXEL __ESIW_ST_PIXEL
  1501. #define __ESIS_STH_ITEM __ESIW_ST_ITEM
  1502. #define __ESIS_STH_VIRTUAL __ESIW_ST_VIRTUAL
  1503. #define __ESIS_STV_NONE (__ESIW_ST_NONE << __ESIW_ST_BIT_COUNT)
  1504. #define __ESIS_STV_PIXEL (__ESIW_ST_PIXEL << __ESIW_ST_BIT_COUNT)
  1505. #define __ESIS_STV_ITEM (__ESIW_ST_ITEM << __ESIW_ST_BIT_COUNT)
  1506. #define __ESIS_STV_VIRTUAL (__ESIW_ST_VIRTUAL << __ESIW_ST_BIT_COUNT)
  1507. #define __ESIS_STH_MASK __ESIW_ST_MASK
  1508. #define __ESIS_STV_MASK (__ESIW_ST_MASK << __ESIW_ST_BIT_COUNT)
  1509. #define __ESIS_ST_MASK (__ESIS_STH_MASK|__ESIS_STV_MASK)
  1510. #define __ESIS_DISABLE_THUMBTRACK_H 0x00000010L
  1511. #define __ESIS_DISABLE_THUMBTRACK_V 0x00000020L
  1512. #define __ESIS_DISABLE_THUMBTRACK (__ESIS_DISABLE_THUMBTRACK_H|__ESIS_DISABLE_THUMBTRACK_V)
  1513. #define __ESIS_DISABLE_AUTOHIDE_SB_H 0x00000040L
  1514. #define __ESIS_DISABLE_AUTOHIDE_SB_V 0x00000080L
  1515. #define __ESIS_DISABLE_AUTOHIDE_SB (__ESIS_DISABLE_AUTOHIDE_SB_H|__ESIS_DISABLE_AUTOHIDE_SB_V)
  1516. #define __ESIS_PREFER_HORZ_WALK 0x00000100L
  1518. #if (!defined __EXT_MFC_NO_GRIDBASEWND)
  1520. // helper flags to optimize event processing when
  1521. // all rows/columns have equal sizes
  1522. #define __EGBS_FIXED_SIZE_COLUMNS 0x00000200L
  1523. #define __EGBS_FIXED_SIZE_ROWS 0x00000400L
  1525. // basic selection/focus type
  1526. #define __EGBS_SFB_NONE 0x00000000L
  1527. #define __EGBS_SFB_CELLS 0x00001000L
  1528. #define __EGBS_SFB_FULL_ROWS 0x00002000L
  1529. #define __EGBS_SFB_FULL_COLUMNS 0x00003000L
  1530. #define __EGBS_SFB_MASK 0x00003000L
  1531. // allow multiple row/column/cell selection
  1532. #define __EGBS_SFM_ROWS 0x00000800L
  1533. #define __EGBS_SFM_COLUMNS 0x00008000L
  1534. #define __EGBS_SFM_MASK (__EGBS_SFM_ROWS|__EGBS_SFM_COLUMNS)
  1535. // enabled multiple selection types
  1536. #define __EGBS_SFM_CELLS_H (__EGBS_SFB_CELLS|__EGBS_SFM_COLUMNS)
  1537. #define __EGBS_SFM_CELLS_V (__EGBS_SFB_CELLS|__EGBS_SFM_ROWS)
  1538. #define __EGBS_SFM_CELLS_HV (__EGBS_SFB_CELLS|__EGBS_SFM_COLUMNS|__EGBS_SFM_ROWS)
  1539. #define __EGBS_SFM_FULL_ROWS (__EGBS_SFB_FULL_ROWS|__EGBS_SFM_ROWS)
  1540. #define __EGBS_SFM_FULL_COLUMNS (__EGBS_SFB_FULL_COLUMNS|__EGBS_SFM_COLUMNS)
  1541. // any selection mask
  1542. #define __EGBS_SF_MASK (__EGBS_SFB_MASK|__EGBS_SFM_MASK)
  1543. // allow selection via outer row/column clicks
  1544. #define __EGBS_SF_SELECT_OUTER_ROWS 0x00010000L
  1545. #define __EGBS_SF_SELECT_OUTER_COLUMNS 0x00020000L
  1546. #define __EGBS_SF_SELECT_OUTER (__EGBS_SF_SELECT_OUTER_COLUMNS|__EGBS_SF_SELECT_OUTER_ROWS)
  1548. // enable row/column resizing
  1549. #define __EGBS_RESIZING_CELLS_OUTER_H 0x00040000L
  1550. #define __EGBS_RESIZING_CELLS_OUTER_V 0x00100000L
  1551. #define __EGBS_RESIZING_CELLS_OUTER (__EGBS_RESIZING_CELLS_OUTER_H|__EGBS_RESIZING_CELLS_OUTER_V)
  1552. #define __EGBS_RESIZING_CELLS_INNER_H 0x00200000L
  1553. #define __EGBS_RESIZING_CELLS_INNER_V 0x00400000L
  1554. #define __EGBS_RESIZING_CELLS_INNER (__EGBS_RESIZING_CELLS_INNER_H|__EGBS_RESIZING_CELLS_INNER_V)
  1555. #define __EGBS_RESIZING_CELLS_MASK (__EGBS_RESIZING_CELLS_OUTER|__EGBS_RESIZING_CELLS_INNER)
  1557. // auto move focused cell to bottom/right corner of selection
  1558. #define __EGBS_AUTO_FOCUS_BOTTOM_RIGHT 0x00800000L
  1560. // allow multiple cell ranges to be selected at a time
  1561. #define __EGBS_MULTI_AREA_SELECTION 0x01000000L
  1563. // no hide selection when not focused
  1564. #define __EGBS_NO_HIDE_SELECTION 0x02000000L
  1566. // draw grid lines
  1567. #define __EGBS_GRIDLINES_H 0x04000000L
  1568. #define __EGBS_GRIDLINES_V 0x08000000L
  1569. #define __EGBS_GRIDLINES (__EGBS_GRIDLINES_H|__EGBS_GRIDLINES_V)
  1571. // mouse click + move selects cell range
  1572. #define __EGBS_LBEXT_SELECTION 0x10000000L
  1574. // subtract overlapped cell ranges in selection areas
  1575. #define __EGBS_SUBTRACT_SEL_AREAS 0x20000000L
  1577. // resize rows/columns on-the-fly (no half-tone tracker lines)
  1578. #define __EGBS_DYNAMIC_RESIZING_H 0x40000000L
  1579. #define __EGBS_DYNAMIC_RESIZING_V 0x80000000L
  1580. #define __EGBS_DYNAMIC_RESIZING (__EGBS_DYNAMIC_RESIZING_H|__EGBS_DYNAMIC_RESIZING_V)
  1582. #endif // (!defined __EXT_MFC_NO_GRIDBASEWND)
  1584. // extended/behavior styles provided with
  1585. // CExtScrollItemWnd::SiwGetStyleEx()
  1586. // ( these styles are not intersected with
  1587. //   CExtScrollItemWnd::SiwGetStyle() style values )
  1589. #if (!defined __EGWS_EX_PM_COLORS)
  1590. #define __EGWS_EX_PM_COLORS 0x80000000L
  1591. #endif
  1594. class __PROF_UIS_API CExtScrollItemCacheInfo
  1595. {
  1596. public:
  1597. LONG m_nPosH;
  1598. LONG m_nMaxH;
  1599. LONG m_nPageSizeH;
  1600. LONG m_nPosV;
  1601. LONG m_nMaxV;
  1602. LONG m_nPageSizeV;
  1603. bool m_bBeginH:1;
  1604. bool m_bEndH:1;
  1605. bool m_bBeginV:1;
  1606. bool m_bEndV:1;
  1607. CExtScrollItemCacheInfo(
  1608. LONG nPosH = 0L,
  1609. LONG nMaxH = 0L,
  1610. LONG nPageSizeH = 0L,
  1611. LONG nPosV = 0L,
  1612. LONG nMaxV = 0L,
  1613. LONG nPageSizeV = 0L,
  1614. bool bBeginH = false,
  1615. bool bEndH = false,
  1616. bool bBeginV = false,
  1617. bool bEndV = false
  1618. );
  1619. CExtScrollItemCacheInfo(
  1620. const CExtScrollItemCacheInfo & other
  1621. );
  1622. CExtScrollItemCacheInfo & operator = (
  1623. const CExtScrollItemCacheInfo & other
  1624. );
  1625. bool operator == (
  1626. const CExtScrollItemCacheInfo & other
  1627. ) const;
  1628. bool operator != (
  1629. const CExtScrollItemCacheInfo & other
  1630. ) const;
  1631. void Empty(
  1632. bool bEmptyH = true,
  1633. bool bEmptyV = true
  1634. );
  1635. void EmptyH();
  1636. void EmptyV();
  1637. bool IsEmpty(
  1638. bool bCheckEmptyH = true,
  1639. bool bCheckEmptyV = true
  1640. ) const;
  1641. bool IsEmptyH() const;
  1642. bool IsEmptyV() const;
  1643. bool IsValid() const;
  1644. static bool IsEqual(
  1645. const CExtScrollItemCacheInfo & left,
  1646. const CExtScrollItemCacheInfo & right,
  1647. bool bComparePosH = true,
  1648. bool bComparePosV = true,
  1649. bool bCompareMaxH = true,
  1650. bool bCompareMaxV = true,
  1651. bool bComparePageSizeH = true,
  1652. bool bComparePageSizeV = true,
  1653. bool bCompareBofH = false,
  1654. bool bCompareBofV = false,
  1655. bool bCompareEofH = false,
  1656. bool bCompareEofV = false
  1657. );
  1658. bool IsEqual(
  1659. const CExtScrollItemCacheInfo & other,
  1660. bool bComparePosH = true,
  1661. bool bComparePosV = true,
  1662. bool bCompareMaxH = true,
  1663. bool bCompareMaxV = true,
  1664. bool bComparePageSizeH = true,
  1665. bool bComparePageSizeV = true,
  1666. bool bCompareBofH = false,
  1667. bool bCompareBofV = false,
  1668. bool bCompareEofH = false,
  1669. bool bCompareEofV = false
  1670. ) const;
  1671. LONG GetExtentH() const;
  1672. LONG GetExtentV() const;
  1673. LONG GetPosChangingH(
  1674. const CExtScrollItemCacheInfo & _sciOld
  1675. ) const;
  1676. LONG GetPosChangingV(
  1677. const CExtScrollItemCacheInfo & _sciOld
  1678. ) const;
  1679. LONG GetMaxChangingH(
  1680. const CExtScrollItemCacheInfo & _sciOld
  1681. ) const;
  1682. LONG GetMaxChangingV(
  1683. const CExtScrollItemCacheInfo & _sciOld
  1684. ) const;
  1685. LONG GetExtentChangingH(
  1686. const CExtScrollItemCacheInfo & _sciOld
  1687. ) const;
  1688. LONG GetExtentChangingV(
  1689. const CExtScrollItemCacheInfo & _sciOld
  1690. ) const;
  1691. LONG GetPageSizeChangingH(
  1692. const CExtScrollItemCacheInfo & _sciOld
  1693. ) const;
  1694. LONG GetPageSizeChangingV(
  1695. const CExtScrollItemCacheInfo & _sciOld
  1696. ) const;
  1697. bool IsShiftToBofH(
  1698. const CExtScrollItemCacheInfo & _sciOld
  1699. ) const;
  1700. bool IsShiftToBofV(
  1701. const CExtScrollItemCacheInfo & _sciOld
  1702. ) const;
  1703. bool IsShiftToEofH(
  1704. const CExtScrollItemCacheInfo & _sciOld
  1705. ) const;
  1706. bool IsShiftToEofV(
  1707. const CExtScrollItemCacheInfo & _sciOld
  1708. ) const;
  1709. void FlipHV();
  1710. void Assign(
  1711. const CExtScrollItemCacheInfo & other,
  1712. bool bAssignH = true,
  1713. bool bAssignV = true
  1714. );
  1715. void AssignH(
  1716. const CExtScrollItemCacheInfo & other
  1717. );
  1718. void AssignV(
  1719. const CExtScrollItemCacheInfo & other
  1720. );
  1721. }; // class CExtScrollItemCacheInfo
  1723. class __PROF_UIS_API CExtScrollItemWnd : public CExtScrollWnd
  1724. {
  1725. public:
  1726. DECLARE_DYNCREATE( CExtScrollItemWnd );
  1727. CExtScrollItemWnd();
  1729. public:
  1730. bool m_bExtractResourceStyles:1;
  1732. protected:
  1733. static bool g_bScrollItemWndClassRegistered;
  1734. bool m_bDirectCreateCall:1;
  1735. DWORD m_dwScrollItemWndStyle, m_dwScrollItemWndStyleEx;
  1737. public:
  1738. virtual DWORD SiwGetStyle() const;
  1739. virtual DWORD SiwModifyStyle(
  1740. DWORD dwStyleAdd,
  1741. DWORD dwStyleRemove = 0L,
  1742. bool bUpdateWnd = true
  1743. );
  1744. virtual DWORD SiwGetStyleEx() const;
  1745. virtual DWORD SiwModifyStyleEx(
  1746. DWORD dwStyleExAdd,
  1747. DWORD dwStyleExRemove = 0L,
  1748. bool bUpdateWnd = true
  1749. );
  1750. DWORD SiwScrollTypeHGet() const;
  1751. DWORD SiwScrollTypeVGet() const;
  1752. DWORD SiwScrollTypeHSet(
  1753. DWORD dwScrollTypeNew,
  1754. bool bUpdateWnd = true
  1755. );
  1756. DWORD SiwScrollTypeVSet(
  1757. DWORD dwScrollTypeNew,
  1758. bool bUpdateWnd = true
  1759. );
  1760. bool SiwPreferHorizontalWalkGet() const;
  1761. bool SiwPreferHorizontalWalkSet(
  1762. bool bPreferHorizontalWalk
  1763. );
  1764. bool SiwThumbTrackEnabledGet( bool bHorz ) const;
  1765. bool SiwThumbTrackEnabledSet(
  1766. bool bHorz,
  1767. bool bEnabled = true
  1768. );
  1769. bool SiwAutohideScrollBarGet( bool bHorz ) const;
  1770. bool SiwAutohideScrollBarSet(
  1771. bool bHorz,
  1772. bool bAutoHide = true
  1773. );
  1775. //{{AFX_VIRTUAL(CExtScrollItemWnd)
  1776. protected:
  1777. virtual void PreSubclassWindow();
  1778. virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
  1779. //}}AFX_VIRTUAL
  1781. public:
  1782. virtual ~CExtScrollItemWnd();
  1784. virtual BOOL Create(
  1785. CWnd * pParentWnd,
  1786. const RECT & rcWnd = CRect( 0, 0, 0, 0 ),
  1787. UINT nDlgCtrlID = UINT( __EXT_MFC_IDC_STATIC ),
  1788. DWORD dwScrollItemWndStyle = 0L,
  1789. DWORD dwWindowStyle = WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
  1790. CCreateContext * pContext = NULL
  1791. );
  1792. virtual bool _CreateHelper();
  1793. static bool RegisterScrollItemWndClass();
  1795. virtual void OnSwGetScrollBarState(
  1796. CSize sizeClient,
  1797. CSize & sizeNeedSB,
  1798. CSize & sizeRange,
  1799. CPoint & ptMove,
  1800. bool bInsideClient
  1801. ) const;
  1802. virtual CSize OnSwGetLineSize( int nDirection ) const;
  1803. virtual void OnSwUpdateScrollBars();
  1804. virtual CSize OnSwGetPageSize( int nDirection ) const;
  1805. virtual CSize OnSwGetTotalSize() const;
  1806. virtual bool OnSwDoScroll(
  1807. UINT nScrollCode,
  1808. UINT nPos,
  1809. bool bDoScroll = true
  1810. );
  1811. virtual bool OnSwDoScrollBy(
  1812. CSize sizeScroll,
  1813. bool bDoScroll = true
  1814. );
  1815. virtual bool SiwFireCacheChanging(
  1816. LONG nScrollPosNewX = -1L, // if <0L - use current
  1817. LONG nScrollPosNewY = -1L, // if <0L - use current
  1818. bool bUpdate = true
  1819. );
  1820. virtual CPoint OnSwGetScrollPaintPos() const;
  1821. virtual void OnSwPaint( CDC & dc );
  1822. virtual bool OnSwQueryThumbTrackEnabled( bool bHorz ) const;
  1823. virtual bool OnSwCanAutoHideScrollBar( bool bHorz ) const;
  1825. virtual CSize OnSiwCalcItemSize() const;
  1826. virtual CSize OnSiwCalcPageMetrics( int nDirection ) const;
  1827. virtual bool OnSiwQueryVirtualBOF( bool bHorz ) const;
  1828. virtual bool OnSiwQueryVirtualEOF( bool bHorz ) const;
  1829. virtual CRect OnSiwGetFrozenRange() const;
  1830. virtual CRect OnSiwGetVisibleRange() const;
  1831. virtual INT OnSiwQueryItemExtentH(
  1832. LONG nColNo,
  1833. INT * p_nExtraSpaceBefore = NULL,
  1834. INT * p_nExtraSpaceAfter = NULL
  1835. ) const;
  1836. virtual INT OnSiwQueryItemExtentV(
  1837. LONG nRowNo,
  1838. INT * p_nExtraSpaceBefore = NULL,
  1839. INT * p_nExtraSpaceAfter = NULL
  1840. ) const;
  1841. virtual bool OnSiwVirtualEndTestH( LONG nColNo, LPARAM lParam ) const;
  1842. virtual bool OnSiwVirtualEndTestV( LONG nRowNo, LPARAM lParam ) const;
  1843. virtual bool OnSiwWalkCell(
  1844. CDC & dc,
  1845. LPVOID pQueryData,
  1846. LONG nVisibleColNo,
  1847. LONG nVisibleRowNo,
  1848. LONG nColNo,
  1849. LONG nRowNo,
  1850. const RECT & rcCellExtra,
  1851. const RECT & rcCell,
  1852. const RECT & rcVisibleRange,
  1853. bool & bVirtualRightReached,
  1854. bool & bVirtualBottomReached,
  1855. DWORD dwAreaFlags,
  1856. bool bFocusedControl
  1857. ) const;
  1858. virtual bool OnSiwWalkItemsH(
  1859. CDC & dc,
  1860. LPVOID pQueryData,
  1861. const RECT & rcRowExtra,
  1862. const RECT & rcRow,
  1863. LONG nVisibleRowNo,
  1864. LONG nRowNo,
  1865. const RECT & rcVisibleRange,
  1866. bool & bVirtualBottomReached,
  1867. DWORD dwAreaFlags,
  1868. bool bFocusedControl
  1869. ) const;
  1870. virtual bool OnSiwWalkItemsV(
  1871. CDC & dc,
  1872. LPVOID pQueryData,
  1873. const RECT & rcColExtra,
  1874. const RECT & rcCol,
  1875. LONG nVisibleColNo,
  1876. LONG nColNo,
  1877. const RECT & rcVisibleRange,
  1878. bool & bVirtualRightReached,
  1879. DWORD dwAreaFlags,
  1880. bool bFocusedControl
  1881. ) const;
  1882. virtual void OnSiwPaintBackground(
  1883. CDC & dc,
  1884. bool bFocusedControl
  1885. ) const;
  1886. virtual void OnSiwPaintForeground(
  1887. CDC & dc,
  1888. bool bFocusedControl
  1889. ) const;
  1890. virtual bool OnSiwQueryFocusedControlState() const;
  1891. virtual void OnSiwDrawFocusRect(
  1892. CDC &dc,
  1893. LPCRECT pRect,
  1894. CObject * pObjSrc = NULL,
  1895. LPARAM lParam = 0L
  1896. ) const;
  1897. virtual COLORREF OnSiwGetReadOnlyTextColor() const;
  1898. virtual COLORREF OnSiwGetReadOnlyBackgroundColor() const;
  1899. virtual COLORREF OnSiwGetSysColor( int nIndex ) const;
  1900. // nLighterOrDarker is related to COLOR_3DFACE brush:
  1901. // -3 - darkest, -2 - darker, -1 - dark,
  1902. // 1 - light, 2 - lighter, 3 - lightest
  1903. virtual CBrush & OnSiwGetLighterOrDarkerBrush( int nLighterOrDarker ) const;
  1904. virtual CFont & OnSiwGetDefaultFont() const;
  1906. virtual bool OnSiwCacheChanged(
  1907. const CExtScrollItemCacheInfo & _sciNew,
  1908. const CExtScrollItemCacheInfo & _sciOld
  1909. );
  1911. protected:
  1912. CExtScrollItemCacheInfo m_sciLast;
  1913. virtual bool _NotifyCacheChanged(
  1914. LONG nPosH,
  1915. LONG nPosOldH,
  1916. LONG nMaxH,
  1917. LONG nPageSizeH,
  1918. LONG nPosV,
  1919. LONG nPosOldV,
  1920. LONG nMaxV,
  1921. LONG nPageSizeV,
  1922. bool bBeginH,
  1923. bool bEndH,
  1924. bool bBeginV,
  1925. bool bEndV
  1926. );
  1927. public:
  1929. protected:
  1930. //{{AFX_MSG(CExtScrollItemWnd)
  1931. //}}AFX_MSG
  1932. DECLARE_MESSAGE_MAP()
  1933. }; // class CExtScrollItemWnd
  1935. #define __EXT_SCROLLITEMWND_CLASS_NAME _T("ProfUIS-ScrollItemWindow")
  1937. #endif // (!defined __EXT_MFC_NO_SCROLLITEMWND)
  1940. #if (!defined __EXT_MFC_NO_SCROLLCONAINERWND)
  1942. /////////////////////////////////////////////////////////////////////////////
  1943. // CExtScrollContainerWnd window
  1945. class __PROF_UIS_API CExtScrollContainerWnd : public CExtScrollWnd
  1946. {
  1947. public:
  1948. mutable CSize m_sizeToScroll;
  1949. DECLARE_DYNCREATE( CExtScrollContainerWnd );
  1950. CExtScrollContainerWnd();
  1951. virtual ~CExtScrollContainerWnd();
  1953. CExtScrollBar m_wndScrollBarH, m_wndScrollBarV;
  1954. CExtLabel m_wndCorner;
  1955. COLORREF m_clrBkColor;
  1956. bool m_bAutoDelete:1, m_bRedirectPreTranslateMessage:1, m_bRedirectOnCmdMsg:1,
  1957. m_bRedirectFocus:1, m_bSynchronizeEnabledState:1;
  1958. UINT m_nScrollRedrawFlags;
  1960. //{{AFX_VIRTUAL(CExtScrollContainerWnd)
  1961. public:
  1962. virtual CScrollBar * GetScrollBarCtrl(int nBar) const;
  1963. virtual BOOL PreTranslateMessage( MSG * pMsg );
  1964. virtual BOOL OnCmdMsg( UINT nID, int nCode, void * pExtra, AFX_CMDHANDLERINFO * pHandlerInfo );
  1965. protected:
  1966. virtual BOOL PreCreateWindow( CREATESTRUCT & cs );
  1967. virtual void PreSubclassWindow();
  1968. virtual void PostNcDestroy();
  1969. //}}AFX_VIRTUAL
  1971. public:
  1972. virtual bool Create(
  1973. CWnd * pWndParent,
  1974. const RECT & rc,
  1975. UINT nDlgCtrlID = AFX_IDW_PANE_FIRST
  1976. );
  1977. virtual CWnd * OnGetWndToScroll();
  1978. virtual CPoint OnSwGetScrollPaintPos() const;
  1979. virtual void OnSwPaint( CDC & dc );
  1980. virtual void OnSwPaintAreaBetweenScrollBarWindows(
  1981. CDC & dc,
  1982. const RECT & rcAreaBetweenScrollBarWindows
  1983. );
  1984. virtual CSize OnSwGetTotalSize() const;
  1985. virtual CSize OnSwGetPageSize( int nDirection ) const;
  1986. virtual CSize OnSwGetLineSize( int nDirection ) const;
  1987. virtual CRect OnSwRecalcLayout(
  1988. bool bDoLayout,
  1989. LPCRECT pRectClientSrc = NULL
  1990. );
  1991. virtual bool OnSwDoScrollBy(
  1992. CSize sizeScroll,
  1993. bool bDoScroll = true
  1994. );
  1996. protected:
  1997. //{{AFX_MSG(CExtScrollContainerWnd)
  1998. afx_msg int OnCreate( LPCREATESTRUCT lpCreateStruct );
  1999. afx_msg void OnSetFocus( CWnd * pOldWnd );
  2000. afx_msg void OnEnable( BOOL bEnable );
  2001. //}}AFX_MSG
  2002. DECLARE_MESSAGE_MAP()
  2003. }; /// class CExtScrollContainerWnd
  2005. #endif // (!defined __EXT_MFC_NO_SCROLLCONAINERWND)
  2007. #endif // (!defined __EXT_MFC_NO_SCROLLWND)
  2009. /////////////////////////////////////////////////////////////////////////////
  2011. //{{AFX_INSERT_LOCATION}}
  2012. // Microsoft Visual C++ will insert additional declarations immediately before the previous line.
  2014. #endif // !defined __EXT_SCROLLWND_H