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

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

界面编程

开发平台：

Visual C++

ExtPaintManager2.cpp：源码内容
  2. // This is part of the Professional User Interface Suite library.
  3. // Copyright (C) 2001-2009 FOSS Software, Inc.
  4. // All rights reserved.
  5. //
  6. // http://www.prof-uis.com
  7. // mailto:support@prof-uis.com
  8. //
  9. // This source code can be used, modified and redistributed
  10. // under the terms of the license agreement that is included
  11. // in the Professional User Interface Suite package.
  12. //
  13. // Warranties and Disclaimers:
  14. // THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND
  15. // INCLUDING, BUT NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY,
  16. // FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  17. // IN NO EVENT WILL FOSS SOFTWARE INC. BE LIABLE FOR ANY DIRECT,
  18. // INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES,
  19. // INCLUDING DAMAGES FOR LOSS OF PROFITS, LOSS OR INACCURACY OF DATA,
  20. // INCURRED BY ANY PERSON FROM SUCH PERSON'S USAGE OF THIS SOFTWARE
  21. // EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
  23. #include "StdAfx.h"
  25. #if (defined __PROF_UIS_BUILTIN_MULTIMON_STUB)
  26. #define COMPILE_MULTIMON_STUBS
  27. #endif // __PROF_UIS_BUILTIN_MULTIMON_STUB
  29. // disable warning 4706
  30. #pragma warning( push )
  31. #pragma warning ( disable : 4706 )
  32. #include <multimon.h>
  33. // rollback warning 4706
  34. #pragma warning( pop )
  36. #if _MFC_VER < 0x700
  37. #include <../src/AfxImpl.h>
  38. #else
  39. #include <../src/mfc/AfxImpl.h>
  40. #endif
  42. #if (!defined __EXT_PAINT_MANAGER_H)
  43. #include <ExtPaintManager.h>
  44. #endif
  46. #if (!defined __ExtCmdManager_H)
  47. #include <ExtCmdManager.h>
  48. #endif
  50. #if (!defined __EXT_MEMORY_DC_H)
  51. #include <../Src/ExtMemoryDC.h>
  52. #endif
  54. #if (!defined __EXT_POPUP_MENU_WND_H)
  55. #include <ExtPopupMenuWnd.h>
  56. #endif
  58. #if (!defined __EXT_MENUCONTROLBAR_H)
  59. #include <ExtMenuControlBar.h>
  60. #endif
  62. #if (!defined __EXTDOCKBAR_H)
  63. #include <../Src/ExtDockBar.h>
  64. #endif
  66. #if (!defined __EXT_STATUSCONTROLBAR_H)
  67. #include <ExtStatusControlBar.h>
  68. #endif
  70. #if (!defined __EXT_MFC_NO_TAB_CONTROLBARS)
  71. #if (!defined __EXT_CONTROLBAR_TABBED_FEATURES_H)
  72. #include "ExtControlBarTabbedFeatures.h"
  73. #endif // __EXT_CONTROLBAR_TABBED_FEATURES_H
  74. #endif
  76. #if( !defined __EXTMINIDOCKFRAMEWND_H)
  77. #include "ExtMiniDockFrameWnd.h"
  78. #endif
  80. #if (!defined __EXT_MFC_NO_SHORTCUTLIST_CTRL)
  81. #if (!defined __EXTSHORTCUTLISTWND_H)
  82. #include <ExtShortcutListWnd.h>
  83. #endif
  84. #endif // (!defined __EXT_MFC_NO_SHORTCUTLIST_CTRL)
  86. #if (!defined __EXT_BUTTON_H)
  87. #include <ExtButton.h>
  88. #endif
  90. #if (!defined __EXT_GROUPBOX_H)
  91. #include <ExtGroupBox.h>
  92. #endif
  94. #if (!defined __PROF_UIS_RES_2007_H)
  95. #include <Resources/Res2007/Res2007.h>
  96. #endif
  98. #if (!defined __PROF_UIS_RES_2010_OFFICE_H)
  99. #include <Resources/Res2010office/Res2010office.h>
  100. #endif
  102. #if (!defined __EXT_SCROLLWND_H)
  103. #include <ExtScrollWnd.h>
  104. #endif 
  106. #if (!defined __EXT_MFC_NO_REPORTGRIDWND)
  107. #if (!defined __EXT_REPORT_GRID_WND_H)
  108. #include <ExtReportGridWnd.h>
  109. #endif
  110. #endif 
  112. #if (!defined __EXT_MFC_NO_DATE_PICKER)
  113. #if (!defined __EXT_DATE_PICKER_H)
  114. #include <ExtDatePicker.h>
  115. #endif
  116. #endif 
  118. #if (!defined __EXT_MFC_NO_TOOLBOX_CTRL)
  119. #if (!defined __EXTTOOLBOXWND_H)
  120. #include <ExtToolBoxWnd.h>
  121. #endif
  122. #endif 
  124. #if (!defined __EXT_MFC_NO_RIBBON_BAR)
  125. #if (!defined __EXT_RIBBON_BAR_H)
  126. #include <ExtRibbonBar.h>
  127. #endif // (!defined __EXT_RIBBON_BAR_H)
  128. #endif
  130. #if (!defined __EXT_MFC_NO_BUILTIN_TEXTFIELD)
  131. #if (!defined __EXT_POPUP_CTRL_MENU_H)
  132. #include <ExtPopupCtrlMenu.h>
  133. #endif
  134. #endif
  136. #if (!defined __EXT_MFC_NO_GRIDWND)
  137. #if (!defined __EXT_GRIDWND_H)
  138. #include <ExtGridWnd.h>
  139. #endif 
  140. #endif
  142. #if (!defined __EXT_TEMPL_H)
  143. #include <ExtTempl.h>
  144. #endif
  146. #if (!defined __EXT_SPIN_H)
  147. #include <ExtSpinWnd.h>
  148. #endif
  150. #if (!defined __EXT_MFC_NO_CUSTOMIZE)
  151. #if (!defined __EXTCUSTOMIZE_H)
  152. #include <ExtCustomize.h>
  153. #endif
  154. #endif // (!defined __EXT_MFC_NO_CUSTOMIZE)
  156. #if (!defined __EXT_MFC_NO_DURATIONWND)
  157. #if (!defined __EXT_DURATIONWND_H)
  158. #include "ExtDurationWnd.h"
  159. #endif
  160. #endif
  162. #if (!defined __EXT_MFC_NO_PAGECONTAINER_CTRL)
  163. #if (!defined __EXT_PAGECONTAINERWND_H)
  164. #include <ExtPageContainerWnd.h>
  165. #endif
  166. #endif
  168. #if (!defined __EXT_RESIZABLE_DIALOG_H)
  169. #include <ExtResizableDialog.h>
  170. #endif
  172. #if (!defined __EXT_EDIT_H)
  173. #include <ExtEdit.h>
  174. #endif
  176. #if (!defined __EXT_COMBO_BOX_H)
  177. #include <ExtComboBox.h>
  178. #endif
  180. #if (! defined __VSSYM32_H__)
  181. #include <vssym32/vssym32.h>
  182. #endif // (! defined __VSSYM32_H__)
  184. #include <math.h>
  185. #include <shlwapi.h>
  187. #include <Resources/Resource.h>
  189. #if (! defined CLEARTYPE_QUALITY )
  190. #define CLEARTYPE_QUALITY 5
  191. #endif
  193. #ifdef _DEBUG
  194. #define new DEBUG_NEW
  195. #undef THIS_FILE
  196. static char THIS_FILE[] = __FILE__;
  197. #endif
  199. // VC+ 6.0 static builds specific: disable warnings 4305, 4309
  200. // warning C4305: 'initializing' : truncation from 'int' to 'short'
  201. // warning C4309: 'initializing' : truncation of constant value
  202. #if _MFC_VER < 0x700
  203. #ifdef __EXT_PROFUIS_STATIC_LINK
  204. #pragma warning( push )
  205. #pragma warning ( disable : 4305 )
  206. #pragma warning ( disable : 4309 )
  207. #endif
  208. #endif
  210. IMPLEMENT_SERIAL(  CExtPaintManager,                         CObject,                                  VERSIONABLE_SCHEMA|1 );
  211. IMPLEMENT_SERIAL(  CExtPaintManagerXP,                       CExtPaintManager,                         VERSIONABLE_SCHEMA|1 );
  212. IMPLEMENT_SERIAL(  CExtPaintManagerOffice2003,               CExtPaintManagerXP,                       VERSIONABLE_SCHEMA|1 );
  213. IMPLEMENT_SERIAL(  CExtPaintManagerOffice2003NoThemes,       CExtPaintManagerOffice2003,               VERSIONABLE_SCHEMA|1 );
  214. IMPLEMENT_SERIAL(  CExtPaintManagerStudio2005,               CExtPaintManagerOffice2003,               VERSIONABLE_SCHEMA|1 );
  215. IMPLEMENT_SERIAL(  CExtPaintManagerStudio2008,               CExtPaintManagerStudio2005,               VERSIONABLE_SCHEMA|1 );
  216. IMPLEMENT_SERIAL(  CExtPaintManagerNativeXP,                 CExtPaintManager,                         VERSIONABLE_SCHEMA|1 );
  217. IMPLEMENT_DYNAMIC( CExtPaintManagerOffice2007_Impl,          CExtPaintManagerOffice2003 )
  218. IMPLEMENT_SERIAL(  CExtPaintManagerOffice2007_R1,            CExtPaintManagerOffice2007_Impl,          VERSIONABLE_SCHEMA|1 );
  219. IMPLEMENT_SERIAL(  CExtPaintManagerOffice2007_R2_LunaBlue,   CExtPaintManagerOffice2007_Impl,          VERSIONABLE_SCHEMA|1 );
  220. IMPLEMENT_SERIAL(  CExtPaintManagerOffice2007_R2_Obsidian,   CExtPaintManagerOffice2007_Impl,          VERSIONABLE_SCHEMA|1 );
  221. IMPLEMENT_SERIAL(  CExtPaintManagerOffice2007_R2_Silver,     CExtPaintManagerOffice2007_Impl,          VERSIONABLE_SCHEMA|1 );
  222. IMPLEMENT_SERIAL(  CExtPaintManagerOffice2007_R3_LunaBlue,   CExtPaintManagerOffice2007_R2_LunaBlue,   VERSIONABLE_SCHEMA|1 );
  223. IMPLEMENT_SERIAL(  CExtPaintManagerOffice2007_R3_Obsidian,   CExtPaintManagerOffice2007_R2_Obsidian,   VERSIONABLE_SCHEMA|1 );
  224. IMPLEMENT_SERIAL(  CExtPaintManagerOffice2007_R3_Silver,     CExtPaintManagerOffice2007_R2_Silver,     VERSIONABLE_SCHEMA|1 );
  225. IMPLEMENT_SERIAL(  CExtPaintManagerOffice2007_Blue,          CExtPaintManagerOffice2007_R3_LunaBlue,   VERSIONABLE_SCHEMA|1 );
  226. IMPLEMENT_SERIAL(  CExtPaintManagerOffice2007_Black,         CExtPaintManagerOffice2007_R3_Obsidian,   VERSIONABLE_SCHEMA|1 );
  227. IMPLEMENT_SERIAL(  CExtPaintManagerOffice2007_Silver,        CExtPaintManagerOffice2007_R3_Silver,     VERSIONABLE_SCHEMA|1 );
  228. IMPLEMENT_DYNAMIC( CExtPaintManagerOffice2010_Impl,          CExtPaintManagerOffice2007_Impl )
  229. IMPLEMENT_SERIAL(  CExtPaintManagerOffice2010_R1,            CExtPaintManagerOffice2010_Impl,          VERSIONABLE_SCHEMA|1 );
  230. IMPLEMENT_SERIAL(  CExtPaintManagerOffice2010_R2_Blue,       CExtPaintManagerOffice2010_Impl,          VERSIONABLE_SCHEMA|1 );
  231. IMPLEMENT_SERIAL(  CExtPaintManagerOffice2010_R2_Silver,     CExtPaintManagerOffice2010_Impl,          VERSIONABLE_SCHEMA|1 );
  232. IMPLEMENT_SERIAL(  CExtPaintManagerOffice2010_R2_Black,      CExtPaintManagerOffice2010_Impl,          VERSIONABLE_SCHEMA|1 );
  234. CExtPaintManager::CExtPaintManagerAutoPtr g_PaintManager;
  236. // CExtSWMR::CExtSWMR(
  237. // __EXT_MFC_SAFE_LPCTSTR strName //  = NULL
  238. // )
  239. // : m_bConstructed( false )
  240. // , m_hProtectWriter( NULL )
  241. // , m_hProtectReaders( NULL )
  242. // , m_hEnumReaders( NULL )
  243. // {
  244. // Create( strName );
  245. // }
  246. //
  247. // CExtSWMR::~CExtSWMR()
  248. // {
  249. // Destroy();
  250. // }
  251. //
  252. // LPCTSTR CExtSWMR::stat_GenerateObjectName(
  253. // __EXT_MFC_SAFE_LPCTSTR strPrefix,
  254. // __EXT_MFC_SAFE_LPCTSTR strSuffix,
  255. // __EXT_MFC_SAFE_LPTSTR strOutNameBuffer,
  256. // size_t nBufferSize,
  257. // bool & bConstructed
  258. // )
  259. // {
  260. // bConstructed = true;
  261. // if( strSuffix == NULL )
  262. // return NULL;
  263. // if( strPrefix == NULL )
  264. // strPrefix = _T("");
  265. // size_t nLenPrefix = size_t( _tcslen( strPrefix ) );
  266. // size_t nLenSuffix = size_t( _tcslen( strSuffix ) );
  267. // if( ( nLenPrefix + nLenSuffix ) >= nBufferSize )
  268. // {
  269. // bConstructed = false;
  270. // return NULL;
  271. // }
  272. // __EXT_MFC_STRCPY( strOutNameBuffer, nBufferSize, strPrefix );
  273. // __EXT_MFC_STRCAT( strOutNameBuffer, nBufferSize, strSuffix );
  274. // return strOutNameBuffer;
  275. // }
  276. //
  277. // bool CExtSWMR::Create(
  278. // __EXT_MFC_SAFE_LPCTSTR strName //  = NULL
  279. // )
  280. // {
  281. // Destroy();
  282. // TCHAR strObjectNameBuffer[ 512 ];
  283. // LPCTSTR strObjectName =
  284. // stat_GenerateObjectName(
  285. // _T("~CExtSWMR~ProtectWriter~"),
  286. // strName,
  287. // strObjectNameBuffer,
  288. // sizeof(strObjectNameBuffer)/sizeof(strObjectNameBuffer[0]),
  289. // m_bConstructed
  290. // );
  291. // if( m_bConstructed )
  292. // m_hProtectWriter =
  293. // ::CreateMutex(
  294. // NULL,
  295. // FALSE,
  296. // strObjectName
  297. // );
  298. // strObjectName =
  299. // stat_GenerateObjectName(
  300. // _T("~CExtSWMR~EventsNoReaders~"),
  301. // strName,
  302. // strObjectNameBuffer,
  303. // sizeof(strObjectNameBuffer)/sizeof(strObjectNameBuffer[0]),
  304. // m_bConstructed
  305. // );
  306. // if( m_bConstructed )
  307. // m_hProtectReaders =
  308. // ::CreateEvent(
  309. // NULL,
  310. // TRUE,
  311. // TRUE,
  312. // strObjectName
  313. // );
  314. // strObjectName =
  315. // stat_GenerateObjectName(
  316. // _T("~CExtSWMR~EnumReaders~"),
  317. // strName,
  318. // strObjectNameBuffer,
  319. // sizeof(strObjectNameBuffer)/sizeof(strObjectNameBuffer[0]),
  320. // m_bConstructed
  321. // );
  322. // if( m_bConstructed )
  323. // m_hEnumReaders =
  324. // ::CreateSemaphore(
  325. // NULL,
  326. // 0,
  327. // 0x7FFFFFFF,
  328. // strObjectName
  329. // );
  330. // if( m_hEnumReaders == NULL
  331. // || m_hProtectReaders == NULL
  332. // || m_hProtectWriter == NULL
  333. // )
  334. // {
  335. // Destroy();
  336. // m_bConstructed = false;
  337. // }
  338. // else
  339. // m_bConstructed = true;
  340. // return m_bConstructed;
  341. // }
  342. //
  343. // void CExtSWMR::Destroy()
  344. // {
  345. // if( m_hEnumReaders != NULL ) 
  346. // {
  347. // ::CloseHandle( m_hEnumReaders );
  348. // m_hEnumReaders = NULL;
  349. // }
  350. // if( m_hProtectReaders != NULL ) 
  351. // {
  352. // ::CloseHandle( m_hProtectReaders );
  353. // m_hProtectReaders = NULL;
  354. // }
  355. // if( m_hProtectWriter != NULL )
  356. // {
  357. // ::CloseHandle( m_hProtectWriter );
  358. // m_hProtectWriter = NULL;
  359. // }
  360. // m_bConstructed = false;
  361. // }
  362. //
  363. // bool CExtSWMR::IsConstructed() const
  364. // {
  365. // return m_bConstructed;
  366. // }
  367. //
  368. // CExtSWMR::LockSection::LockSection(
  369. // CExtSWMR & _SWMR,
  370. // bool bRead,
  371. // DWORD dwTimeout // = INFINITE
  372. // )
  373. // : m_SWMR( _SWMR )
  374. // , m_bRead( bRead )
  375. // , m_bLocked( false )
  376. // {
  377. // if( ! m_SWMR.IsConstructed() )
  378. // return;
  379. // DWORD dwWaitResult = WAIT_ABANDONED;
  380. // if( m_bRead )
  381. // dwWaitResult = m_SWMR.WaitToRead( dwTimeout );
  382. // else
  383. // dwWaitResult = m_SWMR.WaitToWrite( dwTimeout );
  384. // m_bLocked = ( dwWaitResult == WAIT_ABANDONED || dwWaitResult == WAIT_TIMEOUT ) ? false : true;
  385. // }
  386. //
  387. // CExtSWMR::LockSection::~LockSection()
  388. // {
  389. // if( ! m_bLocked )
  390. // return;
  391. // if( m_bRead )
  392. // m_SWMR.DoneReading();
  393. // else
  394. // m_SWMR.DoneWriting();
  395. // }
  396. //
  397. // bool CExtSWMR::LockSection::IsLocked() const
  398. // {
  399. // return m_bLocked;
  400. // }
  401. //
  402. // DWORD CExtSWMR::WaitToWrite(
  403. // DWORD dwTimeout // = INFINITE
  404. // )
  405. // {
  406. // HANDLE arrToWait[2];
  407. // arrToWait[0] = m_hProtectWriter;
  408. // arrToWait[1] = m_hProtectReaders;
  409. // DWORD dwWaitResult =
  410. // ::WaitForMultipleObjects(
  411. // 2,
  412. // arrToWait,
  413. // TRUE,
  414. // dwTimeout
  415. // );
  416. // return dwWaitResult;
  417. // }
  418. //
  419. // void CExtSWMR::DoneWriting()
  420. // {
  421. // ::ReleaseMutex( m_hProtectWriter );
  422. // }
  423. //
  424. // DWORD CExtSWMR::WaitToRead(
  425. // DWORD dwTimeout // = INFINITE
  426. // )
  427. // {
  428. // DWORD dwWaitResult =
  429. // ::WaitForSingleObject(
  430. // m_hProtectWriter,
  431. // dwTimeout
  432. // );
  433. // if( dwWaitResult != WAIT_TIMEOUT )
  434. // {
  435. // LONG nPrev = 0;
  436. // ::ReleaseSemaphore(
  437. // m_hEnumReaders,
  438. // 1,
  439. // &nPrev
  440. // );
  441. // if( nPrev == 0)
  442. // ::ResetEvent( m_hProtectReaders );
  443. // } // if( dwWaitResult != WAIT_TIMEOUT )
  444. // ::ReleaseMutex( m_hProtectWriter );
  445. // return dwWaitResult;
  446. // }
  447. //
  448. // void CExtSWMR::DoneReading()
  449. // {
  450. // HANDLE arrToWait[2];
  451. // arrToWait[0] = m_hProtectWriter;
  452. // arrToWait[1] = m_hEnumReaders;
  453. // ::WaitForMultipleObjects(
  454. // 2,
  455. // arrToWait,
  456. // TRUE,
  457. // INFINITE
  458. // );
  459. // DWORD dwWaitResult =
  460. // ::WaitForSingleObject(
  461. // m_hEnumReaders,
  462. // 0
  463. // );
  464. // bool bLast = ( dwWaitResult == WAIT_TIMEOUT ) ? true : false;
  465. // if( bLast )
  466. // ::SetEvent( m_hProtectReaders );
  467. // else
  468. // ::ReleaseSemaphore(
  469. // m_hEnumReaders,
  470. // 1,
  471. // NULL
  472. // );
  473. // ::ReleaseMutex( m_hProtectWriter );
  474. // }
  476. CExtPmSynchronizeSink::CExtPmSynchronizeSink()
  477. : m_bPmSynchronizeSinkIsSynchronizing( false )
  478. , m_dwPmSynchronizeSinkThreadID( ::GetCurrentThreadId() )
  479. {
  480. }
  482. CExtPmSynchronizeSink::~CExtPmSynchronizeSink()
  483. {
  484. }
  486. DWORD CExtPmSynchronizeSink::PmSynchronizeSink_GetThreadID()
  487. {
  488. return m_dwPmSynchronizeSinkThreadID;
  489. }
  491. bool CExtPmSynchronizeSink::PmSynchronizeSink_IsSynchronizing()
  492. {
  493. return m_bPmSynchronizeSinkIsSynchronizing;
  494. }
  496. bool CExtPmSynchronizeSink::PmSynchronizeSink_IsEqual(
  497. CExtPmSynchronizeSink * pOther
  498. )
  499. {
  500. if( this == pOther )
  501. return true;
  502. return false;
  503. }
  505. INT CExtPmSynchronizeSink::GetIndexOfPmSynchronizeSink(
  506. CExtPmSynchronizeSink * pPmSynchronizeSink
  507. )
  508. {
  509. __PROF_UIS_MANAGE_STATE;
  510. if( pPmSynchronizeSink == NULL )
  511. return -1;
  512. INT nIndex, nCount = INT( m_arrPmSynchronizeSink.GetSize() );
  513. for( nIndex = 0; nIndex < nCount; nIndex ++ )
  514. {
  515. CExtPmSynchronizeSink * pRegistered = m_arrPmSynchronizeSink[ nIndex ];
  516. ASSERT( pRegistered != NULL );
  517. if( pRegistered->PmSynchronizeSink_IsEqual( pPmSynchronizeSink ) )
  518. return nIndex;
  519. } // for( nIndex = 0; nIndex < nCount; nIndex ++ )
  520. return -1;
  521. }
  523. bool CExtPaintManager::CExtPaintManagerAutoPtr::PmSynchronizeSink_PerformSynchronizationWith(
  524. CExtPmSynchronizeSink * pPmSynchronizeSink,
  525. bool bRegister, // = true
  526. bool bSynchronizeItNow // = true
  527. )
  528. {
  529. __PROF_UIS_MANAGE_STATE;
  530. if( bRegister )
  531. {
  532. if( pPmSynchronizeSink == NULL )
  533. return false;
  534. if( pPmSynchronizeSink->PmSynchronizeSink_IsEqual( this ) )
  535. return false;
  536. DWORD dwOwnThreadID = PmSynchronizeSink_GetThreadID();
  537. DWORD dwOtherThreadID = PmSynchronizeSink_GetThreadID();
  538. if( dwOwnThreadID != dwOtherThreadID )
  539. return false;
  540. INT nIndex = GetIndexOfPmSynchronizeSink( pPmSynchronizeSink );
  541. if( nIndex < 0 )
  542. m_arrPmSynchronizeSink.Add( pPmSynchronizeSink );
  543. if( bSynchronizeItNow )
  544. {
  545. LPSTREAM pStream = PmSynchronizeSink_GetData();
  546. if( pStream != NULL )
  547. {
  548. pPmSynchronizeSink ->
  549. PmSynchronizeSink_SynchronizeFrom(
  550. pStream
  551. );
  552. pStream->Release();
  553. } // if( pStream != NULL )
  554. } // if( bSynchronizeItNow )
  555. return true;
  556. } // if( bRegister )
  557. else
  558. {
  559. if( pPmSynchronizeSink == NULL )
  560. {
  561. m_arrPmSynchronizeSink.RemoveAll();
  562. return true;
  563. }
  564. INT nIndex = GetIndexOfPmSynchronizeSink( pPmSynchronizeSink );
  565. if( nIndex < 0 )
  566. return false;
  567. m_arrPmSynchronizeSink.RemoveAt( nIndex );
  568. return true;
  569. } // else from if( bRegister )
  570. }
  572. LPSTREAM CExtPaintManager::CExtPaintManagerAutoPtr::PmSynchronizeSink_GetData(
  573. HGLOBAL hGlobal // = NULL
  574. )
  575. {
  576. __PROF_UIS_MANAGE_STATE;
  577. CExtPaintManager * pPM = GetPM();
  578. if( pPM == NULL )
  579. return NULL;
  580. LPSTREAM pStream = NULL;
  581. SCODE sc =
  582. ::CreateStreamOnHGlobal(
  583. hGlobal,
  584. ( hGlobal != NULL ) ? FALSE : TRUE,
  585. &pStream
  586. );
  587. if( sc != S_OK )
  588. {
  589. ASSERT( FALSE );
  590. return NULL;
  591. }
  592. ASSERT( pStream != NULL );
  593. COleStreamFile _file;
  594. try
  595. {
  596. _file.Attach( pStream );
  597. CArchive ar( &_file, CArchive::store|CArchive::bNoFlushOnDelete );
  598. CRuntimeClass * pRTC = pPM->GetRuntimeClass();
  599. ASSERT( pRTC != NULL );
  600. ar.WriteClass( pRTC );
  601. pPM->SerializeSynchronizationData( ar );
  602. ar.Flush();
  603. ULARGE_INTEGER liNewPosition;
  604. LARGE_INTEGER liOff;
  605. LISet32( liOff, 0 );
  606. sc = pStream->Seek( liOff, STREAM_SEEK_SET, &liNewPosition );
  607. if( sc != S_OK )
  608. {
  609. ASSERT( FALSE );
  610. ::AfxThrowUserException();
  611. }
  612. return pStream;
  613. } // try
  614. catch( CException * pException )
  615. {
  616. pException->Delete();
  617. } // catch( CException * pException )
  618. catch( ... )
  619. {
  620. } // catch( ... )
  621. _file.Detach();
  622. pStream->Release();
  623. return NULL;
  624. }
  626. void CExtPaintManager::CExtPaintManagerAutoPtr::PmSynchronizeSink_SynchronizeFrom(
  627. LPSTREAM pStream
  628. )
  629. {
  630. __PROF_UIS_MANAGE_STATE;
  631. if( pStream == NULL )
  632. return;
  633. if( PmSynchronizeSink_IsSynchronizing() )
  634. return;
  635. m_bPmSynchronizeSinkIsSynchronizing = true;
  636. COleStreamFile _file;
  637. _file.Attach( pStream );
  638. try
  639. {
  640. CArchive ar( &_file, CArchive::load|CArchive::bNoFlushOnDelete, 0 );
  641. CRuntimeClass * pRTC = ar.ReadClass();
  642. ASSERT( pRTC != NULL );
  643. CObject * pObj = pRTC->CreateObject();
  644. if( pObj != NULL )
  645. {
  646. ASSERT_VALID( pObj );
  647. CExtPaintManager * pPaintManager =
  648. DYNAMIC_DOWNCAST( CExtPaintManager, pObj );
  649. if( pPaintManager == NULL )
  650. {
  651. ASSERT( FALSE );
  652. delete pObj;
  653. } // if( pPaintManager == NULL )
  654. else
  655. {
  656. pPaintManager->SerializeSynchronizationData( ar );
  657. InstallPaintManager( pPaintManager );
  658. PmSynchronizeSink_SynchronizeOthers();
  659. } // else from if( pPaintManager == NULL )
  660. } // if( pObj != NULL )
  661. } // try
  662. catch( CException * pException )
  663. {
  664. pException->Delete();
  665. } // catch( CException * pException )
  666. catch( ... )
  667. {
  668. } // catch( ... )
  669. _file.Detach();
  670. m_bPmSynchronizeSinkIsSynchronizing = false;
  671. }
  673. void CExtPmSynchronizeSink::PmSynchronizeSink_SynchronizeOthers(
  674. HGLOBAL hGlobal // = NULL
  675. )
  676. {
  677. __PROF_UIS_MANAGE_STATE;
  678. LPSTREAM pStream = PmSynchronizeSink_GetData( hGlobal );
  679. if( pStream == NULL )
  680. return;
  681. ULARGE_INTEGER liNewPosition;
  682. LARGE_INTEGER liOff;
  683. INT nIndex, nCount = INT( m_arrPmSynchronizeSink.GetSize() );
  684. for( nIndex = 0; nIndex < nCount; nIndex ++ )
  685. {
  686. CExtPmSynchronizeSink * pRegistered = m_arrPmSynchronizeSink[ nIndex ];
  687. ASSERT( pRegistered != NULL );
  688. pRegistered->PmSynchronizeSink_SynchronizeFrom( pStream );
  689. LISet32( liOff, 0 );
  690. SCODE sc = pStream->Seek( liOff, STREAM_SEEK_SET, &liNewPosition );
  691. if( sc != S_OK )
  692. {
  693. ASSERT( FALSE );
  694. break;
  695. }
  696. } // for( nIndex = 0; nIndex < nCount; nIndex ++ )
  697. pStream->Release();
  698. }
  700. CExtPaintManager::CExtPaintManagerAutoPtr::CExtPaintManagerAutoPtr()
  701. : m_pPaintManager( NULL )
  702. , m_bHaveScrollLines( false )
  703. , m_uCachedScrollLines( 0 )
  704. , m_bUxValidColorsExtracted( false )
  705. , m_eCurrentTheme( ThemeUnknown )
  706. , m_strOsVer( _T("Unknown") )
  707. , m_bIsWin32s( false )
  708. , m_bIsWin9x( false )
  709. , m_bIsWin95( false )
  710. , m_bIsWin98( false )
  711. , m_bIsWin98orLater( false )
  712. , m_bIsWinNT( false )
  713. , m_bIsWinNT4( false )
  714. , m_bIsWin2000( false )
  715. , m_bIsWinXP( false )
  716. , m_bIsWinNT4orLater( false )
  717. , m_bIsWin2000orLater( false )
  718. , m_bIsWinXPorLater( false )
  719. , m_bIsWinVista( false )
  720. , m_bIsWinVistaOrLater( false )
  721. , m_bIsWin7( false )
  722. , m_bIsWin7OrLater( false )
  723. , m_hDllMsImg( NULL )
  724. , m_hDllUser32( NULL )
  725. , m_pfnMsImgGradientFill( NULL )
  726. , m_pfnMsImgAlphaBlend( NULL )
  727. , m_pfnMsImgTransparentBlt( NULL )
  728. , m_pfnAnimateWindow( NULL )
  729. , m_pfnSetLayeredWindowAttributes( NULL )
  730. , m_pfnUpdateLayeredWindow( NULL )
  731. , m_pfnPrintWindow( NULL )
  732. , m_nLPX( 96 )
  733. , m_nLPY( 96 )
  734. , m_nLPZ( ( m_nLPX + m_nLPY ) / 2 )
  735. , m_bEnableUiScalingX( true )
  736. , m_bEnableUiScalingY( true )
  737. , m_bEnableUiScalingZ( true )
  738. , m_bLayeredHighlighting2005( false )
  739. , m_bAllowWndUpdateSourceDetection( true )
  740. , m_bAutoSkinScrollBars( true )
  741. , m_nInsallPaintManagerCounter( 0 )
  742. , m_nMsgPaintManagerChanged( ::RegisterWindowMessage( _T("CExtPaintManager::CExtPaintManagerAutoPtr::m_nMsgPaintManagerChanged") ) )
  743. {
  744. #ifdef WM_THEMECHANGED
  745. ASSERT( __ExtMfc_WM_THEMECHANGED == WM_THEMECHANGED );
  746. #endif // WM_THEMECHANGED
  748. memset((char *)&m_osVerData,0,sizeof(OSVERSIONINFO));
  749. m_osVerData.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
  751. CExtSafeString sTmp( _T("") );
  752. VERIFY( ::GetVersionEx(&m_osVerData) );
  753. switch(m_osVerData.dwPlatformId)
  754. {
  755. case VER_PLATFORM_WIN32s:
  756. m_bIsWin32s = true;
  757. sTmp = _T("Win32s");
  758. break;
  759. case VER_PLATFORM_WIN32_WINDOWS:
  760. {
  761. m_bIsWin9x = true;
  762. m_bIsWin95 =
  763. ( ( m_osVerData.dwMajorVersion == 4 )
  764. && ( m_osVerData.dwMinorVersion == 0 )
  765. );
  766. m_bIsWin98orLater = 
  767. ( ( m_osVerData.dwMajorVersion > 4 )
  768. || ( ( m_osVerData.dwMajorVersion == 4 )
  769. && ( m_osVerData.dwMinorVersion > 0 )
  770. )
  771. );
  772. sTmp = _T("Windows ");
  773. if( m_bIsWin98orLater )
  774. {
  775. if( ( m_osVerData.dwMajorVersion == 4 )
  776. && ( m_osVerData.dwMinorVersion > 0 )
  777. )
  778. {
  779. m_bIsWin98 = true;
  780. sTmp += _T("98");
  781. }
  782. else
  783. sTmp += _T("98 or later");
  784. }
  785. else
  786. {
  787. sTmp += _T("95");
  788. }
  789. }
  790. break;
  791. case VER_PLATFORM_WIN32_NT:
  792. m_bIsWinNT = true;
  793. if( m_osVerData.dwMajorVersion == 6 )
  794. {
  795. if( m_osVerData.dwMinorVersion == 0 )
  796. {
  797. m_bIsWinVista = true;
  798. sTmp = _T("Windows Vista");
  799. }
  800. else
  801. {
  802. m_bIsWin7 = true;
  803. sTmp = _T("Windows 7");
  804. }
  805. }
  806. else if( m_osVerData.dwMajorVersion == 5 )
  807. {
  808. if( m_osVerData.dwMinorVersion == 0 )
  809. {
  810. m_bIsWin2000 = true;
  811. sTmp = _T("Windows 2000");
  812. }
  813. else if( m_osVerData.dwMinorVersion == 1 )
  814. {
  815. m_bIsWinXP = true;
  816. sTmp = _T("Windows XP");
  817. }
  818. }
  819. else if( m_osVerData.dwMajorVersion == 4 )
  820. {
  821. m_bIsWinNT4 = true;
  822. sTmp = _T("Windows NT");
  823. }
  824. else
  825. sTmp = _T("Windows NT");
  827. if( m_osVerData.dwMajorVersion >= 4 )
  828. m_bIsWinNT4orLater = true;
  829. if( m_osVerData.dwMajorVersion >= 5 )
  830. {
  831. m_bIsWin2000orLater = true;
  832. if( ! ( m_osVerData.dwMajorVersion == 5
  833. && m_osVerData.dwMinorVersion == 0
  834. )
  835. )
  836. m_bIsWinXPorLater = true;
  837. if( m_osVerData.dwMajorVersion >= 6 )
  838. {
  839. m_bIsWinVistaOrLater = true;
  840. if( m_osVerData.dwMinorVersion >= 1 )
  841. m_bIsWin7OrLater = true;
  842. }
  843. }
  844. break;
  845. } // switch(m_osVerData.dwPlatformId)
  847. if( ! m_bIsWin2000orLater )
  848. m_bAutoSkinScrollBars = false;
  850. m_strOsVer.Format(
  851. _T("%s v.%lu.%lu (build %lu) %s"),
  852. sTmp,
  853. m_osVerData.dwMajorVersion, 
  854. m_osVerData.dwMinorVersion, 
  855. m_osVerData.dwBuildNumber,
  856. m_osVerData.szCSDVersion
  857. );
  859. // init uxtheme.dll data
  860. InitUserExApi();
  862. // init msimg32.dll data
  863. if( m_bIsWin2000orLater )
  864. {
  865. m_hDllMsImg = ::LoadLibrary(_T("msimg32.dll"));
  866. if( m_hDllMsImg != NULL )
  867. {
  868. m_pfnMsImgGradientFill = (PFNGRADIENTFILL)
  869. ::GetProcAddress(
  870. m_hDllMsImg, 
  871. "GradientFill"
  872. );
  873. m_pfnMsImgAlphaBlend = (PFNALPHABLEND)
  874. ::GetProcAddress(
  875. m_hDllMsImg, 
  876. "AlphaBlend"
  877. );
  878. m_pfnMsImgAlphaDIBBlend = (PFNALPHADIBBLEND)
  879. ::GetProcAddress(
  880. m_hDllMsImg, 
  881. "AlphaDIBBlend"
  882. );
  883. m_pfnMsImgTransparentBlt = (PFNTRANSPARENTBLT)
  884. ::GetProcAddress(
  885. m_hDllMsImg, 
  886. "TransparentBlt"
  887. );
  888. m_pfnMsImgTransparentDIBits = (PFNTRANSPARENTDIBITS)
  889. ::GetProcAddress(
  890. m_hDllMsImg, 
  891. "TransparentDIBits"
  892. );
  893. }
  894. } // if( m_bIsWin2000orLater )
  896. // init user32.dll data
  897. m_hDllUser32 = ::LoadLibrary(_T("user32.dll"));
  898. if( m_hDllUser32 != NULL )
  899. {
  900. m_pfnAnimateWindow = (PFNANIMATEWINDOW)
  901. ::GetProcAddress(
  902. m_hDllUser32, 
  903. "AnimateWindow"
  904. );
  905. m_pfnSetLayeredWindowAttributes = (PFNSETLAYEREDWINDOWATTRIBUTES)
  906. ::GetProcAddress(
  907. m_hDllUser32, 
  908. "SetLayeredWindowAttributes"
  909. );
  910. m_pfnUpdateLayeredWindow = (PFNUPDATELAYEREDWINDOW)
  911. ::GetProcAddress(
  912. m_hDllUser32, 
  913. "UpdateLayeredWindow"
  914. );
  915. m_pfnPrintWindow = (PFNPRINTWINDOW)
  916. ::GetProcAddress(
  917. m_hDllUser32, 
  918. "PrintWindow"
  919. );
  920. BOOL ( WINAPI * pfnSetProcessDPIAware )( VOID ) =
  921. ( BOOL ( WINAPI * )( VOID ) )
  922. ::GetProcAddress(
  923. m_hDllUser32, 
  924. "SetProcessDPIAware"
  925. );
  926. if( pfnSetProcessDPIAware != NULL )
  927. pfnSetProcessDPIAware();
  928. //  VOID ( WINAPI * pfnDisableProcessWindowsGhosting )( VOID ) =
  929. //  ( VOID ( WINAPI * )( VOID ) )
  930. //  ::GetProcAddress(
  931. //  m_hDllUser32, 
  932. //  "DisableProcessWindowsGhosting"
  933. //  );
  934. //  if( pfnDisableProcessWindowsGhosting != NULL )
  935. //  pfnDisableProcessWindowsGhosting();
  936. } // if( m_hDllUser32 != NULL )
  938. //  VERIFY(
  939. //  InitPaintManagerInstance()
  940. //  );
  942. CWindowDC dcDesktop( NULL );
  943. m_nLPX = ::GetDeviceCaps( dcDesktop.m_hDC, LOGPIXELSX );
  944. m_nLPY = ::GetDeviceCaps( dcDesktop.m_hDC, LOGPIXELSY );
  945. m_nLPZ = ( m_nLPX + m_nLPY ) / 2;
  947. if( m_bIsWin2000orLater
  948. && CExtPaintManager::stat_GetBPP() >= 15
  949. && m_pfnUpdateLayeredWindow != NULL
  950. )
  951. m_bLayeredHighlighting2005 = true;
  952. }
  954. void CExtPaintManager::CExtPaintManagerAutoPtr::InitUserExApi()
  955. {
  956. m_bUxValidColorsExtracted = false;
  957. m_eCurrentTheme = ThemeUnknown;
  959. if( m_UxTheme.IsAppThemed() )
  960. {
  961. // theme name
  962. WCHAR pszThemeName[MAX_PATH] = L"";
  963. WCHAR pszColor[MAX_PATH] = L"";
  965. if( m_UxTheme.GetCurrentThemeName(
  966. pszThemeName, 
  967. MAX_PATH, 
  968. pszColor, 
  969. MAX_PATH, 
  970. NULL, 
  971. 0 
  972. ) == S_OK
  973. )
  974. {
  975. if( wcsstr( __EXT_MFC_WCSLWR( pszThemeName, wcslen( pszThemeName ) + 1 ), L"luna.msstyles") != 0 )
  976. {
  977. if( wcscmp( __EXT_MFC_WCSLWR( pszColor, wcslen( pszColor ) + 1 ), L"normalcolor") == 0 )
  978. m_eCurrentTheme = ThemeLunaBlue;
  979. else if( wcscmp( __EXT_MFC_WCSLWR( pszColor, wcslen( pszColor ) + 1 ), L"homestead") == 0 )
  980. m_eCurrentTheme = ThemeLunaOlive;
  981. else if( wcscmp( __EXT_MFC_WCSLWR( pszColor, wcslen( pszColor ) + 1 ), L"metallic") == 0 )
  982. m_eCurrentTheme = ThemeLunaSilver;
  983. }
  984. else if( wcsstr( __EXT_MFC_WCSLWR( pszThemeName, wcslen( pszThemeName ) + 1 ), L"royale.msstyles") != 0 )
  985. {
  986. if( wcscmp( __EXT_MFC_WCSLWR( pszColor, wcslen( pszColor ) + 1 ), L"normalcolor") == 0 )
  987. m_eCurrentTheme = ThemeLunaRoyale;
  988. }
  989. }
  991. HWND hWndDesktop = ::GetDesktopWindow();
  992. ASSERT( hWndDesktop != NULL );
  993. if( m_UxTheme.OpenThemeData( hWndDesktop, L"TASKBAND" ) != NULL )
  994. {
  995. if( m_UxTheme.GetThemeColor(TDP_FLASHBUTTON,0,TMT_EDGELIGHTCOLOR,&m_clrUxTaskBandEdgeLightColor) == S_OK
  996. && m_UxTheme.GetThemeColor(TDP_FLASHBUTTON,0,TMT_EDGEHIGHLIGHTCOLOR,&m_clrUxTaskBandEdgeHighLightColor) == S_OK
  997. && m_UxTheme.GetThemeColor(TDP_FLASHBUTTON,0,TMT_EDGESHADOWCOLOR,&m_clrUxTaskBandEdgeShadowColor) == S_OK
  998. && m_UxTheme.GetThemeColor(TDP_FLASHBUTTON,0,TMT_EDGEDKSHADOWCOLOR,&m_clrUxTaskBandEdgeDkShadowColor) == S_OK
  999. && m_UxTheme.GetThemeColor(TDP_FLASHBUTTON,0,TMT_EDGEFILLCOLOR,&m_clrUxTaskBandEdgeFillColor) == S_OK
  1000. && m_UxTheme.GetThemeColor(TDP_FLASHBUTTON,0,TMT_FILLCOLORHINT,&m_clrUxTaskBandFillColorHint) == S_OK
  1001. && m_UxTheme.GetThemeColor(TDP_FLASHBUTTON,0,TMT_ACCENTCOLORHINT,&m_clrUxTaskBandAccentColorHint) == S_OK
  1002. )
  1003. m_bUxValidColorsExtracted = true;
  1004. m_UxTheme.CloseThemeData();
  1005. }
  1006. } // if( m_UxTheme.IsAppThemed() )
  1007. }
  1009. CExtPaintManager::CExtPaintManagerAutoPtr::~CExtPaintManagerAutoPtr()
  1010. {
  1011. UnadviseAll();
  1012. if( m_hDllMsImg != NULL )
  1013. ::FreeLibrary( m_hDllMsImg );
  1014. if( m_hDllUser32 != NULL )
  1015. ::FreeLibrary( m_hDllUser32 );
  1016. if( m_pPaintManager != NULL )
  1017. delete m_pPaintManager;
  1018. m_pPaintManager = NULL;
  1019. }
  1021. void CExtPaintManager::CExtPaintManagerAutoPtr::Advise(
  1022. CExtPmBridge * pPmBridge,
  1023. bool bAddTail // = true
  1024. )
  1025. {
  1026. ASSERT( pPmBridge != NULL );
  1027. if( bAddTail )
  1028. m_listBridges.AddTail( pPmBridge );
  1029. else
  1030. m_listBridges.AddHead( pPmBridge );
  1031. }
  1033. void CExtPaintManager::CExtPaintManagerAutoPtr::Unadvise( CExtPmBridge * pPmBridge )
  1034. {
  1035. ASSERT( pPmBridge != NULL );
  1036. POSITION pos = m_listBridges.Find( pPmBridge );
  1037. if( pos != NULL )
  1038. m_listBridges.RemoveAt( pos );
  1039. }
  1041. void CExtPaintManager::CExtPaintManagerAutoPtr::UnadviseAll()
  1042. {
  1043. m_listBridges.RemoveAll();
  1044. }
  1046. bool CExtPaintManager::CExtPaintManagerAutoPtr::InitPaintManagerInstance()
  1047. {
  1048. if( m_pPaintManager != NULL )
  1049. return true;
  1050. return
  1051. InstallPaintManager(
  1052. (CExtPaintManager *)NULL
  1053. );
  1054. }
  1056. CExtPaintManager * CExtPaintManager::CExtPaintManagerAutoPtr::GetPM()
  1057. {
  1058. InitPaintManagerInstance();
  1059. ASSERT( m_pPaintManager != NULL );
  1060. return m_pPaintManager;
  1061. }
  1063. CExtPaintManager *
  1064. CExtPaintManager::CExtPaintManagerAutoPtr::
  1065. operator -> ()
  1066. {
  1067. return GetPM();
  1068. }
  1070. bool CExtPaintManager::CExtPaintManagerAutoPtr::
  1071. InstallPaintManager(
  1072. CExtPaintManager * pPaintManager
  1073. )
  1074. {
  1075. ASSERT( m_nInsallPaintManagerCounter >= 0 );
  1076. if( m_nInsallPaintManagerCounter != 0 )
  1077. return false;
  1079. if( m_pPaintManager != NULL )
  1080. {
  1081. if( pPaintManager == m_pPaintManager )
  1082. return true;
  1083. if( m_pPaintManager != NULL )
  1084. {
  1085. delete m_pPaintManager;
  1086. m_pPaintManager = NULL;
  1087. }
  1088. } // if( m_pPaintManager != NULL )
  1090. if( pPaintManager != NULL )
  1091. m_pPaintManager = pPaintManager;
  1092. else
  1093. {
  1094. try
  1095. {
  1096. m_pPaintManager = new __DEFAULT_PAINT_MANAGER_CLASS;
  1097. }
  1098. catch( CException * pException )
  1099. {
  1100. pException->Delete();
  1101. }
  1102. catch( ... )
  1103. {
  1104. }
  1105. if( m_pPaintManager == NULL )
  1106. return false;
  1107. }
  1109. m_nInsallPaintManagerCounter ++;
  1110. m_pPaintManager->SyncSysColors();
  1111. m_pPaintManager->InitTranslatedColors();
  1112. m_pPaintManager->InitHelperBrushes();
  1114. g_CmdManager.OnGlobalPaintManagerChanged();
  1116. POSITION pos = m_listBridges.GetHeadPosition();
  1117. for( ; pos != NULL; )
  1118. {
  1119. CExtPmBridge * pPmBridge = m_listBridges.GetNext( pos );
  1120. ASSERT( pPmBridge != NULL );
  1121. pPmBridge->PmBridge_OnPaintManagerChanged(
  1122. m_pPaintManager
  1123. );
  1124. } // for( ; pos != NULL; )
  1126. PmSynchronizeSink_SynchronizeOthers();
  1127. m_nInsallPaintManagerCounter --;
  1129. return true;
  1130. }
  1132. bool CExtPaintManager::CExtPaintManagerAutoPtr::
  1133. InstallPaintManager(
  1134. CRuntimeClass * pRtcPaintManager
  1135. )
  1136. {
  1137. if( pRtcPaintManager == NULL )
  1138. return InitPaintManagerInstance();
  1139. CObject* pObj = pRtcPaintManager->CreateObject();
  1140. if( pObj == NULL )
  1141. {
  1142. ASSERT( FALSE );
  1143. return false;
  1144. }
  1145. ASSERT_VALID( pObj );
  1146. CExtPaintManager * pPaintManager =
  1147. DYNAMIC_DOWNCAST( CExtPaintManager, pObj );
  1148. if( pPaintManager == NULL )
  1149. {
  1150. delete pObj;
  1151. ASSERT( FALSE );
  1152. return false;
  1153. }
  1154. return InstallPaintManager( pPaintManager );
  1155. }
  1157. bool CExtPaintManager::CExtPaintManagerAutoPtr::PaintManagerStateLoad(
  1158. __EXT_MFC_SAFE_LPCTSTR sSectionNameCompany, // under HKEY_CURRENT_USERSoftware
  1159. __EXT_MFC_SAFE_LPCTSTR sSectionNameProduct, // under HKEY_CURRENT_USERSoftware%sSectionNameCompany%
  1160. __EXT_MFC_SAFE_LPCTSTR sSectionNameProfile, // under HKEY_CURRENT_USERSoftware%sSectionNameCompany%%sSectionNameProfile%
  1161. HKEY hKeyRoot, // = HKEY_CURRENT_USER
  1162. bool bEnableThrowExceptions // = false
  1163. )
  1164. {
  1165. ASSERT( sSectionNameCompany != NULL );
  1166. ASSERT( sSectionNameProduct != NULL );
  1167. ASSERT( sSectionNameProfile != NULL );
  1168. bool bRetVal = false;
  1169. try
  1170. {
  1171. CExtSafeString sRegKeyPath =
  1172. CExtCmdManager::GetSubSystemRegKeyPath(
  1173. __PROF_UIS_REG_PAINT_MANAGER,
  1174. sSectionNameProfile,
  1175. sSectionNameCompany,
  1176. sSectionNameProduct
  1177. );
  1178. CMemFile _file;
  1179. if( ! CExtCmdManager::FileObjFromRegistry(
  1180. _file,
  1181. LPCTSTR(sRegKeyPath),
  1182. hKeyRoot,
  1183. bEnableThrowExceptions
  1184. )
  1185. )
  1186. {
  1187. ASSERT( ! bEnableThrowExceptions );
  1188. return false;
  1189. }
  1190. CArchive ar(
  1191. &_file,
  1192. CArchive::load
  1193. );
  1194. bRetVal = 
  1195. PaintManagerStateSerialize(
  1196. ar,
  1197. bEnableThrowExceptions
  1198. );
  1199. ar.Close();
  1200. ASSERT( bRetVal || (! bEnableThrowExceptions ) );
  1201. }
  1202. catch( CException * pXept )
  1203. {
  1204. if( bEnableThrowExceptions )
  1205. throw;
  1206. pXept->Delete();
  1207. }
  1208. catch( ... )
  1209. {
  1210. if( bEnableThrowExceptions )
  1211. throw;
  1212. }
  1213. return bRetVal;
  1214. }
  1216. bool CExtPaintManager::CExtPaintManagerAutoPtr::PaintManagerStateSave(
  1217. __EXT_MFC_SAFE_LPCTSTR sSectionNameCompany, // under HKEY_CURRENT_USERSoftware
  1218. __EXT_MFC_SAFE_LPCTSTR sSectionNameProduct, // under HKEY_CURRENT_USERSoftware%sSectionNameCompany%
  1219. __EXT_MFC_SAFE_LPCTSTR sSectionNameProfile, // under HKEY_CURRENT_USERSoftware%sSectionNameCompany%%sSectionNameProfile%%sSectionNameProfile%
  1220. HKEY hKeyRoot, // = HKEY_CURRENT_USER
  1221. bool bEnableThrowExceptions // = false
  1222. )
  1223. {
  1224. ASSERT( sSectionNameCompany != NULL );
  1225. ASSERT( sSectionNameProduct != NULL );
  1226. ASSERT( sSectionNameProfile != NULL );
  1227. bool bRetVal = false;
  1228. try
  1229. {
  1230. CExtSafeString sRegKeyPath =
  1231. CExtCmdManager::GetSubSystemRegKeyPath(
  1232. __PROF_UIS_REG_PAINT_MANAGER,
  1233. sSectionNameProfile,
  1234. sSectionNameCompany,
  1235. sSectionNameProduct
  1236. );
  1237. CMemFile _file;
  1238. CArchive ar(
  1239. &_file,
  1240. CArchive::store
  1241. );
  1242. bRetVal = 
  1243. PaintManagerStateSerialize(
  1244. ar,
  1245. bEnableThrowExceptions
  1246. );
  1247. ASSERT( bRetVal || (! bEnableThrowExceptions ) );
  1248. if( ! bRetVal )
  1249. return false;
  1250. ar.Flush();
  1251. ar.Close();
  1252. bRetVal =
  1253. CExtCmdManager::FileObjToRegistry(
  1254. _file,
  1255. sRegKeyPath,
  1256. hKeyRoot,
  1257. bEnableThrowExceptions
  1258. );
  1259. ASSERT( bRetVal || (! bEnableThrowExceptions ) );
  1260. }
  1261. catch( CException * pXept )
  1262. {
  1263. if( bEnableThrowExceptions )
  1264. throw;
  1265. pXept->Delete();
  1266. }
  1267. catch( ... )
  1268. {
  1269. if( bEnableThrowExceptions )
  1270. throw;
  1271. }
  1272. return bRetVal;
  1273. }
  1275. bool CExtPaintManager::CExtPaintManagerAutoPtr::PaintManagerStateSerialize(
  1276. CArchive & ar,
  1277. bool bEnableThrowExceptions // = false
  1278. )
  1279. {
  1280. try
  1281. {
  1282. DWORD dwGeneralFlags = 0;
  1283. DWORD dwReserved = 0L;
  1284. if( ar.IsStoring() )
  1285. {
  1286. ar << dwGeneralFlags;
  1287. ar << dwReserved;
  1288. ar << dwReserved;
  1289. ar << dwReserved;
  1290. ar << dwReserved;
  1291. CExtPaintManager * pPM = g_PaintManager.GetPM();
  1292. CRuntimeClass * pRTC = pPM->GetRuntimeClass();
  1293. ASSERT( pRTC != NULL );
  1294. ar.WriteClass( pRTC );
  1296. pPM->OnStateSerialize(
  1297. ar,
  1298. bEnableThrowExceptions
  1299. );
  1300. } // if( ar.IsStoring() )
  1301. else
  1302. {
  1303. ar >> dwGeneralFlags;
  1304. ar >> dwReserved;
  1305. ar >> dwReserved;
  1306. ar >> dwReserved;
  1307. ar >> dwReserved;
  1308. CRuntimeClass * pRTC = ar.ReadClass();
  1309. ASSERT( pRTC != NULL );
  1310. CExtPaintManager * pPM = 
  1311. STATIC_DOWNCAST( CExtPaintManager, pRTC->CreateObject() );
  1312. ASSERT_VALID( pPM );
  1313. ASSERT_KINDOF( CExtPaintManager, pPM );
  1315. pPM->OnStateSerialize(
  1316. ar,
  1317. bEnableThrowExceptions
  1318. );
  1320. InstallPaintManager( pPM );
  1321. } // else from if( ar.IsStoring() )
  1322. dwGeneralFlags;
  1323. dwReserved;
  1324. return true;
  1325. }
  1326. catch( CException * pXept )
  1327. {
  1328. if( bEnableThrowExceptions )
  1329. throw;
  1330. pXept->Delete();
  1331. }
  1332. catch( ... )
  1333. {
  1334. if( bEnableThrowExceptions )
  1335. throw;
  1336. }
  1337. return false;
  1338. }
  1340. UINT CExtPaintManager::CExtPaintManagerAutoPtr::GetMouseWheelScrollLines()
  1341. {
  1342. if( m_bHaveScrollLines )
  1343. return m_uCachedScrollLines;
  1344. m_bHaveScrollLines = true;
  1345. m_uCachedScrollLines = 3;
  1347. #if _MFC_VER < 0x700
  1348. if( ! afxData.bWin4 )
  1349. {
  1350. HKEY hKey;
  1351. if( ::RegOpenKeyEx(
  1352. HKEY_CURRENT_USER,
  1353. _T("Control Panel\Desktop"),
  1354. 0,
  1355. KEY_QUERY_VALUE, &hKey) == ERROR_SUCCESS
  1356. )
  1357. {
  1358. TCHAR szData[256];
  1359. DWORD dwKeyDataType;
  1360. DWORD dwDataBufSize = _countof(szData);
  1361. if( RegQueryValueEx(
  1362. hKey,
  1363. _T("WheelScrollLines"),
  1364. NULL,
  1365. &dwKeyDataType,
  1366. (LPBYTE) &szData,
  1367. &dwDataBufSize
  1368. ) == ERROR_SUCCESS
  1369. )
  1370. {
  1371. m_uCachedScrollLines =
  1372. _tcstoul( szData, NULL, 10 );
  1373. }
  1374. RegCloseKey(hKey);
  1375. }
  1376. }
  1377. else
  1378. #endif // _MFC_VER < 0x700
  1379. if( ! m_bIsWin95 )
  1380. ::SystemParametersInfo(
  1381. SPI_GETWHEELSCROLLLINES,
  1382. 0,
  1383. &m_uCachedScrollLines,
  1384. 0
  1385. );
  1387. if( m_uCachedScrollLines < 2 )
  1388. m_uCachedScrollLines = 2;
  1390. return m_uCachedScrollLines;
  1391. }
  1393. bool CExtPaintManager::CExtPaintManagerAutoPtr::IsWndUpdateSource(
  1394. CWnd * pWndNotifySrc
  1395. )
  1396. {
  1397. ASSERT_VALID( pWndNotifySrc );
  1398. ASSERT( pWndNotifySrc->GetSafeHwnd() != NULL && ::IsWindow(pWndNotifySrc->GetSafeHwnd()) );
  1399. ASSERT( m_pPaintManager != NULL );
  1401. if( ! m_bAllowWndUpdateSourceDetection )
  1402. return false;
  1404. #ifndef __EXT_MFC_NO_STATUSBAR
  1405. if( pWndNotifySrc->IsKindOf(RUNTIME_CLASS(CExtStatusControlBar)) )
  1406. return true;
  1407. #endif // __EXT_MFC_NO_STATUSBAR
  1409. CFrameWnd * pFrame = DYNAMIC_DOWNCAST( CFrameWnd, pWndNotifySrc );
  1410. if( pFrame == NULL )
  1411. pFrame = pWndNotifySrc->GetParentFrame();
  1412. if( pFrame == NULL )
  1413. return true;
  1414. if( pFrame->IsKindOf(RUNTIME_CLASS(CExtMiniDockFrameWnd)) )
  1415. pFrame = pFrame->GetParentFrame();
  1416. if( pFrame == NULL
  1417. || pFrame->IsKindOf(RUNTIME_CLASS(CMiniFrameWnd))
  1418. )
  1419. return true;
  1420. CWnd * pWnd = pFrame->GetControlBar( AFX_IDW_STATUS_BAR );
  1422. #ifndef __EXT_MFC_NO_STATUSBAR
  1423. if( pWnd != NULL
  1424. && pWnd->IsKindOf(RUNTIME_CLASS(CExtStatusControlBar))
  1425. )
  1426. {
  1427. if( pWnd == pWndNotifySrc )
  1428. return true;
  1429. return false;
  1430. }
  1431. #endif // __EXT_MFC_NO_STATUSBAR
  1433. pWnd = pFrame->GetControlBar( AFX_IDW_DOCKBAR_TOP );
  1434. if( pWnd != NULL
  1435. && pWnd->IsKindOf(RUNTIME_CLASS(CExtDockOuterBar))
  1436. )
  1437. {
  1438. if( pWnd == pWndNotifySrc )
  1439. return true;
  1440. return false;
  1441. }
  1442. pWnd = pFrame->GetControlBar( AFX_IDW_DOCKBAR_BOTTOM );
  1443. if( pWnd != NULL
  1444. && pWnd->IsKindOf(RUNTIME_CLASS(CExtDockOuterBar))
  1445. )
  1446. {
  1447. if( pWnd == pWndNotifySrc )
  1448. return true;
  1449. return false;
  1450. }
  1451. pWnd = pFrame->GetControlBar( AFX_IDW_DOCKBAR_LEFT );
  1452. if( pWnd != NULL
  1453. && pWnd->IsKindOf(RUNTIME_CLASS(CExtDockOuterBar))
  1454. )
  1455. {
  1456. if( pWnd == pWndNotifySrc )
  1457. return true;
  1458. return false;
  1459. }
  1460. pWnd = pFrame->GetControlBar( AFX_IDW_DOCKBAR_RIGHT );
  1461. if( pWnd != NULL
  1462. && pWnd->IsKindOf(RUNTIME_CLASS(CExtDockOuterBar))
  1463. )
  1464. {
  1465. if( pWnd == pWndNotifySrc )
  1466. return true;
  1467. return false;
  1468. }
  1469. #if (!defined __EXT_MFC_NO_TABMDI_CTRL)
  1470. for( pWnd = pFrame->GetWindow(GW_CHILD);
  1471. pWnd != NULL;
  1472. pWnd = pWnd->GetWindow(GW_HWNDNEXT)
  1473. )
  1474. {
  1475. CExtTabWnd * pExtTabWnd = DYNAMIC_DOWNCAST( CExtTabMdiWnd, pWnd );
  1476. if( pExtTabWnd != NULL
  1477. && pExtTabWnd->_IsMdiTabCtrl()
  1478. )
  1479. {
  1480. if( pWnd == pWndNotifySrc )
  1481. return true;
  1482. return false;
  1483. }
  1484. }
  1485. #endif // if (!defined __EXT_MFC_NO_TABMDI_CTRL)
  1486. return true;
  1487. }
  1489. void CExtPaintManager::CExtPaintManagerAutoPtr::OnSysColorChange(
  1490. CWnd * pWndNotifySrc
  1491. )
  1492. {
  1493. ASSERT_VALID( pWndNotifySrc );
  1494. ASSERT( pWndNotifySrc->GetSafeHwnd() != NULL && ::IsWindow(pWndNotifySrc->GetSafeHwnd()) );
  1495. ASSERT( m_pPaintManager != NULL );
  1496. if( ! IsWndUpdateSource( pWndNotifySrc ) )
  1497. return;
  1498. m_pPaintManager->OnSysColorChange();
  1500. POSITION pos = m_listBridges.GetHeadPosition();
  1501. for( ; pos != NULL; )
  1502. {
  1503. CExtPmBridge * pPmBridge = m_listBridges.GetNext( pos );
  1504. ASSERT( pPmBridge != NULL );
  1505. pPmBridge->PmBridge_OnSysColorChange(
  1506. m_pPaintManager,
  1507. pWndNotifySrc
  1508. );
  1509. } // for( ; pos != NULL; )
  1510. }
  1512. void CExtPaintManager::CExtPaintManagerAutoPtr::OnSettingChange(
  1513. CWnd * pWndNotifySrc,
  1514. UINT uFlags,
  1515. __EXT_MFC_SAFE_LPCTSTR lpszSection
  1516. )
  1517. {
  1518. ASSERT_VALID( pWndNotifySrc );
  1519. ASSERT( pWndNotifySrc->GetSafeHwnd() != NULL && ::IsWindow(pWndNotifySrc->GetSafeHwnd()) );
  1520. ASSERT( m_pPaintManager != NULL );
  1521. if( ! IsWndUpdateSource( pWndNotifySrc ) )
  1522. return;
  1524. if( m_bIsWin2000orLater
  1525. && CExtPaintManager::stat_GetBPP() >= 15
  1526. && m_pfnUpdateLayeredWindow != NULL
  1527. )
  1528. m_bLayeredHighlighting2005 = true;
  1530. m_bHaveScrollLines = false;
  1531. m_pPaintManager->OnSettingChange( uFlags, lpszSection );
  1533. POSITION pos = m_listBridges.GetHeadPosition();
  1534. for( ; pos != NULL; )
  1535. {
  1536. CExtPmBridge * pPmBridge = m_listBridges.GetNext( pos );
  1537. ASSERT( pPmBridge != NULL );
  1538. pPmBridge->PmBridge_OnSettingChange(
  1539. m_pPaintManager,
  1540. pWndNotifySrc,
  1541. uFlags,
  1542. lpszSection
  1543. );
  1544. } // for( ; pos != NULL; )
  1545. }
  1547. void CExtPaintManager::CExtPaintManagerAutoPtr::OnDisplayChange(
  1548. CWnd * pWndNotifySrc,
  1549. INT nDepthBPP,
  1550. CPoint ptSizes
  1551. )
  1552. {
  1553. ASSERT_VALID( pWndNotifySrc );
  1554. ASSERT( pWndNotifySrc->GetSafeHwnd() != NULL && ::IsWindow(pWndNotifySrc->GetSafeHwnd()) );
  1555. ASSERT( m_pPaintManager != NULL );
  1556. if( ! IsWndUpdateSource( pWndNotifySrc ) )
  1557. return;
  1559. if( m_bIsWin2000orLater
  1560. && CExtPaintManager::stat_GetBPP() >= 15
  1561. && m_pfnUpdateLayeredWindow != NULL
  1562. )
  1563. m_bLayeredHighlighting2005 = true;
  1565. m_bHaveScrollLines = false;
  1566. m_pPaintManager->OnDisplayChange( nDepthBPP, ptSizes );
  1568. POSITION pos = m_listBridges.GetHeadPosition();
  1569. for( ; pos != NULL; )
  1570. {
  1571. CExtPmBridge * pPmBridge = m_listBridges.GetNext( pos );
  1572. ASSERT( pPmBridge != NULL );
  1573. pPmBridge->PmBridge_OnDisplayChange(
  1574. m_pPaintManager,
  1575. pWndNotifySrc,
  1576. nDepthBPP,
  1577. ptSizes
  1578. );
  1579. } // for( ; pos != NULL; )
  1580. }
  1582. void CExtPaintManager::CExtPaintManagerAutoPtr::OnThemeChanged(
  1583. CWnd * pWndNotifySrc,
  1584. WPARAM wParam,
  1585. LPARAM lParam
  1586. )
  1587. {
  1588. ASSERT_VALID( pWndNotifySrc );
  1589. ASSERT( pWndNotifySrc->GetSafeHwnd() != NULL && ::IsWindow(pWndNotifySrc->GetSafeHwnd()) );
  1590. ASSERT( m_pPaintManager != NULL );
  1591. if( ! IsWndUpdateSource( pWndNotifySrc ) )
  1592. return;
  1594. m_bHaveScrollLines = false;
  1595. m_pPaintManager->OnThemeChanged( wParam, lParam );
  1597. POSITION pos = m_listBridges.GetHeadPosition();
  1598. for( ; pos != NULL; )
  1599. {
  1600. CExtPmBridge * pPmBridge = m_listBridges.GetNext( pos );
  1601. ASSERT( pPmBridge != NULL );
  1602. pPmBridge->PmBridge_OnThemeChanged(
  1603. m_pPaintManager,
  1604. pWndNotifySrc,
  1605. wParam,
  1606. lParam
  1607. );
  1608. } // for( ; pos != NULL; )
  1609. }
  1611. const BYTE CExtPaintManager::g_arrWinXpTreeBoxExpandedBmpData_small[] = {
  1612. 0x42, 0x4D, 0x32, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x28, 0x00,
  1613. 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x01, 0x00, 0x18, 0x00, 0x00, 0x00,
  1614. 0x00, 0x00, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  1615. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xD3, 0xC2, 0xB0, 0xB5, 0x98, 0x78, 0xB5, 0x98, 0x78, 0xB5,
  1616. 0x98, 0x78, 0xB5, 0x98, 0x78, 0xB5, 0x98, 0x78, 0xB5, 0x98, 0x78, 0xB5, 0x98, 0x78, 0xD3, 0xC2,
  1617. 0xB0, 0x00, 0xB5, 0x98, 0x78, 0xBF, 0xCC, 0xD2, 0xAE, 0xBE, 0xC6, 0xA8, 0xB8, 0xC2, 0xA7, 0xB8,
  1618. 0xC1, 0xA7, 0xB8, 0xC1, 0xA6, 0xB7, 0xC0, 0xAA, 0xBA, 0xC3, 0xB5, 0x98, 0x78, 0x00, 0xB5, 0x98,
  1619. 0x78, 0xD9, 0xE1, 0xE4, 0xCF, 0xD8, 0xDC, 0xC9, 0xD3, 0xD8, 0xC7, 0xD2, 0xD7, 0xC6, 0xD1, 0xD6,
  1620. 0xC0, 0xCC, 0xD2, 0xBB, 0xC8, 0xCF, 0xB5, 0x98, 0x78, 0x00, 0xB5, 0x98, 0x78, 0xEE, 0xF2, 0xF2,
  1621. 0xEC, 0xF0, 0xF0, 0xE7, 0xED, 0xED, 0xE6, 0xEB, 0xEC, 0xE3, 0xE9, 0xEA, 0xD9, 0xE0, 0xE3, 0xCC,
  1622. 0xD6, 0xDB, 0xB5, 0x98, 0x78, 0x00, 0xB5, 0x98, 0x78, 0xF1, 0xF5, 0xF5, 0x00, 0x00, 0x00, 0x00,
  1623. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xD2, 0xDB, 0xDF, 0xB5, 0x98,
  1624. 0x78, 0x00, 0xB5, 0x98, 0x78, 0xF5, 0xF7, 0xF7, 0xF5, 0xF7, 0xF7, 0xF4, 0xF7, 0xF7, 0xF4, 0xF7,
  1625. 0xF7, 0xF4, 0xF6, 0xF6, 0xEB, 0xF0, 0xF1, 0xDA, 0xE1, 0xE5, 0xB5, 0x98, 0x78, 0x00, 0xB5, 0x98,
  1626. 0x78, 0xFB, 0xFC, 0xFC, 0xFB, 0xFD, 0xFD, 0xFB, 0xFD, 0xFD, 0xFB, 0xFD, 0xFD, 0xFB, 0xFC, 0xFC,
  1627. 0xFA, 0xFC, 0xFC, 0xF3, 0xF6, 0xF7, 0xB5, 0x98, 0x78, 0x00, 0xB5, 0x98, 0x78, 0xFF, 0xFF, 0xFF,
  1628. 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  1629. 0xFF, 0xFF, 0xB5, 0x98, 0x78, 0x00, 0xD3, 0xC2, 0xB0, 0xB5, 0x98, 0x78, 0xB5, 0x98, 0x78, 0xB5,
  1630. 0x98, 0x78, 0xB5, 0x98, 0x78, 0xB5, 0x98, 0x78, 0xB5, 0x98, 0x78, 0xB5, 0x98, 0x78, 0xD3, 0xC2,
  1631. 0xB0, 0x00,
  1632. };
  1634. const BYTE CExtPaintManager::g_arrWinXpTreeBoxCollapsedBmpData_small[] = {
  1635. 0x42, 0x4D, 0x32, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x28, 0x00, 
  1636. 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x01, 0x00, 0x18, 0x00, 0x00, 0x00, 
  1637. 0x00, 0x00, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
  1638. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xD3, 0xC2, 0xB0, 0xB5, 0x98, 0x78, 0xB5, 0x98, 0x78, 0xB5, 
  1639. 0x98, 0x78, 0xB5, 0x98, 0x78, 0xB5, 0x98, 0x78, 0xB5, 0x98, 0x78, 0xB5, 0x98, 0x78, 0xD3, 0xC2, 
  1640. 0xB0, 0x00, 0xB5, 0x98, 0x78, 0xBF, 0xCC, 0xD2, 0xAE, 0xBE, 0xC6, 0xA8, 0xB8, 0xC2, 0xA7, 0xB8, 
  1641. 0xC1, 0xA7, 0xB8, 0xC1, 0xA6, 0xB7, 0xC0, 0xAA, 0xBA, 0xC3, 0xB5, 0x98, 0x78, 0x00, 0xB5, 0x98, 
  1642. 0x78, 0xD9, 0xE1, 0xE4, 0xCF, 0xD8, 0xDC, 0xC9, 0xD3, 0xD8, 0x00, 0x00, 0x00, 0xC6, 0xD1, 0xD6, 
  1643. 0xC0, 0xCC, 0xD2, 0xBB, 0xC8, 0xCF, 0xB5, 0x98, 0x78, 0x00, 0xB5, 0x98, 0x78, 0xEE, 0xF2, 0xF2, 
  1644. 0xEC, 0xF0, 0xF0, 0xE7, 0xED, 0xED, 0x00, 0x00, 0x00, 0xE3, 0xE9, 0xEA, 0xD9, 0xE0, 0xE3, 0xCC, 
  1645. 0xD6, 0xDB, 0xB5, 0x98, 0x78, 0x00, 0xB5, 0x98, 0x78, 0xF1, 0xF5, 0xF5, 0x00, 0x00, 0x00, 0x00, 
  1646. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xD2, 0xDB, 0xDF, 0xB5, 0x98, 
  1647. 0x78, 0x00, 0xB5, 0x98, 0x78, 0xF5, 0xF7, 0xF7, 0xF5, 0xF7, 0xF7, 0xF4, 0xF7, 0xF7, 0x00, 0x00, 
  1648. 0x00, 0xF4, 0xF6, 0xF6, 0xEB, 0xF0, 0xF1, 0xDA, 0xE1, 0xE5, 0xB5, 0x98, 0x78, 0x00, 0xB5, 0x98, 
  1649. 0x78, 0xFB, 0xFC, 0xFC, 0xFB, 0xFD, 0xFD, 0xFB, 0xFD, 0xFD, 0x00, 0x00, 0x00, 0xFB, 0xFC, 0xFC, 
  1650. 0xFA, 0xFC, 0xFC, 0xF3, 0xF6, 0xF7, 0xB5, 0x98, 0x78, 0x00, 0xB5, 0x98, 0x78, 0xFF, 0xFF, 0xFF, 
  1651. 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
  1652. 0xFF, 0xFF, 0xB5, 0x98, 0x78, 0x00, 0xD3, 0xC2, 0xB0, 0xB5, 0x98, 0x78, 0xB5, 0x98, 0x78, 0xB5, 
  1653. 0x98, 0x78, 0xB5, 0x98, 0x78, 0xB5, 0x98, 0x78, 0xB5, 0x98, 0x78, 0xB5, 0x98, 0x78, 0xD3, 0xC2, 
  1654. 0xB0, 0x00,
  1655. };
  1657. const BYTE CExtPaintManager::g_arrWinXpTreeBoxExpandedBmpData_big[] = {
  1658. 0x42,0x4D,0xC2,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x36,0x00,0x00,0x00,0x28,0x00,
  1659. 0x00,0x00,0x0B,0x00,0x00,0x00,0x0B,0x00,0x00,0x00,0x01,0x00,0x18,0x00,0x00,0x00,
  1660. 0x00,0x00,0x8C,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  1661. 0x00,0x00,0x00,0x00,0x00,0x00,0xD7,0xD1,0xCB,0x60,0x48,0x30,0x60,0x48,0x30,0x60,
  1662. 0x48,0x30,0x60,0x48,0x30,0x60,0x48,0x30,0x60,0x48,0x30,0x60,0x48,0x30,0x60,0x48,
  1663. 0x30,0x60,0x48,0x30,0xD7,0xD1,0xCB,0x00,0x00,0x00,0xC0,0xA8,0x90,0xF0,0xE0,0xE0,
  1664. 0xF0,0xE0,0xD0,0xF0,0xD8,0xD0,0xF0,0xD8,0xD0,0xF0,0xD0,0xC0,0xF0,0xD0,0xC0,0xF0,
  1665. 0xD0,0xC0,0xF0,0xC8,0xC0,0xF0,0xC8,0xB0,0x60,0x48,0x30,0x00,0x00,0x00,0xC0,0xA8,
  1666. 0x90,0xF0,0xE8,0xE0,0xF0,0xE0,0xE0,0xF0,0xE0,0xD0,0xF0,0xD8,0xD0,0xF0,0xD8,0xD0,
  1667. 0xF0,0xD0,0xC0,0xF0,0xD0,0xC0,0xF0,0xD0,0xC0,0xF0,0xC8,0xC0,0x60,0x48,0x30,0x00,
  1668. 0x00,0x00,0xC0,0xA8,0x90,0xFF,0xF0,0xE0,0xF0,0xE8,0xE0,0xF0,0xE0,0xE0,0xF0,0xE0,
  1669. 0xD0,0xF0,0xD8,0xD0,0xF0,0xD8,0xD0,0xF0,0xD0,0xC0,0xF0,0xD0,0xC0,0xF0,0xD0,0xC0,
  1670. 0x60,0x48,0x30,0x00,0x00,0x00,0xC0,0xA8,0x90,0xFF,0xF0,0xF0,0xFF,0xF0,0xE0,0xF0,
  1671. 0xE8,0xE0,0xF0,0xE0,0xE0,0xF0,0xE0,0xD0,0xF0,0xD8,0xD0,0xF0,0xD8,0xD0,0xF0,0xD0,
  1672. 0xC0,0xF0,0xD0,0xC0,0x60,0x48,0x30,0x00,0x00,0x00,0xC0,0xA8,0x90,0xFF,0xF8,0xF0,
  1673. 0xFF,0xF0,0xF0,0x60,0x48,0x30,0x60,0x48,0x30,0x60,0x48,0x30,0x60,0x48,0x30,0x60,
  1674. 0x48,0x30,0xF0,0xD8,0xD0,0xF0,0xD0,0xC0,0x60,0x48,0x30,0x00,0x00,0x00,0xC0,0xA8,
  1675. 0xA0,0xFF,0xF8,0xF0,0xFF,0xF8,0xF0,0xFF,0xF0,0xF0,0xFF,0xF0,0xE0,0xF0,0xE8,0xE0,
  1676. 0xF0,0xE0,0xE0,0xF0,0xE0,0xD0,0xF0,0xD8,0xD0,0xF0,0xD8,0xD0,0x60,0x48,0x30,0x00,
  1677. 0x00,0x00,0xC0,0xA8,0xA0,0xFF,0xF8,0xFF,0xFF,0xF8,0xF0,0xFF,0xF8,0xF0,0xFF,0xF0,
  1678. 0xF0,0xFF,0xF0,0xE0,0xF0,0xE8,0xE0,0xF0,0xE0,0xE0,0xF0,0xE0,0xD0,0xF0,0xD8,0xD0,
  1679. 0x60,0x48,0x30,0x00,0x00,0x00,0xC0,0xB0,0xA0,0xFF,0xFF,0xFF,0xFF,0xF8,0xFF,0xFF,
  1680. 0xF8,0xF0,0xFF,0xF8,0xF0,0xFF,0xF0,0xF0,0xFF,0xF0,0xE0,0xF0,0xE8,0xE0,0xF0,0xE0,
  1681. 0xE0,0xF0,0xE0,0xD0,0x60,0x48,0x30,0x00,0x00,0x00,0xC0,0xB0,0xA0,0xFF,0xFF,0xFF,
  1682. 0xFF,0xFF,0xFF,0xFF,0xF8,0xFF,0xFF,0xF8,0xF0,0xFF,0xF8,0xF0,0xFF,0xF0,0xF0,0xFF,
  1683. 0xF0,0xE0,0xF0,0xE8,0xE0,0xF0,0xE0,0xE0,0x60,0x48,0x30,0x00,0x00,0x00,0xEF,0xEB,
  1684. 0xE7,0xC0,0xB0,0xA0,0xC0,0xB0,0xA0,0xC0,0xA8,0xA0,0xC0,0xA8,0xA0,0xC0,0xA8,0xA0,
  1685. 0xC0,0xA8,0x90,0xC0,0xA0,0x90,0xC0,0xA0,0x90,0xC0,0xA0,0x90,0xD7,0xD1,0xCB,0x00,
  1686. 0x00,0x00,0x00
  1687. };
  1689. const BYTE CExtPaintManager::g_arrWinXpTreeBoxCollapsedBmpData_big[] = {
  1690. 0x42,0x4D,0xC2,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x36,0x00,0x00,0x00,0x28,0x00,
  1691. 0x00,0x00,0x0B,0x00,0x00,0x00,0x0B,0x00,0x00,0x00,0x01,0x00,0x18,0x00,0x00,0x00,
  1692. 0x00,0x00,0x8C,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  1693. 0x00,0x00,0x00,0x00,0x00,0x00,0xD7,0xD1,0xCB,0x60,0x48,0x30,0x60,0x48,0x30,0x60,
  1694. 0x48,0x30,0x60,0x48,0x30,0x60,0x48,0x30,0x60,0x48,0x30,0x60,0x48,0x30,0x60,0x48,
  1695. 0x30,0x60,0x48,0x30,0xD7,0xD1,0xCB,0x00,0x00,0x00,0xC0,0xA8,0x90,0xF0,0xE0,0xE0,
  1696. 0xE0,0xD0,0xC0,0xE0,0xC8,0xB0,0xE0,0xC0,0xB0,0xE0,0xC0,0xB0,0xD0,0xB8,0xA0,0xD0,
  1697. 0xB8,0xA0,0xD0,0xB8,0xA0,0xD0,0xB8,0xA0,0x60,0x48,0x30,0x00,0x00,0x00,0xC0,0xA8,
  1698. 0x90,0xF0,0xE8,0xE0,0xF0,0xE0,0xE0,0xF0,0xE0,0xD0,0xF0,0xD8,0xD0,0xF0,0xD8,0xD0,
  1699. 0xF0,0xD0,0xC0,0xF0,0xD0,0xC0,0xF0,0xD0,0xC0,0xD0,0xB8,0xA0,0x60,0x48,0x30,0x00,
  1700. 0x00,0x00,0xC0,0xA8,0x90,0xFF,0xF0,0xE0,0xF0,0xE8,0xE0,0xF0,0xE0,0xE0,0xF0,0xE0,
  1701. 0xD0,0x60,0x48,0x30,0xF0,0xD8,0xD0,0xF0,0xD0,0xC0,0xF0,0xD0,0xC0,0xD0,0xB8,0xA0,
  1702. 0x60,0x48,0x30,0x00,0x00,0x00,0xC0,0xA8,0x90,0xFF,0xF0,0xF0,0xFF,0xF0,0xE0,0xF0,
  1703. 0xE8,0xE0,0xF0,0xE0,0xE0,0x60,0x48,0x30,0xF0,0xD8,0xD0,0xF0,0xD8,0xD0,0xF0,0xD0,
  1704. 0xC0,0xD0,0xB8,0xA0,0x60,0x48,0x30,0x00,0x00,0x00,0xC0,0xA8,0x90,0xFF,0xF8,0xF0,
  1705. 0xFF,0xF0,0xF0,0x60,0x48,0x30,0x60,0x48,0x30,0x60,0x48,0x30,0x60,0x48,0x30,0x60,
  1706. 0x48,0x30,0xF0,0xD8,0xD0,0xE0,0xC0,0xB0,0x60,0x48,0x30,0x00,0x00,0x00,0xC0,0xA8,
  1707. 0xA0,0xFF,0xF8,0xF0,0xFF,0xF8,0xF0,0xFF,0xF0,0xF0,0xFF,0xF0,0xE0,0x60,0x48,0x30,
  1708. 0xF0,0xE0,0xE0,0xF0,0xE0,0xD0,0xF0,0xD8,0xD0,0xE0,0xC0,0xB0,0x60,0x48,0x30,0x00,
  1709. 0x00,0x00,0xC0,0xA8,0xA0,0xFF,0xF8,0xFF,0xFF,0xF8,0xF0,0xFF,0xF8,0xF0,0xFF,0xF0,
  1710. 0xF0,0x60,0x48,0x30,0xF0,0xE8,0xE0,0xF0,0xE0,0xE0,0xF0,0xE0,0xD0,0xE0,0xC0,0xB0,
  1711. 0x60,0x48,0x30,0x00,0x00,0x00,0xC0,0xB0,0xA0,0xFF,0xFF,0xFF,0xFF,0xF8,0xFF,0xFF,
  1712. 0xF8,0xF0,0xFF,0xF8,0xF0,0xFF,0xF0,0xF0,0xFF,0xF0,0xE0,0xF0,0xE8,0xE0,0xF0,0xE0,
  1713. 0xE0,0xE0,0xD0,0xC0,0x60,0x48,0x30,0x00,0x00,0x00,0xC0,0xB0,0xA0,0xFF,0xFF,0xFF,
  1714. 0xFF,0xFF,0xFF,0xFF,0xF8,0xFF,0xFF,0xF8,0xF0,0xFF,0xF8,0xF0,0xFF,0xF0,0xF0,0xFF,
  1715. 0xF0,0xE0,0xF0,0xE8,0xE0,0xF0,0xE0,0xE0,0x60,0x48,0x30,0x00,0x00,0x00,0xEF,0xEB,
  1716. 0xE7,0xC0,0xB0,0xA0,0xC0,0xB0,0xA0,0xC0,0xA8,0xA0,0xC0,0xA8,0xA0,0xC0,0xA8,0xA0,
  1717. 0xC0,0xA8,0x90,0xC0,0xA0,0x90,0xC0,0xA0,0x90,0xC0,0xA0,0x90,0xD7,0xD1,0xCB,0x00,
  1718. 0x00,0x00,0x00
  1719. };
  1721. void CExtPaintManager::LoadWinXpTreeBox(
  1722. CExtCmdIcon & _icon,
  1723. bool bExpanded,
  1724. bool bBig // = false
  1725. )
  1726. {
  1727. ASSERT_VALID( this );
  1728. _icon.Empty();
  1729. if( bBig )
  1730. {
  1731. if( bExpanded )
  1732. _icon.m_bmpNormal.LoadBMP_Buffer(
  1733. g_arrWinXpTreeBoxExpandedBmpData_big,
  1734. sizeof(g_arrWinXpTreeBoxExpandedBmpData_big) / sizeof( g_arrWinXpTreeBoxExpandedBmpData_big[0] ),
  1735. true
  1736. );
  1737. else
  1738. _icon.m_bmpNormal.LoadBMP_Buffer(
  1739. g_arrWinXpTreeBoxCollapsedBmpData_big,
  1740. sizeof(g_arrWinXpTreeBoxCollapsedBmpData_big) / sizeof( g_arrWinXpTreeBoxCollapsedBmpData_big[0] ),
  1741. true
  1742. );
  1743. CSize _size = _icon.m_bmpNormal.GetSize();
  1744. RECT rc;
  1745. ::SetRect( &rc, 0, 0, 1, 1 );
  1746. _icon.m_bmpNormal.AlphaRect( rc, 0x20 );
  1747. ::SetRect( &rc, _size.cx-1, 0, _size.cx, 1 );
  1748. _icon.m_bmpNormal.AlphaRect( rc, 0x20 );
  1749. ::SetRect( &rc, 0, _size.cy-1, 1, _size.cy );
  1750. _icon.m_bmpNormal.AlphaRect( rc, 0x20 );
  1751. ::SetRect( &rc, _size.cx-1, _size.cy-1, _size.cx, _size.cy );
  1752. _icon.m_bmpNormal.AlphaRect( rc, 0x20 );
  1753. }
  1754. else
  1755. {
  1756. if( bExpanded )
  1757. _icon.m_bmpNormal.LoadBMP_Buffer(
  1758. g_arrWinXpTreeBoxExpandedBmpData_small,
  1759. sizeof(g_arrWinXpTreeBoxExpandedBmpData_small) / sizeof( g_arrWinXpTreeBoxExpandedBmpData_small[0] ),
  1760. true
  1761. );
  1762. else
  1763. _icon.m_bmpNormal.LoadBMP_Buffer(
  1764. g_arrWinXpTreeBoxCollapsedBmpData_small,
  1765. sizeof(g_arrWinXpTreeBoxCollapsedBmpData_small) / sizeof( g_arrWinXpTreeBoxCollapsedBmpData_small[0] ),
  1766. true
  1767. );
  1768. _icon.m_bmpNormal.AlphaColor( RGB(255,0,255), RGB(0,0,0), 0 );
  1769. }
  1770. }
  1772. bool CExtPaintManager::glyph_t::stat_DefGlyphRgnTransparencyFunc(
  1773. const glyph_t & _glyph,
  1774. int x,
  1775. int y,
  1776. UINT nColor,
  1777. LPVOID lpCookie
  1778. )
  1779. {
  1780. _glyph;
  1781. x;
  1782. y;
  1783. lpCookie;
  1784. return (nColor == 0) ? true : false;
  1785. }
  1787. CExtPaintManager::glyph_t::glyph_t()
  1788. {
  1789. _Init();
  1790. }
  1792. CExtPaintManager::glyph_t::glyph_t(
  1793. const SIZE & _size,
  1794. UINT nColors,
  1795. const UINT * pColorIndexes
  1796. )
  1797. {
  1798. m_bDynamicData = false;
  1800. ASSERT( _size.cx > 0 );
  1801. ASSERT( _size.cy > 0 );
  1802. m_size.cx = _size.cx;
  1803. m_size.cy = _size.cy;
  1805. ASSERT( nColors > 0 );
  1806. m_nColors = nColors;
  1808. ASSERT( pColorIndexes != NULL );
  1809. m_pColorIndexes = pColorIndexes;
  1810. }
  1812. CExtPaintManager::glyph_t::glyph_t(
  1813. int cx,
  1814. int cy,
  1815. UINT nColors,
  1816. const UINT * pColorIndexes
  1817. )
  1818. {
  1819. m_bDynamicData = false;
  1821. ASSERT( cx > 0 );
  1822. ASSERT( cy > 0 );
  1823. m_size.cx = cx;
  1824. m_size.cy = cy;
  1826. ASSERT( nColors > 0 );
  1827. m_nColors = nColors;
  1829. ASSERT( pColorIndexes != NULL );
  1830. m_pColorIndexes = pColorIndexes;
  1831. }
  1833. CExtPaintManager::glyph_t::glyph_t(
  1834. const glyph_t & other,
  1835. UINT nRotateAngle // = 0
  1836. )
  1837. {
  1838. _Init();
  1839. _CopyFromOther(other);
  1840. #ifdef _DEBUG
  1841. if( other.m_pColorIndexes != NULL )
  1842. {
  1843. ASSERT( m_pColorIndexes != NULL );
  1844. ASSERT( m_pColorIndexes != other.m_pColorIndexes );
  1845. ASSERT( m_bDynamicData );
  1846. }
  1847. #endif // _DEBUG
  1848. ASSERT(
  1849. nRotateAngle == 0
  1850. || nRotateAngle == 90
  1851. || nRotateAngle == 180
  1852. || nRotateAngle == 270
  1853. );
  1854. Rotate(nRotateAngle);
  1855. }
  1857. CExtPaintManager::glyph_t::~glyph_t()
  1858. {
  1859. _Done();
  1860. }
  1862. UINT CExtPaintManager::glyph_t::GetColorPixel(
  1863. int x,
  1864. int y
  1865. ) const
  1866. {
  1867. ASSERT( x >= 0 && x < m_size.cx );
  1868. ASSERT( y >= 0 && y < m_size.cy );
  1869. ASSERT( m_size.cx > 0 );
  1870. ASSERT( m_size.cy > 0 );
  1871. ASSERT( m_nColors > 0 );
  1872. ASSERT( m_pColorIndexes != NULL );
  1873. int nOffset =
  1874. y * m_size.cx + x;
  1875. UINT nValue =
  1876. *( m_pColorIndexes + nOffset );
  1877. return nValue;
  1878. }
  1880. void CExtPaintManager::glyph_t::Rotate(UINT nRotateAngle)
  1881. {
  1882. ASSERT(
  1883. nRotateAngle == 0
  1884. || nRotateAngle == 90
  1885. || nRotateAngle == 180
  1886. || nRotateAngle == 270
  1887. );
  1888. ASSERT( m_bDynamicData );
  1889. ASSERT( m_size.cx > 0 );
  1890. ASSERT( m_size.cy > 0 );
  1891. ASSERT( m_nColors > 0 );
  1892. ASSERT( m_pColorIndexes != NULL );
  1893. if( nRotateAngle == 0 )
  1894. return;
  1896. int nBufferSize =
  1897. m_size.cx * m_size.cy;
  1898. ASSERT( nBufferSize > 0 );
  1899. UINT * pNew = new UINT[nBufferSize];
  1900. ASSERT( pNew != NULL );
  1901. if( pNew == NULL )
  1902. return;
  1904. int x, y;
  1905. UINT * pOld = (UINT *)m_pColorIndexes;
  1906. switch( nRotateAngle )
  1907. {
  1908. case 90:
  1909. {
  1910. for( y = 0; y<m_size.cy; y++ )
  1911. {
  1912. for( x = 0; x<m_size.cx; x++, pOld++ )
  1913. {
  1914. int nNewOffset =
  1915. x*m_size.cy + (m_size.cy - y - 1);
  1916. ASSERT(
  1917. nNewOffset >= 0
  1918. &&
  1919. nNewOffset < nBufferSize
  1920. );
  1921. UINT * p = pNew + nNewOffset;
  1922. *p = *pOld;
  1923. } // for( x = 0; x<m_size.cx; x++, pOld++ )
  1924. } // for( y = 0; y<m_size.cy; y++ )
  1925. m_size = CSize(m_size.cy,m_size.cx);
  1926. }
  1927. break; // case 90
  1928. case 180:
  1929. {
  1930. for( y = 0; y<m_size.cy; y++ )
  1931. {
  1932. for( x = 0; x<m_size.cx; x++, pOld++ )
  1933. {
  1934. int nNewOffset =
  1935. (m_size.cy-y-1)*m_size.cx
  1936. + (m_size.cx-x-1);
  1937. ASSERT(
  1938. nNewOffset >= 0
  1939. &&
  1940. nNewOffset < nBufferSize
  1941. );
  1942. UINT * p = pNew + nNewOffset;
  1943. *p = *pOld;
  1944. } // for( x = 0; x<m_size.cx; x++, pOld++ )
  1945. } // for( y = 0; y<m_size.cy; y++ )
  1946. }
  1947. break; // case 180
  1948. case 270:
  1949. {
  1950. for( y = 0; y<m_size.cy; y++ )
  1951. {
  1952. for( x = 0; x<m_size.cx; x++, pOld++ )
  1953. {
  1954. int nNewOffset =
  1955. (m_size.cx-x-1)*m_size.cy + y;
  1956. ASSERT(
  1957. nNewOffset >= 0
  1958. &&
  1959. nNewOffset < nBufferSize
  1960. );
  1961. UINT * p = pNew + nNewOffset;
  1962. *p = *pOld;
  1963. } // for( x = 0; x<m_size.cx; x++, pOld++ )
  1964. } // for( y = 0; y<m_size.cy; y++ )
  1965. m_size = CSize(m_size.cy,m_size.cx);
  1966. }
  1967. break; // case 270
  1968. } // switch( nRotateAngle )
  1969. UINT nSizeInBytes = 
  1970. nBufferSize * sizeof(UINT);
  1971. __EXT_MFC_MEMCPY(
  1972. (UINT *)m_pColorIndexes,
  1973. nSizeInBytes,
  1974. pNew,
  1975. nSizeInBytes
  1976. );
  1977. delete [] pNew; // ::free(pNew);
  1978. }
  1980. CSize CExtPaintManager::glyph_t::Size() const
  1981. {
  1982. return m_size;
  1983. }
  1985. const UINT * CExtPaintManager::glyph_t::GetSurface() const
  1986. {
  1987. ASSERT( m_size.cx > 0 );
  1988. ASSERT( m_size.cy > 0 );
  1989. ASSERT( m_nColors > 0 );
  1990. ASSERT( m_pColorIndexes != NULL );
  1991. return m_pColorIndexes;
  1992. }
  1994. UINT CExtPaintManager::glyph_t::GetColorsCount() const
  1995. {
  1996. ASSERT( m_size.cx > 0 );
  1997. ASSERT( m_size.cy > 0 );
  1998. ASSERT( m_nColors > 0 );
  1999. ASSERT( m_pColorIndexes != NULL );
  2000. return m_nColors;
  2001. }
  2003. void CExtPaintManager::glyph_t::_Init()
  2004. {
  2005. m_size.cx = m_size.cy = 0;
  2006. m_nColors = 1;
  2007. m_pColorIndexes = NULL;
  2008. m_bDynamicData = false;
  2009. }
  2011. void CExtPaintManager::glyph_t::_Done()
  2012. {
  2013. if( m_bDynamicData )
  2014. {
  2015. ASSERT( m_pColorIndexes != NULL );
  2016. delete [] ((UINT *)m_pColorIndexes); // ::free( (void *)m_pColorIndexes );
  2017. m_pColorIndexes = NULL;
  2018. }
  2019. _Init();
  2020. }
  2022. bool CExtPaintManager::glyph_t::_CopyFromOther( const glyph_t & other )
  2023. {
  2024. _Done();
  2026. if( other.m_pColorIndexes != NULL )
  2027. {
  2028. int nBufferSize =
  2029. other.m_size.cx * other.m_size.cy;
  2030. ASSERT( nBufferSize > 0 );
  2031. m_pColorIndexes = new UINT[nBufferSize];
  2032. ASSERT( m_pColorIndexes != NULL );
  2033. if( m_pColorIndexes == NULL )
  2034. return false;
  2035. UINT nSizeInBytes = 
  2036. nBufferSize * sizeof(UINT);
  2037. __EXT_MFC_MEMCPY(
  2038. (void *)m_pColorIndexes,
  2039. nSizeInBytes,
  2040. other.m_pColorIndexes,
  2041. nSizeInBytes
  2042. );
  2043. m_bDynamicData = true;
  2044. }
  2045. m_size.cx = other.m_size.cx;
  2046. m_size.cy = other.m_size.cy;
  2048. m_nColors = other.m_nColors;
  2050. return true;
  2051. }
  2053. void CExtPaintManager::glyph_t::_SetColorPixel(
  2054. int x,
  2055. int y,
  2056. UINT nValue
  2057. )
  2058. {
  2059. ASSERT( x >= 0 && x < m_size.cx );
  2060. ASSERT( y >= 0 && y < m_size.cy );
  2061. ASSERT( m_bDynamicData );
  2062. ASSERT( m_size.cx > 0 );
  2063. ASSERT( m_size.cy > 0 );
  2064. ASSERT( m_nColors > 0 );
  2065. ASSERT( m_pColorIndexes != NULL );
  2066. int nOffset =
  2067. y * m_size.cx + x;
  2068. UINT * ptr =
  2069. (UINT *)m_pColorIndexes + nOffset;
  2070. *ptr = nValue;
  2071. }
  2073. CRgn & CExtPaintManager::glyph_t::GenerateRgn(
  2074. CRgn & rgn,
  2075. bool (*pGlyphRgnTransparencyFunc)(
  2076. const glyph_t & _glyph,
  2077. int x,
  2078. int y,
  2079. UINT nColor,
  2080. LPVOID lpCookie
  2081. ), // = stat_DefGlyphRgnTransparencyFunc
  2082. LPVOID lpCallbackCookie, // = NULL
  2083. LPLONG pMinNonTransparentX, // = NULL
  2084. LPLONG pMinNonTransparentY, // = NULL
  2085. LPLONG pMaxNonTransparentX, // = NULL
  2086. LPLONG pMaxNonTransparentY, // = NULL
  2087. LPLONG pMinTransparentX, // = NULL
  2088. LPLONG pMinTransparentY, // = NULL
  2089. LPLONG pMaxTransparentX, // = NULL
  2090. LPLONG pMaxTransparentY // = NULL
  2091. ) const
  2092. {
  2093. if( pMinNonTransparentX != NULL )
  2094. *pMinNonTransparentX = 0;
  2095. if( pMinNonTransparentY != NULL )
  2096. *pMinNonTransparentY = 0;
  2097. if( pMaxNonTransparentX != NULL )
  2098. *pMaxNonTransparentX = 0;
  2099. if( pMaxNonTransparentY != NULL )
  2100. *pMaxNonTransparentY;
  2102. if( pMinTransparentX != NULL )
  2103. *pMinTransparentX = 0;
  2104. if( pMinTransparentY != NULL )
  2105. *pMinTransparentY = 0;
  2106. if( pMaxTransparentX != NULL )
  2107. *pMaxTransparentX = 0;
  2108. if( pMaxTransparentY != NULL )
  2109. *pMaxTransparentY;
  2111. if( rgn.GetSafeHandle() != NULL )
  2112. rgn.DeleteObject();
  2113. ASSERT( rgn.GetSafeHandle() == NULL );
  2115. CSize _size = Size();
  2116. if( _size.cx == 0 || _size.cy == 0 )
  2117. {
  2118. ASSERT( FALSE );
  2119. return rgn;
  2120. }
  2122. if( !rgn.CreateRectRgn(0,0,0,0) )
  2123. {
  2124. ASSERT( FALSE );
  2125. return rgn;
  2126. }
  2128. for( int x = 0; x < _size.cx; x++ )
  2129. {
  2130. for( int y = 0; y < _size.cy; y++ )
  2131. {
  2132. UINT nColor = GetColorPixel( x, y );
  2133. if( pGlyphRgnTransparencyFunc(
  2134. *this,
  2135. x,
  2136. y,
  2137. nColor,
  2138. lpCallbackCookie
  2139. )
  2140. )
  2141. { // if pixel transparent
  2143. if( pMinTransparentX != NULL
  2144. && (*pMinTransparentX) > x
  2145. )
  2146. (*pMinTransparentX) = x;
  2147. if( pMinTransparentY != NULL
  2148. && (*pMinTransparentY) > y
  2149. )
  2150. (*pMinTransparentY) = y;
  2152. if( pMaxTransparentX != NULL
  2153. && (*pMaxTransparentX) < x
  2154. )
  2155. (*pMaxTransparentX) = x;
  2156. if( pMaxTransparentY != NULL
  2157. && (*pMaxTransparentY) < y
  2158. )
  2159. (*pMaxTransparentY) = y;
  2161. continue;
  2162. } // if pixel transparent
  2164. if( pMinNonTransparentX != NULL
  2165. && (*pMinNonTransparentX) > x
  2166. )
  2167. (*pMinNonTransparentX) = x;
  2168. if( pMinNonTransparentY != NULL
  2169. && (*pMinNonTransparentY) > y
  2170. )
  2171. (*pMinNonTransparentY) = y;
  2173. if( pMaxNonTransparentX != NULL
  2174. && (*pMaxNonTransparentX) < x
  2175. )
  2176. (*pMaxNonTransparentX) = x;
  2177. if( pMaxNonTransparentY != NULL
  2178. && (*pMaxNonTransparentY) < y
  2179. )
  2180. (*pMaxNonTransparentY) = y;
  2182. CRgn rgnPixel;
  2183. if( !rgnPixel.CreateRectRgn(
  2184. x,
  2185. y,
  2186. x+1,
  2187. y+1
  2188. )
  2189. )
  2190. {
  2191. ASSERT( FALSE );
  2192. return rgn;
  2193. }
  2194. rgn.CombineRgn( &rgn, &rgnPixel, RGN_OR );
  2195. } // for( int y = 0; y < _size.cy; y++ )
  2196. } // for( int x = 0; x < _size.cx; x++ )
  2198. return rgn;
  2199. }
  2201. DWORD CExtPaintManager::stat_DllGetVersion( __EXT_MFC_SAFE_LPCTSTR lpszDllName )
  2202. {
  2203.     HINSTANCE hinstDll = NULL;
  2204.     DWORD dwVersion = 0;
  2206.     // For security purposes, LoadLibrary should be provided with a 
  2207.     // fully-qualified path to the DLL. The lpszDllName variable should be
  2208.     // tested to ensure that it is a fully qualified path before it is used.
  2209.     hinstDll = ::LoadLibrary(lpszDllName);
  2210.     if( hinstDll != NULL )
  2211.     {
  2212.         DLLGETVERSIONPROC pDllGetVersion;
  2213.         pDllGetVersion = 
  2214. (DLLGETVERSIONPROC) ::GetProcAddress( hinstDll, "DllGetVersion" );
  2216. // Because some DLLs might not implement this function, you
  2217.         // must test for it explicitly. Depending on the particular 
  2218.         // DLL, the lack of a DllGetVersion function can be a useful
  2219.         // indicator of the version.
  2220.         if( pDllGetVersion != NULL )
  2221.         {
  2222.             DLLVERSIONINFO dvi;
  2223.             HRESULT hr = 0;
  2225.             ZeroMemory(&dvi, sizeof(dvi));
  2226.             dvi.cbSize = sizeof(dvi);
  2228.             hr = (*pDllGetVersion)(&dvi);
  2229.             if( SUCCEEDED(hr) )
  2230.                dwVersion = MAKELONG( dvi.dwMinorVersion, dvi.dwMajorVersion );
  2231.         }
  2232.         ::FreeLibrary( hinstDll );
  2233.     }
  2234.     return dwVersion;
  2235. }
  2237. HBITMAP CExtPaintManager::stat_GetScreenSurfacePart(
  2238. const RECT & rcScreenSurfacePart,
  2239. COLORREF ** ppClrSurface // = NULL
  2240. )
  2241. {
  2242. if( ppClrSurface != NULL )
  2243. (*ppClrSurface) = NULL;
  2244. INT cx = rcScreenSurfacePart.right - rcScreenSurfacePart.left;
  2245. if( cx <= 0 )
  2246. return NULL;
  2247. INT cy = rcScreenSurfacePart.bottom - rcScreenSurfacePart.top;
  2248. if( cy <= 0 )
  2249. return NULL;
  2250. CDC dcmm;
  2251. if( ! dcmm.CreateCompatibleDC( NULL ) )
  2252. return NULL;
  2253. BITMAPINFOHEADER bih;
  2254. bih.biSize = sizeof(BITMAPINFOHEADER);
  2255. bih.biWidth          = cx;
  2256. bih.biHeight         = cy;
  2257. bih.biPlanes         = 1;
  2258. bih.biBitCount       = 32;
  2259. bih.biCompression    = BI_RGB;
  2260. bih.biSizeImage      = cx * cy;
  2261. bih.biXPelsPerMeter  = 0;
  2262. bih.biYPelsPerMeter  = 0;
  2263. bih.biClrUsed        = 0;
  2264. bih.biClrImportant   = 0;
  2265. HBITMAP hDIB =
  2266. ::CreateDIBSection(
  2267. dcmm.GetSafeHdc(),
  2268. (LPBITMAPINFO)&bih,
  2269. DIB_RGB_COLORS,
  2270. (void **)ppClrSurface,
  2271. NULL,
  2272. NULL
  2273. );
  2274. if( hDIB == NULL )
  2275. return NULL;
  2276. HGDIOBJ hOldBmp = ::SelectObject( dcmm.m_hDC, ((HGDIOBJ)hDIB) );
  2277. CWindowDC dcDesktop( NULL );
  2278. VERIFY(
  2279. dcmm.BitBlt(
  2280. 0,
  2281. 0,
  2282. cx,
  2283. cy,
  2284. &dcDesktop,
  2285. rcScreenSurfacePart.left,
  2286. rcScreenSurfacePart.top,
  2287. SRCCOPY
  2288. )
  2289. );
  2290. ::SelectObject( dcmm.m_hDC, hOldBmp );
  2291. dcmm.DeleteDC();
  2292. return hDIB;
  2293. }
  2295. HBITMAP CExtPaintManager::stat_PrintWnd(
  2296. HWND hWnd,
  2297. UINT nMessage, // = WM_PRINTCLIENT
  2298. LPARAM lParamPrint, // = PRF_NONCLIENT|PRF_CLIENT|PRF_ERASEBKGND|PRF_CHILDREN
  2299. HDC hSrcDC, // = NULL
  2300. const RECT * pRectFillSrc // = NULL
  2301. )
  2302. {
  2303. ASSERT( hWnd != NULL && ::IsWindow(hWnd) );
  2304. ASSERT( nMessage == WM_PRINT || nMessage == WM_PRINTCLIENT );
  2305. CRect rcWnd, rcClient;
  2306. ::GetWindowRect( hWnd, &rcWnd );
  2307. ::GetClientRect( hWnd, &rcClient );
  2308. CSize _sizeDest =
  2309. ( (lParamPrint&PRF_NONCLIENT) != 0 )
  2310. ? rcWnd.Size()
  2311. : rcClient.Size()
  2312. ;
  2313. HDC hDC = ::CreateCompatibleDC( NULL );
  2314. if( hDC == NULL )
  2315. {
  2316. ASSERT( FALSE );
  2317. return NULL;
  2318. }
  2319. BITMAPINFOHEADER bih;
  2320. ::memset( &bih, 0, sizeof(BITMAPINFOHEADER) );
  2321. bih.biSize = sizeof(BITMAPINFOHEADER);
  2322. bih.biWidth = _sizeDest.cx;
  2323. bih.biHeight = _sizeDest.cy;
  2324. bih.biPlanes = 1;
  2325. bih.biBitCount = 32;
  2326. bih.biCompression = BI_RGB;
  2327. bih.biSizeImage = _sizeDest.cx * _sizeDest.cy;
  2328. COLORREF * pSurface = NULL;
  2329. HBITMAP hBmpSufrace =
  2330. ::CreateDIBSection(
  2331. hDC,
  2332. (LPBITMAPINFO)&bih,
  2333. DIB_RGB_COLORS,
  2334. (void **)&pSurface,
  2335. NULL,
  2336. NULL
  2337. );
  2338. ASSERT( hBmpSufrace != NULL );
  2339. if( hBmpSufrace == NULL )
  2340. {
  2341. ::DeleteDC( hDC );
  2342. ASSERT( FALSE );
  2343. return NULL;
  2344. }
  2345. ASSERT( pSurface != NULL );
  2346. HGDIOBJ hBmpOld = ::SelectObject( hDC, (HGDIOBJ)hBmpSufrace );
  2347. if( hSrcDC != NULL
  2348. && pRectFillSrc != NULL
  2349. && pRectFillSrc->left < pRectFillSrc->right
  2350. && pRectFillSrc->top < pRectFillSrc->bottom
  2351. )
  2352. ::BitBlt(
  2353. hDC,
  2354. 0,
  2355. 0,
  2356. pRectFillSrc->right - pRectFillSrc->left,
  2357. pRectFillSrc->bottom - pRectFillSrc->top,
  2358. hSrcDC,
  2359. pRectFillSrc->left,
  2360. pRectFillSrc->top,
  2361. SRCCOPY
  2362. );
  2363. LRESULT lResult =
  2364. ::SendMessage(
  2365. hWnd,
  2366. nMessage,
  2367. (WPARAM)hDC,
  2368. lParamPrint
  2369. );
  2370. lResult;
  2371. // if( lResult != 0 )
  2372. // {
  2373. // bool bOverPaint = true;
  2374. // CWnd * pWnd = CWnd::FromHandlePermanent( hWnd );
  2375. // if( pWnd != NULL )
  2376. // {
  2377. // CRuntimeClass * pRTC = pWnd->GetRuntimeClass();
  2378. // ASSERT( pRTC != NULL );
  2379. // if( ::strncmp( pRTC->m_lpszClassName, "CExt", 4 ) == 0 )
  2380. // bOverPaint = false;
  2381. // }
  2382. // if( bOverPaint )
  2383. // {
  2384. // COLORREF clrBk = ::GetSysColor( COLOR_WINDOW );
  2385. // COLORREF clrBkOld = ::SetBkColor( hDC, clrBk );
  2386. // CRect rect( 0, 0, _sizeDest.cx, _sizeDest.cy );
  2387. // ::ExtTextOut( hDC, 0, 0, ETO_OPAQUE, &rect, NULL, 0, NULL );
  2388. // ::SetBkColor( hDC, clrBkOld );
  2389. // }
  2390. // }
  2391. ::SelectObject( hDC, (HGDIOBJ)hBmpOld );
  2392. ::DeleteDC( hDC );
  2393. return hBmpSufrace;
  2394. }
  2396. void CExtPaintManager::stat_PrintChildren(
  2397. HWND hWndStart,
  2398. UINT nMessage,
  2399. HDC hDC,
  2400. LPARAM lParamPrint,
  2401. bool bDeepTreeWalk, // = true
  2402. CObject * pHelperSrc, // = NULL
  2403. LPARAM lParam // = 0L
  2404. )
  2405. {
  2406. ASSERT( hWndStart != NULL && ::IsWindow(hWndStart) );
  2407. ASSERT( nMessage == WM_PRINT || nMessage == WM_PRINTCLIENT );
  2408. ASSERT( hDC != NULL );
  2409. ASSERT( (lParamPrint&PRF_CHILDREN) != 0 );
  2410. CRect rcStartWnd, rcStartClient;
  2411. ::GetWindowRect( hWndStart, &rcStartWnd );
  2412. ::GetClientRect( hWndStart, &rcStartClient );
  2413. ::ClientToScreen( hWndStart, ((LPPOINT)(&rcStartClient)) );
  2414. ::ClientToScreen( hWndStart, ((LPPOINT)(&rcStartClient))+1 );
  2415. CPoint ptStartNcOffset(
  2416. rcStartWnd.left - rcStartClient.left,
  2417. rcStartWnd.top - rcStartClient.top
  2418. );
  2419. if( (lParamPrint&PRF_NONCLIENT) != 0
  2420. && ( ptStartNcOffset.x != 0
  2421. || ptStartNcOffset.y != 0
  2422. )
  2423. )
  2424. ::OffsetViewportOrgEx(
  2425. hDC,
  2426. -ptStartNcOffset.x,
  2427. -ptStartNcOffset.y,
  2428. NULL
  2429. );
  2430. HWND hWndChild = ::GetWindow( hWndStart, GW_CHILD );
  2431. for( ; hWndChild != NULL; hWndChild = ::GetWindow( hWndChild, GW_HWNDNEXT ) )
  2432. {
  2433. __EXT_MFC_LONG_PTR dwChildStyle = ::__EXT_MFC_GetWindowLong( hWndChild, GWL_STYLE );
  2434. if( (dwChildStyle&WS_VISIBLE) == 0 )
  2435. continue;
  2436. CRect rcChildWnd, rcChildClient;
  2437. ::GetWindowRect( hWndChild, &rcChildWnd );
  2438. ::GetClientRect( hWndChild, &rcChildClient );
  2439. ::ClientToScreen( hWndChild, ((LPPOINT)(&rcChildClient)) );
  2440. ::ClientToScreen( hWndChild, ((LPPOINT)(&rcChildClient))+1 );
  2441. CPoint ptChildNcOffset(
  2442. rcChildWnd.left - rcChildClient.left,
  2443. rcChildWnd.top - rcChildClient.top
  2444. );
  2445. CPoint ptChildRenderOffset( 0, 0 );
  2446. if( (lParamPrint&PRF_NONCLIENT) != 0 )
  2447. {
  2448. ptChildRenderOffset.x = rcStartClient.left - rcChildWnd.left;
  2449. ptChildRenderOffset.y = rcStartClient.top - rcChildWnd.top;
  2450. }
  2451. else
  2452. {
  2453. ptChildRenderOffset.x = rcStartClient.left - rcChildClient.left;
  2454. ptChildRenderOffset.y = rcStartClient.top - rcChildClient.top;
  2455. }
  2456. if( ptChildRenderOffset.x != 0
  2457. || ptChildRenderOffset.y != 0
  2458. )
  2459. ::OffsetViewportOrgEx(
  2460. hDC,
  2461. -ptChildRenderOffset.x,
  2462. -ptChildRenderOffset.y,
  2463. NULL
  2464. );
  2465. ::SendMessage(
  2466. hWndChild,
  2467. nMessage,
  2468. (WPARAM)hDC,
  2469. lParamPrint
  2470. );
  2471. if( bDeepTreeWalk )
  2472. stat_PrintChildren(
  2473. hWndChild,
  2474. nMessage,
  2475. hDC,
  2476. lParamPrint,
  2477. bDeepTreeWalk,
  2478. pHelperSrc,
  2479. lParam
  2480. );
  2481. if( ptChildRenderOffset.x != 0
  2482. || ptChildRenderOffset.y != 0
  2483. )
  2484. ::OffsetViewportOrgEx(
  2485. hDC,
  2486. ptChildRenderOffset.x,
  2487. ptChildRenderOffset.y,
  2488. NULL
  2489. );
  2490. } // for( ; hWndChild != NULL; hWndChild = ::GetWindow( hWndChild, GW_HWNDNEXT ) )
  2491. if( (lParamPrint&PRF_NONCLIENT) != 0
  2492. && ( ptStartNcOffset.x != 0
  2493. || ptStartNcOffset.y != 0
  2494. )
  2495. )
  2496. ::OffsetViewportOrgEx(
  2497. hDC,
  2498. ptStartNcOffset.x,
  2499. ptStartNcOffset.y,
  2500. NULL
  2501. );
  2502. }
  2504. CExtPaintManager::SCROLLBARSKINDATA::SCROLLBARSKINDATA()
  2505. {
  2506. Empty();
  2507. }
  2509. CExtPaintManager::SCROLLBARSKINDATA::~SCROLLBARSKINDATA()
  2510. {
  2511. Empty();
  2512. }
  2514. void CExtPaintManager::SCROLLBARSKINDATA::Empty()
  2515. {
  2516. m_clrZsLineLightEnabled = COLORREF(-1L);
  2517. m_clrZsLineDarkEnabled = COLORREF(-1L);
  2518. m_clrZsLineLightDisabled = COLORREF(-1L);
  2519. m_clrZsLineDarkDisabled = COLORREF(-1L);
  2520. m_bmpEntireArea.Empty();
  2521. m_rcEntirePaddingR.SetRect( 0, 0, 0, 0 );
  2522. m_rcEntirePaddingC.SetRect( 0, 0, 0, 0 );
  2523. INT i, j;
  2524. for( i = 0; i < INT(__ESBSPT_PART_COUNT); i++ )
  2525. {
  2526. for( j = 0; j < INT(__ESBMHT_PART_COUNT); j++ )
  2527. {
  2528. CRect & rcPadding = m_arrPartPadding[i][j];
  2529. rcPadding.SetRect( 0, 0, 0, 0 );
  2530. CExtBitmap & _bmp = m_arrPartBmp[i][j];
  2531. _bmp.Empty();
  2532. m_arrClrSolidBackground[i][j] = COLORREF(-1L);
  2533. }
  2534. }
  2535. }
  2537. CExtBitmap & CExtPaintManager::SCROLLBARSKINDATA::GetPart(
  2538. CExtPaintManager::e_scroll_bar_skin_part_t ePartState,
  2539. CExtPaintManager::e_scroll_bar_mouse_hover_type_t eSBMHT, // part type
  2540. RECT * pRectPadding, // = NULL
  2541. COLORREF * pClrSolidBackground // = NULL
  2542. )
  2543. {
  2544. CExtBitmap & _bmp =
  2545. m_arrPartBmp
  2546. [ INT(ePartState) ]
  2547. [ INT(eSBMHT) ]
  2548. ;
  2549. COLORREF clrSolidBackground =
  2550. m_arrClrSolidBackground
  2551. [ INT(ePartState) ]
  2552. [ INT(eSBMHT) ]
  2553. ;
  2554. if( pClrSolidBackground != NULL )
  2555. (*pClrSolidBackground) = clrSolidBackground;
  2556. if( pRectPadding != NULL )
  2557. {
  2558. const RECT & rcPadding =
  2559. m_arrPartPadding
  2560. [ INT(ePartState) ]
  2561. [ INT(eSBMHT) ]
  2562. ;
  2563. ::CopyRect( pRectPadding, &rcPadding );
  2564. } // if( pRectPadding != NULL )
  2565. if( _bmp.IsEmpty() && INT(ePartState) > 0 )
  2566. {
  2567. return
  2568. GetPart(
  2569. (CExtPaintManager::e_scroll_bar_skin_part_t)(INT(ePartState)-1),
  2570. eSBMHT,
  2571. pRectPadding,
  2572. ( clrSolidBackground == COLORREF(-1L) )
  2573. ? pClrSolidBackground
  2574. : NULL
  2575. );
  2576. } // if( _bmp.IsEmpty() && INT(ePartState) > 0 )
  2577. return _bmp;
  2578. }
  2580. const CExtBitmap & CExtPaintManager::SCROLLBARSKINDATA::GetPart(
  2581. CExtPaintManager::e_scroll_bar_skin_part_t ePartState,
  2582. CExtPaintManager::e_scroll_bar_mouse_hover_type_t eSBMHT, // part type
  2583. RECT * pRectPadding, // = NULL
  2584. COLORREF * pClrSolidBackground // = NULL
  2585. ) const
  2586. {
  2587. return
  2588. ( const_cast < SCROLLBARSKINDATA * > ( this ) )
  2589. -> GetPart( ePartState, eSBMHT, pRectPadding, pClrSolidBackground );
  2590. }
  2592. void CExtPaintManager::SCROLLBARSKINDATA::Load2007_R2(
  2593. UINT nResourceID_BumpyGlyphStack,
  2594. INT nBumpyGlyphStackItemHeight,
  2595. UINT nResourceID_GripperStack,
  2596. INT nGripperStackItemHeight,
  2597. const RECT & rcBumpyGlyphStackItemPadding,
  2598. COLORREF clrSolidBackground,
  2599. COLORREF clrPressedPageAreas,
  2600. UINT nResourceID_ArrowUp_Normal,
  2601. UINT nResourceID_ArrowUp_Disabled,
  2602. UINT nResourceID_ArrowDown_Normal,
  2603. UINT nResourceID_ArrowDown_Disabled,
  2604. bool bRotateArrowsAndBk270,
  2605. UINT nResourceID_BkEntire,
  2606. UINT nResourceID_BkPage,
  2607. const RECT & rcEntirePaddingR,
  2608. const RECT & rcEntirePaddingC
  2609. )
  2610. {
  2611. Empty();
  2612. INT i, j;
  2613. for( i = 0; i < INT(__ESBSPT_PART_COUNT); i++ )
  2614. {
  2615. for( j = 0; j < INT(__ESBMHT_PART_COUNT); j++ )
  2616. {
  2617. CRect & rcPadding = m_arrPartPadding[i][j];
  2618. rcPadding.SetRect( 0, 0, 0, 0 );
  2619. CExtBitmap & _bmp = m_arrPartBmp[i][j];
  2620. _bmp.Empty();
  2621. m_arrClrSolidBackground[i][j] = clrSolidBackground;
  2622. if( ( j == INT(__ESBMHT_PAGE_UP) || j == INT(__ESBMHT_PAGE_DOWN) )
  2623. && i == INT(__ESBSPT_PRESSED)
  2624. )
  2625. m_arrClrSolidBackground[i][j] = clrPressedPageAreas;
  2626. }
  2627. }
  2628. CExtBitmap _bmpBumpyGlyphStack, _bmpGripperStack;
  2629. VERIFY( _bmpBumpyGlyphStack.LoadBMP_Resource( MAKEINTRESOURCE(nResourceID_BumpyGlyphStack) ) );
  2630. VERIFY( _bmpGripperStack.LoadBMP_Resource( MAKEINTRESOURCE(nResourceID_GripperStack) ) );
  2631. _bmpBumpyGlyphStack.PreMultipliedRGBChannelsSet( true );
  2632. _bmpGripperStack.PreMultipliedRGBChannelsSet( true );
  2633. CSize _sizeBumpyGlyph = _bmpBumpyGlyphStack.GetSize();
  2634. CSize _sizeGripper = _bmpGripperStack.GetSize();
  2635. CRect rcBumpyGlyph( 0, 0, _sizeBumpyGlyph.cx, nBumpyGlyphStackItemHeight );
  2636. CRect rcGripper( 0, 0, _sizeGripper.cx, nGripperStackItemHeight );
  2637. // cold parts
  2638. VERIFY(
  2639. m_arrPartBmp[INT(__ESBSPT_COLD)][INT(__ESBMHT_THUMB)].
  2640. FromBitmap( _bmpBumpyGlyphStack, rcBumpyGlyph )
  2641. );
  2642. m_arrPartPadding[INT(__ESBSPT_COLD)][INT(__ESBMHT_THUMB)] = rcBumpyGlyphStackItemPadding;
  2643. VERIFY(
  2644. m_arrPartBmp[INT(__ESBSPT_COLD)][INT(__ESBMHT_GLYPH_THUMB_GRIPPER)].
  2645. FromBitmap( _bmpGripperStack, rcGripper )
  2646. );
  2647. // normal parts
  2648. VERIFY(
  2649. m_arrPartBmp[INT(__ESBSPT_NORMAL)][INT(__ESBMHT_BUTTON_UP)].
  2650. FromBitmap( _bmpBumpyGlyphStack, rcBumpyGlyph )
  2651. );
  2652. m_arrPartPadding[INT(__ESBSPT_NORMAL)][INT(__ESBMHT_BUTTON_UP)] = rcBumpyGlyphStackItemPadding;
  2653. VERIFY(
  2654. m_arrPartBmp[INT(__ESBSPT_NORMAL)][INT(__ESBMHT_BUTTON_DOWN)].
  2655. FromBitmap( _bmpBumpyGlyphStack, rcBumpyGlyph )
  2656. );
  2657. m_arrPartPadding[INT(__ESBSPT_NORMAL)][INT(__ESBMHT_BUTTON_DOWN)] = rcBumpyGlyphStackItemPadding;
  2658. // hot parts
  2659. rcBumpyGlyph.OffsetRect( 0, nBumpyGlyphStackItemHeight );
  2660. rcGripper.OffsetRect( 0, nGripperStackItemHeight );
  2661. VERIFY(
  2662. m_arrPartBmp[INT(__ESBSPT_HOT)][INT(__ESBMHT_BUTTON_UP)].
  2663. FromBitmap( _bmpBumpyGlyphStack, rcBumpyGlyph )
  2664. );
  2665. m_arrPartPadding[INT(__ESBSPT_HOT)][INT(__ESBMHT_BUTTON_UP)] = rcBumpyGlyphStackItemPadding;
  2666. VERIFY(
  2667. m_arrPartBmp[INT(__ESBSPT_HOT)][INT(__ESBMHT_BUTTON_DOWN)].
  2668. FromBitmap( _bmpBumpyGlyphStack, rcBumpyGlyph )
  2669. );
  2670. m_arrPartPadding[INT(__ESBSPT_HOT)][INT(__ESBMHT_BUTTON_DOWN)] = rcBumpyGlyphStackItemPadding;
  2671. VERIFY(
  2672. m_arrPartBmp[INT(__ESBSPT_HOT)][INT(__ESBMHT_THUMB)].
  2673. FromBitmap( _bmpBumpyGlyphStack, rcBumpyGlyph )
  2674. );
  2675. m_arrPartPadding[INT(__ESBSPT_HOT)][INT(__ESBMHT_THUMB)] = rcBumpyGlyphStackItemPadding;
  2676. VERIFY(
  2677. m_arrPartBmp[INT(__ESBSPT_HOT)][INT(__ESBMHT_GLYPH_THUMB_GRIPPER)].
  2678. FromBitmap( _bmpGripperStack, rcGripper )
  2679. );
  2680. // pressed parts
  2681. rcBumpyGlyph.OffsetRect( 0, nBumpyGlyphStackItemHeight );
  2682. rcGripper.OffsetRect( 0, nGripperStackItemHeight );
  2683. VERIFY(
  2684. m_arrPartBmp[INT(__ESBSPT_PRESSED)][INT(__ESBMHT_BUTTON_UP)].
  2685. FromBitmap( _bmpBumpyGlyphStack, rcBumpyGlyph )
  2686. );
  2687. m_arrPartPadding[INT(__ESBSPT_PRESSED)][INT(__ESBMHT_BUTTON_UP)] = rcBumpyGlyphStackItemPadding;
  2688. VERIFY(
  2689. m_arrPartBmp[INT(__ESBSPT_PRESSED)][INT(__ESBMHT_BUTTON_DOWN)].
  2690. FromBitmap( _bmpBumpyGlyphStack, rcBumpyGlyph )
  2691. );
  2692. m_arrPartPadding[INT(__ESBSPT_PRESSED)][INT(__ESBMHT_BUTTON_DOWN)] = rcBumpyGlyphStackItemPadding;
  2693. VERIFY(
  2694. m_arrPartBmp[INT(__ESBSPT_PRESSED)][INT(__ESBMHT_THUMB)].
  2695. FromBitmap( _bmpBumpyGlyphStack, rcBumpyGlyph )
  2696. );
  2697. m_arrPartPadding[INT(__ESBSPT_PRESSED)][INT(__ESBMHT_THUMB)] = rcBumpyGlyphStackItemPadding;
  2698. VERIFY(
  2699. m_arrPartBmp[INT(__ESBSPT_PRESSED)][INT(__ESBMHT_GLYPH_THUMB_GRIPPER)].
  2700. FromBitmap( _bmpGripperStack, rcGripper )
  2701. );
  2702. // arrows
  2703. CExtBitmap _bmpArrowUpNormal, _bmpArrowUpDisabled, _bmpArrowDownNormal, _bmpArrowDownDisabled;
  2704. VERIFY( _bmpArrowUpNormal.LoadBMP_Resource( MAKEINTRESOURCE(nResourceID_ArrowUp_Normal) ) );
  2705. VERIFY( _bmpArrowUpDisabled.LoadBMP_Resource( MAKEINTRESOURCE(nResourceID_ArrowUp_Disabled) ) );
  2706. VERIFY( _bmpArrowDownNormal.LoadBMP_Resource( MAKEINTRESOURCE(nResourceID_ArrowDown_Normal) ) );
  2707. VERIFY( _bmpArrowDownDisabled.LoadBMP_Resource( MAKEINTRESOURCE(nResourceID_ArrowDown_Disabled) ) );
  2708. _bmpArrowUpNormal.PreMultipliedRGBChannelsSet( true );
  2709. _bmpArrowUpDisabled.PreMultipliedRGBChannelsSet( true );
  2710. _bmpArrowDownNormal.PreMultipliedRGBChannelsSet( true );
  2711. _bmpArrowDownDisabled.PreMultipliedRGBChannelsSet( true );
  2712. CSize _sizeArrowUpNormal = _bmpArrowUpNormal.GetSize();
  2713. CSize _sizeArrowUpDisabled = _bmpArrowUpDisabled.GetSize();
  2714. CSize _sizeArrowDownNormal = _bmpArrowDownNormal.GetSize();
  2715. CSize _sizeArrowDownDisabled = _bmpArrowDownDisabled.GetSize();
  2716. VERIFY(
  2717. m_arrPartBmp[INT(__ESBSPT_COLD)][INT(__ESBMHT_GLYPH_ARROW_UP)].
  2718. CreateRotated9xStack(
  2719. _bmpArrowUpNormal,
  2720. bRotateArrowsAndBk270 ? 270 : 0,
  2721. 1,
  2722. _sizeArrowUpNormal.cx,
  2723. _sizeArrowUpNormal.cy,
  2724. false,
  2725. false
  2726. )
  2727. );
  2728. VERIFY(
  2729. m_arrPartBmp[INT(__ESBSPT_DISABLED)][INT(__ESBMHT_GLYPH_ARROW_UP)].
  2730. CreateRotated9xStack(
  2731. _bmpArrowUpDisabled,
  2732. bRotateArrowsAndBk270 ? 270 : 0,
  2733. 1,
  2734. _sizeArrowUpDisabled.cx,
  2735. _sizeArrowUpDisabled.cy,
  2736. false,
  2737. false
  2738. )
  2739. );
  2740. VERIFY(
  2741. m_arrPartBmp[INT(__ESBSPT_COLD)][INT(__ESBMHT_GLYPH_ARROW_DOWN)].
  2742. CreateRotated9xStack(
  2743. _bmpArrowDownNormal,
  2744. bRotateArrowsAndBk270 ? 270 : 0,
  2745. 1,
  2746. _sizeArrowDownNormal.cx,
  2747. _sizeArrowDownNormal.cy,
  2748. false,
  2749. false
  2750. )
  2751. );
  2752. VERIFY(
  2753. m_arrPartBmp[INT(__ESBSPT_DISABLED)][INT(__ESBMHT_GLYPH_ARROW_DOWN)].
  2754. CreateRotated9xStack(
  2755. _bmpArrowDownDisabled,
  2756. bRotateArrowsAndBk270 ? 270 : 0,
  2757. 1,
  2758. _sizeArrowDownDisabled.cx,
  2759. _sizeArrowDownDisabled.cy,
  2760. false,
  2761. false
  2762. )
  2763. );
  2765. // backgrounds
  2766. CExtBitmap _bmpBkEntire, _bmpBkPage;
  2767. VERIFY( _bmpBkEntire.LoadBMP_Resource( MAKEINTRESOURCE(nResourceID_BkEntire) ) );
  2768. VERIFY( _bmpBkPage.LoadBMP_Resource( MAKEINTRESOURCE(nResourceID_BkPage) ) );
  2769. _bmpBkEntire.PreMultipliedRGBChannelsSet( true );
  2770. _bmpBkPage.PreMultipliedRGBChannelsSet( true );
  2771. CSize _sizeBkEntire = _bmpBkEntire.GetSize();
  2772. CSize _sizeBkPage = _bmpBkPage.GetSize();
  2773. VERIFY(
  2774. m_bmpEntireArea.
  2775. CreateRotated9xStack(
  2776. _bmpBkEntire,
  2777. bRotateArrowsAndBk270 ? 270 : 0,
  2778. 1,
  2779. _sizeBkEntire.cx,
  2780. _sizeBkEntire.cy,
  2781. false,
  2782. false
  2783. )
  2784. );
  2785. VERIFY(
  2786. m_arrPartBmp[INT(__ESBSPT_PRESSED)][INT(__ESBMHT_PAGE_DOWN)].
  2787. CreateRotated9xStack(
  2788. _bmpBkPage,
  2789. bRotateArrowsAndBk270 ? 270 : 0,
  2790. 1,
  2791. _sizeBkPage.cx,
  2792. _sizeBkPage.cy,
  2793. false,
  2794. false
  2795. )
  2796. );
  2797. VERIFY(
  2798. m_arrPartBmp[INT(__ESBSPT_PRESSED)][INT(__ESBMHT_PAGE_UP)].AssignFromOther(
  2799. m_arrPartBmp[INT(__ESBSPT_PRESSED)][INT(__ESBMHT_PAGE_DOWN)]
  2800. )
  2801. );
  2802. m_rcEntirePaddingR = rcEntirePaddingR;
  2803. m_rcEntirePaddingC = rcEntirePaddingC;
  2804. }
  2806. void CExtPaintManager::SCROLLBARSKINDATA::Load2007_Zoom(
  2807. UINT nResourceID_ButtonPlus,
  2808. UINT nResourceID_ButtonMinus,
  2809. UINT nResourceID_ButtonThumb,
  2810. COLORREF clrZsLineLightEnabled,
  2811. COLORREF clrZsLineDarkEnabled,
  2812. COLORREF clrZsLineLightDisabled,
  2813. COLORREF clrZsLineDarkDisabled,
  2814. UINT nDockID,
  2815. bool bResourceColorChannelsPreMultiplied // = true
  2816. )
  2817. {
  2818. Empty();
  2819. ASSERT(
  2820. nDockID == AFX_IDW_DOCKBAR_TOP
  2821. || nDockID == AFX_IDW_DOCKBAR_BOTTOM
  2822. || nDockID == AFX_IDW_DOCKBAR_LEFT
  2823. || nDockID == AFX_IDW_DOCKBAR_RIGHT
  2824. );
  2825. INT nAngleCw90 = 0;
  2826. if(      nDockID == AFX_IDW_DOCKBAR_BOTTOM )
  2827.  nAngleCw90 = 180;
  2828. else if( nDockID == AFX_IDW_DOCKBAR_LEFT )
  2829.  nAngleCw90 = 270;
  2830. else if( nDockID == AFX_IDW_DOCKBAR_RIGHT )
  2831.  nAngleCw90 = 90;
  2832. INT i, j;
  2833. for( i = 0; i < INT(__ESBSPT_PART_COUNT); i++ )
  2834. {
  2835. for( j = 0; j < INT(__ESBMHT_PART_COUNT); j++ )
  2836. {
  2837. CRect & rcPadding = m_arrPartPadding[i][j];
  2838. rcPadding.SetRect( 0, 0, 0, 0 );
  2839. CExtBitmap & _bmp = m_arrPartBmp[i][j];
  2840. _bmp.Empty();
  2841. m_arrClrSolidBackground[i][j] = COLORREF(-1L);
  2842. }
  2843. }
  2845. m_clrZsLineLightEnabled = clrZsLineLightEnabled;
  2846. m_clrZsLineDarkEnabled = clrZsLineDarkEnabled;
  2847. m_clrZsLineLightDisabled = clrZsLineLightDisabled;
  2848. m_clrZsLineDarkDisabled = clrZsLineDarkDisabled;
  2850. CRect rcGlyph;
  2851. CExtBitmap _bmpGlyphStack;
  2853. VERIFY( _bmpGlyphStack.LoadBMP_Resource( MAKEINTRESOURCE(nResourceID_ButtonPlus) ) );
  2854. _bmpGlyphStack.PreMultipliedRGBChannelsSet( bResourceColorChannelsPreMultiplied );
  2855. rcGlyph.SetRect( 0, 0, _bmpGlyphStack.GetSize().cx, _bmpGlyphStack.GetSize().cy / 3 );
  2856. VERIFY( m_arrPartBmp[INT(__ESBSPT_NORMAL)][INT(__ESBMHT_BUTTON_DOWN)].FromBitmap( _bmpGlyphStack, rcGlyph ) );
  2857.         m_arrPartBmp[INT(__ESBSPT_COLD)][INT(__ESBMHT_BUTTON_DOWN)] = m_arrPartBmp[INT(__ESBSPT_NORMAL)][INT(__ESBMHT_BUTTON_DOWN)];
  2858.         m_arrPartBmp[INT(__ESBSPT_DISABLED)][INT(__ESBMHT_BUTTON_DOWN)] = m_arrPartBmp[INT(__ESBSPT_NORMAL)][INT(__ESBMHT_BUTTON_DOWN)];
  2859. m_arrPartBmp[INT(__ESBSPT_DISABLED)][INT(__ESBMHT_BUTTON_DOWN)].MakeMono();
  2860. m_arrPartBmp[INT(__ESBSPT_DISABLED)][INT(__ESBMHT_BUTTON_DOWN)].AdjustAlpha( -0.25 );
  2861. rcGlyph.OffsetRect( 0, rcGlyph.Height() );
  2862. VERIFY( m_arrPartBmp[INT(__ESBSPT_HOT)][INT(__ESBMHT_BUTTON_DOWN)].FromBitmap( _bmpGlyphStack, rcGlyph ) );
  2863. rcGlyph.OffsetRect( 0, rcGlyph.Height() );
  2864. VERIFY( m_arrPartBmp[INT(__ESBSPT_PRESSED)][INT(__ESBMHT_BUTTON_DOWN)].FromBitmap( _bmpGlyphStack, rcGlyph ) );
  2866. VERIFY( _bmpGlyphStack.LoadBMP_Resource( MAKEINTRESOURCE(nResourceID_ButtonMinus) ) );
  2867. _bmpGlyphStack.PreMultipliedRGBChannelsSet( bResourceColorChannelsPreMultiplied );
  2868. rcGlyph.SetRect( 0, 0, _bmpGlyphStack.GetSize().cx, _bmpGlyphStack.GetSize().cy / 3 );
  2869. VERIFY( m_arrPartBmp[INT(__ESBSPT_NORMAL)][INT(__ESBMHT_BUTTON_UP)].FromBitmap( _bmpGlyphStack, rcGlyph ) );
  2870.         m_arrPartBmp[INT(__ESBSPT_COLD)][INT(__ESBMHT_BUTTON_UP)] = m_arrPartBmp[INT(__ESBSPT_NORMAL)][INT(__ESBMHT_BUTTON_UP)];
  2871.         m_arrPartBmp[INT(__ESBSPT_DISABLED)][INT(__ESBMHT_BUTTON_UP)] = m_arrPartBmp[INT(__ESBSPT_NORMAL)][INT(__ESBMHT_BUTTON_UP)];
  2872. m_arrPartBmp[INT(__ESBSPT_DISABLED)][INT(__ESBMHT_BUTTON_UP)].MakeMono();
  2873. m_arrPartBmp[INT(__ESBSPT_DISABLED)][INT(__ESBMHT_BUTTON_UP)].AdjustAlpha( -0.25 );
  2874. rcGlyph.OffsetRect( 0, rcGlyph.Height() );
  2875. VERIFY( m_arrPartBmp[INT(__ESBSPT_HOT)][INT(__ESBMHT_BUTTON_UP)].FromBitmap( _bmpGlyphStack, rcGlyph ) );
  2876. rcGlyph.OffsetRect( 0, rcGlyph.Height() );
  2877. VERIFY( m_arrPartBmp[INT(__ESBSPT_PRESSED)][INT(__ESBMHT_BUTTON_UP)].FromBitmap( _bmpGlyphStack, rcGlyph ) );
  2879. VERIFY( _bmpGlyphStack.LoadBMP_Resource( MAKEINTRESOURCE(nResourceID_ButtonThumb) ) );
  2880. _bmpGlyphStack.PreMultipliedRGBChannelsSet( bResourceColorChannelsPreMultiplied );
  2881. rcGlyph.SetRect( 0, 0, _bmpGlyphStack.GetSize().cx, _bmpGlyphStack.GetSize().cy / 3 );
  2882. VERIFY( m_arrPartBmp[INT(__ESBSPT_NORMAL)][INT(__ESBMHT_THUMB)].FromBitmap( _bmpGlyphStack, rcGlyph ) );
  2883.         m_arrPartBmp[INT(__ESBSPT_COLD)][INT(__ESBMHT_THUMB)] = m_arrPartBmp[INT(__ESBSPT_NORMAL)][INT(__ESBMHT_THUMB)];
  2884.         m_arrPartBmp[INT(__ESBSPT_DISABLED)][INT(__ESBMHT_THUMB)] = m_arrPartBmp[INT(__ESBSPT_NORMAL)][INT(__ESBMHT_THUMB)];
  2885. m_arrPartBmp[INT(__ESBSPT_DISABLED)][INT(__ESBMHT_THUMB)].MakeMono();
  2886. m_arrPartBmp[INT(__ESBSPT_DISABLED)][INT(__ESBMHT_THUMB)].AdjustAlpha( -0.25 );
  2887. rcGlyph.OffsetRect( 0, rcGlyph.Height() );
  2888. VERIFY( m_arrPartBmp[INT(__ESBSPT_HOT)][INT(__ESBMHT_THUMB)].FromBitmap( _bmpGlyphStack, rcGlyph ) );
  2889. rcGlyph.OffsetRect( 0, rcGlyph.Height() );
  2890. VERIFY( m_arrPartBmp[INT(__ESBSPT_PRESSED)][INT(__ESBMHT_THUMB)].FromBitmap( _bmpGlyphStack, rcGlyph ) );
  2891. if( nAngleCw90 != 0 )
  2892. {
  2893. for( i = 0; i < INT(__ESBSPT_PART_COUNT); i++ )
  2894. {
  2895. CExtBitmap & _bmp1 = m_arrPartBmp[i][__ESBMHT_THUMB];
  2896. if( _bmp1.IsEmpty() )
  2897. continue;
  2898. CExtBitmap _bmp2;
  2899. VERIFY( _bmp2.CreateRotated9xStack( _bmp1, nAngleCw90, 1, _bmp1.GetSize().cx, _bmp1.GetSize().cy, false, false ) );
  2900. _bmp1 = _bmp2;
  2901. }
  2902. }
  2903. }
  2905. void CExtPaintManager::SCROLLBARSKINDATA::Load2010_Zoom_R1(
  2906. UINT nResourceID_ButtonPlus,
  2907. UINT nResourceID_ButtonMinus,
  2908. UINT nResourceID_ButtonThumb,
  2909. COLORREF clrZsLineLightEnabled,
  2910. COLORREF clrZsLineDarkEnabled,
  2911. COLORREF clrZsLineLightDisabled,
  2912. COLORREF clrZsLineDarkDisabled,
  2913. UINT nDockID,
  2914. bool bResourceColorChannelsPreMultiplied // = true
  2915. )
  2916. {
  2917. Empty();
  2918. ASSERT(
  2919. nDockID == AFX_IDW_DOCKBAR_TOP
  2920. || nDockID == AFX_IDW_DOCKBAR_BOTTOM
  2921. || nDockID == AFX_IDW_DOCKBAR_LEFT
  2922. || nDockID == AFX_IDW_DOCKBAR_RIGHT
  2923. );
  2924. INT nAngleCw90 = 0;
  2925. if(      nDockID == AFX_IDW_DOCKBAR_BOTTOM )
  2926.  nAngleCw90 = 180;
  2927. else if( nDockID == AFX_IDW_DOCKBAR_LEFT )
  2928.  nAngleCw90 = 270;
  2929. else if( nDockID == AFX_IDW_DOCKBAR_RIGHT )
  2930.  nAngleCw90 = 90;
  2931. INT i, j;
  2932. for( i = 0; i < INT(__ESBSPT_PART_COUNT); i++ )
  2933. {
  2934. for( j = 0; j < INT(__ESBMHT_PART_COUNT); j++ )
  2935. {
  2936. CRect & rcPadding = m_arrPartPadding[i][j];
  2937. rcPadding.SetRect( 0, 0, 0, 0 );
  2938. CExtBitmap & _bmp = m_arrPartBmp[i][j];
  2939. _bmp.Empty();
  2940. m_arrClrSolidBackground[i][j] = COLORREF(-1L);
  2941. }
  2942. }
  2944. m_clrZsLineLightEnabled = clrZsLineLightEnabled;
  2945. m_clrZsLineDarkEnabled = clrZsLineDarkEnabled;
  2946. m_clrZsLineLightDisabled = clrZsLineLightDisabled;
  2947. m_clrZsLineDarkDisabled = clrZsLineDarkDisabled;
  2949. CRect rcGlyph;
  2950. CExtBitmap _bmpGlyphStack;
  2952. VERIFY( _bmpGlyphStack.LoadBMP_Resource( MAKEINTRESOURCE(nResourceID_ButtonPlus) ) );
  2953. _bmpGlyphStack.PreMultipliedRGBChannelsSet( bResourceColorChannelsPreMultiplied );
  2954. rcGlyph.SetRect( 0, 0, _bmpGlyphStack.GetSize().cx, _bmpGlyphStack.GetSize().cy / 3 );
  2955. VERIFY( m_arrPartBmp[INT(__ESBSPT_NORMAL)][INT(__ESBMHT_BUTTON_DOWN)].FromBitmap( _bmpGlyphStack, rcGlyph ) );
  2956. m_arrPartBmp[INT(__ESBSPT_NORMAL)][INT(__ESBMHT_BUTTON_DOWN)].MakeMono();
  2957.         m_arrPartBmp[INT(__ESBSPT_COLD)][INT(__ESBMHT_BUTTON_DOWN)] = m_arrPartBmp[INT(__ESBSPT_NORMAL)][INT(__ESBMHT_BUTTON_DOWN)];
  2958.         m_arrPartBmp[INT(__ESBSPT_DISABLED)][INT(__ESBMHT_BUTTON_DOWN)] = m_arrPartBmp[INT(__ESBSPT_NORMAL)][INT(__ESBMHT_BUTTON_DOWN)];
  2959. m_arrPartBmp[INT(__ESBSPT_DISABLED)][INT(__ESBMHT_BUTTON_DOWN)].MakeMono();
  2960. m_arrPartBmp[INT(__ESBSPT_DISABLED)][INT(__ESBMHT_BUTTON_DOWN)].AdjustAlpha( -0.25 );
  2961. //rcGlyph.OffsetRect( 0, rcGlyph.Height() );
  2962. VERIFY( m_arrPartBmp[INT(__ESBSPT_HOT)][INT(__ESBMHT_BUTTON_DOWN)].FromBitmap( _bmpGlyphStack, rcGlyph ) );
  2963. rcGlyph.OffsetRect( 0, rcGlyph.Height() );
  2964. VERIFY( m_arrPartBmp[INT(__ESBSPT_PRESSED)][INT(__ESBMHT_BUTTON_DOWN)].FromBitmap( _bmpGlyphStack, rcGlyph ) );
  2966. VERIFY( _bmpGlyphStack.LoadBMP_Resource( MAKEINTRESOURCE(nResourceID_ButtonMinus) ) );
  2967. _bmpGlyphStack.PreMultipliedRGBChannelsSet( bResourceColorChannelsPreMultiplied );
  2968. rcGlyph.SetRect( 0, 0, _bmpGlyphStack.GetSize().cx, _bmpGlyphStack.GetSize().cy / 3 );
  2969. VERIFY( m_arrPartBmp[INT(__ESBSPT_NORMAL)][INT(__ESBMHT_BUTTON_UP)].FromBitmap( _bmpGlyphStack, rcGlyph ) );
  2970. m_arrPartBmp[INT(__ESBSPT_NORMAL)][INT(__ESBMHT_BUTTON_UP)].MakeMono();
  2971.         m_arrPartBmp[INT(__ESBSPT_COLD)][INT(__ESBMHT_BUTTON_UP)] = m_arrPartBmp[INT(__ESBSPT_NORMAL)][INT(__ESBMHT_BUTTON_UP)];
  2972.         m_arrPartBmp[INT(__ESBSPT_DISABLED)][INT(__ESBMHT_BUTTON_UP)] = m_arrPartBmp[INT(__ESBSPT_NORMAL)][INT(__ESBMHT_BUTTON_UP)];
  2973. m_arrPartBmp[INT(__ESBSPT_DISABLED)][INT(__ESBMHT_BUTTON_UP)].MakeMono();
  2974. m_arrPartBmp[INT(__ESBSPT_DISABLED)][INT(__ESBMHT_BUTTON_UP)].AdjustAlpha( -0.25 );
  2975. //rcGlyph.OffsetRect( 0, rcGlyph.Height() );
  2976. VERIFY( m_arrPartBmp[INT(__ESBSPT_HOT)][INT(__ESBMHT_BUTTON_UP)].FromBitmap( _bmpGlyphStack, rcGlyph ) );
  2977. rcGlyph.OffsetRect( 0, rcGlyph.Height() );
  2978. VERIFY( m_arrPartBmp[INT(__ESBSPT_PRESSED)][INT(__ESBMHT_BUTTON_UP)].FromBitmap( _bmpGlyphStack, rcGlyph ) );
  2980. VERIFY( _bmpGlyphStack.LoadBMP_Resource( MAKEINTRESOURCE(nResourceID_ButtonThumb) ) );
  2981. _bmpGlyphStack.PreMultipliedRGBChannelsSet( bResourceColorChannelsPreMultiplied );
  2982. rcGlyph.SetRect( 0, 0, _bmpGlyphStack.GetSize().cx, _bmpGlyphStack.GetSize().cy / 2 /*3*/ );
  2983. VERIFY( m_arrPartBmp[INT(__ESBSPT_NORMAL)][INT(__ESBMHT_THUMB)].FromBitmap( _bmpGlyphStack, rcGlyph ) );
  2984. m_arrPartBmp[INT(__ESBSPT_NORMAL)][INT(__ESBMHT_THUMB)].MakeMono();
  2985.         m_arrPartBmp[INT(__ESBSPT_COLD)][INT(__ESBMHT_THUMB)] = m_arrPartBmp[INT(__ESBSPT_NORMAL)][INT(__ESBMHT_THUMB)];
  2986.         m_arrPartBmp[INT(__ESBSPT_DISABLED)][INT(__ESBMHT_THUMB)] = m_arrPartBmp[INT(__ESBSPT_NORMAL)][INT(__ESBMHT_THUMB)];
  2987. m_arrPartBmp[INT(__ESBSPT_DISABLED)][INT(__ESBMHT_THUMB)].MakeMono();
  2988. m_arrPartBmp[INT(__ESBSPT_DISABLED)][INT(__ESBMHT_THUMB)].AdjustAlpha( -0.25 );
  2989. //rcGlyph.OffsetRect( 0, rcGlyph.Height() );
  2990. VERIFY( m_arrPartBmp[INT(__ESBSPT_HOT)][INT(__ESBMHT_THUMB)].FromBitmap( _bmpGlyphStack, rcGlyph ) );
  2991. rcGlyph.OffsetRect( 0, rcGlyph.Height() );
  2992. VERIFY( m_arrPartBmp[INT(__ESBSPT_PRESSED)][INT(__ESBMHT_THUMB)].FromBitmap( _bmpGlyphStack, rcGlyph ) );
  2993. if( nAngleCw90 != 0 )
  2994. {
  2995. for( i = 0; i < INT(__ESBSPT_PART_COUNT); i++ )
  2996. {
  2997. CExtBitmap & _bmp1 = m_arrPartBmp[i][__ESBMHT_THUMB];
  2998. if( _bmp1.IsEmpty() )
  2999. continue;
  3000. CExtBitmap _bmp2;
  3001. VERIFY( _bmp2.CreateRotated9xStack( _bmp1, nAngleCw90, 1, _bmp1.GetSize().cx, _bmp1.GetSize().cy, false, false ) );
  3002. _bmp1 = _bmp2;
  3003. }
  3004. }
  3005. }
  3007. void CExtPaintManager::SCROLLBARSKINDATA::Load2010_Zoom_R2(
  3008. UINT nResourceID_ButtonPlus,
  3009. UINT nResourceID_ButtonMinus,
  3010. UINT nResourceID_ButtonThumb,
  3011. COLORREF clrZsLineLightEnabled,
  3012. COLORREF clrZsLineDarkEnabled,
  3013. COLORREF clrZsLineLightDisabled,
  3014. COLORREF clrZsLineDarkDisabled,
  3015. UINT nDockID,
  3016. bool bResourceColorChannelsPreMultiplied // = true
  3017. )
  3018. {
  3019. Empty();
  3020. ASSERT(
  3021. nDockID == AFX_IDW_DOCKBAR_TOP
  3022. || nDockID == AFX_IDW_DOCKBAR_BOTTOM
  3023. || nDockID == AFX_IDW_DOCKBAR_LEFT
  3024. || nDockID == AFX_IDW_DOCKBAR_RIGHT
  3025. );
  3026. INT nAngleCw90 = 0;
  3027. if(      nDockID == AFX_IDW_DOCKBAR_BOTTOM )
  3028.  nAngleCw90 = 180;
  3029. else if( nDockID == AFX_IDW_DOCKBAR_LEFT )
  3030.  nAngleCw90 = 270;
  3031. else if( nDockID == AFX_IDW_DOCKBAR_RIGHT )
  3032.  nAngleCw90 = 90;
  3033. INT i, j;
  3034. for( i = 0; i < INT(__ESBSPT_PART_COUNT); i++ )
  3035. {
  3036. for( j = 0; j < INT(__ESBMHT_PART_COUNT); j++ )
  3037. {
  3038. CRect & rcPadding = m_arrPartPadding[i][j];
  3039. rcPadding.SetRect( 0, 0, 0, 0 );
  3040. CExtBitmap & _bmp = m_arrPartBmp[i][j];
  3041. _bmp.Empty();
  3042. m_arrClrSolidBackground[i][j] = COLORREF(-1L);
  3043. }
  3044. }
  3046. m_clrZsLineLightEnabled = clrZsLineLightEnabled;
  3047. m_clrZsLineDarkEnabled = clrZsLineDarkEnabled;
  3048. m_clrZsLineLightDisabled = clrZsLineLightDisabled;
  3049. m_clrZsLineDarkDisabled = clrZsLineDarkDisabled;
  3051. CExtBitmap _bmpGlyphStack;
  3053. VERIFY( _bmpGlyphStack.LoadBMP_Resource( MAKEINTRESOURCE(nResourceID_ButtonPlus) ) );
  3054. _bmpGlyphStack.PreMultipliedRGBChannelsSet( bResourceColorChannelsPreMultiplied );
  3055. CSize sizeStack = _bmpGlyphStack.GetSize();
  3056. CSize sizeGryph( sizeStack.cx, sizeStack.cy / 3 );
  3057. CRect rc1( 0, 0, sizeGryph.cx, sizeGryph.cy );
  3058. CRect rc2 = rc1; rc2.OffsetRect( 0, sizeGryph.cy );
  3059. CRect rc3 = rc2; rc3.OffsetRect( 0, sizeGryph.cy );
  3060. VERIFY( m_arrPartBmp[INT(__ESBSPT_NORMAL)][INT(__ESBMHT_BUTTON_DOWN)].FromBitmap( _bmpGlyphStack, rc3 ) );
  3061. //m_arrPartBmp[INT(__ESBSPT_NORMAL)][INT(__ESBMHT_BUTTON_DOWN)].MakeMono();
  3062.         m_arrPartBmp[INT(__ESBSPT_COLD)][INT(__ESBMHT_BUTTON_DOWN)] = m_arrPartBmp[INT(__ESBSPT_NORMAL)][INT(__ESBMHT_BUTTON_DOWN)];
  3063.         m_arrPartBmp[INT(__ESBSPT_DISABLED)][INT(__ESBMHT_BUTTON_DOWN)] = m_arrPartBmp[INT(__ESBSPT_NORMAL)][INT(__ESBMHT_BUTTON_DOWN)];
  3064. m_arrPartBmp[INT(__ESBSPT_DISABLED)][INT(__ESBMHT_BUTTON_DOWN)].MakeMono();
  3065. m_arrPartBmp[INT(__ESBSPT_DISABLED)][INT(__ESBMHT_BUTTON_DOWN)].AdjustAlpha( -0.25 );
  3066. VERIFY( m_arrPartBmp[INT(__ESBSPT_HOT)][INT(__ESBMHT_BUTTON_DOWN)].FromBitmap( _bmpGlyphStack, rc1 ) );
  3067. VERIFY( m_arrPartBmp[INT(__ESBSPT_PRESSED)][INT(__ESBMHT_BUTTON_DOWN)].FromBitmap( _bmpGlyphStack, rc2 ) );
  3069. VERIFY( _bmpGlyphStack.LoadBMP_Resource( MAKEINTRESOURCE(nResourceID_ButtonMinus) ) );
  3070. _bmpGlyphStack.PreMultipliedRGBChannelsSet( bResourceColorChannelsPreMultiplied );
  3071. sizeStack = _bmpGlyphStack.GetSize();
  3072. sizeGryph.cx = sizeStack.cx; sizeGryph.cy = sizeStack.cy / 3;
  3073. rc1.SetRect( 0, 0, sizeGryph.cx, sizeGryph.cy );
  3074. rc2 = rc1; rc2.OffsetRect( 0, sizeGryph.cy );
  3075. rc3 = rc2; rc3.OffsetRect( 0, sizeGryph.cy );
  3076. VERIFY( m_arrPartBmp[INT(__ESBSPT_NORMAL)][INT(__ESBMHT_BUTTON_UP)].FromBitmap( _bmpGlyphStack, rc3 ) );
  3077. //m_arrPartBmp[INT(__ESBSPT_NORMAL)][INT(__ESBMHT_BUTTON_UP)].MakeMono();
  3078.         m_arrPartBmp[INT(__ESBSPT_COLD)][INT(__ESBMHT_BUTTON_UP)] = m_arrPartBmp[INT(__ESBSPT_NORMAL)][INT(__ESBMHT_BUTTON_UP)];
  3079.         m_arrPartBmp[INT(__ESBSPT_DISABLED)][INT(__ESBMHT_BUTTON_UP)] = m_arrPartBmp[INT(__ESBSPT_NORMAL)][INT(__ESBMHT_BUTTON_UP)];
  3080. m_arrPartBmp[INT(__ESBSPT_DISABLED)][INT(__ESBMHT_BUTTON_UP)].MakeMono();
  3081. m_arrPartBmp[INT(__ESBSPT_DISABLED)][INT(__ESBMHT_BUTTON_UP)].AdjustAlpha( -0.25 );
  3082. VERIFY( m_arrPartBmp[INT(__ESBSPT_HOT)][INT(__ESBMHT_BUTTON_UP)].FromBitmap( _bmpGlyphStack, rc1 ) );
  3083. VERIFY( m_arrPartBmp[INT(__ESBSPT_PRESSED)][INT(__ESBMHT_BUTTON_UP)].FromBitmap( _bmpGlyphStack, rc2 ) );
  3085. VERIFY( _bmpGlyphStack.LoadBMP_Resource( MAKEINTRESOURCE(nResourceID_ButtonThumb) ) );
  3086. _bmpGlyphStack.PreMultipliedRGBChannelsSet( bResourceColorChannelsPreMultiplied );
  3087. sizeStack = _bmpGlyphStack.GetSize();
  3088. sizeGryph.cx = sizeStack.cx; sizeGryph.cy = sizeStack.cy / 3;
  3089. rc1.SetRect( 0, 0, sizeGryph.cx, sizeGryph.cy );
  3090. rc2 = rc1; rc2.OffsetRect( 0, sizeGryph.cy );
  3091. rc3 = rc2; rc3.OffsetRect( 0, sizeGryph.cy );
  3092. VERIFY( m_arrPartBmp[INT(__ESBSPT_NORMAL)][INT(__ESBMHT_THUMB)].FromBitmap( _bmpGlyphStack, rc1 ) );
  3093. //m_arrPartBmp[INT(__ESBSPT_NORMAL)][INT(__ESBMHT_THUMB)].MakeMono();
  3094.         m_arrPartBmp[INT(__ESBSPT_COLD)][INT(__ESBMHT_THUMB)] = m_arrPartBmp[INT(__ESBSPT_NORMAL)][INT(__ESBMHT_THUMB)];
  3095.         m_arrPartBmp[INT(__ESBSPT_DISABLED)][INT(__ESBMHT_THUMB)] = m_arrPartBmp[INT(__ESBSPT_NORMAL)][INT(__ESBMHT_THUMB)];
  3096. m_arrPartBmp[INT(__ESBSPT_DISABLED)][INT(__ESBMHT_THUMB)].MakeMono();
  3097. m_arrPartBmp[INT(__ESBSPT_DISABLED)][INT(__ESBMHT_THUMB)].AdjustAlpha( -0.25 );
  3098. VERIFY( m_arrPartBmp[INT(__ESBSPT_HOT)][INT(__ESBMHT_THUMB)].FromBitmap( _bmpGlyphStack, rc2 ) );
  3099. VERIFY( m_arrPartBmp[INT(__ESBSPT_PRESSED)][INT(__ESBMHT_THUMB)].FromBitmap( _bmpGlyphStack, rc3 ) );
  3100. if( nAngleCw90 != 0 )
  3101. {
  3102. for( i = 0; i < INT(__ESBSPT_PART_COUNT); i++ )
  3103. {
  3104. CExtBitmap & _bmp1 = m_arrPartBmp[i][__ESBMHT_THUMB];
  3105. if( _bmp1.IsEmpty() )
  3106. continue;
  3107. CExtBitmap _bmp2;
  3108. VERIFY( _bmp2.CreateRotated9xStack( _bmp1, nAngleCw90, 1, _bmp1.GetSize().cx, _bmp1.GetSize().cy, false, false ) );
  3109. _bmp1 = _bmp2;
  3110. }
  3111. }
  3112. }
  3114. void CExtPaintManager::SCROLLBARSKINDATA::Load2007_R1(
  3115. UINT nResourceID_BumpyGlyphStack,
  3116. INT nBumpyGlyphStackItemHeight,
  3117. UINT nResourceID_GripperStack,
  3118. const RECT & rcBumpyGlyphStackItemPadding,
  3119. COLORREF clrSolidBackground,
  3120. COLORREF clrPressedPageAreas,
  3121. UINT nResourceID_ArrowUp_Normal,
  3122. UINT nResourceID_ArrowUp_Disabled,
  3123. UINT nResourceID_ArrowDown_Normal,
  3124. UINT nResourceID_ArrowDown_Disabled,
  3125. bool bRotateArrowsAndBk270,
  3126. UINT nResourceID_BkEntire,
  3127. UINT nResourceID_BkPage,
  3128. const RECT & rcEntirePaddingR,
  3129. const RECT & rcEntirePaddingC
  3130. )
  3131. {
  3132. Empty();
  3133. INT i, j;
  3134. for( i = 0; i < INT(__ESBSPT_PART_COUNT); i++ )
  3135. {
  3136. for( j = 0; j < INT(__ESBMHT_PART_COUNT); j++ )
  3137. {
  3138. CRect & rcPadding = m_arrPartPadding[i][j];
  3139. rcPadding.SetRect( 0, 0, 0, 0 );
  3140. CExtBitmap & _bmp = m_arrPartBmp[i][j];
  3141. _bmp.Empty();
  3142. m_arrClrSolidBackground[i][j] = clrSolidBackground;
  3143. if( ( j == INT(__ESBMHT_PAGE_UP) || j == INT(__ESBMHT_PAGE_DOWN) )
  3144. && i == INT(__ESBSPT_PRESSED)
  3145. )
  3146. m_arrClrSolidBackground[i][j] = clrPressedPageAreas;
  3147. }
  3148. }
  3149. CExtBitmap _bmpBumpyGlyphStack, _bmpGripperStack;
  3150. VERIFY( _bmpBumpyGlyphStack.LoadBMP_Resource( MAKEINTRESOURCE(nResourceID_BumpyGlyphStack) ) );
  3151. VERIFY( _bmpGripperStack.LoadBMP_Resource( MAKEINTRESOURCE(nResourceID_GripperStack) ) );
  3152. _bmpBumpyGlyphStack.PreMultipliedRGBChannelsSet( true );
  3153. _bmpGripperStack.PreMultipliedRGBChannelsSet( true );
  3154. CSize _sizeBumpyGlyph = _bmpBumpyGlyphStack.GetSize();
  3155. CSize _sizeGripper = _bmpGripperStack.GetSize();
  3156. CRect rcBumpyGlyph( 0, 0, _sizeBumpyGlyph.cx, nBumpyGlyphStackItemHeight );
  3157. CRect rcGripper( 0, 0, _sizeGripper.cx, _sizeGripper.cy );
  3158. // cold parts
  3159. rcBumpyGlyph.OffsetRect( 0, nBumpyGlyphStackItemHeight );
  3160. VERIFY(
  3161. m_arrPartBmp[INT(__ESBSPT_COLD)][INT(__ESBMHT_THUMB)].
  3162. FromBitmap( _bmpBumpyGlyphStack, rcBumpyGlyph )
  3163. );
  3164. m_arrPartPadding[INT(__ESBSPT_COLD)][INT(__ESBMHT_THUMB)] = rcBumpyGlyphStackItemPadding;
  3165. VERIFY(
  3166. m_arrPartBmp[INT(__ESBSPT_COLD)][INT(__ESBMHT_GLYPH_THUMB_GRIPPER)].
  3167. FromBitmap( _bmpGripperStack, rcGripper )
  3168. );
  3169. // normal parts
  3170. VERIFY(
  3171. m_arrPartBmp[INT(__ESBSPT_NORMAL)][INT(__ESBMHT_BUTTON_UP)].
  3172. FromBitmap( _bmpBumpyGlyphStack, rcBumpyGlyph )
  3173. );
  3174. m_arrPartPadding[INT(__ESBSPT_NORMAL)][INT(__ESBMHT_BUTTON_UP)] = rcBumpyGlyphStackItemPadding;
  3175. VERIFY(
  3176. m_arrPartBmp[INT(__ESBSPT_NORMAL)][INT(__ESBMHT_BUTTON_DOWN)].
  3177. FromBitmap( _bmpBumpyGlyphStack, rcBumpyGlyph )
  3178. );
  3179. m_arrPartPadding[INT(__ESBSPT_NORMAL)][INT(__ESBMHT_BUTTON_DOWN)] = rcBumpyGlyphStackItemPadding;
  3180. // hot parts
  3181. rcBumpyGlyph.OffsetRect( 0, nBumpyGlyphStackItemHeight );
  3182. //rcGripper.OffsetRect( 0, nGripperStackItemHeight );
  3183. VERIFY(
  3184. m_arrPartBmp[INT(__ESBSPT_HOT)][INT(__ESBMHT_BUTTON_UP)].
  3185. FromBitmap( _bmpBumpyGlyphStack, rcBumpyGlyph )
  3186. );
  3187. m_arrPartPadding[INT(__ESBSPT_HOT)][INT(__ESBMHT_BUTTON_UP)] = rcBumpyGlyphStackItemPadding;
  3188. VERIFY(
  3189. m_arrPartBmp[INT(__ESBSPT_HOT)][INT(__ESBMHT_BUTTON_DOWN)].
  3190. FromBitmap( _bmpBumpyGlyphStack, rcBumpyGlyph )
  3191. );
  3192. m_arrPartPadding[INT(__ESBSPT_HOT)][INT(__ESBMHT_BUTTON_DOWN)] = rcBumpyGlyphStackItemPadding;
  3193. VERIFY(
  3194. m_arrPartBmp[INT(__ESBSPT_HOT)][INT(__ESBMHT_THUMB)].
  3195. FromBitmap( _bmpBumpyGlyphStack, rcBumpyGlyph )
  3196. );
  3197. m_arrPartPadding[INT(__ESBSPT_HOT)][INT(__ESBMHT_THUMB)] = rcBumpyGlyphStackItemPadding;
  3198. VERIFY(
  3199. m_arrPartBmp[INT(__ESBSPT_HOT)][INT(__ESBMHT_GLYPH_THUMB_GRIPPER)].
  3200. FromBitmap( _bmpGripperStack, rcGripper )
  3201. );
  3202. // pressed parts
  3203. rcBumpyGlyph.OffsetRect( 0, nBumpyGlyphStackItemHeight );
  3204. //rcGripper.OffsetRect( 0, nGripperStackItemHeight );
  3205. VERIFY(
  3206. m_arrPartBmp[INT(__ESBSPT_PRESSED)][INT(__ESBMHT_BUTTON_UP)].
  3207. FromBitmap( _bmpBumpyGlyphStack, rcBumpyGlyph )
  3208. );
  3209. m_arrPartPadding[INT(__ESBSPT_PRESSED)][INT(__ESBMHT_BUTTON_UP)] = rcBumpyGlyphStackItemPadding;
  3210. VERIFY(
  3211. m_arrPartBmp[INT(__ESBSPT_PRESSED)][INT(__ESBMHT_BUTTON_DOWN)].
  3212. FromBitmap( _bmpBumpyGlyphStack, rcBumpyGlyph )
  3213. );
  3214. m_arrPartPadding[INT(__ESBSPT_PRESSED)][INT(__ESBMHT_BUTTON_DOWN)] = rcBumpyGlyphStackItemPadding;
  3215. VERIFY(
  3216. m_arrPartBmp[INT(__ESBSPT_PRESSED)][INT(__ESBMHT_THUMB)].
  3217. FromBitmap( _bmpBumpyGlyphStack, rcBumpyGlyph )
  3218. );
  3219. m_arrPartPadding[INT(__ESBSPT_PRESSED)][INT(__ESBMHT_THUMB)] = rcBumpyGlyphStackItemPadding;
  3220. VERIFY(
  3221. m_arrPartBmp[INT(__ESBSPT_PRESSED)][INT(__ESBMHT_GLYPH_THUMB_GRIPPER)].
  3222. FromBitmap( _bmpGripperStack, rcGripper )
  3223. );
  3224. // arrows
  3225. CExtBitmap _bmpArrowUpNormal, _bmpArrowUpDisabled, _bmpArrowDownNormal, _bmpArrowDownDisabled;
  3226. VERIFY( _bmpArrowUpNormal.LoadBMP_Resource( MAKEINTRESOURCE(nResourceID_ArrowUp_Normal) ) );
  3227. VERIFY( _bmpArrowUpDisabled.LoadBMP_Resource( MAKEINTRESOURCE(nResourceID_ArrowUp_Disabled) ) );
  3228. VERIFY( _bmpArrowDownNormal.LoadBMP_Resource( MAKEINTRESOURCE(nResourceID_ArrowDown_Normal) ) );
  3229. VERIFY( _bmpArrowDownDisabled.LoadBMP_Resource( MAKEINTRESOURCE(nResourceID_ArrowDown_Disabled) ) );
  3230. //  _bmpArrowUpNormal.PreMultipliedRGBChannelsSet( true );
  3231. //  _bmpArrowUpDisabled.PreMultipliedRGBChannelsSet( true );
  3232. //  _bmpArrowDownNormal.PreMultipliedRGBChannelsSet( true );
  3233. //  _bmpArrowDownDisabled.PreMultipliedRGBChannelsSet( true );
  3234. CSize _sizeArrowUpNormal = _bmpArrowUpNormal.GetSize();
  3235. CSize _sizeArrowUpDisabled = _bmpArrowUpDisabled.GetSize();
  3236. CSize _sizeArrowDownNormal = _bmpArrowDownNormal.GetSize();
  3237. CSize _sizeArrowDownDisabled = _bmpArrowDownDisabled.GetSize();
  3238. VERIFY(
  3239. m_arrPartBmp[INT(__ESBSPT_COLD)][INT(__ESBMHT_GLYPH_ARROW_UP)].
  3240. CreateRotated9xStack(
  3241. _bmpArrowUpNormal,
  3242. bRotateArrowsAndBk270 ? 270 : 0,
  3243. 1,
  3244. _sizeArrowUpNormal.cx,
  3245. _sizeArrowUpNormal.cy,
  3246. false,
  3247. false
  3248. )
  3249. );
  3250. VERIFY(
  3251. m_arrPartBmp[INT(__ESBSPT_DISABLED)][INT(__ESBMHT_GLYPH_ARROW_UP)].
  3252. CreateRotated9xStack(
  3253. _bmpArrowUpDisabled,
  3254. bRotateArrowsAndBk270 ? 270 : 0,
  3255. 1,
  3256. _sizeArrowUpDisabled.cx,
  3257. _sizeArrowUpDisabled.cy,
  3258. false,
  3259. false
  3260. )
  3261. );
  3262. VERIFY(
  3263. m_arrPartBmp[INT(__ESBSPT_COLD)][INT(__ESBMHT_GLYPH_ARROW_DOWN)].
  3264. CreateRotated9xStack(
  3265. _bmpArrowDownNormal,
  3266. bRotateArrowsAndBk270 ? 270 : 0,
  3267. 1,
  3268. _sizeArrowDownNormal.cx,
  3269. _sizeArrowDownNormal.cy,
  3270. false,
  3271. false
  3272. )
  3273. );
  3274. VERIFY(
  3275. m_arrPartBmp[INT(__ESBSPT_DISABLED)][INT(__ESBMHT_GLYPH_ARROW_DOWN)].
  3276. CreateRotated9xStack(
  3277. _bmpArrowDownDisabled,
  3278. bRotateArrowsAndBk270 ? 270 : 0,
  3279. 1,
  3280. _sizeArrowDownDisabled.cx,
  3281. _sizeArrowDownDisabled.cy,
  3282. false,
  3283. false
  3284. )
  3285. );
  3286. // backgrounds
  3287. CExtBitmap _bmpBkEntire, _bmpBkPage;
  3288. VERIFY( _bmpBkEntire.LoadBMP_Resource( MAKEINTRESOURCE(nResourceID_BkEntire) ) );
  3289. VERIFY( _bmpBkPage.LoadBMP_Resource( MAKEINTRESOURCE(nResourceID_BkPage) ) );
  3290. _bmpBkEntire.PreMultipliedRGBChannelsSet( true );
  3291. _bmpBkPage.PreMultipliedRGBChannelsSet( true );
  3292. CSize _sizeBkEntire = _bmpBkEntire.GetSize();
  3293. CSize _sizeBkPage = _bmpBkPage.GetSize();
  3294. VERIFY(
  3295. m_bmpEntireArea.
  3296. CreateRotated9xStack(
  3297. _bmpBkEntire,
  3298. bRotateArrowsAndBk270 ? 270 : 0,
  3299. 1,
  3300. _sizeBkEntire.cx,
  3301. _sizeBkEntire.cy,
  3302. false,
  3303. false
  3304. )
  3305. );
  3306. VERIFY(
  3307. m_arrPartBmp[INT(__ESBSPT_PRESSED)][INT(__ESBMHT_PAGE_DOWN)].
  3308. CreateRotated9xStack(
  3309. _bmpBkPage,
  3310. bRotateArrowsAndBk270 ? 270 : 0,
  3311. 1,
  3312. _sizeBkPage.cx,
  3313. _sizeBkPage.cy,
  3314. false,
  3315. false
  3316. )
  3317. );
  3318. VERIFY(
  3319. m_arrPartBmp[INT(__ESBSPT_PRESSED)][INT(__ESBMHT_PAGE_UP)].AssignFromOther(
  3320. m_arrPartBmp[INT(__ESBSPT_PRESSED)][INT(__ESBMHT_PAGE_DOWN)]
  3321. )
  3322. );
  3323. m_rcEntirePaddingR = rcEntirePaddingR;
  3324. m_rcEntirePaddingC = rcEntirePaddingC;
  3325. }
  3327. CExtPaintManager::PAINTSCROLLBARDATA::PAINTSCROLLBARDATA()
  3328. : m_bHorzBar( false )
  3329. , m_bEnabled( false )
  3330. , m_bHoveredAreaIsPressed( false )
  3331. , m_bHelperLightAccent( true )
  3332. , m_eSBMHT( CExtPaintManager::__ESBMHT_NOWHERE )
  3333. , m_rcBar( 0, 0, 0, 0 )
  3334. , m_rcButtonUp( 0, 0, 0, 0 )
  3335. , m_rcButtonDown( 0, 0, 0, 0 )
  3336. , m_rcThumb( 0, 0, 0, 0 )
  3337. , m_rcPageUp( 0, 0, 0, 0 )
  3338. , m_rcPageDown( 0, 0, 0, 0 )
  3339. , m_pHelperSrc( NULL )
  3340. , m_lParam( 0L )
  3341. , m_rcScrollableArea( 0, 0, 0, 0 )
  3342. {
  3343. m_DSI.cbSize = sizeof(SCROLLINFO);
  3344. ::memset( &m_DSI, 0, sizeof(SCROLLINFO) );
  3345. }
  3347. CExtPaintManager::PAINTSCROLLBARDATA::PAINTSCROLLBARDATA(
  3348. bool bHorzBar,
  3349. bool bEnabled,
  3350. bool bHoveredAreaIsPressed,
  3351. CExtPaintManager::e_scroll_bar_mouse_hover_type_t eSBMHT,
  3352. const RECT & rcBar,
  3353. const RECT & rcButtonUp,
  3354. const RECT & rcButtonDown,
  3355. const RECT & rcThumb,
  3356. const RECT & rcPageUp,
  3357. const RECT & rcPageDown,
  3358. CObject * pHelperSrc, // = NULL
  3359. LPARAM lParam // = 0L
  3360. )
  3361. : m_bHorzBar( bHorzBar )
  3362. , m_bEnabled( bEnabled )
  3363. , m_bHoveredAreaIsPressed( bHoveredAreaIsPressed )
  3364. , m_bHelperLightAccent( true )
  3365. , m_eSBMHT( eSBMHT )
  3366. , m_rcBar( rcBar )
  3367. , m_rcButtonUp( rcButtonUp )
  3368. , m_rcButtonDown( rcButtonDown )
  3369. , m_rcThumb( rcThumb )
  3370. , m_rcPageUp( rcPageUp )
  3371. , m_rcPageDown( rcPageDown )
  3372. , m_pHelperSrc( pHelperSrc )
  3373. , m_lParam( lParam )
  3374. {
  3375. if( m_bHorzBar )
  3376. m_rcScrollableArea.SetRect(
  3377. m_rcButtonUp.right,
  3378. m_rcButtonUp.top,
  3379. m_rcButtonDown.left,
  3380. m_rcButtonDown.bottom
  3381. );
  3382. else
  3383. m_rcScrollableArea.SetRect(
  3384. m_rcButtonUp.left,
  3385. m_rcButtonUp.bottom,
  3386. m_rcButtonDown.right,
  3387. m_rcButtonDown.top
  3388. );
  3389. m_DSI.cbSize = sizeof(SCROLLINFO);
  3390. ::memset( &m_DSI, 0, sizeof(SCROLLINFO) );
  3391. }
  3393. CExtPaintManager::PAINTSCROLLBARDATA::PAINTSCROLLBARDATA(
  3394. CExtScrollBar * pExtScrollBar,
  3395. bool bHoveredAreaIsPressed, // false
  3396. CExtPaintManager::e_scroll_bar_mouse_hover_type_t eSBMHT, // = CExtPaintManager::__ESBMHT_NOWHERE
  3397. LPARAM lParam // = 0L
  3398. )
  3399. : m_bHorzBar( false )
  3400. , m_bEnabled( false )
  3401. , m_bHoveredAreaIsPressed( bHoveredAreaIsPressed )
  3402. , m_bHelperLightAccent( true )
  3403. , m_eSBMHT( eSBMHT )
  3404. , m_rcBar( 0, 0, 0, 0 )
  3405. , m_rcButtonUp( 0, 0, 0, 0 )
  3406. , m_rcButtonDown( 0, 0, 0, 0 )
  3407. , m_rcThumb( 0, 0, 0, 0 )
  3408. , m_rcPageUp( 0, 0, 0, 0 )
  3409. , m_rcPageDown( 0, 0, 0, 0 )
  3410. , m_pHelperSrc( pExtScrollBar )
  3411. , m_lParam( lParam )
  3412. {
  3413. m_DSI.cbSize = sizeof(SCROLLINFO);
  3414. ::memset( &m_DSI, 0, sizeof(SCROLLINFO) );
  3415. if( pExtScrollBar == NULL )
  3416. return;
  3417. ASSERT_VALID( pExtScrollBar );
  3418. CExtScrollBar::eScrollerOrientation_t _eSO = pExtScrollBar->GetScrollerOrientation();
  3419. if( _eSO != CExtScrollBar::__ESO_TOP
  3420. && _eSO != CExtScrollBar::__ESO_BOTTOM
  3421. && _eSO != CExtScrollBar::__ESO_LEFT
  3422. && _eSO != CExtScrollBar::__ESO_RIGHT
  3423. )
  3424. return;
  3425. m_bHorzBar =
  3426. ( _eSO == CExtScrollBar::__ESO_TOP
  3427. || _eSO == CExtScrollBar::__ESO_BOTTOM
  3428. )
  3429. ? true : false;
  3430. pExtScrollBar->GetClientRect( &m_rcBar );
  3431. SCROLLINFO _scroll_info;
  3432. ::memset( &_scroll_info, 0, sizeof(SCROLLINFO) );
  3433. if( pExtScrollBar->IsWindowEnabled() )
  3434. {
  3435. m_bEnabled = true;
  3436. _scroll_info.cbSize = sizeof(SCROLLINFO);
  3437. if( ! pExtScrollBar->GetScrollInfo(
  3438. &_scroll_info,
  3439. SIF_ALL
  3440. )
  3441. )
  3442. {
  3443. pExtScrollBar->GetScrollRange(
  3444. &_scroll_info.nMin,
  3445. &_scroll_info.nMax
  3446. );
  3447. _scroll_info.nPage = 0;
  3448. _scroll_info.nTrackPos
  3449. = _scroll_info.nPos
  3450. = pExtScrollBar->GetScrollPos();
  3451. }
  3452. // if( pExtScrollBar->m_nHelperTrackPos != -1 )
  3453. // _scroll_info.nTrackPos = pExtScrollBar->m_nHelperTrackPos;
  3454. __EXT_MFC_MEMCPY( 
  3455. &m_DSI,
  3456. sizeof(SCROLLINFO),
  3457. &_scroll_info, 
  3458. sizeof(SCROLLINFO) 
  3459. );
  3460. _scroll_info.nTrackPos -= _scroll_info.nMin;
  3461. _scroll_info.nPos -= _scroll_info.nMin;
  3462. _scroll_info.nMax -= _scroll_info.nMin;
  3463. _scroll_info.nMin = 0;
  3464. } // if( pExtScrollBar->IsWindowEnabled() )
  3465. else
  3466. __EXT_MFC_MEMCPY( 
  3467. &m_DSI,
  3468. sizeof(SCROLLINFO),
  3469. &_scroll_info, 
  3470. sizeof(SCROLLINFO) 
  3471. );
  3472. if( _scroll_info.nMin < _scroll_info.nMax
  3473. && _scroll_info.nMax < (INT_MAX-1)
  3474. && _scroll_info.nPage > 0
  3475. && _scroll_info.nPage == UINT( _scroll_info.nMax - _scroll_info.nMin )
  3476. )
  3477. {
  3478. // layout issue
  3479. _scroll_info.nMax ++;
  3480. if( _scroll_info.nPos > 0 )
  3481. _scroll_info.nPos ++;
  3482. if( _scroll_info.nTrackPos > 0 )
  3483. _scroll_info.nTrackPos ++;
  3484. }
  3485. INT nScrollLimit = 0, nExtentMD = 0, nExtentThumb = 0, nExtentBtn = 0, nExtentThumbMin = 4;
  3486. nScrollLimit =
  3487.   _scroll_info.nMax
  3488. - _scroll_info.nMin
  3489. - _scroll_info.nPage
  3490. + 1
  3491. ;
  3492. ASSERT( nScrollLimit >= 0 );
  3493. INT nScrollTotalRange = _scroll_info.nMax;
  3494. if( pExtScrollBar->IsKindOf( RUNTIME_CLASS(CExtZoomScrollBar) ) )
  3495. {
  3496. CExtPaintManager::SCROLLBARSKINDATA * _pSBSD =
  3497. pExtScrollBar->PmBridge_GetPM()->
  3498. ScrollBar_GetSkinData(
  3499. m_bHorzBar, pExtScrollBar, lParam, false );
  3500. if( _pSBSD != NULL )
  3501. {
  3502. CExtBitmap & _bmpSkinnedButtonUp =
  3503. _pSBSD->m_arrPartBmp[INT(__ESBSPT_NORMAL)][INT(__ESBMHT_BUTTON_UP)];
  3504. ASSERT( ! _bmpSkinnedButtonUp.IsEmpty() );
  3505. CExtBitmap & _bmpSkinnedButtonThumb =
  3506. _pSBSD->m_arrPartBmp[INT(__ESBSPT_NORMAL)][INT(__ESBMHT_THUMB)];
  3507. ASSERT( ! _bmpSkinnedButtonUp.IsEmpty() );
  3508. CExtPaintManager * pPM = pExtScrollBar->PmBridge_GetPM();
  3509. ASSERT_VALID( pPM );
  3510. if( m_bHorzBar )
  3511. {
  3512. nExtentBtn   = _bmpSkinnedButtonUp.GetSize().cx;
  3513. nExtentThumb = nExtentThumbMin = _bmpSkinnedButtonThumb.GetSize().cx;
  3514. nExtentBtn   = pPM->UiScalingDo( nExtentBtn, CExtPaintManager::__EUIST_X );
  3515. nExtentThumb = pPM->UiScalingDo( nExtentThumb, CExtPaintManager::__EUIST_X );
  3516. }
  3517. else
  3518. {
  3519. nExtentBtn = _bmpSkinnedButtonUp.GetSize().cy;
  3520. nExtentThumb = nExtentThumbMin = _bmpSkinnedButtonThumb.GetSize().cy;
  3521. nExtentBtn   = pPM->UiScalingDo( nExtentBtn, CExtPaintManager::__EUIST_Y );
  3522. nExtentThumb = pPM->UiScalingDo( nExtentThumb, CExtPaintManager::__EUIST_Y );
  3523. }
  3524. } // if( _pSBSD != NULL )
  3525. else
  3526. {
  3527. if( m_bHorzBar )
  3528. {
  3529. nExtentBtn = pExtScrollBar->m_nHorzButtonWidth;
  3530. nExtentThumb = nExtentThumbMin = pExtScrollBar->m_nHorzThumbMinWidth;
  3531. }
  3532. else
  3533. {
  3534. nExtentBtn = pExtScrollBar->m_nVertButtonHeight;
  3535. nExtentThumb = nExtentThumbMin = pExtScrollBar->m_nVertThumbMinHeight;
  3536. }
  3537. } // else from if( _pSBSD != NULL )
  3538. } // if( pExtScrollBar->IsKindOf( RUNTIME_CLASS(CExtZoomScrollBar) ) )
  3539. else
  3540. {
  3541. if( m_bHorzBar )
  3542. {
  3543. nExtentBtn = pExtScrollBar->m_nHorzButtonWidth;
  3544. nExtentThumbMin = pExtScrollBar->m_nHorzThumbMinWidth;
  3545. }
  3546. else
  3547. {
  3548. nExtentBtn = pExtScrollBar->m_nVertButtonHeight;
  3549. nExtentThumbMin = pExtScrollBar->m_nVertThumbMinHeight;
  3550. }
  3551. if( nScrollLimit > 0L )
  3552. {
  3553. if( _scroll_info.nPage == 0 )
  3554. {
  3555. nExtentThumb = nExtentBtn;
  3556. if( nExtentThumb == 0 )
  3557. nExtentThumb = 6;
  3558. } // if( _scroll_info.nPage == 0 )
  3559. else
  3560. {
  3561. if( nScrollTotalRange > INT(_scroll_info.nPage) )
  3562. {
  3563. nExtentMD = nScrollTotalRange/_scroll_info.nPage;
  3564. } // if( nScrollTotalRange > _scroll_info.nPage )
  3565. } // else from if( _scroll_info.nPage == 0 )
  3566. } // if( nScrollLimit > 0L )
  3567. } // else from if( pExtScrollBar->IsKindOf( RUNTIME_CLASS(CExtZoomScrollBar) ) )
  3568. if( ! m_bEnabled )
  3569. nExtentThumb = nExtentThumbMin = 0;
  3570. CRect rcScrollable = m_rcBar;
  3571. m_rcButtonUp = m_rcBar;
  3572. m_rcButtonDown = m_rcBar;
  3573. if( m_bHorzBar )
  3574. {
  3575. rcScrollable.DeflateRect( nExtentBtn, 0 );
  3576. m_rcButtonUp.right = m_rcButtonUp.left + nExtentBtn;
  3577. m_rcButtonDown.left = m_rcButtonDown.right - nExtentBtn;
  3578. if( rcScrollable.Width() > 5 )
  3579. {
  3580. if( nExtentThumb == 0 && nExtentMD != 0L )
  3581. nExtentThumb =
  3582. ::MulDiv( rcScrollable.Width(), _scroll_info.nPage, nScrollTotalRange );
  3583. if( m_bEnabled && /*nExtentThumb != 0 &&*/ nExtentThumb < nExtentThumbMin )
  3584. nExtentThumb = nExtentThumbMin;
  3585. if( nExtentThumb != 0 )
  3586. {
  3587. m_rcThumb = rcScrollable;
  3588. m_rcThumb.right = m_rcThumb.left + nExtentThumb;
  3589. if( nScrollLimit > 0 )
  3590. {
  3591. INT nRestSpace = rcScrollable.Width() - m_rcThumb.Width();
  3592. if( nRestSpace < 0 )
  3593. nRestSpace = 0;
  3594. INT nOffset = ::MulDiv( nRestSpace, _scroll_info.nTrackPos, nScrollLimit );
  3595. m_rcThumb.OffsetRect( nOffset, 0 );
  3596. if( _scroll_info.nTrackPos > 0 )
  3597. {
  3598. m_rcPageUp = rcScrollable;
  3599. m_rcPageUp.right = m_rcThumb.left;
  3600. }
  3601. if( _scroll_info.nTrackPos < nScrollLimit )
  3602. {
  3603. m_rcPageDown = rcScrollable;
  3604. m_rcPageDown.left = m_rcThumb.right;
  3605. }
  3606. } // if( nScrollLimit > 0 )
  3607. } // if( nExtentThumb != 0 )
  3608. } // if( rcScrollable.Width() > 5 )
  3609. if( (! m_rcButtonUp.IsRectEmpty() )
  3610. && (! m_rcButtonDown.IsRectEmpty() )
  3611. && m_rcButtonUp.right > m_rcButtonDown.left
  3612. )
  3613. {
  3614. m_rcButtonUp.right
  3615. = m_rcButtonDown.left
  3616. = m_rcButtonUp.left
  3617. + ( m_rcButtonDown.right - m_rcButtonUp.left ) / 2;
  3618. m_rcPageUp.SetRect( 0, 0, 0, 0 );
  3619. m_rcPageDown.SetRect( 0, 0, 0, 0 );
  3620. m_rcThumb.SetRect( 0, 0, 0, 0 );
  3621. }
  3622. } // if( m_bHorzBar )
  3623. else
  3624. {
  3625. rcScrollable.DeflateRect( 0, nExtentBtn );
  3626. m_rcButtonUp.bottom = m_rcButtonUp.top + nExtentBtn;
  3627. m_rcButtonDown.top = m_rcButtonDown.bottom - nExtentBtn;
  3628. if( rcScrollable.Height() > 5 )
  3629. {
  3630. if( nExtentThumb == 0 && nExtentMD != 0L )
  3631. nExtentThumb =
  3632. ::MulDiv( rcScrollable.Height(), _scroll_info.nPage, nScrollTotalRange );
  3633. if( m_bEnabled && /*nExtentThumb != 0 &&*/ nExtentThumb < nExtentThumbMin )
  3634. nExtentThumb = nExtentThumbMin;
  3635. if( nExtentThumb != 0 )
  3636. {
  3637. m_rcThumb = rcScrollable;
  3638. m_rcThumb.bottom = m_rcThumb.top + nExtentThumb;
  3639. if( nScrollLimit > 0 )
  3640. {
  3641. INT nRestSpace = rcScrollable.Height() - m_rcThumb.Height();
  3642. if( nRestSpace < 0 )
  3643. nRestSpace = 0;
  3644. INT nOffset = ::MulDiv( nRestSpace, _scroll_info.nTrackPos, nScrollLimit );
  3645. m_rcThumb.OffsetRect( 0, nOffset );
  3646. if( _scroll_info.nTrackPos > 0 )
  3647. {
  3648. m_rcPageUp = rcScrollable;
  3649. m_rcPageUp.bottom = m_rcThumb.top;
  3650. }
  3651. if( _scroll_info.nTrackPos < nScrollLimit )
  3652. {
  3653. m_rcPageDown = rcScrollable;
  3654. m_rcPageDown.top = m_rcThumb.bottom;
  3655. }
  3656. } // if( nScrollLimit > 0 )
  3657. } // if( nExtentThumb != 0 )
  3658. } // if( rcScrollable.Height() > 5 )
  3659. if( (! m_rcButtonUp.IsRectEmpty() )
  3660. && (! m_rcButtonDown.IsRectEmpty() )
  3661. && m_rcButtonUp.bottom > m_rcButtonDown.top
  3662. )
  3663. {
  3664. m_rcButtonUp.bottom
  3665. = m_rcButtonDown.top
  3666. = m_rcButtonUp.top
  3667. + ( m_rcButtonDown.bottom - m_rcButtonUp.top ) / 2;
  3668. m_rcPageUp.SetRect( 0, 0, 0, 0 );
  3669. m_rcPageDown.SetRect( 0, 0, 0, 0 );
  3670. m_rcThumb.SetRect( 0, 0, 0, 0 );
  3671. }
  3672. } // else from if( m_bHorzBar )
  3674. if( m_bHorzBar )
  3675. m_rcScrollableArea.SetRect(
  3676. m_rcButtonUp.right,
  3677. m_rcButtonUp.top,
  3678. m_rcButtonDown.left,
  3679. m_rcButtonDown.bottom
  3680. );
  3681. else
  3682. m_rcScrollableArea.SetRect(
  3683. m_rcButtonUp.left,
  3684. m_rcButtonUp.bottom,
  3685. m_rcButtonDown.right,
  3686. m_rcButtonDown.top
  3687. );
  3688. }
  3690. CExtPaintManager::PAINTSCROLLBARDATA::~PAINTSCROLLBARDATA()
  3691. {
  3692. }
  3694. COLORREF CExtPaintManager::stat_PaintShadedEllipse_ComputeColorValue(
  3695. double lfA,
  3696. COLORREF clrShadeAccentLight,
  3697. COLORREF clrShadeAccentDark
  3698. )
  3699. {
  3700. double lfD = - 2.356 - lfA;
  3701. if( lfD < ( - 3.1415926535897932384626433832795 ) )
  3702. lfD = 6.293 + lfD;
  3703. else if( lfD > 3.1415926535897932384626433832795 )
  3704. lfD = 6.293 - lfD;
  3705. double lfW = ( ::cos( lfD ) + 1.0 ) *  0.5;
  3706. return
  3707. RGB(
  3708. BYTE( lfW * GetRValue( clrShadeAccentLight ) + ( 1.0 - lfW ) * GetRValue( clrShadeAccentDark ) ),
  3709. BYTE( lfW * GetGValue( clrShadeAccentLight ) + ( 1.0 - lfW ) * GetGValue( clrShadeAccentDark ) ),
  3710. BYTE( lfW * GetBValue( clrShadeAccentLight ) + ( 1.0 - lfW ) * GetBValue( clrShadeAccentDark ) )
  3711. );
  3712. }
  3714. void CExtPaintManager::stat_PaintShadedEllipse(
  3715. HDC hDC,
  3716. const POINT & ptEllipseCenter,
  3717. LONG nRadiusH,
  3718. LONG nRadiusV,
  3719. COLORREF clrShadeAccentLight,
  3720. COLORREF clrShadeAccentDark
  3721. )
  3722. {
  3723. ASSERT(
  3724. hDC != NULL
  3725. && ( ptEllipseCenter.x + nRadiusH <= LONG_MAX )
  3726. && ( ptEllipseCenter.y + nRadiusV <= LONG_MAX )
  3727. && ( ptEllipseCenter.x - nRadiusH  >= LONG_MIN )
  3728. && ( ptEllipseCenter.y - nRadiusV  >= LONG_MIN )
  3729. );
  3730. LONG nX = nRadiusH, nY = 0, nBoxSquare = nRadiusH * nRadiusH;
  3731. LONG nTemp0 = 8 * nRadiusH * nRadiusV * nRadiusV; 
  3732. LONG nTemp1 = 0;
  3733. LONG nTemp2 = 4 * nBoxSquare - nRadiusH * 4 * nRadiusV * nRadiusV + nRadiusV * nRadiusV; 
  3734. LONG nTemp3 = nBoxSquare - nTemp0 + 4 * nRadiusV * nRadiusV;
  3735. for( ; nTemp3 < 0; )
  3736. {
  3737. double lfA = double( ::atan2( double(nY), double(nX) ) );
  3738. COLORREF clr = stat_PaintShadedEllipse_ComputeColorValue( lfA, clrShadeAccentLight, clrShadeAccentDark );
  3739. ::SetPixelV( hDC, ptEllipseCenter.x + nX, ptEllipseCenter.y + nY, clr );
  3740. clr = stat_PaintShadedEllipse_ComputeColorValue( 3.1415926535897932384626433832795 - lfA, clrShadeAccentLight, clrShadeAccentDark );
  3741. ::SetPixelV( hDC, ptEllipseCenter.x - nX, ptEllipseCenter.y + nY, clr );
  3742. clr = stat_PaintShadedEllipse_ComputeColorValue( -3.1415926535897932384626433832795 + lfA, clrShadeAccentLight, clrShadeAccentDark );
  3743. ::SetPixelV( hDC, ptEllipseCenter.x - nX, ptEllipseCenter.y - nY, clr );
  3744. clr = stat_PaintShadedEllipse_ComputeColorValue( -lfA, clrShadeAccentLight, clrShadeAccentDark );
  3745. ::SetPixelV( hDC, ptEllipseCenter.x + nX, ptEllipseCenter.y - nY, clr );
  3746. nY ++; 
  3747. nTemp1 = nTemp1 + 8 * nBoxSquare; 
  3748. if( nTemp2 < 0 )
  3749. {
  3750. nTemp2 = nTemp2 + nTemp1 + 4 * nBoxSquare;
  3751. nTemp3 = nTemp3 + nTemp1;
  3752. }
  3753. else 
  3754. {
  3755. nX --;
  3756. nTemp0 = nTemp0 - 8 * nRadiusV * nRadiusV;
  3757. nTemp2 = nTemp2 - nTemp0 + nTemp1 + 4 * nBoxSquare;
  3758. nTemp3 = nTemp3 - nTemp0 + nTemp1 + 4 * nRadiusV * nRadiusV; 
  3759. } 
  3760. }  // for( ; nTemp3 < 0; )
  3761. for( ; true; )
  3762. {
  3763. double lfA = double( ::atan2( double(nY), double(nX) ) );
  3764. COLORREF clr = stat_PaintShadedEllipse_ComputeColorValue( lfA, clrShadeAccentLight, clrShadeAccentDark );
  3765. ::SetPixelV( hDC, ptEllipseCenter.x + nX, ptEllipseCenter.y + nY, clr );
  3766. clr = stat_PaintShadedEllipse_ComputeColorValue( 3.1415926535897932384626433832795 - lfA, clrShadeAccentLight, clrShadeAccentDark );
  3767. ::SetPixelV( hDC, ptEllipseCenter.x - nX, ptEllipseCenter.y + nY, clr );
  3768. clr = stat_PaintShadedEllipse_ComputeColorValue( -3.1415926535897932384626433832795 + lfA, clrShadeAccentLight, clrShadeAccentDark );
  3769. ::SetPixelV( hDC, ptEllipseCenter.x - nX, ptEllipseCenter.y - nY, clr );
  3770. clr = stat_PaintShadedEllipse_ComputeColorValue( -lfA, clrShadeAccentLight, clrShadeAccentDark );
  3771. ::SetPixelV( hDC, ptEllipseCenter.x + nX, ptEllipseCenter.y - nY, clr );
  3772. nX --;
  3773. nTemp0 = nTemp0 - 8 * nRadiusV * nRadiusV; 
  3774. if( nTemp3 < 0 ) 
  3775. { 
  3776. nY ++;
  3777. nTemp1 = nTemp1 + 8 * nBoxSquare;
  3778. nTemp3 = nTemp3 - nTemp0 + 4 * nRadiusV * nRadiusV + nTemp1; 
  3779. }
  3780. else 
  3781. nTemp3 = nTemp3 - nTemp0 + 4 * nRadiusV * nRadiusV; 
  3782. if( nX < 0 )
  3783. break;
  3784. } // for( ; true; )
  3785. } 
  3787. void CExtPaintManager::PAINTSCROLLBARDATA::PaintDefault(
  3788. CDC & dc,
  3789. CExtPaintManager * pPM
  3790. )
  3791. {
  3792. ASSERT( dc.GetSafeHdc() != NULL );
  3793. ASSERT_VALID( pPM );
  3794. if( m_rcBar.IsRectEmpty()
  3795. || (! dc.RectVisible( &m_rcBar ) )
  3796. )
  3797. return;
  3798. CExtPaintManager::SCROLLBARSKINDATA * pSBSD =
  3799. pPM->ScrollBar_GetSkinData(
  3800. m_bHorzBar,
  3801. m_pHelperSrc,
  3802. m_lParam,
  3803. m_bHelperLightAccent
  3804. );
  3805. if( pSBSD != NULL )
  3806. {
  3807. PaintSkinned(
  3808. dc,
  3809. pPM,
  3810. *pSBSD
  3811. );
  3812. return;
  3813. } // if( pSBSD != NULL )
  3814. if( m_pHelperSrc != NULL )
  3815. {
  3816. ASSERT_VALID( m_pHelperSrc );
  3817. if( m_pHelperSrc->IsKindOf( RUNTIME_CLASS(CExtZoomScrollBar) ) )
  3818. {
  3819. bool bTransparent = false;
  3820. #if (!defined __EXT_MFC_NO_STATUSBAR)
  3821. CExtStatusControlBar * pWndParent = DYNAMIC_DOWNCAST( CExtStatusControlBar, (((CExtZoomScrollBar*)m_pHelperSrc)->GetParent()) );
  3822. if( pWndParent != NULL )
  3823. {
  3824. CExtPaintManager * pPM = ((CExtZoomScrollBar*)m_pHelperSrc)->PmBridge_GetPM();
  3825. ASSERT_VALID( pPM );
  3826. CRect rcPaint, _rcClient;
  3827. pWndParent->GetWindowRect( &rcPaint );
  3828. ((CExtZoomScrollBar*)m_pHelperSrc)->ScreenToClient( &rcPaint );
  3829. ((CExtZoomScrollBar*)m_pHelperSrc)->GetClientRect( &_rcClient );
  3830. ((CExtZoomScrollBar*)m_pHelperSrc)->ClientToScreen( &_rcClient );
  3831. pWndParent->ScreenToClient( &_rcClient );
  3832. if( pWndParent->m_bCompleteRepaint )
  3833. {
  3834. dc.OffsetViewportOrg(   _rcClient.left, 0 );
  3835. bool bRet = pPM->StatusBar_EraseBackground( dc, rcPaint, pWndParent );
  3836. dc.OffsetViewportOrg( - _rcClient.left, 0 );
  3837. if( ! bRet )
  3838. {
  3839. bool bTransparent = false;
  3840. if( pPM->GetCb2DbTransparentMode(pWndParent) )
  3841. {
  3842. if( pPM->PaintDockerBkgnd( true, dc, ((CExtZoomScrollBar*)m_pHelperSrc) ) )
  3843. bTransparent = true;
  3844. }
  3845. if( ! bTransparent )
  3846. dc.FillSolidRect( 
  3847. &rcPaint, 
  3848. pPM->GetColor( CExtPaintManager::CLR_3DFACE_OUT, pWndParent ) 
  3849. );
  3850. }
  3851. INT nIndex = pWndParent->CommandToIndex( ((CExtZoomScrollBar*)m_pHelperSrc)->GetDlgCtrlID() );
  3852. if( nIndex >= 0 )
  3853. {
  3854. dc.OffsetViewportOrg( _rcClient.left, 0 );
  3855. pPM->StatusBar_ErasePaneBackground( dc, nIndex, rcPaint, pWndParent );
  3856. dc.OffsetViewportOrg( -_rcClient.left, 0 );
  3857. bTransparent = true;
  3858. }
  3859. } // if( pWndParent->m_bCompleteRepaint )
  3860. } // if( pWndParent != NULL )
  3861. #endif // (!defined __EXT_MFC_NO_STATUSBAR)
  3862. if( ! bTransparent )
  3863. {
  3864. if( (! bTransparent )
  3865. && pPM->GetCb2DbTransparentMode( m_pHelperSrc )
  3866. )
  3867. {
  3868. CExtPaintManager::stat_ExcludeChildAreas(
  3869. dc,
  3870. ((CExtZoomScrollBar*)m_pHelperSrc)->GetSafeHwnd(),
  3871. CExtPaintManager::stat_DefExcludeChildAreaCallback
  3872. );
  3873. if( pPM->PaintDockerBkgnd( true, dc, ((CExtZoomScrollBar*)m_pHelperSrc) ) )
  3874. bTransparent = true;
  3875. }
  3876. if( ! bTransparent )
  3877. dc.FillSolidRect(
  3878. &m_rcBar,
  3879. pPM->GetColor( CExtPaintManager::CLR_3DFACE_OUT, ((CExtZoomScrollBar*)m_pHelperSrc) ) 
  3880. );
  3881. } // if( ! bTransparent )
  3882. CRect rcLineH( m_rcScrollableArea );
  3883. CRect rcLineV( m_rcScrollableArea );
  3884. if( m_bHorzBar )
  3885. {
  3886. rcLineH.bottom = rcLineH.top + 1;
  3887. rcLineH.OffsetRect( 0, m_rcScrollableArea.Height() / 2 + 1 );
  3888. rcLineV.right = rcLineV.left + 1;
  3889. rcLineV.OffsetRect( m_rcScrollableArea.Width() / 2, 0 );
  3890. rcLineV.bottom = rcLineV.top + 7;
  3891. rcLineV.OffsetRect( 0, (m_rcScrollableArea.Height() - 7 ) / 2 + 2 );
  3892. }
  3893. else
  3894. {
  3895. rcLineH.right = rcLineH.left + 1;
  3896. rcLineH.OffsetRect( m_rcScrollableArea.Width() / 2 + 1, 0 );
  3897. rcLineV.right = rcLineV.left + 7;
  3898. rcLineV.OffsetRect( (m_rcScrollableArea.Width() - 7 ) / 2 + 1 , 0 );
  3899. rcLineV.bottom = rcLineV.top + 1;
  3900. rcLineV.OffsetRect( 0, m_rcScrollableArea.Height() / 2 );
  3901. }
  3902. COLORREF clrZsLineLight = pPM->GetColor( COLOR_3DHIGHLIGHT );
  3903. COLORREF clrZsLineDark =  pPM->GetColor( COLOR_3DSHADOW );
  3904. rcLineH.OffsetRect( 
  3905. m_bHorzBar ? 0 : -1, 
  3906. m_bHorzBar ? -1 : 0
  3907. );
  3908. rcLineV.OffsetRect(
  3909. m_bHorzBar ? -2 : 0,
  3910. m_bHorzBar ? -2 : -1
  3911. );
  3912. if( m_bHorzBar )
  3913. rcLineV.OffsetRect( 2, 0 );
  3914. else
  3915. rcLineV.OffsetRect( 0, 2 );
  3916. if( clrZsLineDark !=  COLORREF(-1L) )
  3917. {
  3918. dc.FillSolidRect( &rcLineH, clrZsLineDark );
  3919. dc.FillSolidRect( &rcLineV, clrZsLineDark );
  3920. } // if( clrZsLineDark !=  COLORREF(-1L) )
  3921. if( clrZsLineLight !=  COLORREF(-1L) )
  3922. {
  3923. rcLineH.OffsetRect( 1, 1 );
  3924. rcLineV.OffsetRect( 1, 1 );
  3925. dc.FillSolidRect( &rcLineH, clrZsLineLight );
  3926. dc.FillSolidRect( &rcLineV, clrZsLineLight );
  3927. } // if( clrZsLineLight !=  COLORREF(-1L) )
  3928. COLORREF clrButtonBk = pPM->GetColor( COLOR_3DFACE, m_pHelperSrc, m_lParam );
  3929. CBrush _brushBkDefault( clrButtonBk );
  3930. HGDIOBJ hOldPen = ::SelectObject( dc.m_hDC, ::GetStockObject( NULL_PEN ) );
  3931. CRect arrRcButtons[] = { m_rcButtonDown, m_rcButtonUp, m_rcThumb };
  3932. INT nButtonIndex, nButtonCount = INT( sizeof(arrRcButtons)/sizeof(arrRcButtons[0]) );
  3933. for( nButtonIndex = 0; nButtonIndex < nButtonCount; nButtonIndex ++ )
  3934. {
  3935. CRect rcButton = arrRcButtons[ nButtonIndex ];
  3936. INT nMetric = min( rcButton.Width(), rcButton.Height() );
  3937. nMetric &= ~1;
  3938. rcButton.left += ( rcButton.Width() - nMetric ) / 2;
  3939. rcButton.right = rcButton.left + nMetric;
  3940. rcButton.top += ( rcButton.Height() - nMetric ) / 2;
  3941. rcButton.bottom = rcButton.top + nMetric;
  3942. bool bHover = false;
  3943. bool bPressed = false;
  3944. if( m_bEnabled )
  3945. {
  3946. switch( nButtonIndex )
  3947. {
  3948. case 0:
  3949. if( m_eSBMHT == __ESBMHT_BUTTON_DOWN )
  3950. bHover = true;
  3951. break;
  3952. case 1:
  3953. if( m_eSBMHT == __ESBMHT_BUTTON_UP )
  3954. bHover = true;
  3955. break;
  3956. case 2:
  3957. if( m_eSBMHT == __ESBMHT_THUMB )
  3958. bHover = true;
  3959. break;
  3960. } // switch( nButtonIndex )
  3961. if( bHover )
  3962. bPressed = m_bHoveredAreaIsPressed;
  3963. } // if( m_bEnabled )
  3964. COLORREF clrButtonText = pPM->GetColor( m_bEnabled ? COLOR_BTNTEXT : CLR_TEXT_DISABLED, m_pHelperSrc, m_lParam );
  3965. COLORREF clrButtonShadeOuterTL = pPM->GetColor( COLOR_3DHIGHLIGHT, m_pHelperSrc, m_lParam );
  3966. COLORREF clrButtonShadeOuterRB = pPM->GetColor( COLOR_3DDKSHADOW, m_pHelperSrc, m_lParam );
  3967. COLORREF clrButtonShadeInnerTL = clrButtonShadeOuterTL;
  3968. COLORREF clrButtonShadeInnerRB = pPM->GetColor( COLOR_3DSHADOW, m_pHelperSrc, m_lParam );
  3969. if( bPressed )
  3970. {
  3971. COLORREF clrTmp;
  3972. //clrTmp = clrButtonShadeOuterTL;
  3973. //clrButtonShadeOuterTL = clrButtonShadeOuterRB;
  3974. //clrButtonShadeOuterRB = clrTmp;
  3975. clrTmp = clrButtonShadeInnerTL;
  3976. clrButtonShadeInnerTL = clrButtonShadeInnerRB;
  3977. clrButtonShadeInnerRB = clrTmp;
  3978. } // if( bPressed )
  3979. CBrush * pOldBrush =
  3980. dc.SelectObject(
  3981. ( m_bEnabled && ( bPressed || bHover ) )
  3982. ? ( bPressed ? (&(pPM->m_brushDarkerDefault)) : (&(pPM->m_brushLighterDefault)) )
  3983. : (&_brushBkDefault)
  3984. );
  3985. if( nButtonIndex == 2 )
  3986. rcButton.InflateRect( 0, 0, 1, 1 );
  3987. dc.Ellipse( &rcButton );
  3988. dc.SelectObject( pOldBrush );
  3989. if( nButtonIndex == 2 )
  3990. rcButton.DeflateRect( 0, 0, 1, 1 );
  3991. CPoint ptCenter = rcButton.CenterPoint();
  3992. INT nHalfMetricToDraw = nMetric/2;
  3993. stat_PaintShadedEllipse(
  3994. dc.m_hDC,
  3995. ptCenter,
  3996. nHalfMetricToDraw,
  3997. nHalfMetricToDraw,
  3998. clrButtonShadeOuterTL,
  3999. clrButtonShadeOuterRB
  4000. );
  4001. nHalfMetricToDraw --;
  4002. stat_PaintShadedEllipse(
  4003. dc.m_hDC,
  4004. ptCenter,
  4005. nHalfMetricToDraw,
  4006. nHalfMetricToDraw,
  4007. clrButtonShadeInnerTL,
  4008. clrButtonShadeInnerRB
  4009. );
  4010. nHalfMetricToDraw /= 2;
  4011. if( nHalfMetricToDraw > 0 )
  4012. {
  4013. switch( nButtonIndex )
  4014. {
  4015. case 0:
  4016. dc.FillSolidRect(
  4017. ptCenter.x,
  4018. ptCenter.y - nHalfMetricToDraw,
  4019. 1,
  4020. nHalfMetricToDraw * 2 + 1,
  4021. clrButtonText
  4022. );
  4023. case 1: // continuing case 0
  4024. dc.FillSolidRect(
  4025. ptCenter.x - nHalfMetricToDraw,
  4026. ptCenter.y,
  4027. nHalfMetricToDraw * 2 + 1,
  4028. 1,
  4029. clrButtonText
  4030. );
  4031. break;
  4032. } // switch( nButtonIndex )
  4033. } // if( nHalfMetricToDraw > 0 )
  4034. } // for( nButtonIndex = 0; nButtonIndex < nButtonCount; nButtonIndex ++ )
  4035. ::SelectObject( dc.m_hDC, hOldPen );
  4036. return;
  4037. } // if( m_pHelperSrc->IsKindOf( RUNTIME_CLASS(CExtZoomScrollBar) ) )
  4038. } // if( m_pHelperSrc != NULL )
  4039. dc.FillRect(
  4040. &m_rcBar,
  4041. &pPM->m_brushLightSystem
  4042. );
  4043. //m_bEnabled = false;
  4044. //m_eSBMHT = __ESBMHT_BUTTON_UP;
  4045. //m_eSBMHT = __ESBMHT_PAGE_DOWN;
  4046. //m_eSBMHT = __ESBMHT_THUMB;
  4047. //m_bHoveredAreaIsPressed = true;
  4048. if( g_PaintManager.m_UxTheme.IsControlsThemed() )
  4049. {
  4050. HWND hWnd = NULL;
  4051. if( m_pHelperSrc != NULL )
  4052. {
  4053. CWnd * pWnd = DYNAMIC_DOWNCAST( CWnd, m_pHelperSrc );
  4054. hWnd = pWnd->GetSafeHwnd();