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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 对话框与窗口 > 查看源码
XTPSkinManagerSchema.cpp
资源名称：Xtreme.ToolkitPro.v12.0.0.rar　[点击查看]
上传用户：szled88
上传日期：2015-04-09
资源大小：43957k
文件大小：47k
源码类别：

对话框与窗口

开发平台：

Visual C++

XTPSkinManagerSchema.cpp：源码内容
  1. // XTPSkinManagerSchema.cpp: implementation of the CXTPSkinManagerSchema class.
  2. //
  3. // This file is a part of the XTREME SKINFRAMEWORK MFC class library.
  4. // (c)1998-2008 Codejock Software, All Rights Reserved.
  5. //
  6. // THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE
  7. // RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN
  8. // CONSENT OF CODEJOCK SOFTWARE.
  9. //
  10. // THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED
  11. // IN THE XTREME TOOLKIT PRO LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO
  12. // YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A
  13. // SINGLE COMPUTER.
  14. //
  15. // CONTACT INFORMATION:
  16. // support@codejock.com
  17. // http://www.codejock.com
  18. //
  19. /////////////////////////////////////////////////////////////////////////////
  21. #include "stdafx.h"
  23. #include "Common/Tmschema.h"
  24. #include "Common/XTPVC50Helpers.h"
  25. #include "Common/XTPVC80Helpers.h"
  26. #include "Common/XTPDrawHelpers.h"
  28. #include "XTPSkinManagerSchema.h"
  29. #include "XTPSkinManagerResource.h"
  30. #include "XTPSkinManager.h"
  31. #include "XTPSkinImage.h"
  32. #include "XTPSkinObjectFrame.h"
  33. #include "XTPSkinDrawTools.h"
  35. #ifdef _DEBUG
  36. #undef THIS_FILE
  37. static char THIS_FILE[]=__FILE__;
  38. #define new DEBUG_NEW
  39. #endif
  41. #ifndef OIC_WINLOGO
  42. #define OIC_WINLOGO         32517
  43. #endif
  45. #ifndef LAYOUT_BITMAPORIENTATIONPRESERVED
  46. #define LAYOUT_BITMAPORIENTATIONPRESERVED 0x00000008
  47. #endif
  49. void InflateBorders(CRect& rcBorders, int cxFrame, int cyFrame)
  50. {
  51. rcBorders.left += cxFrame;
  52. rcBorders.right +=  cxFrame;
  54. rcBorders.top += cyFrame;
  55. rcBorders.bottom +=  cyFrame;
  56. }
  59. CXTPSkinManagerSchemaProperty::CXTPSkinManagerSchemaProperty()
  60. {
  61. propType = XTP_SKINPROPERTY_UNKNOWN;
  62. nPropertyCode = 0;
  63. ZeroMemory(&rcVal, sizeof(RECT));
  64. }
  66. CXTPSkinManagerSchemaProperty::~CXTPSkinManagerSchemaProperty()
  67. {
  68. ClearProperty();
  69. }
  71. void CXTPSkinManagerSchemaProperty::ClearProperty()
  72. {
  73. if (propType == XTP_SKINPROPERTY_STRING)
  74. delete[] lpszVal;
  76. if (propType == XTP_SKINPROPERTY_FONT)
  77. delete lfVal;
  79. propType = XTP_SKINPROPERTY_UNKNOWN;
  80. }
  82. void CXTPSkinManagerSchemaProperty::SetPropertyColor(LPCTSTR lpszValue)
  83. {
  84. ClearProperty();
  85. int r = 0, g = 0, b = 0;
  86. SCANF_S(lpszValue, _T("%i %i %i"), &r, &g, &b);
  87. clrVal = RGB(r, g, b);
  88. }
  90. void CXTPSkinManagerSchemaProperty::SetPropertyString(LPCTSTR lpszValue)
  91. {
  92. ClearProperty();
  94. int nLen = (int)_tcslen(lpszValue);
  95. lpszVal = new TCHAR[nLen + 1];
  96. STRCPY_S(lpszVal, nLen + 1, lpszValue);
  98. propType = XTP_SKINPROPERTY_STRING;
  99. }
  101. void CXTPSkinManagerSchemaProperty::SetPropertyBool(LPCTSTR lpszValue)
  102. {
  103. ClearProperty();
  104. bVal = _tcsicmp(lpszValue, _T("TRUE")) == 0;
  105. }
  107. void CXTPSkinManagerSchemaProperty::SetPropertyInt(LPCTSTR lpszValue)
  108. {
  109. ClearProperty();
  110. iVal = _ttoi(lpszValue);
  111. }
  113. void CXTPSkinManagerSchemaProperty::SetPropertyEnum(int nEnumValue)
  114. {
  115. ClearProperty();
  116. iVal = nEnumValue;
  117. }
  120. void CXTPSkinManagerSchemaProperty::SetPropertySize(LPCTSTR lpszValue)
  121. {
  122. ClearProperty();
  123. SCANF_S(lpszValue, _T("%i,%i"), &szVal.cx, &szVal.cy);
  124. }
  126. void CXTPSkinManagerSchemaProperty::SetPropertyRect(LPCTSTR lpszValue)
  127. {
  128. ClearProperty();
  129. SCANF_S(lpszValue, _T("%ld,%ld,%ld,%ld"), &rcVal.left, &rcVal.right, &rcVal.top, &rcVal.bottom);
  130. }
  132. void CXTPSkinManagerSchemaProperty::SetPropertyFont(LPCTSTR lpszValue)
  133. {
  134. ClearProperty();
  135. lfVal = new LOGFONT;
  136. ZeroMemory(lfVal, sizeof(LOGFONT));
  138. CWindowDC dc (NULL);
  139. lfVal->lfCharSet = (BYTE)::GetTextCharsetInfo (dc, NULL, 0);
  141. TCHAR chBold[50];
  142. chBold[0] = 0;
  143. SCANF_S(lpszValue, _T("%[^,], %ld, %s"), SCANF_PARAM_S(lfVal->lfFaceName, LF_FACESIZE), &lfVal->lfHeight, SCANF_PARAM_S(chBold, 50));
  144. lfVal->lfWeight = _tcsicmp(chBold, _T("BOLD")) != 0?  FW_NORMAL: FW_BOLD;
  146. int ppi = dc.GetDeviceCaps(LOGPIXELSY);
  148. lfVal->lfHeight = - MulDiv(lfVal->lfHeight, ppi, 72);
  149. }
  151. BOOL CXTPSkinManagerSchemaProperty::operator==(const CXTPSkinManagerSchemaProperty& prop) const
  152. {
  153. if (&prop == this)
  154. return TRUE;
  156. if (prop.propType != propType)
  157. return FALSE;
  159. switch (propType)
  160. {
  161. case XTP_SKINPROPERTY_COLOR:    return clrVal == prop.clrVal;
  162. case XTP_SKINPROPERTY_STRING:   return _tcsicmp(lpszVal, prop.lpszVal) == 0;
  163. case XTP_SKINPROPERTY_BOOL:     return bVal == prop.bVal;
  164. case XTP_SKINPROPERTY_RECT:     return ::EqualRect(&prop.rcVal, &rcVal);
  165. case XTP_SKINPROPERTY_INT:      return iVal == prop.iVal;
  166. case XTP_SKINPROPERTY_POSITION: return (szVal.cx == prop.szVal.cx) && (szVal.cy == prop.szVal.cy);
  167. case XTP_SKINPROPERTY_ENUM:     return iVal == prop.iVal;
  168. case XTP_SKINPROPERTY_FONT:     return memcmp(lfVal, prop.lfVal, sizeof(LOGFONT)) == 0;
  169. }
  171. return FALSE;
  172. }
  175. //////////////////////////////////////////////////////////////////////
  176. // Construction/Destruction
  177. //////////////////////////////////////////////////////////////////////
  179. CXTPSkinManagerSchema::CXTPSkinManagerSchema(CXTPSkinManager* pManager)
  180. : m_pManager(pManager)
  181. {
  182. m_bPreMultiplyImages = TRUE;
  184. m_nGlobalClassId = GetClassCode(_T("GLOBALS"));
  185. m_nWindowClassId = GetClassCode(_T("WINDOW"));
  187. m_mapProperties.InitHashTable(199, FALSE);
  188. }
  190. CXTPSkinManagerSchema::~CXTPSkinManagerSchema()
  191. {
  192. RemoveAllProperties();
  193. }
  195. void CXTPSkinManagerSchema::RemoveAllProperties()
  196. {
  197. POSITION pos = m_mapProperties.GetStartPosition();
  198. UINT nProperty;
  199. CXTPSkinManagerSchemaProperty* pProperty;
  200. while (pos != NULL)
  201. {
  202. m_mapProperties.GetNextAssoc( pos, nProperty, pProperty);
  203. delete pProperty;
  204. }
  205. m_mapProperties.RemoveAll();
  207. }
  210. UINT CXTPSkinManagerSchema::GetClassCode(LPCTSTR lpszClass)
  211. {
  212. if (_tcsicmp(_T("Globals"), lpszClass) == 0) return 1;
  213. if (_tcsicmp(_T("Documentation"), lpszClass) == 0) return 2;
  214. if (_tcsicmp(_T("SysMetrics"), lpszClass) == 0) return 3;
  215. if (_tcsicmp(_T("ListBox"), lpszClass) == 0) return 4;
  216. if (_tcsicmp(_T("Dialog"), lpszClass) == 0) return 5;
  218. if (_tcsicmp(_T("Menu"), lpszClass) == 0) return 0;
  221. UINT nClass = 5;
  223. #include "XTPSkinManagerSchema.inc"
  224. #undef BEGIN_TM_CLASS_PARTS
  225. #define BEGIN_TM_CLASS_PARTS(name)            nClass++; if (_tcsicmp(_T(#name), lpszClass) == 0) return nClass;
  226. #include "Common/Tmschema.h"
  228. TRACE(_T("Warning: %s class not supported"), lpszClass);
  229. return 0; // Not supported
  230. }
  232. int CXTPSkinManagerSchema::GetEnumCode(LPCTSTR lpszProperty, LPCTSTR lpszValue)
  233. {
  234. #include "XTPSkinManagerSchema.inc"
  235. #undef BEGIN_TM_ENUM
  236. #undef TM_ENUM
  237. #undef END_TM_ENUM
  238. #define BEGIN_TM_ENUM(name)            if (_tcsicmp(_T(#name), lpszProperty) == 0) {
  239. #define TM_ENUM(val, prefix, name)     if (_tcsicmp(_T(#name), lpszValue) == 0) return val;
  240. #define END_TM_ENUM()                      }
  241. #include "Common/Tmschema.h"
  243. return -1;
  244. }
  246. UINT CXTPSkinManagerSchema::GetClassPartCode(LPCTSTR lpszClass, LPCTSTR lpszClassPart)
  247. {
  248. #include "XTPSkinManagerSchema.inc"
  249. #undef BEGIN_TM_CLASS_PARTS
  250. #undef TM_PART
  251. #undef END_TM_CLASS_PARTS
  252. #define BEGIN_TM_CLASS_PARTS(name)          if (_tcsicmp(_T(#name), lpszClass) == 0) {
  253. #define TM_PART(val, prefix, name)          if (_tcsicmp(_T(#name), lpszClassPart) == 0) return val;
  254. #define END_TM_CLASS_PARTS()                }
  255. #include "Common/Tmschema.h"
  257. return 0;
  258. }
  260. UINT CXTPSkinManagerSchema::GetStateCode(LPCTSTR lpszClassPart, LPCTSTR lpszState)
  261. {
  262. #include "XTPSkinManagerSchema.inc"
  263. #undef BEGIN_TM_PART_STATES
  264. #undef TM_STATE
  265. #undef END_TM_PART_STATES
  266. #define BEGIN_TM_PART_STATES(name)          if (_tcsicmp(_T(#name), lpszClassPart) == 0) {
  267. #define TM_STATE(val, prefix, name)         if (_tcsicmp(_T(#name), lpszState) == 0) return val;
  268. #define END_TM_PART_STATES()                }
  269. #include "Common/Tmschema.h"
  271. return 0;
  272. }
  274. UINT CXTPSkinManagerSchema::GetPropertyCode(LPCTSTR lpszProperty, XTPSkinManagerProperty& nPropertyType)
  275. {
  277. #include "XTPSkinManagerSchema.inc"
  278. #undef TM_PROP
  279. #define TM_PROP(val, prefix, name, primval)   if (_tcsicmp(_T(#name), lpszProperty) == 0) { nPropertyType = XTP_SKINPROPERTY_##primval; return val; }
  280. #include "Common/Tmschema.h"
  282. return 0;
  283. }
  285. UINT CXTPSkinManagerSchema::CalculatePropertyCode(UINT iClassId, int iPartId, int iStateId, int iPropId)
  286. {
  287. return iPropId + ((iClassId + ((iPartId + (iStateId << 6 )) << 6)) << 14);
  288. }
  290. UINT CXTPSkinManagerSchema::GetSchemaPartCode(CString strSchemaPart)
  291. {
  292. if (strSchemaPart.Find(_T(':')) != -1)
  293. return 0; // Not Supported;
  295. REMOVE_S(strSchemaPart, _T(' '));
  297. CString strClass, strClassPart, strState;
  299. int nStateIndex = strSchemaPart.Find(_T('('));
  300. if (nStateIndex != -1)
  301. {
  302. strState = strSchemaPart.Mid(nStateIndex + 1, strSchemaPart.GetLength() - nStateIndex - 2);
  303. strSchemaPart = strSchemaPart.Left(nStateIndex);
  304. }
  307. int nClassPartIndex = strSchemaPart.Find(_T('.'));
  308. if (nClassPartIndex != -1)
  309. {
  310. strClass = strSchemaPart.Left(nClassPartIndex);
  311. strClassPart = strSchemaPart.Mid(nClassPartIndex + 1);
  312. }
  313. else
  314. {
  315. strClass = strSchemaPart;
  316. }
  318. int nClassPartCode = 0;
  319. if (!strClassPart.IsEmpty())
  320. {
  321. nClassPartCode = GetClassPartCode(strClass, strClassPart);
  322. if (nClassPartCode == 0)
  323. {
  324. ASSERT(FALSE);
  325. return 0;
  326. }
  327. }
  329. int nStateCode = 0;
  330. if (!strState.IsEmpty())
  331. {
  332. nStateCode = GetStateCode(strClassPart.IsEmpty()? strClass: strClassPart, strState);
  333. if (nStateCode == 0)
  334. {
  335. ASSERT(FALSE);
  336. return 0;
  337. }
  338. }
  340. int nClassCode = GetClassCode(strClass);
  341. if (nClassCode == 0)
  342. return 0;
  344. return CalculatePropertyCode(nClassCode, nClassPartCode, nStateCode, 0);
  345. }
  347. CXTPSkinManagerSchemaProperty* CXTPSkinManagerSchema::CreateProperty(LPCTSTR lpszProperty, XTPSkinManagerProperty nPropertyType, LPCTSTR lpszValue)
  348. {
  349. CXTPSkinManagerSchemaProperty* pProperty = new CXTPSkinManagerSchemaProperty();
  351. switch (nPropertyType)
  352. {
  353. case XTP_SKINPROPERTY_COLOR:    pProperty->SetPropertyColor(lpszValue); break;
  354. case XTP_SKINPROPERTY_STRING:   pProperty->SetPropertyString(lpszValue); break;
  355. case XTP_SKINPROPERTY_BOOL:     pProperty->SetPropertyBool(lpszValue); break;
  356. case XTP_SKINPROPERTY_RECT:     pProperty->SetPropertyRect(lpszValue); break;
  357. case XTP_SKINPROPERTY_INT:      pProperty->SetPropertyInt(lpszValue); break;
  358. case XTP_SKINPROPERTY_POSITION: pProperty->SetPropertySize(lpszValue); break;
  359. case XTP_SKINPROPERTY_ENUM:     pProperty->SetPropertyEnum(GetEnumCode(lpszProperty, lpszValue)); break;
  360. case XTP_SKINPROPERTY_FONT:     pProperty->SetPropertyFont(lpszValue); break;
  362. default:
  363. delete pProperty;
  364. return NULL;
  365. }
  367. pProperty->propType = nPropertyType;
  368. return pProperty;
  369. }
  372. HRESULT CXTPSkinManagerSchema::ReadProperties(CXTPSkinManagerResourceFile* pResourceFile)
  373. {
  374. RemoveAllProperties();
  376. CString str, strSchemaPart;
  378. UINT nSchemaPart = 0;
  380. while (pResourceFile->ReadString(str))
  381. {
  382. str.TrimLeft();
  384. int nCommentIndex = str.Find(_T(';'));
  386. if (nCommentIndex == 0)
  387. continue;
  389. if (nCommentIndex > 0)
  390. {
  391. str = str.Left(nCommentIndex);
  392. }
  394. if (str.IsEmpty())
  395. continue;
  397. str.MakeUpper();
  399. if (str[0] == _T('['))
  400. {
  401. strSchemaPart = str.Mid(1, str.GetLength() - 2);
  402. nSchemaPart = GetSchemaPartCode(strSchemaPart);
  403. }
  404. else if (nSchemaPart)
  405. {
  406. int nPos = str.Find(_T('='));
  407. if (nPos <= 0)
  408. continue;
  410. CString strProperty = str.Left(nPos);
  411. strProperty.TrimRight();
  412. strProperty.MakeUpper();
  414. XTPSkinManagerProperty nPropertyType = XTP_SKINPROPERTY_UNKNOWN;
  415. UINT nPropertyCode = GetPropertyCode(strProperty, nPropertyType);
  417. if (nPropertyCode == 0 || nPropertyType == XTP_SKINPROPERTY_UNKNOWN)
  418. {
  419. continue;
  420. }
  422. CString strValue = str.Mid(nPos + 1);
  423. strValue.TrimLeft();
  424. strValue.TrimRight();
  425. strValue.MakeUpper();
  427. CXTPSkinManagerSchemaProperty* pProperty = 0;
  430. if (m_mapProperties.Lookup(nSchemaPart + nPropertyCode, pProperty))
  431. {
  432. m_mapProperties.RemoveKey(nSchemaPart + nPropertyCode);
  433. delete pProperty;
  434. }
  436. pProperty = CreateProperty(strProperty, nPropertyType, strValue);
  438. if (pProperty == 0)
  439. {
  440. continue;
  441. }
  443. pProperty->nPropertyCode = nPropertyCode;
  445. m_mapProperties.SetAt(nSchemaPart + nPropertyCode, pProperty);
  446. }
  447. }
  449. int nAlpha = 0;
  450. if (SUCCEEDED(GetIntProperty(GetClassCode(_T("DOCUMENTATION")), 0, 0, TMT_ALPHALEVEL, nAlpha)) && nAlpha == 255)
  451. {
  452. m_bPreMultiplyImages = FALSE;
  453. }
  455. return S_OK;
  456. }
  459. CXTPSkinManagerSchemaProperty* CXTPSkinManagerSchema::GetProperty(UINT iClassId, int iPartId, int iStateId, int iPropId)
  460. {
  461. CXTPSkinManagerSchemaProperty* pProperty;
  462. if (iStateId)
  463. {
  464. if (m_mapProperties.Lookup(CalculatePropertyCode(iClassId, iPartId, iStateId, iPropId), pProperty))
  465. return pProperty;
  466. }
  468. if (m_mapProperties.Lookup(CalculatePropertyCode(iClassId, iPartId, 0, iPropId), pProperty))
  469. return pProperty;
  471. if (m_mapProperties.Lookup(CalculatePropertyCode(iClassId, 0, 0, iPropId), pProperty))
  472. return pProperty;
  474. if (m_mapProperties.Lookup(CalculatePropertyCode(m_nGlobalClassId, 0, 0, iPropId), pProperty))
  475. return pProperty;
  477. return NULL;
  478. }
  480. HRESULT CXTPSkinManagerSchema::GetStringProperty(UINT iClassId, int iPartId, int iStateId, int iPropId, CString& str)
  481. {
  482. CXTPSkinManagerSchemaProperty* pProperty = GetProperty(iClassId, iPartId, iStateId, iPropId);
  484. if (!pProperty)
  485. return E_FAIL;
  487. if (pProperty->propType != XTP_SKINPROPERTY_STRING)
  488. return E_INVALIDARG;
  490. str = pProperty->lpszVal;
  492. return S_OK;
  493. }
  495. HRESULT CXTPSkinManagerSchema::GetRectProperty(UINT iClassId, int iPartId, int iStateId, int iPropId, CRect& rc)
  496. {
  497. CXTPSkinManagerSchemaProperty* pProperty = GetProperty(iClassId, iPartId, iStateId, iPropId);
  499. if (!pProperty)
  500. return E_FAIL;
  502. if (pProperty->propType != XTP_SKINPROPERTY_RECT)
  503. return E_INVALIDARG;
  505. rc = pProperty->rcVal;
  507. return S_OK;
  508. }
  511. HRESULT CXTPSkinManagerSchema::GetIntProperty(UINT iClassId, int iPartId, int iStateId, int iPropId, int& iVal)
  512. {
  513. CXTPSkinManagerSchemaProperty* pProperty = GetProperty(iClassId, iPartId, iStateId, iPropId);
  515. if (!pProperty)
  516. return E_FAIL;
  518. if (pProperty->propType != XTP_SKINPROPERTY_INT)
  519. return E_INVALIDARG;
  521. iVal = pProperty->iVal;
  523. return S_OK;
  524. }
  526. HRESULT CXTPSkinManagerSchema::GetBoolProperty(UINT iClassId, int iPartId, int iStateId, int iPropId, BOOL& bVal)
  527. {
  528. CXTPSkinManagerSchemaProperty* pProperty = GetProperty(iClassId, iPartId, iStateId, iPropId);
  530. if (!pProperty)
  531. return E_FAIL;
  533. if (pProperty->propType != XTP_SKINPROPERTY_BOOL)
  534. return E_INVALIDARG;
  536. bVal = pProperty->bVal;
  538. return S_OK;
  539. }
  541. HRESULT CXTPSkinManagerSchema::GetColorProperty(UINT iClassId, int iPartId, int iStateId, int iPropId, COLORREF& clrVal)
  542. {
  543. CXTPSkinManagerSchemaProperty* pProperty = GetProperty(iClassId, iPartId, iStateId, iPropId);
  545. if (!pProperty)
  546. return E_FAIL;
  548. if (pProperty->propType != XTP_SKINPROPERTY_COLOR)
  549. return E_INVALIDARG;
  551. clrVal = pProperty->clrVal;
  552. GetSkinManager()->ApplyColorFilter(clrVal);
  554. return S_OK;
  555. }
  557. HRESULT CXTPSkinManagerSchema::GetEnumProperty(UINT iClassId, int iPartId, int iStateId, int iPropId, int& nVal)
  558. {
  559. CXTPSkinManagerSchemaProperty* pProperty = GetProperty(iClassId, iPartId, iStateId, iPropId);
  561. if (!pProperty)
  562. return E_FAIL;
  564. if (pProperty->propType != XTP_SKINPROPERTY_ENUM)
  565. return E_INVALIDARG;
  567. nVal = pProperty->iVal;
  569. return S_OK;
  570. }
  572. HRESULT CXTPSkinManagerSchema::GetFontProperty(UINT iClassId, int iPartId, int iStateId, int iPropId, LOGFONT& lfVal)
  573. {
  574. CXTPSkinManagerSchemaProperty* pProperty = GetProperty(iClassId, iPartId, iStateId, iPropId);
  576. if (!pProperty)
  577. return E_FAIL;
  579. if (pProperty->propType != XTP_SKINPROPERTY_FONT)
  580. return E_INVALIDARG;
  582. lfVal = *pProperty->lfVal;
  584. return S_OK;
  585. }
  587. HRESULT CXTPSkinManagerSchema::GetSizeProperty(UINT iClassId, int iPartId, int iStateId, int iPropId, CSize& szVal)
  588. {
  589. CXTPSkinManagerSchemaProperty* pProperty = GetProperty(iClassId, iPartId, iStateId, iPropId);
  591. if (!pProperty)
  592. return E_FAIL;
  594. if (pProperty->propType != XTP_SKINPROPERTY_POSITION)
  595. return E_INVALIDARG;
  597. szVal = pProperty->szVal;
  599. return S_OK;
  601. }
  603. //////////////////////////////////////////////////////////////////////////
  604. // CXTPSkinManagerSchemaDefault
  606. CXTPSkinManagerSchemaDefault::CXTPSkinManagerSchemaDefault(CXTPSkinManager* pManager)
  607. : CXTPSkinManagerSchema(pManager)
  608. {
  609. m_strSchemaName = _T("Default");
  610. m_nFrameButtonOffset = 0;
  611. }
  613. CXTPSkinManagerSchemaDefault::~CXTPSkinManagerSchemaDefault()
  614. {
  615. FreeFrameRegions();
  617. }
  619. int CXTPSkinManagerSchema::FindBestImageGlyphSize(CXTPSkinManagerClass* pClass, int iPartId, int iStateId, const CRect& rcDest, int nImageCount, BOOL bHorizontalImageLayout)
  620. {
  621. int nImageFile = TMT_IMAGEFILE5;
  622. CString strImageFile;
  624. while (nImageFile >= TMT_IMAGEFILE1)
  625. {
  626. strImageFile = pClass->GetThemeString(iPartId, iStateId, nImageFile);
  627. if (!strImageFile.IsEmpty())
  628. {
  629. CSize sz = pClass->GetImages()->GetExtent(m_pManager->GetResourceFile(), strImageFile);
  630. if (sz == CSize(0))
  631. return -1;
  633. if (bHorizontalImageLayout) sz.cx /= nImageCount; else sz.cy /= nImageCount;
  635. if ((nImageFile == TMT_IMAGEFILE1) || (rcDest.Height() >= sz.cy && rcDest.Width() >= sz.cx))
  636. return nImageFile;
  637. }
  638. nImageFile--;
  639. }
  641. return nImageFile;
  642. }
  644. BOOL CXTPSkinManagerSchema::DrawThemeBackgroundGlyph(CDC* pDC, CXTPSkinManagerClass* pClass, int iPartId, int iStateId, const RECT *pRect)
  645. {
  646. int nImageFile = TMT_GLYPHIMAGEFILE;
  648. int nImageCount = pClass->GetThemeInt(iPartId, iStateId, TMT_IMAGECOUNT, 1);
  649. if (nImageCount < 1)
  650. nImageCount = 1;
  652. BOOL bHorizontalImageLayout = pClass->GetThemeEnumValue(iPartId, iStateId, TMT_IMAGELAYOUT, IL_HORIZONTAL) == IL_HORIZONTAL;
  654. CRect rcDest(pRect);
  655. CRect rcContentMargins = pClass->GetThemeRect(iPartId, iStateId, TMT_CONTENTMARGINS);
  656. rcDest.DeflateRect(rcContentMargins);
  659. if (pClass->GetThemeEnumValue(iPartId, iStateId, TMT_IMAGESELECTTYPE) == IST_SIZE)
  660. {
  661. nImageFile = FindBestImageGlyphSize(pClass, iPartId, iStateId, rcDest, nImageCount, bHorizontalImageLayout);
  662. if (nImageFile == -1)
  663. return FALSE;
  664. }
  666. CString strImageFile = pClass->GetThemeString(iPartId, iStateId, nImageFile);
  667. if (strImageFile.IsEmpty())
  668. return FALSE;
  670. CXTPSkinImage* pImage = pClass->GetImages()->LoadFile(m_pManager->GetResourceFile(), strImageFile);
  671. if (!pImage)
  672. {
  673. return FALSE;
  674. }
  677. CSize sz(pImage->GetWidth(), pImage->GetHeight());
  678. if (bHorizontalImageLayout) sz.cx /= nImageCount; else sz.cy /= nImageCount;
  680. BOOL bTransparent = pImage->IsAlphaImage()? FALSE: pClass->GetThemeBool(iPartId, iStateId, TMT_GLYPHTRANSPARENT);
  682. CPoint ptTopLeft((rcDest.left + rcDest.right - sz.cx)/2, (rcDest.top + rcDest.bottom - sz.cy)/2);
  683. if (ptTopLeft.y < rcDest.top)
  684. ptTopLeft.y  = rcDest.top;
  686. CRect rcGlyph(ptTopLeft, sz);
  688. CRect rcSrcImage = bHorizontalImageLayout? CRect((iStateId - 1) * sz.cx,  0, iStateId * sz.cx, sz.cy):
  689. CRect(0, (iStateId - 1) * sz.cy, sz.cx, iStateId * sz.cy);
  691. if (nImageCount <= iStateId - 1)
  692. rcSrcImage = CRect(0, 0, sz.cx, sz.cy);
  694. COLORREF clrTransparent = COLORREF_NULL;
  695. if (bTransparent)
  696. {
  697. clrTransparent = pClass->GetThemeColor(iPartId, iStateId, TMT_TRANSPARENTCOLOR, RGB(0xFF, 0, 0xFF));
  698. }
  699. pImage->DrawImage(pDC, rcGlyph, rcSrcImage, CRect(0, 0, 0, 0), clrTransparent, ST_TRUESIZE, FALSE);
  701. return TRUE;
  702. }
  704. BOOL CXTPSkinManagerSchema::DrawThemeBackgroundBorder(CDC* pDC, CXTPSkinManagerClass* pClass, int iPartId, int iStateId, const RECT *pRect)
  705. {
  706. int nBorderSize = pClass->GetThemeInt(iPartId, iStateId, TMT_BORDERSIZE, 1);
  708. COLORREF clrBorderColor = pClass->GetThemeColor(iPartId, iStateId, TMT_BORDERCOLOR);
  709. COLORREF clrFillColor = pClass->GetThemeColor(iPartId, iStateId, TMT_FILLCOLOR);
  710. BOOL bBorderOnly = pClass->GetThemeBool(iPartId, iStateId, TMT_BORDERONLY, FALSE);
  712. CRect rc(pRect);
  714. if ((nBorderSize > 0) && (clrBorderColor != COLORREF_NULL))
  715. {
  716. pDC->FillSolidRect(rc.left, rc.top, rc.Width(), nBorderSize, clrBorderColor);
  717. pDC->FillSolidRect(rc.left, rc.bottom - nBorderSize, rc.Width(), nBorderSize, clrBorderColor);
  719. pDC->FillSolidRect(rc.left, rc.top + nBorderSize, nBorderSize, rc.Height() - nBorderSize * 2, clrBorderColor);
  720. pDC->FillSolidRect(rc.right - nBorderSize, rc.top + nBorderSize, nBorderSize, rc.Height() - nBorderSize * 2, clrBorderColor);
  722. rc.DeflateRect(nBorderSize, nBorderSize);
  723. }
  725. if ((clrFillColor != COLORREF_NULL) && (!bBorderOnly))
  726. {
  727. pDC->FillSolidRect(rc, clrFillColor);
  728. }
  730. return TRUE;
  731. }
  734. BOOL CXTPSkinManagerSchemaDefault::DrawThemeBackground(CDC* pDC, CXTPSkinManagerClass* pClass, int iPartId, int iStateId, const RECT *pRect)
  735. {
  736. int nBackgroundType = pClass->GetThemeEnumValue(iPartId, iStateId, TMT_BGTYPE, BT_IMAGEFILE);
  738. if (nBackgroundType == BT_BORDERFILL)
  739. {
  740. return DrawThemeBackgroundBorder(pDC, pClass, iPartId, iStateId, pRect);
  741. }
  743. if (nBackgroundType != BT_IMAGEFILE)
  744. return TRUE;
  746. int nImageFile = (pClass->GetThemeEnumValue(iPartId, iStateId, TMT_IMAGESELECTTYPE) != IST_NONE) &&
  747. (pClass->GetThemeEnumValue(iPartId, iStateId, TMT_GLYPHTYPE, GT_NONE) == GT_NONE) ?
  748. TMT_IMAGEFILE1: TMT_IMAGEFILE;
  750. CString strImageFile = pClass->GetThemeString(iPartId, iStateId, nImageFile);
  751. if (strImageFile.IsEmpty())
  752. {
  753. if (nImageFile != TMT_IMAGEFILE1)
  754. return FALSE;
  756. strImageFile = pClass->GetThemeString(iPartId, iStateId, TMT_IMAGEFILE);
  757. if (strImageFile.IsEmpty())
  758. return FALSE;
  760. }
  762. CRect rcSizingMargins = pClass->GetThemeRect(iPartId, iStateId, TMT_SIZINGMARGINS);
  764. CXTPSkinImage* pImage = pClass->GetImages()->LoadFile(m_pManager->GetResourceFile(), strImageFile);
  765. if (!pImage)
  766. {
  767. return FALSE;
  768. }
  770. int nImageCount = pClass->GetThemeInt(iPartId, iStateId, TMT_IMAGECOUNT, 1);
  771. if (nImageCount < 1)
  772. nImageCount = 1;
  774. BOOL bHorizontalImageLayout = pClass->GetThemeEnumValue(iPartId, iStateId, TMT_IMAGELAYOUT, IL_HORIZONTAL) == IL_HORIZONTAL;
  776. CSize sz(pImage->GetWidth(), pImage->GetHeight());
  777. if (bHorizontalImageLayout) sz.cx /= nImageCount; else sz.cy /= nImageCount;
  779. BOOL bTransparent = pImage->IsAlphaImage()? FALSE: pClass->GetThemeBool(iPartId, iStateId, TMT_TRANSPARENT);
  781. CRect rcImage(*pRect);
  783. int nSizingType = pClass->GetThemeEnumValue(iPartId, iStateId, TMT_SIZINGTYPE, ST_STRETCH);
  784. if (nSizingType == ST_TRUESIZE)
  785. {
  786. CSize szDest(sz);
  788. if (pClass->GetThemeInt(iPartId, iStateId, TMT_TRUESIZESTRETCHMARK) > 0)
  789. {
  790. if (szDest.cx > rcImage.Width())
  791. {
  792. szDest.cx = rcImage.Width();
  793. }
  795. if (szDest.cy > rcImage.Height())
  796. {
  797. szDest.cy = rcImage.Height();
  798. }
  799. }
  801. CPoint ptTopLeft((rcImage.left + rcImage.right - szDest.cx)/2, (rcImage.top + rcImage.bottom - szDest.cy)/2);
  802. if (ptTopLeft.y < rcImage.top)
  803. ptTopLeft.y = rcImage.top;
  805. if (ptTopLeft.x < rcImage.left)
  806. ptTopLeft.x = rcImage.left;
  808. if (pClass->GetThemeEnumValue(iPartId, iStateId, TMT_VALIGN) == VA_BOTTOM)
  809. rcImage = CRect(CPoint(ptTopLeft.x, rcImage.bottom - szDest.cy), szDest);
  810. else
  811. rcImage = CRect(ptTopLeft, szDest);
  813. rcSizingMargins = CRect(0, 0, 0, 0);
  815. }
  817. CRect rcSrcImage = bHorizontalImageLayout? CRect((iStateId - 1) * sz.cx,  0, iStateId * sz.cx, sz.cy):
  818. CRect(0, (iStateId - 1) * sz.cy, sz.cx, iStateId * sz.cy);
  820. if ((nImageCount <= iStateId - 1) || (iStateId == 0))
  821. rcSrcImage = CRect(0, 0, sz.cx, sz.cy);
  823. COLORREF clrTransparent = COLORREF_NULL;
  824. if (bTransparent)
  825. {
  826. clrTransparent = pClass->GetThemeColor(iPartId, iStateId, TMT_TRANSPARENTCOLOR, RGB(0xFF, 0, 0xFF));
  827. }
  829. BOOL bBorderOnly = pClass->GetThemeBool(iPartId, iStateId, TMT_BORDERONLY);
  831. if (pClass->GetClassCode() == m_nWindowClassId && (iPartId >= WP_FRAMELEFT && iPartId <= WP_SMALLFRAMEBOTTOM))
  832. bBorderOnly = FALSE;
  834. pImage->m_bMirrorImage =  pClass->GetThemeBool(iPartId, iStateId, TMT_MIRRORIMAGE, TRUE);
  836. pImage->CreateSolidRectArray(nImageCount, bHorizontalImageLayout, rcSizingMargins);
  838. pImage->DrawImage(pDC, rcImage, rcSrcImage, rcSizingMargins, clrTransparent, nSizingType, bBorderOnly);
  840. if (pClass->GetThemeEnumValue(iPartId, iStateId, TMT_GLYPHTYPE) == GT_IMAGEGLYPH)
  841. {
  842. DrawThemeBackgroundGlyph(pDC, pClass, iPartId, iStateId, pRect);
  843. }
  845. return TRUE;
  846. }
  848. CSize CXTPSkinManagerSchemaDefault::GetCaptionButtonSize(CXTPSkinManagerClass* pClass, int yButton)
  849. {
  850. int iPartId = WP_CLOSEBUTTON, iStateId = 1;
  852. if (pClass->GetThemeEnumValue(iPartId, iStateId, TMT_BGTYPE) != BT_IMAGEFILE)
  853. return CSize(yButton, yButton);
  855. int nImageFile = (pClass->GetThemeEnumValue(iPartId, iStateId, TMT_IMAGESELECTTYPE) != IST_NONE) &&
  856. (pClass->GetThemeEnumValue(iPartId, iStateId, TMT_GLYPHTYPE, GT_NONE) == GT_NONE) ?
  857. TMT_IMAGEFILE1: TMT_IMAGEFILE;
  859. CString strImageFile = pClass->GetThemeString(iPartId, iStateId, nImageFile);
  860. if (strImageFile.IsEmpty())
  861. {
  862. if (nImageFile != TMT_IMAGEFILE1)
  863. return CSize(yButton, yButton);
  865. strImageFile = pClass->GetThemeString(iPartId, iStateId, TMT_IMAGEFILE);
  866. if (strImageFile.IsEmpty())
  867. return CSize(yButton, yButton);
  869. }
  872. CXTPSkinImage* pImage = pClass->GetImages()->LoadFile(m_pManager->GetResourceFile(), strImageFile);
  873. if (!pImage)
  874. {
  875. return CSize(yButton, yButton);
  876. }
  878. int nImageCount = pClass->GetThemeInt(iPartId, iStateId, TMT_IMAGECOUNT, 1);
  879. if (nImageCount < 1)
  880. nImageCount = 1;
  882. BOOL bHorizontalImageLayout = pClass->GetThemeEnumValue(iPartId, iStateId, TMT_IMAGELAYOUT, IL_HORIZONTAL) == IL_HORIZONTAL;
  884. CSize sz(pImage->GetWidth(), pImage->GetHeight());
  885. if (bHorizontalImageLayout) sz.cx /= nImageCount; else sz.cy /= nImageCount;
  887. int xButton = MulDiv(sz.cx, yButton, sz.cy) + MulDiv(sz.cx - sz.cy, 4, sz.cy);
  889. return CSize(xButton, yButton);
  890. }
  892. int CXTPSkinManagerSchemaDefault::DrawThemeFrameButtons(CDC* pDC, CXTPSkinObjectFrame* pFrame)
  893. {
  894. CXTPWindowRect rc(pFrame);
  895. rc.OffsetRect(-rc.TopLeft());
  897. CRect rcBorders = pFrame->GetBorders();
  898. int nCaptionHeight = rcBorders.top;
  899. LONG lStyle = pFrame->GetStyle();
  900. DWORD dwExStyle = pFrame->GetExStyle();
  902. int cBorders = GetWindowBorders(lStyle, dwExStyle, TRUE, FALSE);
  904. int cxFrame = cBorders * m_pManager->GetMetrics()->m_cxBorder;
  906. int nTop = 0;
  907. if (dwExStyle & WS_EX_WINDOWEDGE)
  908. nTop++;
  909. else if (dwExStyle & WS_EX_STATICEDGE)
  910. nTop++;
  912. if (lStyle & WS_SIZEBOX)
  913. nTop += (1 + m_pManager->GetMetrics()->m_nBorderSize) / 2;
  915. int yButton = nCaptionHeight - 5 - cxFrame + m_nFrameButtonOffset;
  917. if (dwExStyle & WS_EX_CLIENTEDGE)
  918. {
  919. yButton -= 2;
  920. nTop -= 1;
  921. }
  923. CXTPSkinManagerClass* pClass = m_pManager->GetSkinClass(_T("WINDOW"));
  924. CSize szButton = dwExStyle & WS_EX_TOOLWINDOW ? CSize(yButton, yButton) : GetCaptionButtonSize(pClass, yButton);
  926. CRect rcButton = CRect(CPoint(rc.right - szButton.cx - cBorders - 2, nTop + (nCaptionHeight - szButton.cy)/2), szButton);
  928. CXTPSkinObjectFrame::CCaptionButtons* pButtons = pFrame->GetCaptionButtons();
  930. for (int i = 0; i < (int)pButtons->GetSize(); i++)
  931. {
  932. CXTPSkinObjectFrame::CCaptionButton* pButton = pButtons->GetAt(i);
  934. pButton->m_rcButton = rcButton;
  935. pButton->Draw(pDC, pFrame->IsActive());
  937. rcButton.OffsetRect(-rcButton.Width() - 2, 0);
  938. }
  940. return rcButton.right + 2;
  941. }
  943. void CXTPSkinManagerSchema::DrawNonClientRect(CDC* pDC, CRect rcFrame, CXTPSkinObjectFrame* pFrame)
  944. {
  945. DWORD dwExStyle = pFrame->GetExStyle();
  946. DWORD dwStyle = pFrame->GetStyle();
  948. if (dwExStyle & WS_EX_WINDOWEDGE)
  949. {
  950. DrawEdge(pDC->GetSafeHdc(), &rcFrame, EDGE_RAISED, BF_RECT | BF_ADJUST);
  951. }
  952. else if (dwExStyle & WS_EX_STATICEDGE)
  953. {
  954. DrawEdge(pDC->GetSafeHdc(), &rcFrame, BDR_SUNKENOUTER, BF_RECT | BF_ADJUST);
  955. }
  957. if ((dwStyle & WS_CAPTION) || (dwExStyle & WS_EX_DLGMODALFRAME))
  958. {
  959. COLORREF clr = GetColor((dwExStyle & (WS_EX_CLIENTEDGE | WS_EX_DLGMODALFRAME | WS_EX_WINDOWEDGE | WS_EX_STATICEDGE))
  960. || (dwStyle & WS_DLGFRAME) ? COLOR_3DFACE : COLOR_WINDOWFRAME);
  962. pDC->Draw3dRect(rcFrame, clr, clr);
  963. rcFrame.DeflateRect(1, 1);
  964. }
  966. if (dwStyle & WS_SIZEBOX)
  967. {
  968. int nSize = m_pManager->GetMetrics()->m_nBorderSize;
  969. XTPSkinFrameworkDrawFrame(pDC->GetSafeHdc(), rcFrame, nSize, GetColor(COLOR_3DFACE));
  971. rcFrame.DeflateRect(nSize, nSize);
  972. }
  975. if (dwExStyle & WS_EX_CLIENTEDGE)
  976. {
  977. DrawClientEdge(pDC, rcFrame, pFrame);
  978. }
  979. }
  981. void CXTPSkinManagerSchema::DrawClientEdge(CDC* pDC, const CRect& rcFrame, CXTPSkinObjectFrame* pFrame)
  982. {
  983. CRect rc = rcFrame;
  985. CXTPSkinManagerClass* pClass = m_pManager->GetSkinClass(pFrame->GetClassName());
  987. if (pClass->GetThemeEnumValue(0, 0, TMT_BGTYPE) == BT_BORDERFILL)
  988. {
  989. COLORREF clrBorderColor = pClass->GetThemeColor(0, 0, TMT_BORDERCOLOR);
  991. pDC->Draw3dRect(rc, clrBorderColor, clrBorderColor);
  992. rc.DeflateRect(1, 1);
  994. HBRUSH hBrush = pFrame->GetClientBrush(pDC);
  995. XTPSkinFrameworkDrawFrame(pDC->GetSafeHdc(), &rc, 1, hBrush);
  996. }
  997. else
  998. {
  999. pDC->Draw3dRect(rc, m_pManager->GetMetrics()->m_clrEdgeShadow, m_pManager->GetMetrics()->m_clrEdgeHighLight);
  1000. rc.DeflateRect(1, 1);
  1001. pDC->Draw3dRect(rc, m_pManager->GetMetrics()->m_clrEdgeDkShadow, m_pManager->GetMetrics()->m_clrEdgeLight);
  1002. rc.DeflateRect(1, 1);
  1003. }
  1004. }
  1007. HICON GetFrameSmIcon(CXTPSkinObjectFrame* pFrame)
  1008. {
  1009. DWORD dwStyle = pFrame->GetStyle();
  1010. DWORD dwExStyle = pFrame->GetExStyle();
  1012. if (dwExStyle & WS_EX_TOOLWINDOW)
  1013. return NULL;
  1015. if ((dwStyle & WS_SYSMENU) == 0)
  1016. return NULL;
  1018. HICON hIcon = (HICON)(DWORD_PTR)::SendMessage(pFrame->m_hWnd, WM_GETICON, ICON_SMALL, 0);
  1019. if (hIcon)
  1020. return hIcon;
  1022. hIcon = (HICON)(DWORD_PTR)::GetClassLongPtr(pFrame->m_hWnd, GCLP_HICONSM);
  1023. if (hIcon)
  1024. return hIcon;
  1026. if (((dwStyle & (WS_BORDER | WS_DLGFRAME)) != WS_DLGFRAME) && ((dwExStyle & WS_EX_DLGMODALFRAME) == 0))
  1027. {
  1028. ULONG_PTR dwResult;
  1030. if (SendMessageTimeout(pFrame->GetSafeHwnd(),
  1031. WM_QUERYDRAGICON,
  1032. 0,
  1033. 0,
  1034. SMTO_NORMAL,
  1035. 100,
  1036. &dwResult))
  1037. {
  1038. hIcon = (HICON)dwResult;
  1039. }
  1041. if (hIcon == NULL)
  1042. {
  1043. hIcon = AfxGetApp()->LoadOEMIcon(OIC_WINLOGO);
  1044. }
  1045. }
  1047. return hIcon;
  1048. }
  1050. void CXTPSkinManagerSchemaDefault::DrawThemeFrame(CDC* pDC, CXTPSkinObjectFrame* pFrame)
  1051. {
  1052. CXTPWindowRect rc(pFrame);
  1053. rc.OffsetRect(-rc.TopLeft());
  1055. DWORD dwStyle = pFrame->GetStyle();
  1056. DWORD dwExStyle = pFrame->GetExStyle();
  1058. if ((dwStyle & WS_CAPTION) != WS_CAPTION)
  1059. {
  1060. DrawNonClientRect(pDC, rc, pFrame);
  1061. return;
  1062. }
  1064. BOOL bToolWindow = (dwExStyle & WS_EX_TOOLWINDOW) == WS_EX_TOOLWINDOW;
  1066. CRect rcBorders = pFrame->GetBorders();
  1068. if (dwExStyle & WS_EX_CLIENTEDGE)
  1069. {
  1070. DrawClientEdge(pDC, CRect(rcBorders.left - 2, rcBorders.top - 2, rc.Width() - rcBorders.right + 2,
  1071. rc.Height() - rcBorders.bottom + 2), pFrame);
  1073. InflateBorders(rcBorders, -2, -2);
  1074. }
  1077. CRect rcCaption(0, 0, rc.right, rcBorders.top);
  1078. CRect rcFrame(0, rcBorders.top, rc.Width(), rc.Height());
  1080. CXTPSkinManagerClass* pClassWindow = m_pManager->GetSkinClass(_T("WINDOW"));
  1082. int nFrameState = pFrame->IsActive()? FS_ACTIVE: FS_INACTIVE;
  1084. pClassWindow->DrawThemeBackground(pDC, bToolWindow? WP_SMALLFRAMELEFT: WP_FRAMELEFT, nFrameState,
  1085. CRect(rcFrame.left, rcFrame.top, rcFrame.left + rcBorders.left, rcFrame.bottom - rcBorders.bottom));
  1087. pClassWindow->DrawThemeBackground(pDC, bToolWindow? WP_SMALLFRAMERIGHT: WP_FRAMERIGHT, nFrameState,
  1088. CRect(rcFrame.right - rcBorders.right, rcFrame.top, rcFrame.right , rcFrame.bottom - rcBorders.bottom));
  1090. pClassWindow->DrawThemeBackground(pDC, bToolWindow? WP_SMALLFRAMEBOTTOM: WP_FRAMEBOTTOM, nFrameState,
  1091. CRect(rcFrame.left, rcFrame.bottom - rcBorders.bottom, rcFrame.right , rcFrame.bottom));
  1093. {
  1094. CXTPLockGuard lock(m_csDraw);
  1095. CXTPBufferDC dc(*pDC, rcCaption);
  1097. pClassWindow->DrawThemeBackground(&dc, bToolWindow? WP_SMALLCAPTION: WP_CAPTION, nFrameState, rcCaption);
  1100. CSize szIcon(GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON));
  1102. int nTextLeft = rcBorders.left;
  1104. HICON hIcon = GetFrameSmIcon(pFrame);
  1106. int cBorders = GetWindowBorders(dwStyle, dwExStyle, TRUE, FALSE) - m_pManager->GetMetrics()->m_cyBorder;
  1108. if (hIcon)
  1109. {
  1111. int cxySlot = rcBorders.top - cBorders;
  1112. int nTop = cBorders  + (cxySlot  - szIcon.cy)/2;
  1114. CRect rcButn(rcBorders.left + 2, nTop, rcBorders.left + 2 + szIcon.cx, nTop + szIcon.cy);
  1116. DWORD dwLayout = XTPDrawHelpers()->IsContextRTL(&dc);
  1117. if (dwLayout & LAYOUT_RTL)
  1118. XTPDrawHelpers()->SetContextRTL(&dc, dwLayout | LAYOUT_BITMAPORIENTATIONPRESERVED);
  1120. DrawIconEx(dc.m_hDC, rcButn.left, rcButn.top,hIcon,
  1121. rcButn.Width(), rcButn.Height(), 0, NULL, DI_NORMAL);
  1123. if (dwLayout & LAYOUT_RTL)
  1124. XTPDrawHelpers()->SetContextRTL(&dc, dwLayout);
  1127. nTextLeft = 2 + szIcon.cx + rcBorders.left;
  1128. }
  1131. int nTextRight = DrawThemeFrameButtons(&dc, pFrame);
  1133. dc.SetTextColor(m_pManager->GetThemeSysColor(pFrame->IsActive() ? TMT_CAPTIONTEXT : TMT_INACTIVECAPTIONTEXT));
  1135. CFont* pOldFont = dc.SelectObject(bToolWindow ? &m_pManager->GetMetrics()->m_fntSmCaption : &m_pManager->GetMetrics()->m_fntCaption);
  1137. CString strCaption;
  1139. CXTPDrawHelpers::GetWindowCaption(pFrame->GetSafeHwnd(), strCaption);
  1141. CRect rcText(nTextLeft, 1 + cBorders, nTextRight, rcBorders.top);
  1142. pClassWindow->DrawThemeText(&dc, bToolWindow ?  WP_SMALLCAPTION : WP_CAPTION, pFrame->IsActive() ? CS_ACTIVE : CS_INACTIVE,
  1143. strCaption, DT_VCENTER | DT_SINGLELINE | DT_END_ELLIPSIS | DT_NOPREFIX
  1144. | (dwExStyle & WS_EX_RTLREADING ? DT_RTLREADING : 0) | (dwExStyle & WS_EX_RIGHT ? DT_RIGHT : 0), rcText);
  1146. dc.SelectObject(pOldFont);
  1147. }
  1148. }
  1150. int CXTPSkinManagerSchemaDefault::GetWindowBorders(LONG lStyle, DWORD dwExStyle, BOOL fWindow, BOOL fClient)
  1151. {
  1152. int cBorders = 0;
  1154. if (fWindow)
  1155. {
  1156. if (dwExStyle & WS_EX_WINDOWEDGE)
  1157. cBorders += 2;
  1158. else if (dwExStyle & WS_EX_STATICEDGE)
  1159. cBorders++;
  1161. if ((lStyle & WS_CAPTION) || (dwExStyle & WS_EX_DLGMODALFRAME))
  1162. cBorders++;
  1164. if (lStyle & WS_SIZEBOX)
  1165. cBorders += m_pManager->GetMetrics()->m_nBorderSize;
  1166. }
  1168. if (fClient)
  1169. {
  1170. if (dwExStyle & WS_EX_CLIENTEDGE)
  1171. cBorders += 2;
  1172. }
  1174. return(cBorders);
  1175. }
  1178. CRect CXTPSkinManagerSchemaDefault::CalcFrameBorders(CXTPSkinObjectFrame* pFrame)
  1179. {
  1180. DWORD dwExStyle = pFrame->GetExStyle();
  1181. DWORD dwStyle = pFrame->GetStyle();
  1183. return CalcFrameBorders(dwStyle, dwExStyle);
  1184. }
  1186. CRect CXTPSkinManagerSchemaDefault::CalcFrameBorders(DWORD dwStyle, DWORD dwExStyle)
  1187. {
  1188. BOOL bToolWindow = (dwExStyle & WS_EX_TOOLWINDOW) == WS_EX_TOOLWINDOW;
  1189. CXTPSkinManagerMetrics* pMetrics = m_pManager->GetMetrics();
  1191. if (((dwStyle & (WS_CAPTION | WS_MAXIMIZE)) == (WS_CAPTION | WS_MAXIMIZE) && ((dwStyle & WS_CHILD) == 0)))
  1192. {
  1193. int nCaptionHeight = bToolWindow ? pMetrics->m_cySmallCaption: pMetrics->m_cyCaption;
  1195. CRect rc(0, 0, 100, 100);
  1196. AdjustWindowRectEx(rc, dwStyle, FALSE, dwExStyle);
  1197. int nBorder = -rc.left;
  1198. return CRect(nBorder, nBorder + nCaptionHeight, nBorder, nBorder);
  1199. }
  1203. CRect rcBorders(0, 0, 0, 0);
  1204. if ((dwStyle & WS_CAPTION) == WS_CAPTION)
  1205. {
  1206. int nCaptionHeight = bToolWindow ? pMetrics->m_cySmallCaption: pMetrics->m_cyCaption;
  1207. rcBorders.top += nCaptionHeight;
  1208. }
  1210. int cBorders = GetWindowBorders(dwStyle, dwExStyle, TRUE, FALSE);
  1212. InflateBorders(rcBorders, cBorders * pMetrics->m_cxBorder, cBorders * pMetrics->m_cyBorder);
  1214. if ((dwExStyle & WS_EX_CLIENTEDGE) == WS_EX_CLIENTEDGE)
  1215. {
  1216. InflateBorders(rcBorders, pMetrics->m_cxEdge, pMetrics->m_cyEdge);
  1217. }
  1219. return rcBorders;
  1220. }
  1222. AFX_INLINE void IncludeRgnPart(CRgn* pRgn, int x1, int y, int x2)
  1223. {
  1224. if (x1 < x2)
  1225. {
  1226. if (pRgn->GetSafeHandle() == NULL)
  1227. {
  1228. pRgn->CreateRectRgn(0, 0, 0, 0);
  1229. }
  1230. CRgn rgnExclude;
  1231. rgnExclude.CreateRectRgn(x1, y, x2, y + 1);
  1232. pRgn->CombineRgn(pRgn, &rgnExclude, RGN_OR);
  1233. }
  1234. }
  1236. void CXTPSkinManagerSchemaDefault::RegionFromBitmap(CDC* pDC, CRgn* pRgnLeft, CRgn* pRgnRight, int& nRgnFrameCenter, const CRect& rc, const CRect& rcSizingMargins, COLORREF clrTransparent)
  1237. {
  1238. CSize sz = rc.Size();
  1239. nRgnFrameCenter = 0;
  1240. BOOL bCheckCenter = TRUE;
  1242. for (int y = 0; y < sz.cy; y++)
  1243. {
  1244. int x = 0;
  1246. while (pDC->GetPixel(x, y) == clrTransparent && x < rcSizingMargins.left)
  1247. {
  1248. x++;
  1249. }
  1251. if (x > 0)
  1252. {
  1253. IncludeRgnPart(pRgnLeft, 0, y, x);
  1254. }
  1256. x = sz.cx - 1;
  1257. int nOffset = sz.cx - rcSizingMargins.right;
  1259. while (x >= nOffset)
  1260. {
  1261. int x0 = x;
  1263. while (x >= nOffset && pDC->GetPixel(x, y) == clrTransparent)
  1264. {
  1265. x--;
  1266. }
  1268. if (x != x0)
  1269. {
  1270. IncludeRgnPart(pRgnRight, x - nOffset + 1, y, x0 - nOffset + 1);
  1271. }
  1273. while (x >= nOffset && pDC->GetPixel(x, y) != clrTransparent)
  1274. {
  1275. x--;
  1276. }
  1278. if (x == x0)
  1279. break;
  1280. }
  1283. if (bCheckCenter)
  1284. {
  1285. x = rcSizingMargins.left;
  1287. while (pDC->GetPixel(x, y) == clrTransparent && x < sz.cx - rcSizingMargins.right)
  1288. {
  1289. x++;
  1290. }
  1291. if (x == sz.cx - rcSizingMargins.right)
  1292. {
  1293. nRgnFrameCenter++;
  1294. }
  1295. else
  1296. {
  1297. bCheckCenter = FALSE;
  1298. }
  1299. }
  1300. }
  1301. }
  1303. CXTPSkinManagerSchemaDefault::FRAMEREGION* CXTPSkinManagerSchemaDefault::CreateFrameRegion(CXTPSkinObjectFrame* pFrame, CSize szDest)
  1304. {
  1305. int nCaptionHeight = pFrame->GetBorders().top;
  1306. BOOL bToolWindow = pFrame->GetExStyle() & WS_EX_TOOLWINDOW;
  1308. for (int i = 0; i < m_arrFrameRegions.GetSize(); i++)
  1309. {
  1310. FRAMEREGION* pRegion = m_arrFrameRegions[i];
  1312. if (nCaptionHeight == pRegion->nCaptionHeight && bToolWindow == pRegion->bToolWindow)
  1313. {
  1314. if (szDest.cx < pRegion->rcFrameSizingMargins.left + pRegion->rcFrameSizingMargins.right)
  1315. break;
  1316. return pRegion;
  1317. }
  1318. }
  1320. int iPartId = bToolWindow ? WP_SMALLCAPTION : WP_CAPTION;
  1322. CXTPSkinManagerClass* pClass = m_pManager->GetSkinClass(_T("WINDOW"));
  1324. CString strImageFile = pClass->GetThemeString(iPartId, FS_ACTIVE, TMT_IMAGEFILE);
  1325. if (strImageFile.IsEmpty())
  1326. return  NULL;
  1328. CSize sz = pClass->GetImages()->GetExtent(m_pManager->GetResourceFile(), strImageFile);
  1329. if (sz == CSize(0))
  1330. return  NULL;
  1332. CXTPSkinImage* pImage = pClass->GetImages()->LoadFile(m_pManager->GetResourceFile(), strImageFile);
  1333. if (!pImage)
  1334. return NULL;
  1336. int nImageCount = pClass->GetThemeInt(iPartId, FS_ACTIVE, TMT_IMAGECOUNT, 1);
  1337. ASSERT(nImageCount >= 1);
  1338. if (nImageCount < 1)
  1339. return NULL;
  1342. FRAMEREGION* pRegion = new FRAMEREGION();
  1343. pRegion->bAutoDelete = FALSE;
  1344. pRegion->rcFrameSizingMargins.SetRectEmpty();
  1346. CWindowDC dcWindow(pFrame);
  1347. CDC dc;
  1348. dc.CreateCompatibleDC(&dcWindow);
  1350. CRect rcSrc(0, 0, sz.cx, sz.cy / nImageCount);
  1351. CRect rcDest(0, 0, sz.cx, nCaptionHeight);
  1354. CBitmap bmp;
  1355. bmp.CreateCompatibleBitmap(&dcWindow, rcDest.Width(), rcDest.Height());
  1357. CBitmap* pOldBitmap = dc.SelectObject(&bmp);
  1359. BOOL bTransparent = pImage->IsAlphaImage()? FALSE: pClass->GetThemeBool(iPartId, FS_ACTIVE, TMT_TRANSPARENT);
  1360. COLORREF clrTransparent = COLORREF_NULL;
  1361. if (bTransparent)
  1362. {
  1363. clrTransparent = pClass->GetThemeColor(iPartId, FS_ACTIVE, TMT_TRANSPARENTCOLOR, RGB(0xFF, 0, 0xFF));
  1364. }
  1366. dc.FillSolidRect(rcDest, clrTransparent != COLORREF_NULL ? clrTransparent : RGB(0xFF, 0, 0xFF));
  1368. CRect rcSizingMargins = pClass->GetThemeRect(iPartId, FS_ACTIVE, TMT_SIZINGMARGINS);
  1370. if (rcSizingMargins.top + rcSizingMargins.bottom > rcDest.Height())
  1371. {
  1372. rcSizingMargins.bottom = max(0, rcDest.Height() - rcSizingMargins.top);
  1373. }
  1375. CRect rcDestSizingMargins = rcSizingMargins;
  1376. if (szDest.cx < rcSizingMargins.left + rcSizingMargins.right)
  1377. {
  1378. rcDest.right = szDest.cx;
  1379. pRegion->bAutoDelete = TRUE;
  1381. rcDestSizingMargins.left = MulDiv(rcDest.Width(), rcSizingMargins.left, (rcSizingMargins.left + rcSizingMargins.right));
  1382. rcDestSizingMargins.right = rcDest.Width() - rcSizingMargins.left;
  1383. }
  1385. pImage->DrawImage(&dc, rcDest, rcSrc, rcSizingMargins, clrTransparent, ST_STRETCH, FALSE);
  1388. RegionFromBitmap(&dc, &pRegion->rgnFrameLeft, &pRegion->rgnFrameRight, pRegion->nRgnFrameCenter,
  1389. rcDest, rcDestSizingMargins, clrTransparent != COLORREF_NULL ? clrTransparent : RGB(0xFF, 0, 0xFF));
  1391. dc.SelectObject(pOldBitmap);
  1393. pRegion->rcFrameSizingMargins = rcDestSizingMargins;
  1394. pRegion->bToolWindow = bToolWindow;
  1395. pRegion->nCaptionHeight = nCaptionHeight;
  1397. if (!pRegion->bAutoDelete)
  1398. m_arrFrameRegions.Add(pRegion);
  1400. return pRegion;
  1401. }
  1403. void CXTPSkinManagerSchemaDefault::FreeFrameRegions()
  1404. {
  1405. for (int i = 0; i < m_arrFrameRegions.GetSize(); i++)
  1406. {
  1407. delete m_arrFrameRegions[i];
  1408. }
  1409. m_arrFrameRegions.RemoveAll();
  1410. }
  1412. void CXTPSkinManagerSchemaDefault::RefreshMetrcis()
  1413. {
  1414. FreeFrameRegions();
  1415. }
  1417. HRGN CXTPSkinManagerSchemaDefault::CalcFrameRegion(CXTPSkinObjectFrame* pFrame, CSize sz)
  1418. {
  1419. CRgn rgnResult;
  1421. if ((pFrame->GetStyle() & WS_MAXIMIZE) && ((pFrame->GetStyle() & WS_CHILD) == 0))
  1422. {
  1423. int nBorder = pFrame->GetBorders().left;
  1425. CRect rc = XTPMultiMonitor()->GetWorkArea(pFrame);
  1426. if (rc.Width() == sz.cx)
  1427. rgnResult.CreateRectRgn(nBorder, nBorder, sz.cx + 2 * nBorder, sz.cy + 2 * nBorder);
  1428. else
  1429. rgnResult.CreateRectRgn(nBorder, nBorder, sz.cx - nBorder, sz.cy - nBorder);
  1431. return (HRGN)rgnResult.Detach();
  1432. }
  1433. rgnResult.CreateRectRgn(0, 0, sz.cx, sz.cy);
  1435. FRAMEREGION* pRegion = CreateFrameRegion(pFrame, sz);
  1436. if (!pRegion)
  1437. {
  1438. return (HRGN)rgnResult.Detach();
  1439. }
  1441. if (pRegion->rgnFrameLeft.GetSafeHandle())
  1442. {
  1443. rgnResult.CombineRgn(&rgnResult, &pRegion->rgnFrameLeft, RGN_DIFF);
  1444. }
  1446. if (pRegion->rgnFrameRight.GetSafeHandle())
  1447. {
  1448. CRgn rgnFrameRight;
  1449. rgnFrameRight.CreateRectRgn(0, 0, 0, 0);
  1450. rgnFrameRight.CopyRgn(&pRegion->rgnFrameRight);
  1452. rgnFrameRight.OffsetRgn(sz.cx - pRegion->rcFrameSizingMargins.right, 0);
  1454. rgnResult.CombineRgn(&rgnResult, &rgnFrameRight, RGN_DIFF);
  1455. }
  1457. if (pRegion->nRgnFrameCenter > 0)
  1458. {
  1459. CRgn rgnFrameCenter;
  1460. rgnFrameCenter.CreateRectRgn(pRegion->rcFrameSizingMargins.left, 0, sz.cx - pRegion->rcFrameSizingMargins.right, pRegion->nRgnFrameCenter);
  1462. rgnResult.CombineRgn(&rgnResult, &rgnFrameCenter, RGN_DIFF);
  1463. }
  1465. if (pRegion->bAutoDelete)
  1466. delete pRegion;
  1468. return (HRGN)rgnResult.Detach();
  1469. }
  1471. COLORREF CXTPSkinManagerSchema::GetColor(int nIndex) const
  1472. {
  1473. return m_pManager->GetMetrics()->GetColor(nIndex);
  1474. }
  1476. COLORREF CXTPSkinManagerSchema::GetScrollBarSizeBoxColor(CXTPSkinObjectFrame* /*pFrame*/)
  1477. {
  1478. return GetColor(COLOR_3DFACE);
  1479. }
  1481. void CXTPSkinManagerSchemaDefault::DrawThemeScrollBar(CDC* pDC, CXTPSkinObjectFrame* pFrame, XTP_SKINSCROLLBARPOSINFO* pSBInfo)
  1482. {
  1483. #define ABS_UPACTIVE  17
  1484. #define ABS_DOWNACTIVE 18
  1485. #define ABS_LEFTACTIVE 19
  1486. #define ABS_RIGHTACTIVE 20
  1488. #define GETPARTSTATE(ht, pressed, hot, normal, disabled, active) 
  1489. (!bEnabled ? disabled : nPressetHt == ht ? pressed : 
  1490. nHotHt == ht ? hot : bActive ? (active) : normal)
  1492. XTP_SKINSCROLLBARTRACKINFO* pSBTrack = pFrame->GetScrollBarTrackInfo();
  1494. BOOL nPressetHt = pSBTrack && pSBTrack->pSBInfo == pSBInfo ?
  1495. (pSBTrack->bTrackThumb || pSBTrack->fHitOld ? pSBInfo->ht : -1) : -1;
  1497. BOOL nHotHt = pSBTrack ? -1 : pSBInfo->ht;
  1498. BOOL bActive = (pSBTrack && pSBTrack->pSBInfo == pSBInfo) || nHotHt  > 0 ;
  1501. int cWidth = (pSBInfo->pxRight - pSBInfo->pxLeft);
  1502. BOOL fVert = pSBInfo->fVert;
  1504. if (cWidth <= 0)
  1505. {
  1506. return;
  1507. }
  1509. HBRUSH hBrush = pFrame->GetClientBrush(pDC);
  1510. FillRect(pDC->GetSafeHdc(), &pSBInfo->rc, hBrush);
  1512. BOOL bEnabled = pSBInfo->posMax - pSBInfo->posMin - pSBInfo->page + 1 > 0;
  1513. if (bEnabled && pSBInfo->nBar == SB_CTL)
  1514. bEnabled = (pFrame->GetStyle() & WS_DISABLED) == 0;
  1516. CXTPSkinManagerClass* pClassScrollBar = m_pManager->GetSkinClass(_T("SCROLLBAR"));
  1518. int nBtnTrackSize =   pSBInfo->pxThumbBottom - pSBInfo->pxThumbTop;
  1519. int nBtnTrackPos = pSBInfo->pxThumbTop - pSBInfo->pxUpArrow;
  1521. if (!bEnabled || pSBInfo->pxThumbBottom > pSBInfo->pxDownArrow)
  1522. nBtnTrackPos = nBtnTrackSize = 0;
  1524. int nStateCount = pClassScrollBar->GetThemeInt(SBP_ARROWBTN, 0, TMT_IMAGECOUNT, 16);
  1527. if (!fVert)
  1528. {
  1529. CRect rcHScroll(pSBInfo->rc);
  1531. CRect rcArrowLeft(rcHScroll.left, rcHScroll.top, pSBInfo->pxUpArrow, rcHScroll.bottom);
  1532. CRect rcArrowRight(pSBInfo->pxDownArrow, rcHScroll.top, rcHScroll.right, rcHScroll.bottom);
  1534. pClassScrollBar->DrawThemeBackground(pDC, SBP_ARROWBTN, GETPARTSTATE(XTP_HTSCROLLUP,
  1535. ABS_LEFTPRESSED, ABS_LEFTHOT, ABS_LEFTNORMAL, ABS_LEFTDISABLED, nStateCount == 20 ? ABS_LEFTACTIVE : ABS_LEFTNORMAL),  rcArrowLeft);
  1536. pClassScrollBar->DrawThemeBackground(pDC, SBP_ARROWBTN, GETPARTSTATE(XTP_HTSCROLLDOWN,
  1537. ABS_RIGHTPRESSED, ABS_RIGHTHOT, ABS_RIGHTNORMAL, ABS_RIGHTDISABLED, nStateCount == 20 ? ABS_RIGHTACTIVE : ABS_RIGHTNORMAL),  rcArrowRight);
  1539. CRect rcTrack(rcArrowLeft.right, rcHScroll.top, rcArrowRight.left, rcHScroll.bottom);
  1541. if (!rcTrack.IsRectEmpty())
  1542. {
  1543. CRect rcLowerTrack(rcTrack.left, rcTrack.top, rcTrack.left + nBtnTrackPos, rcTrack.bottom);
  1544. CRect rcBtnTrack(rcLowerTrack.right, rcTrack.top, rcLowerTrack.right + nBtnTrackSize, rcTrack.bottom);
  1545. CRect rcUpperTrack(rcBtnTrack.right, rcTrack.top, rcTrack.right, rcTrack.bottom);
  1547. if (!rcLowerTrack.IsRectEmpty())
  1548. pClassScrollBar->DrawThemeBackground(pDC, SBP_LOWERTRACKHORZ, GETPARTSTATE(XTP_HTSCROLLUPPAGE, SCRBS_PRESSED, SCRBS_HOT, SCRBS_NORMAL, SCRBS_DISABLED, SCRBS_NORMAL),  rcLowerTrack);
  1550. if (!rcBtnTrack.IsRectEmpty())
  1551. {
  1552. pClassScrollBar->DrawThemeBackground(pDC, SBP_THUMBBTNHORZ, GETPARTSTATE(XTP_HTSCROLLTHUMB, SCRBS_PRESSED, SCRBS_HOT, SCRBS_NORMAL, SCRBS_DISABLED, SCRBS_NORMAL),  rcBtnTrack);
  1554. if (rcBtnTrack.Width() > 9)
  1555. pClassScrollBar->DrawThemeBackground(pDC, SBP_GRIPPERHORZ, GETPARTSTATE(XTP_HTSCROLLTHUMB, SCRBS_PRESSED, SCRBS_HOT, SCRBS_NORMAL, SCRBS_DISABLED, SCRBS_NORMAL),  rcBtnTrack);
  1556. }
  1558. if (!rcUpperTrack.IsRectEmpty())
  1559. pClassScrollBar->DrawThemeBackground(pDC, SBP_UPPERTRACKHORZ, GETPARTSTATE(XTP_HTSCROLLDOWNPAGE, SCRBS_PRESSED, SCRBS_HOT, SCRBS_NORMAL, SCRBS_DISABLED, SCRBS_NORMAL),  rcUpperTrack);
  1560. }
  1561. }
  1562. else
  1563. {
  1564. CRect rcVScroll(pSBInfo->rc);
  1566. CRect rcArrowUp(rcVScroll.left, rcVScroll.top, rcVScroll.right, pSBInfo->pxUpArrow);
  1567. CRect rcArrowDown(rcVScroll.left, pSBInfo->pxDownArrow, rcVScroll.right, rcVScroll.bottom);
  1569. pClassScrollBar->DrawThemeBackground(pDC, SBP_ARROWBTN, GETPARTSTATE(XTP_HTSCROLLUP,
  1570. ABS_UPPRESSED, ABS_UPHOT, ABS_UPNORMAL, ABS_UPDISABLED,  nStateCount == 20 ? ABS_UPACTIVE : ABS_UPNORMAL),  rcArrowUp);
  1571. pClassScrollBar->DrawThemeBackground(pDC, SBP_ARROWBTN, GETPARTSTATE(XTP_HTSCROLLDOWN,
  1572. ABS_DOWNPRESSED, ABS_DOWNHOT, ABS_DOWNNORMAL, ABS_DOWNDISABLED, nStateCount == 20 ? ABS_DOWNACTIVE : ABS_DOWNNORMAL),  rcArrowDown);
  1574. CRect rcTrack(rcVScroll.left, rcArrowUp.bottom, rcVScroll.right, rcArrowDown.top);
  1576. if (!rcTrack.IsRectEmpty())
  1577. {
  1578. CRect rcLowerTrack(rcTrack.left, rcTrack.top, rcTrack.right, rcTrack.top + nBtnTrackPos);
  1579. CRect rcBtnTrack(rcTrack.left, rcLowerTrack.bottom, rcTrack.right, rcLowerTrack.bottom + nBtnTrackSize);
  1580. CRect rcUpperTrack(rcTrack.left, rcBtnTrack.bottom, rcTrack.right, rcTrack.bottom);
  1582. if (!rcLowerTrack.IsRectEmpty())
  1583. pClassScrollBar->DrawThemeBackground(pDC, SBP_LOWERTRACKVERT, GETPARTSTATE(XTP_HTSCROLLUPPAGE, SCRBS_PRESSED, SCRBS_HOT, SCRBS_NORMAL, SCRBS_DISABLED, SCRBS_NORMAL),  rcLowerTrack);
  1585. if (!rcBtnTrack.IsRectEmpty())
  1586. {
  1587. pClassScrollBar->DrawThemeBackground(pDC, SBP_THUMBBTNVERT, GETPARTSTATE(XTP_HTSCROLLTHUMB, SCRBS_PRESSED, SCRBS_HOT, SCRBS_NORMAL, SCRBS_DISABLED, SCRBS_NORMAL),  rcBtnTrack);
  1588. if (rcBtnTrack.Height() > 13)
  1589. pClassScrollBar->DrawThemeBackground(pDC, SBP_GRIPPERVERT, GETPARTSTATE(XTP_HTSCROLLTHUMB, SCRBS_PRESSED, SCRBS_HOT, SCRBS_NORMAL, SCRBS_DISABLED, SCRBS_NORMAL),  rcBtnTrack);
  1590. }
  1592. if (!rcUpperTrack.IsRectEmpty())
  1593. pClassScrollBar->DrawThemeBackground(pDC, SBP_UPPERTRACKVERT, GETPARTSTATE(XTP_HTSCROLLDOWNPAGE, SCRBS_PRESSED, SCRBS_HOT, SCRBS_NORMAL, SCRBS_DISABLED, SCRBS_NORMAL),  rcUpperTrack);
  1594. }
  1595. }
  1596. }