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

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

界面编程

开发平台：

Visual C++

ExtSpinWnd.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 __EXT_MFC_NO_SPIN)
  26. #if (!defined __EXT_SPIN_H)
  27. #include <ExtSpinWnd.h>
  28. #endif
  30. #if (!defined __EXT_PAINT_MANAGER_H)
  31. #include <ExtPaintManager.h>
  32. #endif
  34. #if (!defined __EXT_MEMORY_DC_H)
  35. #include <../Src/ExtMemoryDC.h>
  36. #endif
  38. #if (!defined __EXT_POPUP_MENU_WND_H)
  39. #include <ExtPopupMenuWnd.h>
  40. #endif
  42. #ifdef _DEBUG
  43. #define new DEBUG_NEW
  44. #undef THIS_FILE
  45. static char THIS_FILE[] = __FILE__;
  46. #endif
  48. /////////////////////////////////////////////////////////////////////////////
  49. // CExtSpinWnd
  51. IMPLEMENT_DYNCREATE( CExtSpinWnd, CSpinButtonCtrl );
  53. CExtSpinWnd::CExtSpinWnd()
  54. : m_clrBackground( COLORREF(-1L) )
  55. , m_bCanceling( false )
  56. , m_bButtonUpHovered( false )
  57. , m_bButtonDownHovered( false )
  58. , m_bButtonUpPressed( false )
  59. , m_bButtonDownPressed( false )
  60. , m_bNcCalcSize( false )
  61. {
  62. }
  64. CExtSpinWnd::~CExtSpinWnd()
  65. {
  66. CExtAnimationSite * pAcAS = AnimationClient_SiteGet();
  67. if( pAcAS != NULL )
  68. pAcAS->AnimationSite_ClientRemove( this );
  69. }
  71. BEGIN_MESSAGE_MAP(CExtSpinWnd, CSpinButtonCtrl)
  72. //{{AFX_MSG_MAP(CExtSpinWnd)
  73. ON_WM_PAINT()
  74. ON_WM_ERASEBKGND()
  75. ON_WM_CANCELMODE()
  76. ON_WM_LBUTTONDOWN()
  77. ON_WM_LBUTTONUP()
  78. ON_WM_MOUSEMOVE()
  79. ON_WM_CAPTURECHANGED()
  80. ON_WM_NCCALCSIZE()
  81. ON_WM_NCPAINT()
  82. ON_WM_SIZE()
  83. //}}AFX_MSG_MAP
  84. ON_WM_ACTIVATEAPP()
  85. END_MESSAGE_MAP()
  87. /////////////////////////////////////////////////////////////////////////////
  88. // CExtSpinWnd message handlers
  90. void CExtSpinWnd::OnPaint() 
  91. {
  92. ASSERT_VALID( this );
  93.     if( ! m_bNcCalcSize )
  94.         SetWindowPos(
  95.             NULL, 0, 0, 0, 0,
  96.             SWP_NOMOVE|SWP_NOSIZE 
  97.             |SWP_NOZORDER|SWP_NOOWNERZORDER|SWP_FRAMECHANGED
  98.             );
  99. CPaintDC dcPaint( this );
  100. CRect rcClient;
  101. GetClientRect( &rcClient );
  102. if( ! dcPaint.RectVisible(&rcClient) )
  103. return;
  104. CExtMemoryDC dc( &dcPaint, &rcClient );
  105. OnSpinDrawEntire( dc, rcClient );
  106. }
  108. bool CExtSpinWnd::_IsBuddyToEdit()
  109. {
  110. ASSERT_VALID( this );
  111. DWORD dwStyle = GetStyle();
  112. bool bBuddyToEdit = false;
  113. bool bSpinAlignRight = false;
  114. bool bSpinAlignLeft = false;
  115. if( (dwStyle&UDS_AUTOBUDDY) != 0 )
  116. {
  117. CWnd * pWnd = this->GetWindow( GW_HWNDPREV );
  118. if( pWnd != NULL )
  119. {
  120. ASSERT_VALID( pWnd );
  121. static const TCHAR szEdit[] = _T("EDIT");
  122. TCHAR szCompare[ sizeof(szEdit)/sizeof(szEdit[0]) + 1 ] = _T("");
  123. ::GetClassName( 
  124. pWnd->GetSafeHwnd(), 
  125. szCompare, 
  126. sizeof(szCompare)/sizeof(szCompare[0]) 
  127. );
  128. if( !lstrcmpi( szCompare, szEdit ) )
  129. {
  130. bSpinAlignRight = ( (dwStyle&UDS_ALIGNRIGHT) != 0 ) ? true : false;
  131. bSpinAlignLeft = ( (dwStyle&UDS_ALIGNLEFT) != 0 ) ? true : false;
  132. bBuddyToEdit = (bSpinAlignRight || bSpinAlignLeft) ? true : false;
  133. }
  134. }
  135. }
  136. return bBuddyToEdit;
  137. }
  139. bool CExtSpinWnd::_IsEnabled()
  140. {
  141. ASSERT_VALID( this );
  142. bool bEnabled  = IsWindowEnabled() ? true : false;
  143. if( !bEnabled )
  144. return bEnabled;
  145. DWORD dwStyle = GetStyle();
  146. if( (dwStyle&UDS_AUTOBUDDY) != 0 )
  147. {
  148. CWnd * pWnd = this->GetWindow( GW_HWNDPREV );
  149. if( pWnd != NULL )
  150. {
  151. ASSERT_VALID( pWnd );
  152. bEnabled  = pWnd->IsWindowEnabled() ? true : false;
  153. }
  154. }
  155. return bEnabled;
  156. }
  158. bool CExtSpinWnd::_IsReadOnly()
  159. {
  160. ASSERT_VALID( this );
  161. bool bReadOnly = false;
  162. if( _IsBuddyToEdit() )
  163. {
  164. CWnd * pWnd = this->GetWindow( GW_HWNDPREV );
  165. if( pWnd != NULL )
  166. {
  167. ASSERT_VALID( pWnd );
  168. DWORD dwStyle = pWnd->GetStyle();
  169. if( (dwStyle&ES_READONLY) != 0 )
  170. bReadOnly = true;
  171. }
  172. }
  173. return bReadOnly;
  174. }
  176. bool CExtSpinWnd::GetButtonRect( 
  177. CRect & rcButtonUp,
  178. CRect & rcButtonDown,
  179. const CRect * prcClient // = NULL
  180. )
  181. {
  182. ASSERT_VALID( this );
  184. CRect rcClient;
  185. if( prcClient == NULL )
  186. GetClientRect( &rcClient );
  187. else
  188. rcClient = *prcClient;
  190. DWORD dwStyle = GetStyle();
  191. bool bHorz = ((dwStyle&UDS_HORZ) != 0) ? true : false;
  193. rcButtonUp = rcButtonDown = rcClient;
  194. if( !bHorz )
  195. {
  196. rcButtonUp.bottom = rcButtonUp.top + (rcClient.Height() / 2);
  197. rcButtonDown.top = rcButtonUp.bottom;
  198. }
  199. else
  200. {
  201. rcButtonUp.right = (rcClient.Width() / 2);
  202. rcButtonDown.left = rcButtonUp.right;
  203. }
  205. return true;
  206. }
  208. void CExtSpinWnd::OnSpinEraseClientArea(
  209. CDC & dc,
  210. const CRect & rcClient
  211. )
  212. {
  213. ASSERT_VALID( this );
  214. ASSERT( dc.GetSafeHdc() != NULL );
  216. if( !dc.RectVisible( rcClient ) )
  217. return;
  219. COLORREF clrBackground = OnQueryBkColor();
  220. if( _IsBuddyToEdit() 
  221. && clrBackground == COLORREF(-1L)
  222. )
  223. {
  224. if( (!_IsEnabled())
  225. || _IsReadOnly()
  226. )
  227. clrBackground = PmBridge_GetPM()->GetColor( COLOR_3DFACE, this );
  228. else
  229. clrBackground = PmBridge_GetPM()->GetColor( COLOR_WINDOW, this );
  230. }
  231. bool bTransparent = false;
  232. if( (! bTransparent )
  233. && PmBridge_GetPM()->GetCb2DbTransparentMode(this)
  234. && ( clrBackground == COLORREF(-1L) )
  235. )
  236. {
  237. CExtPaintManager::stat_ExcludeChildAreas(
  238. dc,
  239. GetSafeHwnd(),
  240. CExtPaintManager::stat_DefExcludeChildAreaCallback
  241. );
  242. if( PmBridge_GetPM()->PaintDockerBkgnd( true, dc, this ) )
  243. bTransparent = true;
  244. }
  245. if( ! bTransparent )
  246. dc.FillSolidRect(
  247. &rcClient,
  248. (clrBackground != COLORREF(-1L)) 
  249. ? clrBackground 
  250. : PmBridge_GetPM()->GetColor( CExtPaintManager::CLR_3DFACE_OUT, this ) 
  251. );
  253. PmBridge_GetPM()->OnPaintSessionComplete( this );
  254. }
  256. void CExtSpinWnd::OnSpinDrawEntire(
  257. CDC & dc,
  258. const CRect & rcClient
  259. )
  260. {
  261. ASSERT_VALID( this );
  262. ASSERT( dc.GetSafeHdc() != NULL );
  264. if( ! dc.RectVisible( rcClient ) )
  265. return;
  267. if( AnimationClient_StatePaint( dc ) )
  268. return;
  270. OnSpinEraseClientArea( 
  271. dc, 
  272. rcClient 
  273. );
  275. DWORD dwStyle = GetStyle();
  277. bool bHorz = ((dwStyle&UDS_HORZ) != 0) ? true : false;
  278. bool bEnabled  = _IsEnabled();
  279. bool bFlat = false;
  280. bool bHotTrack = ((dwStyle&UDS_HOTTRACK) != 0) ? true : false;
  281. bool bDrawBorder = true;
  283. CRect rcButtonUp;
  284. CRect rcButtonDown;
  285. GetButtonRect( 
  286. rcButtonUp, 
  287. rcButtonDown,
  288. &rcClient 
  289. );
  291. PmBridge_GetPM()->PaintSpinButton(
  292. dc,
  293. rcButtonUp,
  294. true,
  295. bHorz,
  296. bEnabled,
  297. bFlat,
  298. bDrawBorder,
  299. m_bButtonUpPressed,
  300. m_bButtonUpHovered,
  301. bHotTrack,
  302. this,
  303. 0L
  304. );
  306. PmBridge_GetPM()->PaintSpinButton(
  307. dc,
  308. rcButtonDown,
  309. false,
  310. bHorz,
  311. bEnabled,
  312. bFlat,
  313. bDrawBorder,
  314. m_bButtonDownPressed,
  315. m_bButtonDownHovered,
  316. bHotTrack,
  317. this,
  318. 0L
  319. );
  320. }
  322. BOOL CExtSpinWnd::OnEraseBkgnd(CDC* pDC) 
  323. {
  324. pDC;
  325. return TRUE;
  326. }
  328. #if _MFC_VER < 0x700
  329. void CExtSpinWnd::OnActivateApp(BOOL bActive, HTASK hTask) 
  330. #else
  331. void CExtSpinWnd::OnActivateApp(BOOL bActive, DWORD hTask) 
  332. #endif
  333. {
  334. CSpinButtonCtrl::OnActivateApp(bActive, hTask);
  335. if( ! bActive )
  336. SendMessage( WM_CANCELMODE );
  337. }
  339. void CExtSpinWnd::OnCancelMode() 
  340. {
  341. CSpinButtonCtrl::OnCancelMode();
  343. if( m_bCanceling )
  344. return;
  345. m_bCanceling = true;
  347. if( ::GetCapture() == GetSafeHwnd() )
  348. ::ReleaseCapture();
  350. if( m_bButtonUpHovered
  351. || m_bButtonDownHovered
  352. || m_bButtonUpPressed
  353. || m_bButtonDownPressed
  354. )
  355. {
  356. bool bExitingPushedState = ( m_bButtonUpPressed || m_bButtonDownPressed ) ? true : false;
  357. bool bAnimationLocked = AnimationClient_CacheGeneratorIsLocked();
  358. if( ! bAnimationLocked )
  359. {
  360. AnimationClient_CacheGeneratorLock();
  361. // if( AnimationClient_StateGet(true).IsEmpty() )
  362.   AnimationClient_CacheNextStateMinInfo(
  363. false,
  364. bExitingPushedState ? __EAPT_BY_PRESSED_STATE_TURNED_OFF : __EAPT_BY_HOVERED_STATE_TURNED_OFF
  365. );
  366. }
  368. m_bButtonUpHovered = false;
  369. m_bButtonDownHovered = false;
  370. m_bButtonUpPressed = false;
  371. m_bButtonDownPressed = false;
  373. if( ! bAnimationLocked )
  374. {
  375.   AnimationClient_CacheNextStateMinInfo(
  376. true,
  377. bExitingPushedState ? __EAPT_BY_PRESSED_STATE_TURNED_OFF : __EAPT_BY_HOVERED_STATE_TURNED_OFF
  378. );
  379. AnimationClient_CacheGeneratorUnlock();
  380. }
  382. Invalidate();
  383. }
  385. m_bCanceling = false;
  386. }
  388. void CExtSpinWnd::OnCaptureChanged(CWnd *pWnd) 
  389. {
  390. CSpinButtonCtrl::OnCaptureChanged(pWnd);
  392. if( m_bCanceling )
  393. return;
  395. HWND hWndCapture = ::GetCapture();
  396. if( hWndCapture != m_hWnd
  397. && hWndCapture != NULL
  398. )
  399. SendMessage( WM_CANCELMODE );
  400. }
  402. void CExtSpinWnd::OnLButtonDown(UINT nFlags, CPoint point) 
  403. {
  404. CSpinButtonCtrl::OnLButtonDown(nFlags, point);
  405. _ProcessMouseClick( point, true, MK_LBUTTON );
  406. }
  408. void CExtSpinWnd::OnLButtonUp(UINT nFlags, CPoint point) 
  409. {
  410. CSpinButtonCtrl::OnLButtonUp(nFlags, point);
  411. _ProcessMouseClick( point, false, MK_LBUTTON );
  412. }
  414. void CExtSpinWnd::OnMouseMove(UINT nFlags, CPoint point) 
  415. {
  416. CSpinButtonCtrl::OnMouseMove(nFlags, point);
  417. _ProcessMouseMove( point );
  418. }
  420. void CExtSpinWnd::PreSubclassWindow() 
  421. {
  422. CSpinButtonCtrl::PreSubclassWindow();
  424. m_bCanceling = false;
  425. m_bButtonUpHovered = false;
  426. m_bButtonDownHovered = false;
  427. m_bButtonUpPressed = false;
  428. m_bButtonDownPressed = false;
  429. m_bNcCalcSize = false;
  431. AnimationSite_ClientProgressStop( this );
  432. AnimationClient_StateGet( false ).Empty();
  433. AnimationClient_StateGet( true ).Empty();
  434. CRect rcClient;
  435. GetClientRect( &rcClient );
  436. AnimationClient_TargetRectSet( rcClient );
  437. }
  439. LRESULT CExtSpinWnd::WindowProc(UINT message, WPARAM wParam, LPARAM lParam) 
  440. {
  441. #if (defined WM_UPDATEUISTATE)
  442. ASSERT( WM_UPDATEUISTATE == 0x0128 );
  443. #endif
  444. // WM_UPDATEUISTATE causes repaint without WM_PAINT, so we eat it
  445. if( message == 0x0128 )
  446. return 0;
  447. if( message == WM_SETTEXT 
  448. || message == WM_ENABLE
  450. )
  451. {
  452. LRESULT lResult = CSpinButtonCtrl::WindowProc(message, wParam, lParam);
  453. Invalidate();
  454. UpdateWindow();
  455. return lResult;
  456. }
  457. if( message == WM_TIMER )
  458. {
  459. if( AnimationSite_OnHookTimer( UINT(wParam) ) )
  460. return 0L;
  461. }
  462. if( message == WM_PRINT || message == WM_PRINTCLIENT )
  463. {
  464. CDC * pDC = CDC::FromHandle( (HDC)wParam );
  465. CRect rcClient;
  466. GetClientRect( &rcClient );
  467. OnSpinDrawEntire( *pDC, rcClient );
  468. return (!0);
  469. }
  470. return CSpinButtonCtrl::WindowProc(message, wParam, lParam);
  471. }
  473. void CExtSpinWnd::SetBkColor( COLORREF clrBk )
  474. { 
  475. ASSERT_VALID( this );
  476. m_clrBackground = clrBk; 
  477. if( GetSafeHwnd() != NULL )
  478. Invalidate();
  479. }
  481. COLORREF CExtSpinWnd::GetBkColor() const
  482. { 
  483. ASSERT_VALID( this );
  484. return m_clrBackground; 
  485. }
  487. COLORREF CExtSpinWnd::OnQueryBkColor() const
  488. { 
  489. ASSERT_VALID( this );
  490. return GetBkColor(); 
  491. }
  493. bool CExtSpinWnd::_ProcessMouseClick(
  494. CPoint point,
  495. bool bButtonPressed,
  496. INT nMouseButton // MK_... values
  497. )
  498. {
  499. ASSERT_VALID( this );
  501. // process only left mouse button clicks
  502. if( nMouseButton != MK_LBUTTON )
  503. return false;
  505. CRect rcButtonUp, rcButtonDown;
  506. GetButtonRect( rcButtonUp, rcButtonDown );
  508. bool bButtonUpHoveredPrev = m_bButtonUpHovered;
  509. bool bButtonDownHoveredPrev = m_bButtonDownHovered;
  510. bool bButtonUpHoveredNext = false;
  511. bool bButtonDownHoveredNext = false;
  513. bool bButtonUpPressedPrev = m_bButtonUpPressed;
  514. bool bButtonDownPressedPrev = m_bButtonDownPressed;
  515. bool bButtonUpPressedNext = false;
  516. bool bButtonDownPressedNext = false;
  518. if( (! rcButtonUp.IsRectEmpty() )
  519. && rcButtonUp.PtInRect( point )
  520. )
  521. {
  522. bButtonUpHoveredNext = true;
  523. if( bButtonPressed )
  524. bButtonUpPressedNext = true;
  525. }
  526. if( (! rcButtonDown.IsRectEmpty() )
  527. && rcButtonDown.PtInRect( point )
  528. )
  529. {
  530. bButtonDownHoveredNext = true;
  531. if( bButtonPressed )
  532. bButtonDownPressedNext = true;
  533. }
  535. if( bButtonUpHoveredNext
  536. || bButtonDownHoveredNext
  537. || bButtonUpPressedNext
  538. || bButtonDownPressedNext
  539. )
  540. {
  541. if( ::GetCapture() != GetSafeHwnd() )
  542. ::SetCapture( GetSafeHwnd() );
  543. }
  544. else
  545. {
  546. if( ::GetCapture() == GetSafeHwnd() )
  547. ::ReleaseCapture();
  548. }
  550. if( bButtonUpHoveredNext != bButtonUpHoveredPrev
  551. || bButtonDownHoveredNext != bButtonDownHoveredPrev
  552. || bButtonUpPressedNext != bButtonUpPressedPrev
  553. || bButtonDownPressedNext != bButtonDownPressedPrev
  554. )
  555. {
  556. bool bAnimationLocked = AnimationClient_CacheGeneratorIsLocked();
  557. if( ! bAnimationLocked )
  558. {
  559. AnimationClient_CacheGeneratorLock();
  560. // if( AnimationClient_StateGet(true).IsEmpty() )
  561.   AnimationClient_CacheNextStateMinInfo(
  562. false,
  563. ( ( bButtonUpPressedNext != bButtonUpPressedPrev
  564. || bButtonDownPressedNext != bButtonDownPressedPrev
  565. )
  566. && ( bButtonUpPressedNext || bButtonDownPressedNext )
  567. )
  568. ? __EAPT_BY_PRESSED_STATE_TURNED_ON : __EAPT_BY_PRESSED_STATE_TURNED_OFF
  569. );
  570. }
  572. m_bButtonUpHovered = bButtonUpHoveredNext;
  573. m_bButtonDownHovered = bButtonDownHoveredNext;
  574. m_bButtonUpPressed = bButtonUpPressedNext;
  575. m_bButtonDownPressed = bButtonDownPressedNext;
  577. if( ! bAnimationLocked )
  578. {
  579.   AnimationClient_CacheNextStateMinInfo(
  580. true,
  581. ( ( bButtonUpPressedNext != bButtonUpPressedPrev
  582. || bButtonDownPressedNext != bButtonDownPressedPrev
  583. )
  584. && ( bButtonUpPressedNext || bButtonDownPressedNext )
  585. )
  586. ? __EAPT_BY_PRESSED_STATE_TURNED_ON : __EAPT_BY_PRESSED_STATE_TURNED_OFF
  587. );
  588. AnimationClient_CacheGeneratorUnlock();
  589. }
  591. Invalidate();
  592. }
  594. return true;
  595. }
  597. bool CExtSpinWnd::_ProcessMouseMove( CPoint point )
  598. {
  599. ASSERT_VALID( this );
  601. if( CExtPopupMenuWnd::IsMenuTracking() 
  602. || (! CExtPopupMenuWnd::TestHoverEnabledFromActiveHWND( GetSafeHwnd() ) )
  603. )
  604. return false;
  606. CRect rcButtonUp, rcButtonDown;
  607. GetButtonRect( rcButtonUp, rcButtonDown );
  608. bool bButtonUpHoveredPrev   = m_bButtonUpHovered;
  609. bool bButtonDownHoveredPrev = m_bButtonDownHovered;
  610. bool bButtonUpHoveredNext   = false;
  611. bool bButtonDownHoveredNext = false;
  612. if( (! rcButtonUp.IsRectEmpty() )
  613. && rcButtonUp.PtInRect( point )
  614. )
  615. bButtonUpHoveredNext = true;
  616. if( (! rcButtonDown.IsRectEmpty() )
  617. && rcButtonDown.PtInRect( point )
  618. )
  619. bButtonDownHoveredNext = true;
  621. if( bButtonUpHoveredNext
  622. || bButtonDownHoveredNext
  623. )
  624. {
  625. if( ::GetCapture() != GetSafeHwnd() )
  626. ::SetCapture( GetSafeHwnd() );
  627. }
  628. else if( (! m_bButtonUpPressed )
  629. && (! m_bButtonDownPressed)
  630. )
  631. {
  632. if( ::GetCapture() == GetSafeHwnd() )
  633. ::ReleaseCapture();
  634. }
  636. if( bButtonUpHoveredNext != bButtonUpHoveredPrev
  637. || bButtonDownHoveredNext != bButtonDownHoveredPrev
  638. )
  639. {
  640. bool bAnimationLocked = AnimationClient_CacheGeneratorIsLocked();
  641. if( ! bAnimationLocked )
  642. {
  643. AnimationClient_CacheGeneratorLock();
  644.   AnimationClient_CacheNextStateMinInfo(
  645. false,
  646. ( bButtonUpHoveredNext || bButtonDownHoveredNext )
  647. ? __EAPT_BY_HOVERED_STATE_TURNED_ON : __EAPT_BY_HOVERED_STATE_TURNED_OFF
  648. );
  649. }
  651. m_bButtonUpHovered = bButtonUpHoveredNext;
  652. m_bButtonDownHovered = bButtonDownHoveredNext;
  654. if( ! bAnimationLocked )
  655. {
  656.   AnimationClient_CacheNextStateMinInfo(
  657. true,
  658. ( bButtonUpHoveredNext || bButtonDownHoveredNext )
  659. ? __EAPT_BY_HOVERED_STATE_TURNED_ON : __EAPT_BY_HOVERED_STATE_TURNED_OFF
  660. );
  661. AnimationClient_CacheGeneratorUnlock();
  662. }
  664. Invalidate();
  665. }
  667. return true;
  668. }
  670. void CExtSpinWnd::OnNcCalcSize( BOOL bCalcValidRects, NCCALCSIZE_PARAMS FAR* lpncsp ) 
  671. {
  672. bCalcValidRects;
  673. CRect & rcNcRect = reinterpret_cast < CRect & > ( lpncsp->rgrc[0] );
  674. if( _IsBuddyToEdit() )
  675. {
  676. DWORD dwStyle = GetStyle();
  677. bool bSpinAlignRight = ( (dwStyle&UDS_ALIGNRIGHT) != 0 ) ? true : false;
  678. bool bSpinAlignLeft = ( (dwStyle&UDS_ALIGNLEFT) != 0 ) ? true : false;
  679. bool bHasScrolBars = false;
  680. CWnd * pWnd = this->GetWindow( GW_HWNDPREV );
  681. if( pWnd != NULL )
  682. {
  683. ASSERT_VALID( pWnd );
  684. DWORD dwStyle = pWnd->GetStyle();
  685. if( (dwStyle&WS_VSCROLL) != 0
  686. || (dwStyle&WS_HSCROLL) != 0
  687. )
  688. bHasScrolBars = true;
  689. }
  691. CRect rcNcAreaMargins = 
  692. PmBridge_GetPM()->Spin_QueryNcAreaMargins(
  693. bSpinAlignRight,
  694. bSpinAlignLeft,
  695. bHasScrolBars
  696. );
  698.   rcNcRect.DeflateRect( rcNcAreaMargins );
  700. __EXT_MFC_LONG_PTR dwExStyle = ::__EXT_MFC_GetWindowLong( GetSafeHwnd(), GWL_EXSTYLE );
  701. bool bRTL = ( (dwExStyle & WS_EX_LAYOUTRTL) != 0 ) ? true : false;
  703. if( bRTL )
  704. rcNcRect.OffsetRect( 3, 0 );
  705. }
  706. m_bNcCalcSize = true;
  707. }
  709. void CExtSpinWnd::OnNcPaint() 
  710. {
  711. if( _IsBuddyToEdit() )
  712. {
  713. CWnd * pWnd = this->GetWindow( GW_HWNDPREV );
  714. if( pWnd != NULL )
  715. {
  716. ASSERT_VALID( pWnd );
  717. pWnd->SendMessage( WM_NCPAINT );
  718. }
  719. }
  720. }
  722. void CExtSpinWnd::OnSize(UINT nType, int cx, int cy) 
  723. {
  724. AnimationSite_ClientProgressStop( this );
  725. AnimationClient_StateGet( false ).Empty();
  726. AnimationClient_StateGet( true ).Empty();
  727. CRect rectButton;
  728. GetClientRect( &rectButton );
  729. AnimationClient_TargetRectSet( rectButton );
  731. CSpinButtonCtrl::OnSize( nType, cx, cy );
  732. }
  734. void CExtSpinWnd::PmBridge_OnPaintManagerChanged(
  735. CExtPaintManager * pGlobalPM
  736. )
  737. {
  738. m_bNcCalcSize = false;
  739. if( GetSafeHwnd() != NULL )
  740. SetWindowPos(
  741. NULL, 0, 0, 0, 0,
  742. SWP_NOMOVE|SWP_NOSIZE 
  743. |SWP_NOZORDER|SWP_NOOWNERZORDER|SWP_FRAMECHANGED
  744. );
  745. CExtAnimationSingleton::PmBridge_OnPaintManagerChanged( pGlobalPM );
  746. }
  748. HWND CExtSpinWnd::AnimationSite_GetSafeHWND() const
  749. {
  750. __PROF_UIS_MANAGE_STATE;
  751. HWND hWnd = GetSafeHwnd();
  752. return hWnd;
  753. }
  755. const CExtAnimationParameters *
  756. CExtSpinWnd::AnimationClient_OnQueryAnimationParameters(
  757. INT eAPT // __EAPT_*** animation type
  758. ) const
  759. {
  760. ASSERT_VALID( this );
  761. const CExtAnimationParameters * pAnimationParameters =
  762. PmBridge_GetPM()->Animation_GetParameters(
  763. eAPT,
  764. (CObject*)this,
  765. this
  766. );
  767. return pAnimationParameters;
  768. }
  770. bool CExtSpinWnd::AnimationClient_CacheNextState(
  771. CDC & dc,
  772. const RECT & rcAcAnimationTarget,
  773. bool bAnimate,
  774. INT eAPT // __EAPT_*** animation type
  775. )
  776. {
  777. ASSERT_VALID( this );
  778. ASSERT_VALID( (&dc) );
  779. ASSERT( dc.GetSafeHdc() != NULL );
  780. ASSERT( AnimationClient_CacheGeneratorIsLocked() );
  782. OnSpinDrawEntire( dc, &rcAcAnimationTarget );
  784. return
  785. CExtAnimationSingleton::AnimationClient_CacheNextState(
  786. dc,
  787. rcAcAnimationTarget,
  788. bAnimate,
  789. eAPT
  790. );
  791. }
  793. #endif // (!defined __EXT_MFC_NO_SPIN)