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

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

对话框与窗口

开发平台：

Visual C++

XTColorPageStandard.cpp：源码内容
  1. // XTColorPageStandard.cpp : implementation file
  2. //
  3. // This file is a part of the XTREME CONTROLS 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"
  22. #include "Resource.h"
  24. #include "Common/XTPColorManager.h"
  25. #include "Common/XTPDrawHelpers.h"
  27. #include "XTDefines.h"
  28. #include "XTColorDialog.h"
  29. #include "XTColorPageStandard.h"
  31. #ifdef _DEBUG
  32. #define new DEBUG_NEW
  33. #undef THIS_FILE
  34. static char THIS_FILE[] = __FILE__;
  35. #endif
  37. const COLORREF CXTColorHex::clrSelArray[] =
  38. {
  39. RGB(0x00, 0x33, 0x66), // row 1
  40. RGB(0x33, 0x66, 0x99),
  41. RGB(0x33, 0x66, 0xCC),
  42. RGB(0x00, 0x33, 0x99),
  43. RGB(0x00, 0x00, 0x99),
  44. RGB(0x00, 0x00, 0xCC),
  45. RGB(0x00, 0x00, 0x66),
  47. RGB(0x00, 0x66, 0x66), // row 2
  48. RGB(0x00, 0x66, 0x99),
  49. RGB(0x00, 0x99, 0xCC),
  50. RGB(0x00, 0x66, 0xCC),
  51. RGB(0x00, 0x33, 0xCC),
  52. RGB(0x00, 0x00, 0xFF),
  53. RGB(0x33, 0x33, 0xFF),
  54. RGB(0x33, 0x33, 0x99),
  56. RGB(0x00, 0x80, 0x80), // row 3
  57. RGB(0x00, 0x99, 0x99),
  58. RGB(0x33, 0xCC, 0xCC),
  59. RGB(0x00, 0xCC, 0xFF),
  60. RGB(0x00, 0x99, 0xFF),
  61. RGB(0x00, 0x66, 0xFF),
  62. RGB(0x33, 0x66, 0xFF),
  63. RGB(0x33, 0x33, 0xCC),
  64. RGB(0x66, 0x66, 0x99),
  66. RGB(0x33, 0x99, 0x66), // row 4
  67. RGB(0x00, 0xCC, 0x99),
  68. RGB(0x00, 0xFF, 0xCC),
  69. RGB(0x00, 0xFF, 0xFF),
  70. RGB(0x33, 0xCC, 0xFF),
  71. RGB(0x33, 0x99, 0xFF),
  72. RGB(0x66, 0x99, 0xFF),
  73. RGB(0x66, 0x66, 0xFF),
  74. RGB(0x66, 0x00, 0xFF),
  75. RGB(0x66, 0x00, 0xCC),
  77. RGB(0x33, 0x99, 0x33), // row 5
  78. RGB(0x00, 0xCC, 0x66),
  79. RGB(0x00, 0xFF, 0x99),
  80. RGB(0x66, 0xFF, 0xCC),
  81. RGB(0x66, 0xFF, 0xFF),
  82. RGB(0x66, 0xCC, 0xFF),
  83. RGB(0x99, 0xCC, 0xFF),
  84. RGB(0x99, 0x99, 0xFF),
  85. RGB(0x99, 0x66, 0xFF),
  86. RGB(0x99, 0x33, 0xFF),
  87. RGB(0x99, 0x00, 0xFF),
  89. RGB(0x00, 0x66, 0x00), // row 6
  90. RGB(0x00, 0xCC, 0x00),
  91. RGB(0x00, 0xFF, 0x00),
  92. RGB(0x66, 0xFF, 0x99),
  93. RGB(0x99, 0xFF, 0xCC),
  94. RGB(0xCC, 0xFF, 0xFF),
  95. RGB(0xCC, 0xEC, 0xFF),
  96. RGB(0xCC, 0xCC, 0xFF),
  97. RGB(0xCC, 0x99, 0xFF),
  98. RGB(0xCC, 0x66, 0xFF),
  99. RGB(0xCC, 0x00, 0xFF),
  100. RGB(0x99, 0x00, 0xCC),
  102. RGB(0x00, 0x33, 0x00), // row 7
  103. RGB(0x00, 0x80, 0x00),
  104. RGB(0x33, 0xCC, 0x33),
  105. RGB(0x66, 0xFF, 0x66),
  106. RGB(0x99, 0xFF, 0x99),
  107. RGB(0xCC, 0xFF, 0xCC),
  108. RGB(0xFF, 0xFF, 0xFF),
  109. RGB(0xFF, 0xCC, 0xFF),
  110. RGB(0xFF, 0x99, 0xFF),
  111. RGB(0xFF, 0x66, 0xFF),
  112. RGB(0xFF, 0x00, 0xFF),
  113. RGB(0xCC, 0x00, 0xCC),
  114. RGB(0x66, 0x00, 0x66),
  116. RGB(0x33, 0x66, 0x00), // row 8
  117. RGB(0x00, 0x99, 0x00),
  118. RGB(0x66, 0xFF, 0x33),
  119. RGB(0x99, 0xFF, 0x66),
  120. RGB(0xCC, 0xFF, 0x99),
  121. RGB(0xFF, 0xFF, 0xCC),
  122. RGB(0xFF, 0xCC, 0xCC),
  123. RGB(0xFF, 0x99, 0xCC),
  124. RGB(0xFF, 0x66, 0xCC),
  125. RGB(0xFF, 0x33, 0xCC),
  126. RGB(0xCC, 0x00, 0x99),
  127. RGB(0x80, 0x00, 0x80),
  129. RGB(0x33, 0x33, 0x00), // row 9
  130. RGB(0x66, 0x99, 0x00),
  131. RGB(0x99, 0xFF, 0x33),
  132. RGB(0xCC, 0xFF, 0x66),
  133. RGB(0xFF, 0xFF, 0x99),
  134. RGB(0xFF, 0xCC, 0x99),
  135. RGB(0xFF, 0x99, 0x99),
  136. RGB(0xFF, 0x66, 0x99),
  137. RGB(0xFF, 0x33, 0x99),
  138. RGB(0xCC, 0x33, 0x99),
  139. RGB(0x99, 0x00, 0x99),
  141. RGB(0x66, 0x66, 0x33), // row 10
  142. RGB(0x99, 0xCC, 0x00),
  143. RGB(0xCC, 0xFF, 0x33),
  144. RGB(0xFF, 0xFF, 0x66),
  145. RGB(0xFF, 0xCC, 0x66),
  146. RGB(0xFF, 0x99, 0x66),
  147. RGB(0xFF, 0x7C, 0x80),
  148. RGB(0xFF, 0x00, 0x66),
  149. RGB(0xD6, 0x00, 0x93),
  150. RGB(0x99, 0x33, 0x66),
  152. RGB(0x80, 0x80, 0x00), // row 11
  153. RGB(0xCC, 0xCC, 0x00),
  154. RGB(0xFF, 0xFF, 0x00),
  155. RGB(0xFF, 0xCC, 0x00),
  156. RGB(0xFF, 0x99, 0x33),
  157. RGB(0xFF, 0x66, 0x00),
  158. RGB(0xFF, 0x50, 0x50),
  159. RGB(0xCC, 0x00, 0x66),
  160. RGB(0x66, 0x00, 0x33),
  162. RGB(0x99, 0x66, 0x33), // row 12
  163. RGB(0xCC, 0x99, 0x00),
  164. RGB(0xFF, 0x99, 0x00),
  165. RGB(0xCC, 0x66, 0x00),
  166. RGB(0xFF, 0x33, 0x00),
  167. RGB(0xFF, 0x00, 0x00),
  168. RGB(0xCC, 0x00, 0x00),
  169. RGB(0x99, 0x00, 0x33),
  171. RGB(0x66, 0x33, 0x00), // row 13
  172. RGB(0x99, 0x66, 0x00),
  173. RGB(0xCC, 0x33, 0x00),
  174. RGB(0x99, 0x33, 0x00),
  175. RGB(0x99, 0x00, 0x00),
  176. RGB(0x80, 0x00, 0x00),
  177. RGB(0xA5, 0x00, 0x21),
  179. RGB(0xF8, 0xF8, 0xF8), // row 1 (gray scale)
  180. RGB(0xDD, 0xDD, 0xDD),
  181. RGB(0xB2, 0xB2, 0xB2),
  182. RGB(0x80, 0x80, 0x80),
  183. RGB(0x5F, 0x5F, 0x5F),
  184. RGB(0x33, 0x33, 0x33),
  185. RGB(0x1C, 0x1C, 0x1C),
  186. RGB(0x08, 0x08, 0x08),
  188. RGB(0xEA, 0xEA, 0xEA), // row 2 (gray scale)
  189. RGB(0xC0, 0xC0, 0xC0),
  190. RGB(0x96, 0x96, 0x96),
  191. RGB(0x77, 0x77, 0x77),
  192. RGB(0x4D, 0x4D, 0x4D),
  193. RGB(0x29, 0x29, 0x29),
  194. RGB(0x11, 0x11, 0x11),
  196. RGB(0xFF, 0xFF, 0xFF), // large white cell
  197. RGB(0x00, 0x00, 0x00)   // large black cell
  198. };
  200. bool CXTColorHex::IsValidColor(COLORREF cr) const
  201. {
  202. int i;
  203. for (i = 0; i < _countof(clrSelArray); ++i)
  204. {
  205. if (cr == clrSelArray[i])
  206. {
  207. return true;
  208. }
  209. }
  210. return false;
  211. }
  213. /////////////////////////////////////////////////////////////////////////////
  214. // CXTColorHex
  216. CXTColorHex::CXTColorHex()
  217. {
  218. m_bSmallCell = TRUE;
  219. m_clrColor = (COLORREF)-1;
  220. m_bLBtnDown = FALSE;
  221. m_bPreSubclassInit = true;
  222. }
  224. CXTColorHex::~CXTColorHex()
  225. {
  226. while (!m_arCells.IsEmpty())
  227. {
  228. HEXCOLOR_CELL* pCI = m_arCells.RemoveHead();
  229. SAFE_DELETE_AR (pCI->pPoint);
  230. SAFE_DELETE (pCI);
  231. }
  232. }
  234. BEGIN_MESSAGE_MAP(CXTColorHex, CStatic)
  235. //{{AFX_MSG_MAP(CXTColorHex)
  236. ON_WM_PAINT()
  237. ON_WM_LBUTTONDOWN()
  238. ON_WM_LBUTTONUP()
  239. ON_WM_MOUSEMOVE()
  240. ON_WM_ERASEBKGND()
  241. ON_WM_LBUTTONDBLCLK()
  242. ON_WM_CREATE()
  243. //}}AFX_MSG_MAP
  244. END_MESSAGE_MAP()
  246. #define CX_ANCHOR   42
  247. #define CY_ANCHOR   3
  248. #define CX_HEXDISP  182
  249. #define CY_HEXDISP  196
  251. void CXTColorHex::OnPaint()
  252. {
  253. CPaintDC dc(this); // device context for painting
  255. CXTPClientRect rc(this);
  256. CXTPBufferDC memDC(dc);
  258. if (m_bmpPicker.GetSafeHandle() == NULL)
  259. {
  260. // create bitmap
  261. m_bmpPicker.DeleteObject();
  262. m_bmpPicker.CreateCompatibleBitmap(&memDC,
  263. rc.Width(), rc.Height());
  265. // create picker DC
  266. CDC dcPicker;
  267. dcPicker.CreateCompatibleDC(&memDC);
  268. CBitmap* pOldBitmap = dcPicker.SelectObject(&m_bmpPicker);
  270. dcPicker.SetBkMode(TRANSPARENT);
  272. HBRUSH hBrush = (HBRUSH)GetParent()->SendMessage(WM_CTLCOLORSTATIC, (WPARAM)dcPicker.GetSafeHdc(), (LPARAM)m_hWnd);
  273. if (hBrush)
  274. {
  275. ::FillRect(dcPicker.GetSafeHdc(), rc, hBrush);
  276. }
  277. else
  278. {
  279. dcPicker.FillSolidRect(rc, GetXtremeColor(COLOR_3DFACE));
  280. }
  282. DrawColorSelector(&dcPicker);
  283. dcPicker.SelectObject(pOldBitmap);
  284. }
  286. memDC.DrawState(CPoint(0, 0), rc.Size(), &m_bmpPicker, DSS_NORMAL, 0);
  287. SelectColorCell(&memDC);
  288. }
  290. BOOL CXTColorHex::OnEraseBkgnd(CDC* /*pDC*/)
  291. {
  292. return TRUE;
  293. }
  295. void CXTColorHex::SelectColorCell(CDC* pDC)
  296. {
  297. CXTColorDialog* pParentWnd = (CXTColorDialog*)GetParent()->GetParent();
  298. ASSERT(pParentWnd);
  299. if (!pParentWnd)
  300. return;
  301. if (pParentWnd->GetColor() == m_clrColor)
  302. {
  303. if (m_clrColor == RGB(0xff, 0xff, 0xff))
  304. {
  305. CXTPClientRect rcClient(this);
  306. CPoint ptCurrent = m_ptCurrent;
  308. m_ptCurrent.x = (rcClient.Width()-14)/2;
  309. m_ptCurrent.y = 74 + CY_ANCHOR;
  310. DrawSelectCell(pDC);
  312. m_ptCurrent.x = (rcClient.Width()-CX_HEXDISP)/2;
  313. m_ptCurrent.y = 171 + CY_ANCHOR;
  314. DrawLargeSelectCell(pDC);
  316. m_ptCurrent = ptCurrent;
  317. }
  318. else if (m_clrColor == RGB(0x00, 0x00, 0x00))
  319. {
  320. DrawLargeSelectCell(pDC);
  321. }
  322. else if (IsValidColor(m_clrColor))
  323. {
  324. if (m_bSmallCell)
  325. {
  326. DrawSelectCell(pDC);
  327. }
  328. else
  329. {
  330. DrawLargeSelectCell(pDC);
  331. }
  332. }
  333. }
  334. }
  336. void CXTColorHex::DrawLargeSelectCell(CDC* pDC)
  337. {
  338. int x = m_ptCurrent.x;
  339. int y = m_ptCurrent.y;
  340. x -= 2;
  342. COLORREF clr = RGB(0x00, 0x00, 0x00);
  344. // outer border
  345. int i;
  346. for (i = 0; i < 3; ++i)
  347. pDC->SetPixel(x + i, y-i, clr);
  349. pDC->SetPixel(x + 3, y-2, clr);
  350. pDC->SetPixel(x + 4, y-3, clr);
  351. pDC->SetPixel(x + 5, y-3, clr);
  352. pDC->SetPixel(x + 6, y-4, clr);
  353. pDC->SetPixel(x + 7, y-4, clr);
  354. pDC->SetPixel(x + 8, y-5, clr);
  355. pDC->SetPixel(x + 9, y-5, clr);
  356. pDC->SetPixel(x + 10, y-6, clr);
  357. pDC->SetPixel(x + 11, y-6, clr);
  358. pDC->SetPixel(x + 12, y-7, clr);
  359. pDC->SetPixel(x + 13, y-7, clr);
  360. pDC->SetPixel(x + 14, y-8, clr);
  361. pDC->SetPixel(x + 15, y-8, clr);
  362. pDC->SetPixel(x + 16, y-8, clr);
  363. pDC->SetPixel(x + 17, y-8, clr);
  364. pDC->SetPixel(x + 18, y-8, clr);
  365. pDC->SetPixel(x + 19, y-7, clr);
  366. pDC->SetPixel(x + 20, y-7, clr);
  367. pDC->SetPixel(x + 21, y-6, clr);
  368. pDC->SetPixel(x + 22, y-6, clr);
  369. pDC->SetPixel(x + 23, y-5, clr);
  370. pDC->SetPixel(x + 24, y-5, clr);
  371. pDC->SetPixel(x + 25, y-4, clr);
  372. pDC->SetPixel(x + 26, y-4, clr);
  373. pDC->SetPixel(x + 27, y-3, clr);
  374. pDC->SetPixel(x + 28, y-3, clr);
  375. pDC->SetPixel(x + 29, y-2, clr);
  376. pDC->SetPixel(x + 30, y-2, clr);
  377. pDC->SetPixel(x + 31, y-1, clr);
  379. for (i = 0; i < 17; ++i)
  380. pDC->SetPixel(x + 32, y + i, clr);
  382. pDC->SetPixel(x + 31, y + 17, clr);
  383. pDC->SetPixel(x + 30, y + 18, clr);
  384. pDC->SetPixel(x + 29, y + 18, clr);
  385. pDC->SetPixel(x + 28, y + 19, clr);
  386. pDC->SetPixel(x + 27, y + 19, clr);
  387. pDC->SetPixel(x + 26, y + 20, clr);
  388. pDC->SetPixel(x + 25, y + 20, clr);
  389. pDC->SetPixel(x + 24, y + 21, clr);
  390. pDC->SetPixel(x + 23, y + 21, clr);
  391. pDC->SetPixel(x + 22, y + 22, clr);
  392. pDC->SetPixel(x + 21, y + 22, clr);
  393. pDC->SetPixel(x + 20, y + 23, clr);
  394. pDC->SetPixel(x + 19, y + 23, clr);
  395. pDC->SetPixel(x + 18, y + 24, clr);
  396. pDC->SetPixel(x + 17, y + 24, clr);
  397. pDC->SetPixel(x + 16, y + 24, clr);
  398. pDC->SetPixel(x + 15, y + 24, clr);
  399. pDC->SetPixel(x + 14, y + 24, clr);
  400. pDC->SetPixel(x + 13, y + 23, clr);
  401. pDC->SetPixel(x + 12, y + 23, clr);
  402. pDC->SetPixel(x + 11, y + 22, clr);
  403. pDC->SetPixel(x + 10, y + 22, clr);
  404. pDC->SetPixel(x + 9, y + 21, clr);
  405. pDC->SetPixel(x + 8, y + 21, clr);
  406. pDC->SetPixel(x + 7, y + 20, clr);
  407. pDC->SetPixel(x + 6, y + 20, clr);
  408. pDC->SetPixel(x + 5, y + 19, clr);
  409. pDC->SetPixel(x + 4, y + 19, clr);
  410. pDC->SetPixel(x + 3, y + 18, clr);
  411. pDC->SetPixel(x + 2, y + 18, clr);
  412. pDC->SetPixel(x + 1, y + 17, clr);
  414. for (i = 0; i < 17; ++i)
  415. pDC->SetPixel(x, y + i, clr);
  417. // inner border
  418. for (i = 0; i < 15; ++i)
  419. pDC->SetPixel(x + 4, y + 1 + i, clr);
  421. pDC->SetPixel(x + 5, y + 16, clr);
  422. pDC->SetPixel(x + 6, y + 16, clr);
  423. pDC->SetPixel(x + 7, y + 17, clr);
  424. pDC->SetPixel(x + 8, y + 17, clr);
  425. pDC->SetPixel(x + 9, y + 18, clr);
  426. pDC->SetPixel(x + 10, y + 18, clr);
  427. pDC->SetPixel(x + 11, y + 19, clr);
  428. pDC->SetPixel(x + 12, y + 19, clr);
  429. pDC->SetPixel(x + 13, y + 20, clr);
  430. pDC->SetPixel(x + 14, y + 20, clr);
  431. pDC->SetPixel(x + 15, y + 21, clr);
  432. pDC->SetPixel(x + 16, y + 21, clr);
  433. pDC->SetPixel(x + 17, y + 21, clr);
  434. pDC->SetPixel(x + 18, y + 20, clr);
  435. pDC->SetPixel(x + 19, y + 20, clr);
  436. pDC->SetPixel(x + 20, y + 19, clr);
  437. pDC->SetPixel(x + 21, y + 19, clr);
  438. pDC->SetPixel(x + 22, y + 18, clr);
  439. pDC->SetPixel(x + 23, y + 18, clr);
  440. pDC->SetPixel(x + 24, y + 17, clr);
  441. pDC->SetPixel(x + 25, y + 17, clr);
  442. pDC->SetPixel(x + 26, y + 16, clr);
  443. pDC->SetPixel(x + 27, y + 16, clr);
  445. for (i = 0; i < 15; ++i)
  446. pDC->SetPixel(x + 28, y + 1 + i, clr);
  448. pDC->SetPixel(x + 27, y, clr);
  449. pDC->SetPixel(x + 26, y, clr);
  450. pDC->SetPixel(x + 25, y-1, clr);
  451. pDC->SetPixel(x + 24, y-1, clr);
  452. pDC->SetPixel(x + 23, y-2, clr);
  453. pDC->SetPixel(x + 22, y-2, clr);
  454. pDC->SetPixel(x + 21, y-3, clr);
  455. pDC->SetPixel(x + 20, y-3, clr);
  456. pDC->SetPixel(x + 19, y-4, clr);
  457. pDC->SetPixel(x + 18, y-4, clr);
  458. pDC->SetPixel(x + 17, y-5, clr);
  459. pDC->SetPixel(x + 16, y-5, clr);
  460. pDC->SetPixel(x + 15, y-5, clr);
  461. pDC->SetPixel(x + 14, y-4, clr);
  462. pDC->SetPixel(x + 13, y-4, clr);
  463. pDC->SetPixel(x + 12, y-3, clr);
  464. pDC->SetPixel(x + 11, y-3, clr);
  465. pDC->SetPixel(x + 10, y-2, clr);
  466. pDC->SetPixel(x + 9, y-2, clr);
  467. pDC->SetPixel(x + 8, y-1, clr);
  468. pDC->SetPixel(x + 7, y-1, clr);
  469. pDC->SetPixel(x + 6, y, clr);
  470. pDC->SetPixel(x + 5, y, clr);
  472. // fill inside.
  473. clr = RGB(0xff, 0xff, 0xff);
  475. for (i = 0; i < 17; ++i)
  476. {
  477. pDC->SetPixel(x + 1, y + i, clr);
  478. pDC->SetPixel(x + 2, y + i, clr);
  479. pDC->SetPixel(x + 3, y + i, clr);
  480. }
  482. pDC->SetPixel(x + 4, y, clr);
  483. pDC->SetPixel(x + 4, y + 16, clr);
  485. for (i = 0; i < 17; ++i)
  486. {
  487. pDC->SetPixel(x + 29, y + i, clr);
  488. pDC->SetPixel(x + 30, y + i, clr);
  489. pDC->SetPixel(x + 31, y + i, clr);
  490. }
  492. pDC->SetPixel(x + 28, y, clr);
  493. pDC->SetPixel(x + 28, y + 16, clr);
  495. for (i = 0; i < 5; ++i)
  496. {
  497. pDC->SetPixel(x + 2 + i, y-1, clr);
  498. pDC->SetPixel(x + 4 + i, y-2, clr);
  499. pDC->SetPixel(x + 6 + i, y-3, clr);
  500. pDC->SetPixel(x + 8 + i, y-4, clr);
  501. pDC->SetPixel(x + 10 + i, y-5, clr);
  502. pDC->SetPixel(x + 12 + i, y-6, clr);
  503. pDC->SetPixel(x + 16 + i, y-6, clr);
  504. pDC->SetPixel(x + 14 + i, y-7, clr);
  505. pDC->SetPixel(x + 18 + i, y-5, clr);
  506. pDC->SetPixel(x + 20 + i, y-4, clr);
  507. pDC->SetPixel(x + 22 + i, y-3, clr);
  508. pDC->SetPixel(x + 24 + i, y-2, clr);
  509. pDC->SetPixel(x + 26 + i, y-1, clr);
  510. pDC->SetPixel(x + 26 + i, y + 17, clr);
  511. pDC->SetPixel(x + 24 + i, y + 18, clr);
  512. pDC->SetPixel(x + 22 + i, y + 19, clr);
  513. pDC->SetPixel(x + 20 + i, y + 20, clr);
  514. pDC->SetPixel(x + 18 + i, y + 21, clr);
  515. pDC->SetPixel(x + 14 + i, y + 23, clr);
  516. pDC->SetPixel(x + 16 + i, y + 22, clr);
  517. pDC->SetPixel(x + 12 + i, y + 22, clr);
  518. pDC->SetPixel(x + 10 + i, y + 21, clr);
  519. pDC->SetPixel(x + 8 + i, y + 20, clr);
  520. pDC->SetPixel(x + 6 + i, y + 19, clr);
  521. pDC->SetPixel(x + 4 + i, y + 18, clr);
  522. pDC->SetPixel(x + 2 + i, y + 17, clr);
  523. }
  524. }
  526. void CXTColorHex::DrawSelectCell(CDC* pDC)
  527. {
  528. COLORREF clr = RGB(0x00, 0x00, 0x00);
  529. int x = m_ptCurrent.x;
  530. int y = m_ptCurrent.y;
  531. x -= 2;
  532. y -= 1;
  534. // outer border
  535. int i;
  536. for (i = 0; i < 11; ++i)
  537. pDC->SetPixel(x, y + i, clr);
  539. pDC->SetPixel(x + 1, y + 11, clr);
  540. pDC->SetPixel(x + 2, y + 11, clr);
  541. pDC->SetPixel(x + 3, y + 12, clr);
  542. pDC->SetPixel(x + 4, y + 12, clr);
  543. pDC->SetPixel(x + 5, y + 13, clr);
  544. pDC->SetPixel(x + 6, y + 13, clr);
  546. for (i = 0; i < 5; ++i)
  547. pDC->SetPixel(x + 7 + i, y + 14, clr);
  549. pDC->SetPixel(x + 12, y + 13, clr);
  550. pDC->SetPixel(x + 13, y + 13, clr);
  551. pDC->SetPixel(x + 14, y + 12, clr);
  552. pDC->SetPixel(x + 15, y + 12, clr);
  553. pDC->SetPixel(x + 16, y + 11, clr);
  554. pDC->SetPixel(x + 17, y + 11, clr);
  556. for (i = 0; i < 11; ++i)
  557. pDC->SetPixel(x + 18, y + i, clr);
  559. pDC->SetPixel(x + 16, y-1, clr);
  560. pDC->SetPixel(x + 17, y-1, clr);
  561. pDC->SetPixel(x + 14, y-2, clr);
  562. pDC->SetPixel(x + 15, y-2, clr);
  563. pDC->SetPixel(x + 12, y-3, clr);
  564. pDC->SetPixel(x + 13, y-3, clr);
  566. for (i = 0; i < 5; ++i)
  567. pDC->SetPixel(x + 7 + i, y-4, clr);
  569. pDC->SetPixel(x + 5, y-3, clr);
  570. pDC->SetPixel(x + 6, y-3, clr);
  571. pDC->SetPixel(x + 3, y-2, clr);
  572. pDC->SetPixel(x + 4, y-2, clr);
  573. pDC->SetPixel(x + 1, y-1, clr);
  574. pDC->SetPixel(x + 2, y-1, clr);
  576. // inner border
  577. for (i = 0; i < 7; ++i)
  578. pDC->SetPixel(x + 3, y + 2 + i, clr);
  580. pDC->SetPixel(x + 4, y + 9, clr);
  581. pDC->SetPixel(x + 5, y + 9, clr);
  582. pDC->SetPixel(x + 6, y + 10, clr);
  583. pDC->SetPixel(x + 7, y + 10, clr);
  585. for (i = 0; i < 3; ++i)
  586. pDC->SetPixel(x + 8 + i, y + 11, clr);
  588. pDC->SetPixel(x + 11, y + 10, clr);
  589. pDC->SetPixel(x + 12, y + 10, clr);
  590. pDC->SetPixel(x + 13, y + 9, clr);
  591. pDC->SetPixel(x + 14, y + 9, clr);
  593. for (i = 0; i < 7; ++i)
  594. pDC->SetPixel(x + 15, y + 2 + i, clr);
  596. pDC->SetPixel(x + 13, y + 1, clr);
  597. pDC->SetPixel(x + 14, y + 1, clr);
  598. pDC->SetPixel(x + 11, y, clr);
  599. pDC->SetPixel(x + 12, y, clr);
  601. for (i = 0; i < 3; ++i)
  602. pDC->SetPixel(x + 8 + i, y-1, clr);
  604. pDC->SetPixel(x + 6, y, clr);
  605. pDC->SetPixel(x + 7, y, clr);
  606. pDC->SetPixel(x + 4, y + 1, clr);
  607. pDC->SetPixel(x + 5, y + 1, clr);
  609. // fill inside.
  610. clr = RGB(0xff, 0xff, 0xff);
  611. x++;
  613. for (i = 0; i < 11; ++i)
  614. {
  615. pDC->SetPixel(x, y + i, clr);
  616. pDC->SetPixel(x + 1, y + i, clr);
  617. }
  619. for (i = 0; i < 3; ++i)
  620. pDC->SetPixel(x + 2, y + 9 + i, clr);
  622. pDC->SetPixel(x + 3, y + 10, clr);
  623. pDC->SetPixel(x + 3, y + 11, clr);
  625. for (i = 0; i < 3; ++i)
  626. pDC->SetPixel(x + 4, y + 10 + i, clr);
  628. pDC->SetPixel(x + 5, y + 11, clr);
  629. pDC->SetPixel(x + 5, y + 12, clr);
  631. for (i = 0; i < 3; ++i)
  632. pDC->SetPixel(x + 6, y + 11 + i, clr);
  634. pDC->SetPixel(x + 7, y + 12, clr);
  635. pDC->SetPixel(x + 7, y + 13, clr);
  636. pDC->SetPixel(x + 8, y + 12, clr);
  637. pDC->SetPixel(x + 8, y + 13, clr);
  638. pDC->SetPixel(x + 9, y + 12, clr);
  639. pDC->SetPixel(x + 9, y + 13, clr);
  641. for (i = 0; i < 3; ++i)
  642. pDC->SetPixel(x + 10, y + 11 + i, clr);
  644. pDC->SetPixel(x + 11, y + 11, clr);
  645. pDC->SetPixel(x + 11, y + 12, clr);
  647. for (i = 0; i < 3; ++i)
  648. pDC->SetPixel(x + 12, y + 10 + i, clr);
  650. pDC->SetPixel(x + 13, y + 10, clr);
  651. pDC->SetPixel(x + 13, y + 11, clr);
  653. for (i = 0; i < 3; ++i)
  654. pDC->SetPixel(x + 14, y + 9 + i, clr);
  656. for (i = 0; i < 11; ++i)
  657. {
  658. pDC->SetPixel(x + 15, y + i, clr);
  659. pDC->SetPixel(x + 16, y + i, clr);
  660. }
  662. for (i = 0; i < 3; ++i)
  663. pDC->SetPixel(x + 14, y-1 + i, clr);
  665. pDC->SetPixel(x + 13, y, clr);
  666. pDC->SetPixel(x + 13, y-1, clr);
  668. for (i = 0; i < 3; ++i)
  669. pDC->SetPixel(x + 12, y-2 + i, clr);
  671. pDC->SetPixel(x + 11, y-1, clr);
  672. pDC->SetPixel(x + 11, y-2, clr);
  674. for (i = 0; i < 3; ++i)
  675. pDC->SetPixel(x + 10, y-3 + i, clr);
  677. pDC->SetPixel(x + 7, y-2, clr);
  678. pDC->SetPixel(x + 7, y-3, clr);
  679. pDC->SetPixel(x + 8, y-2, clr);
  680. pDC->SetPixel(x + 8, y-3, clr);
  681. pDC->SetPixel(x + 9, y-2, clr);
  682. pDC->SetPixel(x + 9, y-3, clr);
  684. for (i = 0; i < 3; ++i)
  685. pDC->SetPixel(x + 6, y-3 + i, clr);
  687. pDC->SetPixel(x + 5, y-1, clr);
  688. pDC->SetPixel(x + 5, y-2, clr);
  690. for (i = 0; i < 3; ++i)
  691. pDC->SetPixel(x + 4, y-2 + i, clr);
  693. pDC->SetPixel(x + 3, y, clr);
  694. pDC->SetPixel(x + 3, y-1, clr);
  696. for (i = 0; i < 3; ++i)
  697. pDC->SetPixel(x + 2, y-1 + i, clr);
  698. }
  700. void CXTColorHex::DrawCell(CDC* pDC, CPoint point, COLORREF clr, int l, int u, int r, int d)
  701. {
  702. HEXCOLOR_CELL* pCI = new HEXCOLOR_CELL;
  704. CPen penNew(PS_SOLID, 1, clr);
  705. CPen* pOldPen = pDC->SelectObject(&penNew);
  707. pCI->clr = clr;
  708. pCI->bSmall = TRUE;
  709. pCI->pPoint = new CPoint[168];
  710. pCI->direction[0] = l;
  711. pCI->direction[1] = u;
  712. pCI->direction[2] = r;
  713. pCI->direction[3] = d;
  715. m_arCells.AddTail(pCI);
  717. if (clr == m_clrColor)
  718. {
  719. m_ptCurrent.x = point.x;
  720. m_ptCurrent.y = point.y;
  721. }
  723. int idx = 0;
  724. int i;
  725. for (i = 0; i < 9; ++i)
  726. {
  727. CPoint point1(point.x, point.y + i);
  728. pDC->SetPixel(point1, clr);
  729. if (pCI != NULL)
  730. {
  731. pCI->pPoint[idx] = point1;
  732. idx++;
  733. }
  734. CPoint point2(point.x + 1, point.y + i);
  735. pDC->SetPixel(point2, clr);
  736. if (pCI != NULL)
  737. {
  738. pCI->pPoint[idx] = point2;
  739. idx++;
  740. }
  741. }
  742. for (i = 0; i < 11; ++i)
  743. {
  744. CPoint point1(point.x + 2, (point.y-1)+i);
  745. pDC->SetPixel(point1, clr);
  746. if (pCI != NULL)
  747. {
  748. pCI->pPoint[idx] = point1;
  749. idx++;
  750. }
  751. CPoint point2(point.x + 3, (point.y-1)+i);
  752. pDC->SetPixel(point2, clr);
  753. if (pCI != NULL)
  754. {
  755. pCI->pPoint[idx] = point2;
  756. idx++;
  757. }
  758. }
  759. for (i = 0; i < 13; ++i)
  760. {
  761. CPoint point1(point.x + 4, (point.y-2)+i);
  762. pDC->SetPixel(point1, clr);
  763. if (pCI != NULL)
  764. {
  765. pCI->pPoint[idx] = point1;
  766. idx++;
  767. }
  768. CPoint point2(point.x + 5, (point.y-2)+i);
  769. pDC->SetPixel(point2, clr);
  770. if (pCI != NULL)
  771. {
  772. pCI->pPoint[idx] = point2;
  773. idx++;
  774. }
  775. }
  776. for (i = 0; i < 15; ++i)
  777. {
  778. CPoint point1(point.x + 6, (point.y-3)+i);
  779. pDC->SetPixel(point1, clr);
  780. if (pCI != NULL)
  781. {
  782. pCI->pPoint[idx] = point1;
  783. idx++;
  784. }
  785. CPoint point2(point.x + 7, (point.y-3)+i);
  786. pDC->SetPixel(point2, clr);
  787. if (pCI != NULL)
  788. {
  789. pCI->pPoint[idx] = point2;
  790. idx++;
  791. }
  792. CPoint point3(point.x + 8, (point.y-3)+i);
  793. pDC->SetPixel(point3, clr);
  794. if (pCI != NULL)
  795. {
  796. pCI->pPoint[idx] = point3;
  797. idx++;
  798. }
  799. }
  800. for (i = 0; i < 13; ++i)
  801. {
  802. CPoint point1(point.x + 9, (point.y-2)+i);
  803. pDC->SetPixel(point1, clr);
  804. if (pCI != NULL)
  805. {
  806. pCI->pPoint[idx] = point1;
  807. idx++;
  808. }
  809. CPoint point2(point.x + 10, (point.y-2)+i);
  810. pDC->SetPixel(point2, clr);
  811. if (pCI != NULL)
  812. {
  813. pCI->pPoint[idx] = point2;
  814. idx++;
  815. }
  816. }
  817. for (i = 0; i < 11; ++i)
  818. {
  819. CPoint point1(point.x + 11, (point.y-1)+i);
  820. pDC->SetPixel(point1, clr);
  821. if (pCI != NULL)
  822. {
  823. pCI->pPoint[idx] = point1;
  824. idx++;
  825. }
  826. CPoint point2(point.x + 12, (point.y-1)+i);
  827. pDC->SetPixel(point2, clr);
  828. if (pCI != NULL)
  829. {
  830. pCI->pPoint[idx] = point2;
  831. idx++;
  832. }
  833. }
  834. for (i = 0; i < 9; ++i)
  835. {
  836. CPoint point1(point.x + 13, point.y + i);
  837. pDC->SetPixel(point1, clr);
  838. if (pCI != NULL)
  839. {
  840. pCI->pPoint[idx] = point1;
  841. idx++;
  842. }
  843. }
  845. pDC->SelectObject(pOldPen);
  846. }
  848. void CXTColorHex::DrawLargeCell(CDC* pDC, CPoint point, COLORREF clr, int l, int u, int r, int d)
  849. {
  850. HEXCOLOR_CELL* pCI = new HEXCOLOR_CELL;
  852. CPen penNew(PS_SOLID, 1, clr);
  853. CPen* pOldPen = pDC->SelectObject(&penNew);
  855. pCI->clr = clr;
  856. pCI->bSmall = FALSE;
  857. pCI->pPoint = new CPoint[691];
  858. pCI->direction[0] = l;
  859. pCI->direction[1] = u;
  860. pCI->direction[2] = r;
  861. pCI->direction[3] = d;
  863. m_arCells.AddTail(pCI);
  865. if (clr == m_clrColor)
  866. {
  867. m_ptCurrent.x = point.x;
  868. m_ptCurrent.y = point.y;
  869. }
  871. int idx = 0;
  872. int i;
  873. for (i = 0; i < 17; ++i)
  874. {
  875. CPoint point1(point.x, point.y + i);
  876. pDC->SetPixel(point1, clr);
  877. if (pCI != NULL)
  878. {
  879. pCI->pPoint[idx] = point1;
  880. idx++;
  881. }
  882. CPoint point2(point.x + 1, point.y + i);
  883. pDC->SetPixel(point2, clr);
  884. if (pCI != NULL)
  885. {
  886. pCI->pPoint[idx] = point2;
  887. idx++;
  888. }
  889. }
  890. for (i = 0; i < 19; ++i)
  891. {
  892. CPoint point1(point.x + 2, (point.y-1)+i);
  893. pDC->SetPixel(point1, clr);
  894. if (pCI != NULL)
  895. {
  896. pCI->pPoint[idx] = point1;
  897. idx++;
  898. }
  899. CPoint point2(point.x + 3, (point.y-1)+i);
  900. pDC->SetPixel(point2, clr);
  901. if (pCI != NULL)
  902. {
  903. pCI->pPoint[idx] = point2;
  904. idx++;
  905. }
  906. }
  907. for (i = 0; i < 21; ++i)
  908. {
  909. CPoint point1(point.x + 4, (point.y-2)+i);
  910. pDC->SetPixel(point1, clr);
  911. if (pCI != NULL)
  912. {
  913. pCI->pPoint[idx] = point1;
  914. idx++;
  915. }
  916. CPoint point2(point.x + 5, (point.y-2)+i);
  917. pDC->SetPixel(point2, clr);
  918. if (pCI != NULL)
  919. {
  920. pCI->pPoint[idx] = point2;
  921. idx++;
  922. }
  923. }
  924. for (i = 0; i < 23; ++i)
  925. {
  926. CPoint point1(point.x + 6, (point.y-3)+i);
  927. pDC->SetPixel(point1, clr);
  928. if (pCI != NULL)
  929. {
  930. pCI->pPoint[idx] = point1;
  931. idx++;
  932. }
  933. }
  934. for (i = 0; i < 25; ++i)
  935. {
  936. CPoint point1(point.x + 7, (point.y-4)+i);
  937. pDC->SetPixel(point1, clr);
  938. if (pCI != NULL)
  939. {
  940. pCI->pPoint[idx] = point1;
  941. idx++;
  942. }
  943. CPoint point2(point.x + 8, (point.y-4)+i);
  944. pDC->SetPixel(point2, clr);
  945. if (pCI != NULL)
  946. {
  947. pCI->pPoint[idx] = point2;
  948. idx++;
  949. }
  950. }
  951. for (i = 0; i < 27; ++i)
  952. {
  953. CPoint point1(point.x + 9, (point.y-5)+i);
  954. pDC->SetPixel(point1, clr);
  955. if (pCI != NULL)
  956. {
  957. pCI->pPoint[idx] = point1;
  958. idx++;
  959. }
  960. CPoint point2(point.x + 10, (point.y-5)+i);
  961. pDC->SetPixel(point2, clr);
  962. if (pCI != NULL)
  963. {
  964. pCI->pPoint[idx] = point2;
  965. idx++;
  966. }
  967. }
  968. for (i = 0; i < 29; ++i)
  969. {
  970. CPoint point1(point.x + 11, (point.y-6)+i);
  971. pDC->SetPixel(point1, clr);
  972. if (pCI != NULL)
  973. {
  974. pCI->pPoint[idx] = point1;
  975. idx++;
  976. }
  977. CPoint point2(point.x + 12, (point.y-6)+i);
  978. pDC->SetPixel(point2, clr);
  979. if (pCI != NULL)
  980. {
  981. pCI->pPoint[idx] = point2;
  982. idx++;
  983. }
  984. }
  985. for (i = 0; i < 31; ++i)
  986. {
  987. CPoint point1(point.x + 13, (point.y-7)+i);
  988. pDC->SetPixel(point1, clr);
  989. if (pCI != NULL)
  990. {
  991. pCI->pPoint[idx] = point1;
  992. idx++;
  993. }
  994. CPoint point2(point.x + 14, (point.y-7)+i);
  995. pDC->SetPixel(point2, clr);
  996. if (pCI != NULL)
  997. {
  998. pCI->pPoint[idx] = point2;
  999. idx++;
  1000. }
  1001. CPoint point3(point.x + 15, (point.y-7)+i);
  1002. pDC->SetPixel(point3, clr);
  1003. if (pCI != NULL)
  1004. {
  1005. pCI->pPoint[idx] = point3;
  1006. idx++;
  1007. }
  1008. }
  1009. for (i = 0; i < 29; ++i)
  1010. {
  1011. CPoint point1(point.x + 16, (point.y-6)+i);
  1012. pDC->SetPixel(point1, clr);
  1013. if (pCI != NULL)
  1014. {
  1015. pCI->pPoint[idx] = point1;
  1016. idx++;
  1017. }
  1018. CPoint point2(point.x + 17, (point.y-6)+i);
  1019. pDC->SetPixel(point2, clr);
  1020. if (pCI != NULL)
  1021. {
  1022. pCI->pPoint[idx] = point2;
  1023. idx++;
  1024. }
  1025. }
  1026. for (i = 0; i < 27; ++i)
  1027. {
  1028. CPoint point1(point.x + 18, (point.y-5)+i);
  1029. pDC->SetPixel(point1, clr);
  1030. if (pCI != NULL)
  1031. {
  1032. pCI->pPoint[idx] = point1;
  1033. idx++;
  1034. }
  1035. CPoint point2(point.x + 19, (point.y-5)+i);
  1036. pDC->SetPixel(point2, clr);
  1037. if (pCI != NULL)
  1038. {
  1039. pCI->pPoint[idx] = point2;
  1040. idx++;
  1041. }
  1042. }
  1043. for (i = 0; i < 25; ++i)
  1044. {
  1045. CPoint point1(point.x + 20, (point.y-4)+i);
  1046. pDC->SetPixel(point1, clr);
  1047. if (pCI != NULL)
  1048. {
  1049. pCI->pPoint[idx] = point1;
  1050. idx++;
  1051. }
  1052. CPoint point2(point.x + 21, (point.y-4)+i);
  1053. pDC->SetPixel(point2, clr);
  1054. if (pCI != NULL)
  1055. {
  1056. pCI->pPoint[idx] = point2;
  1057. idx++;
  1058. }
  1059. }
  1060. for (i = 0; i < 23; ++i)
  1061. {
  1062. CPoint point1(point.x + 22, (point.y-3)+i);
  1063. pDC->SetPixel(point1, clr);
  1064. if (pCI != NULL)
  1065. {
  1066. pCI->pPoint[idx] = point1;
  1067. idx++;
  1068. }
  1069. }
  1070. for (i = 0; i < 21; ++i)
  1071. {
  1072. CPoint point1(point.x + 23, (point.y-2)+i);
  1073. pDC->SetPixel(point1, clr);
  1074. if (pCI != NULL)
  1075. {
  1076. pCI->pPoint[idx] = point1;
  1077. idx++;
  1078. }
  1079. CPoint point2(point.x + 24, (point.y-2)+i);
  1080. pDC->SetPixel(point2, clr);
  1081. if (pCI != NULL)
  1082. {
  1083. pCI->pPoint[idx] = point2;
  1084. idx++;
  1085. }
  1086. }
  1087. for (i = 0; i < 19; ++i)
  1088. {
  1089. CPoint point1(point.x + 25, (point.y-1)+i);
  1090. pDC->SetPixel(point1, clr);
  1091. if (pCI != NULL)
  1092. {
  1093. pCI->pPoint[idx] = point1;
  1094. idx++;
  1095. }
  1096. CPoint point2(point.x + 26, (point.y-1)+i);
  1097. pDC->SetPixel(point2, clr);
  1098. if (pCI != NULL)
  1099. {
  1100. pCI->pPoint[idx] = point2;
  1101. idx++;
  1102. }
  1103. }
  1104. for (i = 0; i < 17; ++i)
  1105. {
  1106. CPoint point1(point.x + 27, point.y + i);
  1107. pDC->SetPixel(point1, clr);
  1108. if (pCI != NULL)
  1109. {
  1110. pCI->pPoint[idx] = point1;
  1111. idx++;
  1112. }
  1113. CPoint point2(point.x + 28, point.y + i);
  1114. pDC->SetPixel(point2, clr);
  1115. if (pCI != NULL)
  1116. {
  1117. pCI->pPoint[idx] = point2;
  1118. idx++;
  1119. }
  1120. }
  1122. pDC->SelectObject(pOldPen);
  1123. }
  1125. void CXTColorHex::DrawColorSelector(CDC* pDC)
  1126. {
  1127. CXTPClientRect rcClient(this);
  1129. int x = ((rcClient.Width()-CX_HEXDISP)/2)+CX_ANCHOR;
  1130. int y = CY_ANCHOR;
  1132. int i = -1;
  1133. DrawCell(pDC, CPoint(x, y), clrSelArray[++i], -1, -1, 1, 8);
  1134. DrawCell(pDC, CPoint(x + 14, y), clrSelArray[++i], 0, -1, 2, 9);
  1135. DrawCell(pDC, CPoint(x + 28, y), clrSelArray[++i], 1, -1, 3, 10);
  1136. DrawCell(pDC, CPoint(x + 42, y), clrSelArray[++i], 2, -1, 4, 11);
  1137. DrawCell(pDC, CPoint(x + 56, y), clrSelArray[++i], 3, -1, 5, 12);
  1138. DrawCell(pDC, CPoint(x + 70, y), clrSelArray[++i], 4, -1, 6, 13);
  1139. DrawCell(pDC, CPoint(x + 84, y), clrSelArray[++i], 5, -1, 7, 14);
  1141. x -= 7;
  1142. y += 12;
  1143. DrawCell(pDC, CPoint(x, y), clrSelArray[++i], 6, -1, 8, 16);
  1144. DrawCell(pDC, CPoint(x + 14, y), clrSelArray[++i], 7, 0, 9, 17);
  1145. DrawCell(pDC, CPoint(x + 28, y), clrSelArray[++i], 8, 1, 10, 18);
  1146. DrawCell(pDC, CPoint(x + 42, y), clrSelArray[++i], 9, 2, 11, 19);
  1147. DrawCell(pDC, CPoint(x + 56, y), clrSelArray[++i], 10, 3, 12, 20);
  1148. DrawCell(pDC, CPoint(x + 70, y), clrSelArray[++i], 11, 4, 13, 21);
  1149. DrawCell(pDC, CPoint(x + 84, y), clrSelArray[++i], 12, 5, 14, 22);
  1150. DrawCell(pDC, CPoint(x + 98, y), clrSelArray[++i], 13, 6, 15, 23);
  1152. x -= 7;
  1153. y += 12;
  1154. DrawCell(pDC, CPoint(x, y), clrSelArray[++i], 14, 6, 16, 25);
  1155. DrawCell(pDC, CPoint(x + 14, y), clrSelArray[++i], 15, 7, 17, 26);
  1156. DrawCell(pDC, CPoint(x + 28, y), clrSelArray[++i], 16, 8, 18, 27);
  1157. DrawCell(pDC, CPoint(x + 42, y), clrSelArray[++i], 17, 9, 19, 28);
  1158. DrawCell(pDC, CPoint(x + 56, y), clrSelArray[++i], 18, 10, 20, 29);
  1159. DrawCell(pDC, CPoint(x + 70, y), clrSelArray[++i], 19, 11, 21, 30);
  1160. DrawCell(pDC, CPoint(x + 84, y), clrSelArray[++i], 20, 12, 22, 31);
  1161. DrawCell(pDC, CPoint(x + 98, y), clrSelArray[++i], 21, 13, 23, 32);
  1162. DrawCell(pDC, CPoint(x + 112, y), clrSelArray[++i], 22, 14, 24, 33);
  1164. x -= 7;
  1165. y += 12;
  1166. DrawCell(pDC, CPoint(x, y), clrSelArray[++i], 23, 14, 25, 35);
  1167. DrawCell(pDC, CPoint(x + 14, y), clrSelArray[++i], 24, 15, 26, 36);
  1168. DrawCell(pDC, CPoint(x + 28, y), clrSelArray[++i], 25, 16, 27, 37);
  1169. DrawCell(pDC, CPoint(x + 42, y), clrSelArray[++i], 26, 17, 28, 38);
  1170. DrawCell(pDC, CPoint(x + 56, y), clrSelArray[++i], 27, 18, 29, 39);
  1171. DrawCell(pDC, CPoint(x + 70, y), clrSelArray[++i], 28, 19, 30, 40);
  1172. DrawCell(pDC, CPoint(x + 84, y), clrSelArray[++i], 29, 20, 31, 41);
  1173. DrawCell(pDC, CPoint(x + 98, y), clrSelArray[++i], 30, 21, 32, 42);
  1174. DrawCell(pDC, CPoint(x + 112, y), clrSelArray[++i], 31, 22, 33, 43);
  1175. DrawCell(pDC, CPoint(x + 126, y), clrSelArray[++i], 32, 23, 34, 44);
  1177. x -= 7;
  1178. y += 12;
  1179. DrawCell(pDC, CPoint(x, y), clrSelArray[++i], 33, 23, 35, 46);
  1180. DrawCell(pDC, CPoint(x + 14, y), clrSelArray[++i], 34, 24, 36, 47);
  1181. DrawCell(pDC, CPoint(x + 28, y), clrSelArray[++i], 35, 25, 37, 48);
  1182. DrawCell(pDC, CPoint(x + 42, y), clrSelArray[++i], 36, 26, 38, 49);
  1183. DrawCell(pDC, CPoint(x + 56, y), clrSelArray[++i], 37, 27, 39, 50);
  1184. DrawCell(pDC, CPoint(x + 70, y), clrSelArray[++i], 38, 28, 40, 51);
  1185. DrawCell(pDC, CPoint(x + 84, y), clrSelArray[++i], 39, 29, 41, 52);
  1186. DrawCell(pDC, CPoint(x + 98, y), clrSelArray[++i], 40, 30, 42, 53);
  1187. DrawCell(pDC, CPoint(x + 112, y), clrSelArray[++i], 41, 31, 43, 54);
  1188. DrawCell(pDC, CPoint(x + 126, y), clrSelArray[++i], 42, 32, 44, 55);
  1189. DrawCell(pDC, CPoint(x + 140, y), clrSelArray[++i], 43, 33, 45, 56);
  1191. x -= 7;
  1192. y += 12;
  1193. DrawCell(pDC, CPoint(x, y), clrSelArray[++i], 44, 33, 46, 58);
  1194. DrawCell(pDC, CPoint(x + 14, y), clrSelArray[++i], 45, 34, 47, 59);
  1195. DrawCell(pDC, CPoint(x + 28, y), clrSelArray[++i], 46, 35, 48, 60);
  1196. DrawCell(pDC, CPoint(x + 42, y), clrSelArray[++i], 47, 36, 49, 61);
  1197. DrawCell(pDC, CPoint(x + 56, y), clrSelArray[++i], 48, 37, 50, 62);
  1198. DrawCell(pDC, CPoint(x + 70, y), clrSelArray[++i], 49, 38, 51, 63);
  1199. DrawCell(pDC, CPoint(x + 84, y), clrSelArray[++i], 50, 39, 52, 64);
  1200. DrawCell(pDC, CPoint(x + 98, y), clrSelArray[++i], 51, 40, 53, 65);
  1201. DrawCell(pDC, CPoint(x + 112, y), clrSelArray[++i], 52, 41, 54, 66);
  1202. DrawCell(pDC, CPoint(x + 126, y), clrSelArray[++i], 53, 42, 55, 67);
  1203. DrawCell(pDC, CPoint(x + 140, y), clrSelArray[++i], 54, 43, 56, 68);
  1204. DrawCell(pDC, CPoint(x + 154, y), clrSelArray[++i], 55, 44, 57, 69);
  1206. x -= 7;
  1207. y += 12;
  1208. DrawCell(pDC, CPoint(x, y), clrSelArray[++i], 56, 44, 58, 70);
  1209. DrawCell(pDC, CPoint(x + 14, y), clrSelArray[++i], 57, 45, 59, 71);
  1210. DrawCell(pDC, CPoint(x + 28, y), clrSelArray[++i], 58, 46, 60, 72);
  1211. DrawCell(pDC, CPoint(x + 42, y), clrSelArray[++i], 59, 47, 61, 73);
  1212. DrawCell(pDC, CPoint(x + 56, y), clrSelArray[++i], 60, 48, 62, 74);
  1213. DrawCell(pDC, CPoint(x + 70, y), clrSelArray[++i], 61, 49, 63, 75);
  1214. DrawCell(pDC, CPoint(x + 84, y), clrSelArray[++i], 62, 50, 64, 76);
  1215. DrawCell(pDC, CPoint(x + 98, y), clrSelArray[++i], 63, 51, 65, 77);
  1216. DrawCell(pDC, CPoint(x + 112, y), clrSelArray[++i], 64, 52, 66, 78);
  1217. DrawCell(pDC, CPoint(x + 126, y), clrSelArray[++i], 65, 53, 67, 79);
  1218. DrawCell(pDC, CPoint(x + 140, y), clrSelArray[++i], 66, 54, 68, 80);
  1219. DrawCell(pDC, CPoint(x + 154, y), clrSelArray[++i], 67, 55, 69, 81);
  1220. DrawCell(pDC, CPoint(x + 168, y), clrSelArray[++i], 68, 56, 70, 82);
  1222. x += 7;
  1223. y += 12;
  1224. DrawCell(pDC, CPoint(x, y), clrSelArray[++i], 69, 57, 71, 82);
  1225. DrawCell(pDC, CPoint(x + 14, y), clrSelArray[++i], 70, 58, 72, 83);
  1226. DrawCell(pDC, CPoint(x + 28, y), clrSelArray[++i], 71, 59, 73, 84);
  1227. DrawCell(pDC, CPoint(x + 42, y), clrSelArray[++i], 72, 60, 74, 85);
  1228. DrawCell(pDC, CPoint(x + 56, y), clrSelArray[++i], 73, 61, 75, 86);
  1229. DrawCell(pDC, CPoint(x + 70, y), clrSelArray[++i], 74, 62, 76, 87);
  1230. DrawCell(pDC, CPoint(x + 84, y), clrSelArray[++i], 75, 63, 77, 88);
  1231. DrawCell(pDC, CPoint(x + 98, y), clrSelArray[++i], 76, 64, 78, 89);
  1232. DrawCell(pDC, CPoint(x + 112, y), clrSelArray[++i], 77, 65, 79, 90);
  1233. DrawCell(pDC, CPoint(x + 126, y), clrSelArray[++i], 78, 66, 80, 91);
  1234. DrawCell(pDC, CPoint(x + 140, y), clrSelArray[++i], 79, 67, 81, 92);
  1235. DrawCell(pDC, CPoint(x + 154, y), clrSelArray[++i], 80, 68, 82, 93);
  1237. x += 7;
  1238. y += 12;
  1239. DrawCell(pDC, CPoint(x, y), clrSelArray[++i], 81, 70, 83, 93);
  1240. DrawCell(pDC, CPoint(x + 14, y), clrSelArray[++i], 82, 71, 84, 94);
  1241. DrawCell(pDC, CPoint(x + 28, y), clrSelArray[++i], 83, 72, 85, 95);
  1242. DrawCell(pDC, CPoint(x + 42, y), clrSelArray[++i], 84, 73, 86, 96);
  1243. DrawCell(pDC, CPoint(x + 56, y), clrSelArray[++i], 85, 74, 87, 97);
  1244. DrawCell(pDC, CPoint(x + 70, y), clrSelArray[++i], 86, 75, 88, 98);
  1245. DrawCell(pDC, CPoint(x + 84, y), clrSelArray[++i], 87, 76, 89, 99);
  1246. DrawCell(pDC, CPoint(x + 98, y), clrSelArray[++i], 88, 77, 90, 100);
  1247. DrawCell(pDC, CPoint(x + 112, y), clrSelArray[++i], 89, 78, 91, 101);
  1248. DrawCell(pDC, CPoint(x + 126, y), clrSelArray[++i], 90, 79, 92, 102);
  1249. DrawCell(pDC, CPoint(x + 140, y), clrSelArray[++i], 91, 80, 93, 103);
  1251. x += 7;
  1252. y += 12;
  1253. DrawCell(pDC, CPoint(x, y), clrSelArray[++i], 92, 82, 94, 103);
  1254. DrawCell(pDC, CPoint(x + 14, y), clrSelArray[++i], 93, 83, 95, 104);
  1255. DrawCell(pDC, CPoint(x + 28, y), clrSelArray[++i], 94, 84, 96, 105);
  1256. DrawCell(pDC, CPoint(x + 42, y), clrSelArray[++i], 95, 85, 97, 106);
  1257. DrawCell(pDC, CPoint(x + 56, y), clrSelArray[++i], 96, 86, 98, 107);
  1258. DrawCell(pDC, CPoint(x + 70, y), clrSelArray[++i], 97, 87, 99, 108);
  1259. DrawCell(pDC, CPoint(x + 84, y), clrSelArray[++i], 98, 88, 100, 109);
  1260. DrawCell(pDC, CPoint(x + 98, y), clrSelArray[++i], 99, 89, 101, 110);
  1261. DrawCell(pDC, CPoint(x + 112, y), clrSelArray[++i], 100, 90, 102, 111);
  1262. DrawCell(pDC, CPoint(x + 126, y), clrSelArray[++i], 101, 91, 103, 112);
  1264. x += 7;
  1265. y += 12;
  1266. DrawCell(pDC, CPoint(x, y), clrSelArray[++i], 102, 93, 104, 112);
  1267. DrawCell(pDC, CPoint(x + 14, y), clrSelArray[++i], 103, 94, 105, 113);
  1268. DrawCell(pDC, CPoint(x + 28, y), clrSelArray[++i], 104, 95, 106, 114);
  1269. DrawCell(pDC, CPoint(x + 42, y), clrSelArray[++i], 105, 96, 107, 115);
  1270. DrawCell(pDC, CPoint(x + 56, y), clrSelArray[++i], 106, 97, 108, 116);
  1271. DrawCell(pDC, CPoint(x + 70, y), clrSelArray[++i], 107, 98, 109, 117);
  1272. DrawCell(pDC, CPoint(x + 84, y), clrSelArray[++i], 108, 99, 110, 118);
  1273. DrawCell(pDC, CPoint(x + 98, y), clrSelArray[++i], 109, 100, 111, 119);
  1274. DrawCell(pDC, CPoint(x + 112, y), clrSelArray[++i], 110, 101, 112, 120);
  1276. x += 7;
  1277. y += 12;
  1278. DrawCell(pDC, CPoint(x, y), clrSelArray[++i], 111, 103, 113, 120);
  1279. DrawCell(pDC, CPoint(x + 14, y), clrSelArray[++i], 112, 104, 114, 121);
  1280. DrawCell(pDC, CPoint(x + 28, y), clrSelArray[++i], 113, 105, 115, 122);
  1281. DrawCell(pDC, CPoint(x + 42, y), clrSelArray[++i], 114, 106, 116, 123);
  1282. DrawCell(pDC, CPoint(x + 56, y), clrSelArray[++i], 115, 107, 117, 124);
  1283. DrawCell(pDC, CPoint(x + 70, y), clrSelArray[++i], 116, 108, 118, 125);
  1284. DrawCell(pDC, CPoint(x + 84, y), clrSelArray[++i], 117, 109, 119, 126);
  1285. DrawCell(pDC, CPoint(x + 98, y), clrSelArray[++i], 118, 110, 120, 142);
  1287. x += 7;
  1288. y += 12;
  1289. DrawCell(pDC, CPoint(x, y), clrSelArray[++i], 119, 112, 121, 121);
  1290. DrawCell(pDC, CPoint(x + 14, y), clrSelArray[++i], 120, 113, 122, 122);
  1291. DrawCell(pDC, CPoint(x + 28, y), clrSelArray[++i], 121, 114, 123, 123);
  1292. DrawCell(pDC, CPoint(x + 42, y), clrSelArray[++i], 122, 115, 124, 124);
  1293. DrawCell(pDC, CPoint(x + 56, y), clrSelArray[++i], 123, 116, 125, 125);
  1294. DrawCell(pDC, CPoint(x + 70, y), clrSelArray[++i], 124, 117, 126, 126);
  1295. DrawCell(pDC, CPoint(x + 84, y), clrSelArray[++i], 125, 118, 142, 142);
  1297. // Grey scale colors.
  1298. x -= 7;
  1299. y += 25;
  1300. DrawCell(pDC, CPoint(x, y), clrSelArray[++i], 142, 142, 135, 135);
  1301. DrawCell(pDC, CPoint(x + 14, y), clrSelArray[++i], 135, 135, 136, 136);
  1302. DrawCell(pDC, CPoint(x + 28, y), clrSelArray[++i], 136, 136, 137, 137);
  1303. DrawCell(pDC, CPoint(x + 42, y), clrSelArray[++i], 137, 137, 138, 138);
  1304. DrawCell(pDC, CPoint(x + 56, y), clrSelArray[++i], 138, 138, 139, 139);
  1305. DrawCell(pDC, CPoint(x + 70, y), clrSelArray[++i], 139, 139, 140, 140);
  1306. DrawCell(pDC, CPoint(x + 84, y), clrSelArray[++i], 140, 140, 141, 141);
  1307. DrawCell(pDC, CPoint(x + 98, y), clrSelArray[++i], 141, 141, 143, 143);
  1309. x += 7;
  1310. y += 12;
  1311. DrawCell(pDC, CPoint(x, y), clrSelArray[++i], 127, 127, 128, 128);
  1312. DrawCell(pDC, CPoint(x + 14, y), clrSelArray[++i], 128, 128, 129, 129);
  1313. DrawCell(pDC, CPoint(x + 28, y), clrSelArray[++i], 129, 129, 130, 130);
  1314. DrawCell(pDC, CPoint(x + 42, y), clrSelArray[++i], 130, 130, 131, 131);
  1315. DrawCell(pDC, CPoint(x + 56, y), clrSelArray[++i], 131, 131, 132, 132);
  1316. DrawCell(pDC, CPoint(x + 70, y), clrSelArray[++i], 132, 132, 133, 133);
  1317. DrawCell(pDC, CPoint(x + 84, y), clrSelArray[++i], 133, 133, 134, 134);
  1319. x = (rcClient.Width() - CX_HEXDISP)/2;
  1320. DrawLargeCell(pDC, CPoint(x, y-12), clrSelArray[++i], 126, 126, 127, 127);
  1322. x = ((rcClient.Width() - CX_HEXDISP)/2) + (CX_HEXDISP-29);
  1323. DrawLargeCell(pDC, CPoint(x, y - 12), clrSelArray[++i], 134, 134, -1, -1);
  1324. }
  1326. void CXTColorHex::UpdateSelection(CPoint point)
  1327. {
  1328. COLORREF clr = ColorFromPoint(point);
  1330. if ((clr != (COLORREF)-1) && (m_clrColor != clr))
  1331. {
  1332. m_clrColor = clr;
  1333. GetParent()->SendMessage(XTWM_UPDATECOLOR,
  1334. (WPARAM)(COLORREF)m_clrColor);
  1336. CRect rc;
  1337. GetClientRect(&rc);
  1339. CClientDC dc(this);
  1340. CXTPBufferDC memDC(dc, rc);
  1342. memDC.DrawState(CPoint(0, 0), rc.Size(), &m_bmpPicker, DSS_NORMAL, 0);
  1343. SelectColorCell(&memDC);
  1344. }
  1345. }
  1347. void CXTColorHex::OnLButtonDown(UINT nFlags, CPoint point)
  1348. {
  1349. if (GetFocus() != this)
  1350. SetFocus();
  1352. UpdateSelection(point);
  1353. m_bLBtnDown = TRUE;
  1355. CWnd::OnLButtonDown(nFlags, point);
  1356. }
  1359. void CXTColorHex::OnLButtonDblClk(UINT nFlags, CPoint point)
  1360. {
  1361. CStatic::OnLButtonDblClk(nFlags, point);
  1363. if (GetFocus() != this)
  1364. SetFocus();
  1366. COLORREF clr = ColorFromPoint(point);
  1368. if (clr != (COLORREF)-1)
  1369. {
  1370. UpdateSelection(point);
  1371. m_bLBtnDown = TRUE;
  1373. CPropertyPage* pParentPage = (CPropertyPage*)GetParent();
  1374. ASSERT_VALID(pParentPage);
  1376. CPropertySheet* pParentSheet = (CPropertySheet*)pParentPage->GetParent();
  1377. ASSERT_VALID(pParentSheet);
  1379. pParentSheet->EndDialog(IDOK);
  1380. }
  1381. }
  1383. COLORREF CXTColorHex::ColorFromPoint(CPoint point)
  1384. {
  1385. POSITION pos;
  1386. for (pos = m_arCells.GetHeadPosition(); pos; m_arCells.GetNext(pos))
  1387. {
  1388. HEXCOLOR_CELL* pCI = m_arCells.GetAt(pos);
  1389. ASSERT(pCI != NULL);
  1391. if (pCI == NULL)
  1392. return (COLORREF)-1;
  1394. int nPixelCount = pCI->bSmall ? 168 : 691;
  1395. int i;
  1396. for (i = 0; i < nPixelCount; ++i)
  1397. {
  1398. if (point == pCI->pPoint[i])
  1399. {
  1400. m_ptCurrent = pCI->pPoint[0];
  1401. m_bSmallCell = pCI->bSmall;
  1402. return pCI->clr;
  1403. }
  1404. }
  1405. }
  1407. return (COLORREF)-1;
  1408. }
  1410. void CXTColorHex::OnLButtonUp(UINT nFlags, CPoint point)
  1411. {
  1412. m_bLBtnDown = FALSE;
  1413. CWnd::OnLButtonUp(nFlags, point);
  1414. }
  1416. void CXTColorHex::OnMouseMove(UINT nFlags, CPoint point)
  1417. {
  1418. if (m_bLBtnDown)
  1419. {
  1420. UpdateSelection(point);
  1421. }
  1423. CWnd::OnMouseMove(nFlags, point);
  1424. }
  1426. bool CXTColorHex::Init()
  1427. {
  1428. if (::IsWindow(m_hWnd))
  1429. {
  1430. ModifyStyle(NULL, SS_NOTIFY);
  1431. return true;
  1432. }
  1434. return false;
  1435. }
  1437. void CXTColorHex::PreSubclassWindow()
  1438. {
  1439. CWnd::PreSubclassWindow();
  1441. if (m_bPreSubclassInit)
  1442. {
  1443. // Initialize the control.
  1444. Init();
  1445. }
  1446. }
  1448. int CXTColorHex::OnCreate(LPCREATESTRUCT lpCreateStruct)
  1449. {
  1450. if (CWnd::OnCreate(lpCreateStruct) == -1)
  1451. return -1;
  1453. // Initialize the control.
  1454. Init();
  1456. return 0;
  1457. }
  1459. BOOL CXTColorHex::PreCreateWindow(CREATESTRUCT& cs)
  1460. {
  1461. if (!CWnd::PreCreateWindow(cs))
  1462. return FALSE;
  1464. // When creating controls dynamically Init() must
  1465. // be called from OnCreate() and not from
  1466. // PreSubclassWindow().
  1468. m_bPreSubclassInit = false;
  1470. return TRUE;
  1471. }
  1473. CXTColorHex::HEXCOLOR_CELL* CXTColorHex::GetColorCell(COLORREF clr)
  1474. {
  1475. bool bWhite = false;
  1477. POSITION pos;
  1478. for (pos = m_arCells.GetHeadPosition(); pos; m_arCells.GetNext(pos))
  1479. {
  1480. HEXCOLOR_CELL* pCI = m_arCells.GetAt(pos);
  1481. ASSERT(pCI != NULL);
  1482. if (!pCI)
  1483. continue;
  1485. if (clr == pCI->clr)
  1486. {
  1487. if (clr == RGB(0xff, 0xff, 0xff) && bWhite == false)
  1488. {
  1489. if (m_ptCurrent.y >= 176) // big hex selected
  1490. {
  1491. bWhite = true;
  1492. continue;
  1493. }
  1494. }
  1495. return pCI;
  1496. }
  1497. }
  1499. return NULL;
  1500. }
  1502. void CXTColorHex::SetSelectedColor(int iIndex)
  1503. {
  1504. if (iIndex != -1)
  1505. {
  1506. POSITION pos2 = m_arCells.FindIndex(iIndex);
  1507. ASSERT(pos2 != NULL);
  1509. HEXCOLOR_CELL* pClrCell = m_arCells.GetAt(pos2);
  1510. ASSERT(pClrCell != NULL);
  1512. if (pClrCell)
  1513. UpdateSelection(pClrCell->pPoint[0]);
  1514. }
  1515. }
  1517. void CXTColorHex::SetSelectedColor(COLORREF clr)
  1518. {
  1519. m_clrColor = clr;
  1520. int iIndex = -1;
  1522. POSITION pos;
  1523. for (pos = m_arCells.GetHeadPosition(); pos; m_arCells.GetNext(pos), ++iIndex)
  1524. {
  1525. HEXCOLOR_CELL* pCI = m_arCells.GetAt(pos);
  1526. ASSERT(pCI != NULL);
  1528. if (pCI && (clr == pCI->clr))
  1529. {
  1530. SetSelectedColor(iIndex);
  1531. }
  1532. }
  1533. }
  1535. BOOL CXTColorHex::PreTranslateMessage(MSG* pMsg)
  1536. {
  1537. switch (pMsg->message)
  1538. {
  1539. case WM_KEYDOWN:
  1540. {
  1541. HEXCOLOR_CELL* pClrCell = GetColorCell(m_clrColor);
  1542. if (pClrCell == NULL)
  1543. pClrCell = GetColorCell(RGB(0x00, 0x00, 0x00));
  1545. TCHAR vkey = (TCHAR)pMsg->wParam;
  1546. switch (vkey)
  1547. {
  1548. case VK_LEFT:
  1549. SetSelectedColor(pClrCell->direction[0]);
  1550. break;
  1551. case VK_UP:
  1552. SetSelectedColor(pClrCell->direction[1]);
  1553. break;
  1554. case VK_RIGHT:
  1555. SetSelectedColor(pClrCell->direction[2]);
  1556. break;
  1557. case VK_DOWN:
  1558. SetSelectedColor(pClrCell->direction[3]);
  1559. break;
  1560. case VK_RETURN:
  1561. case VK_SPACE:
  1562. CPropertyPage* pParentPage = (CPropertyPage*)GetParent();
  1563. ASSERT_VALID(pParentPage);
  1565. CPropertySheet* pParentSheet = (CPropertySheet*)pParentPage->GetParent();
  1566. ASSERT_VALID(pParentSheet);
  1568. pParentSheet->EndDialog(IDOK);
  1569. break;
  1570. }
  1571. }
  1572. break;
  1573. }
  1575. return CStatic::PreTranslateMessage(pMsg);
  1576. }
  1578. /////////////////////////////////////////////////////////////////////////////
  1579. // CXTColorPageStandard
  1581. BEGIN_MESSAGE_MAP(CXTColorPageStandard, CPropertyPage)
  1582. //{{AFX_MSG_MAP(CXTColorPageStandard)
  1583. //ON_WM_PAINT()
  1584. //ON_WM_ERASEBKGND()
  1585. //}}AFX_MSG_MAP
  1586. ON_MESSAGE(XTWM_UPDATECOLOR, OnUpdateColor)
  1587. END_MESSAGE_MAP()
  1589. /////////////////////////////////////////////////////////////////////////////
  1590. // CXTColorPageStandard construction/destruction
  1592. CXTColorPageStandard::CXTColorPageStandard(CXTColorDialog* pParentSheet)
  1593. : CPropertyPage(CXTColorPageStandard::IDD)
  1594. {
  1595. m_psp.dwFlags &= ~PSP_HASHELP;
  1596. m_pParentSheet = pParentSheet;
  1598. //{{AFX_DATA_INIT(CXTColorPageStandard)
  1599. //}}AFX_DATA_INIT
  1600. }
  1602. CXTColorPageStandard::~CXTColorPageStandard()
  1603. {
  1604. }
  1606. void CXTColorPageStandard::DoDataExchange(CDataExchange* pDX)
  1607. {
  1608. CPropertyPage::DoDataExchange(pDX);
  1609. //{{AFX_DATA_MAP(CXTColorPageStandard)
  1610. DDX_Control(pDX, XT_IDC_CLR_HEX, m_colorHex);
  1611. //}}AFX_DATA_MAP
  1612. }
  1614. LRESULT CXTColorPageStandard::OnUpdateColor(WPARAM wParam, LPARAM /*lParam*/)
  1615. {
  1616. m_pParentSheet->SetNewColor((COLORREF)wParam, FALSE);
  1617. return 0;
  1618. }