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

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

对话框与窗口

开发平台：

Visual C++

XTColorSelectorCtrl.cpp：源码内容
  1. // XTColorSelectorCtrl.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"
  23. #include "Common/Resource.h"
  25. #include "Common/XTPVC50Helpers.h"
  26. #include "Common/XTPVC80Helpers.h"
  27. #include "Common/XTPResourceManager.h"
  28. #include "Common/XTPColorManager.h"
  29. #include "Common/XTPDrawHelpers.h"
  31. #include "XTDefines.h"
  32. #include "XTGlobal.h"
  33. #include "XTColorDialog.h"
  34. #include "XTColorSelectorCtrl.h"
  35. #include "XTFunctions.h"
  37. #ifdef _DEBUG
  38. #define new DEBUG_NEW
  39. #undef THIS_FILE
  40. static char THIS_FILE[] = __FILE__;
  41. #endif
  43. CUIntArray CXTColorSelectorCtrl::m_arUserDefColors;
  45. IMPLEMENT_THEME_HOST(CXTColorSelectorCtrl)
  46. IMPLEMENT_THEME_REFRESH(CXTColorSelectorCtrl, CWnd)
  48. /////////////////////////////////////////////////////////////////////////////
  49. // CXTColorSelectorCtrl
  51. CXTColorSelectorCtrl::CXTColorSelectorCtrl()
  52. : CXTThemeManagerStyleHost(GetThemeFactoryClass())
  53. {
  54. m_pColorDlg = NULL;
  55. m_point = CPoint(0, 0);
  56. m_nCols = 8;
  57. m_nCurSel = -1;
  58. m_sizeButton = CSize(18, 18);
  59. m_dwPopup = NULL;
  60. m_pParentWnd = NULL;
  61. m_clrColor = CLR_DEFAULT;
  62. m_clrDefault = CLR_DEFAULT;
  63. m_nPressed = -1;
  64. m_rcBorders = CRect(0, 0, 0, 0);
  66. m_pExtendedColors = NULL;
  67. m_nExtendedColors = 0;
  68. }
  72. CXTColorSelectorCtrl::~CXTColorSelectorCtrl()
  73. {
  75. // Free memory allocated to create color cells.
  76. while (!m_arCells.IsEmpty())
  77. {
  78. COLOR_CELL* pColorCell = m_arCells.RemoveHead();
  79. SAFE_DELETE (pColorCell);
  80. }
  81. }
  84. BEGIN_MESSAGE_MAP(CXTColorSelectorCtrl, CWnd)
  85. //{{AFX_MSG_MAP(CXTColorSelectorCtrl)
  86. ON_WM_CREATE()
  87. ON_WM_PAINT()
  88. ON_WM_MOUSEMOVE()
  89. ON_WM_LBUTTONDOWN()
  90. ON_WM_LBUTTONUP()
  91. ON_WM_KEYDOWN()
  92. ON_WM_ERASEBKGND()
  93. ON_WM_NCHITTEST_EX()
  94. ON_WM_SETFOCUS()
  95. ON_WM_MOUSEACTIVATE()
  96. //}}AFX_MSG_MAP
  97. ON_MESSAGE_VOID(WM_MOUSELEAVE, OnMouseLeave)
  98. END_MESSAGE_MAP()
  101. static XTP_PICK_BUTTON standardColors[] =
  102. {
  103. {   RGB(0x00, 0x00, 0x00), XTP_IDS_CLR_BLACK            },
  104. {   RGB(0x80, 0x80, 0x80), XTP_IDS_CLR_GRAY             },
  105. {   RGB(0x80, 0x00, 0x00), XTP_IDS_CLR_MAROON           },
  106. {   RGB(0x80, 0x80, 0x00), XTP_IDS_CLR_OLIVE            },
  107. {   RGB(0x00, 0x80, 0x00), XTP_IDS_CLR_GREEN            },
  108. {   RGB(0x00, 0x80, 0x80), XTP_IDS_CLR_TEAL             },
  109. {   RGB(0x00, 0x00, 0x80), XTP_IDS_CLR_NAVY             },
  110. {   RGB(0x80, 0x00, 0x80), XTP_IDS_CLR_PURPLE           },
  111. {   RGB(0xFF, 0xFF, 0xFF), XTP_IDS_CLR_WHITE            },
  112. {   RGB(0xC0, 0xC0, 0xC0), XTP_IDS_CLR_SILVER           },
  113. {   RGB(0xFF, 0x00, 0x00), XTP_IDS_CLR_RED              },
  114. {   RGB(0xFF, 0xFF, 0x00), XTP_IDS_CLR_YELLOW           },
  115. {   RGB(0x00, 0xFF, 0x00), XTP_IDS_CLR_LIME             },
  116. {   RGB(0x00, 0xFF, 0xFF), XTP_IDS_CLR_AQUA             },
  117. {   RGB(0x00, 0x00, 0xFF), XTP_IDS_CLR_BLUE             },
  118. {   RGB(0xFF, 0x00, 0xFF), XTP_IDS_CLR_FUCHSIA          },
  119. };
  121. static XTP_PICK_BUTTON extendedColors[] =
  122. {
  123. {   RGB(0x00, 0x00, 0x00), XTP_IDS_CLR_BLACK            },
  124. {   RGB(0x99, 0x33, 0x00), XTP_IDS_CLR_BROWN            },
  125. {   RGB(0x33, 0x33, 0x00), XTP_IDS_CLR_OLIVE_GREEN      },
  126. {   RGB(0x00, 0x33, 0x00), XTP_IDS_CLR_DARK_GREEN       },
  127. {   RGB(0x00, 0x33, 0x66), XTP_IDS_CLR_DARK_TEAL        },
  128. {   RGB(0x00, 0x00, 0x80), XTP_IDS_CLR_DARK_BLUE        },
  129. {   RGB(0x33, 0x33, 0x99), XTP_IDS_CLR_INDIGO           },
  130. {   RGB(0x33, 0x33, 0x33), XTP_IDS_CLR_GRAY80           },
  131. {   RGB(0x80, 0x00, 0x00), XTP_IDS_CLR_DARK_RED         },
  132. {   RGB(0xFF, 0x66, 0x00), XTP_IDS_CLR_ORANGE           },
  133. {   RGB(0x80, 0x80, 0x00), XTP_IDS_CLR_DARK_YELLOW      },
  134. {   RGB(0x00, 0x80, 0x00), XTP_IDS_CLR_GREEN            },
  135. {   RGB(0x00, 0x80, 0x80), XTP_IDS_CLR_TEAL             },
  136. {   RGB(0x00, 0x00, 0xFF), XTP_IDS_CLR_BLUE             },
  137. {   RGB(0x66, 0x66, 0x99), XTP_IDS_CLR_BLUEGRAY         },
  138. {   RGB(0x80, 0x80, 0x80), XTP_IDS_CLR_GRAY50           },
  139. {   RGB(0xFF, 0x00, 0x00), XTP_IDS_CLR_RED              },
  140. {   RGB(0xFF, 0x99, 0x00), XTP_IDS_CLR_LIGHTORANGE      },
  141. {   RGB(0x99, 0xCC, 0x00), XTP_IDS_CLR_LIME             },
  142. {   RGB(0x33, 0x99, 0x66), XTP_IDS_CLR_SEA_GREEN        },
  143. {   RGB(0x33, 0xCC, 0xCC), XTP_IDS_CLR_AQUA             },
  144. {   RGB(0x33, 0x66, 0xFF), XTP_IDS_CLR_LIGHT_BLUE       },
  145. {   RGB(0x80, 0x00, 0x80), XTP_IDS_CLR_VIOLET           },
  146. {   RGB(0x99, 0x99, 0x99), XTP_IDS_CLR_GRAY40           },
  147. {   RGB(0xFF, 0x00, 0xFF), XTP_IDS_CLR_PINK             },
  148. {   RGB(0xFF, 0xCC, 0x00), XTP_IDS_CLR_GOLD             },
  149. {   RGB(0xFF, 0xFF, 0x00), XTP_IDS_CLR_YELLOW           },
  150. {   RGB(0x00, 0xFF, 0x00), XTP_IDS_CLR_BRIGHT_GREEN     },
  151. {   RGB(0x00, 0xFF, 0xFF), XTP_IDS_CLR_TURQUOISE        },
  152. {   RGB(0x00, 0xCC, 0xFF), XTP_IDS_CLR_SKY_BLUE         },
  153. {   RGB(0x99, 0x33, 0x66), XTP_IDS_CLR_PLUM             },
  154. {   RGB(0xC0, 0xC0, 0xC0), XTP_IDS_CLR_GRAY25           },
  155. {   RGB(0xFF, 0x99, 0xCC), XTP_IDS_CLR_ROSE             },
  156. {   RGB(0xFF, 0xCC, 0x99), XTP_IDS_CLR_TAN              },
  157. {   RGB(0xFF, 0xFF, 0x99), XTP_IDS_CLR_LIGHT_YELLOW     },
  158. {   RGB(0xCC, 0xFF, 0xCC), XTP_IDS_CLR_LIGHT_GREEN      },
  159. {   RGB(0xCC, 0xFF, 0xFF), XTP_IDS_CLR_LIGHT_TURQUOISE  },
  160. {   RGB(0x99, 0xCC, 0xFF), XTP_IDS_CLR_PALE_BLUE        },
  161. {   RGB(0xCC, 0x99, 0xFF), XTP_IDS_CLR_LAVENDER         },
  162. {   RGB(0xFF, 0xFF, 0xFF), XTP_IDS_CLR_WHITE            },
  163. };
  166. /////////////////////////////////////////////////////////////////////////////
  167. // CXTColorSelectorCtrl message handlers
  169. CSize CXTColorSelectorCtrl::CalcSize()
  170. {
  171. CSize sz;
  173. sz.cx = (m_sizeButton.cx * m_nCols + m_rcBorders.left + m_rcBorders.right);
  174. sz.cy = m_rcBorders.top + m_rcBorders.bottom;
  176. if ((m_dwPopup & CPS_XT_NOAUTOMATIC) == 0)
  177. {
  178. sz.cy += 27;
  179. }
  181. if (m_pExtendedColors)
  182. {
  183. m_dwPopup |= CPS_XT_EXTENDED;
  184. ASSERT(m_nExtendedColors > 0);
  185. }
  187. if (m_dwPopup & CPS_XT_EXTENDED)
  188. {
  189. int nColors = m_pExtendedColors == NULL ? _countof(extendedColors) : m_nExtendedColors;
  190. sz.cy += ((nColors + m_nCols - 1) / m_nCols) * m_sizeButton.cy;
  191. }
  192. else
  193. {
  194. sz.cy += 22 + 2 * m_sizeButton.cy;
  195. }
  198. if ((m_dwPopup & CPS_XT_MORECOLORS) != 0)
  199. {
  200. sz.cy += 27;
  202. if (m_arUserDefColors.GetSize() > 0)
  203. {
  204. sz.cy += 4 + m_sizeButton.cy;
  205. }
  206. }
  207. return sz;
  208. }
  211. BOOL CXTColorSelectorCtrl::Create(CRect rect, CWnd* pParentWnd, DWORD dwPopup, COLORREF clrColor,
  212. COLORREF clrDefault/*= CLR_DEFAULT*/)
  213. {
  214. m_pParentWnd = pParentWnd;
  215. ASSERT(m_pParentWnd != NULL); // must be valid.
  216. if (!m_pParentWnd)
  217. return FALSE;
  219. AddListener(m_pParentWnd->m_hWnd);
  221. m_dwPopup = dwPopup;
  222. m_clrColor = clrColor;
  223. m_clrDefault = clrDefault;
  225. m_rcWnd = rect;
  227. CSize sz = CalcSize();
  229. if (dwPopup & WS_POPUP)
  230. {
  231. if (m_dwPopup & CPS_XT_RIGHTALIGN)
  232. {
  233. m_rcWnd.left = m_rcWnd.right - sz.cx;
  234. }
  235. else
  236. {
  237. m_rcWnd.right = m_rcWnd.left + sz.cx;
  238. }
  240. m_rcWnd.top = rect.bottom;
  241. m_rcWnd.bottom = m_rcWnd.top + sz.cy;
  242. }
  243. else
  244. {
  245. rect.right = rect.left + sz.cx;
  246. rect.bottom = rect.top + sz.cy;
  247. }
  250. // register the wnd class.
  251. CString wndClass = ::AfxRegisterWndClass(0, AfxGetApp()->LoadStandardCursor(IDC_ARROW));
  253. // call the base class for creation.
  254. if (!CWnd::CreateEx(NULL, wndClass, _T(""), WS_CHILD,
  255. m_rcWnd, m_pParentWnd, 0, NULL))
  256. {
  257. TRACE0("Failed to create color popup window.n");
  258. return FALSE;
  259. }
  261. // Set the font and control ID.
  262. SetFont(&XTAuxData().font);
  264. if ((dwPopup & WS_VISIBLE) && ((m_dwPopup & WS_POPUP) == 0))
  265. {
  266. ShowWindow(SW_SHOWNA);
  267. }
  270. return TRUE;
  271. }
  274. int CXTColorSelectorCtrl::OnCreate(LPCREATESTRUCT lpCreateStruct)
  275. {
  276. if (CWnd::OnCreate(lpCreateStruct) == -1)
  277. return -1;
  279. int nIndex = -1;
  280. bool bChecked = false;
  282. // Create the ToolTip control.
  283. m_tooltip.Create(this);
  284. m_tooltip.Activate(TRUE);
  286. int nLeft = m_rcBorders.left;
  287. int nTop = m_rcBorders.top;
  288. int nRight = lpCreateStruct->cx - m_rcBorders.right;
  289. int nResID;
  290. COLOR_CELL* pColorCell;
  291. CString strText, strColorToolTip;
  293. if ((m_dwPopup & CPS_XT_NOAUTOMATIC) == 0)
  294. {
  295. nResID = m_dwPopup & CPS_XT_NOFILL ? XTP_IDS_CLR_NOFILL : XTP_IDS_CLR_AUTOMATIC;
  297. VERIFY(XTPResourceManager()->LoadString(&strText, nResID));
  298. int nTipIndex = FIND_S(strText, _T('n'), 0);
  299. if (nTipIndex > 0)
  300. {
  301. strColorToolTip = strText.Mid(nTipIndex + 1);
  302. strText.ReleaseBuffer(nTipIndex);
  303. }
  304. else
  305. {
  306. strColorToolTip = strText;
  307. }
  309. nIndex++;
  311. // Create the automatic color button.
  312. pColorCell = new COLOR_CELL;
  313. STRCPY_S(pColorCell->szText, 256, strText);
  315. pColorCell->nID = nResID;
  316. pColorCell->rect = CRect(nLeft, nTop, nRight, nTop + 23);
  317. pColorCell->nIndex = nIndex;
  318. pColorCell->bChecked = false;
  319. pColorCell->dwStyle = m_dwPopup;
  320. pColorCell->clr = m_clrDefault;
  322. m_arCells.AddTail(pColorCell);
  324. m_tooltip.AddTool(this, strColorToolTip, pColorCell->rect, nResID);
  326. if (!(m_dwPopup & CPS_XT_NOFILL))
  327. {
  328. if (m_clrColor == m_clrDefault)
  329. {
  330. bChecked = true;
  331. pColorCell->bChecked = true;
  332. }
  333. }
  334. else if (m_clrColor == m_clrDefault && m_clrDefault == COLORREF_NULL)
  335. {
  336. bChecked = true;
  337. pColorCell->bChecked = true;
  338. }
  340. nTop += 27;
  341. }
  343. // Create the color pick buttons.
  344. XTP_PICK_BUTTON* pickBtn = (m_dwPopup & CPS_XT_EXTENDED) ? (m_pExtendedColors ? m_pExtendedColors : extendedColors) : standardColors;
  345. int nColors = (m_dwPopup & CPS_XT_EXTENDED) ? (m_pExtendedColors ? m_nExtendedColors : _countof(extendedColors)) : _countof(standardColors);
  347. nTop += ((m_dwPopup & CPS_XT_EXTENDED) ? 0 : 22);
  349. CRect rect(nLeft, nTop, nLeft + m_sizeButton.cx, nTop + m_sizeButton.cy);
  350. int x;
  352. for (x = 0; x < nColors; x++)
  353. {
  354. if (x > 0 && ((x % m_nCols) == 0))
  355. {
  356. nTop += m_sizeButton.cy;
  357. rect = CRect(nLeft, nTop, nLeft + m_sizeButton.cy, nTop + m_sizeButton.cy);
  358. }
  359. nIndex++;
  361. nResID = pickBtn[x].toolTipID;
  362. COLORREF clrColor = pickBtn[x].clrButton;
  364. pColorCell = new COLOR_CELL;
  365. pColorCell->szText[0] = 0;
  366. pColorCell->nID = nResID;
  367. pColorCell->rect = rect;
  368. pColorCell->nIndex = nIndex;
  369. pColorCell->bChecked = false;
  370. pColorCell->dwStyle = CPS_XT_PICKBOX;
  371. pColorCell->clr = clrColor;
  373. m_arCells.AddTail(pColorCell);
  375. VERIFY(XTPResourceManager()->LoadString(&strColorToolTip, nResID));
  377. m_tooltip.AddTool(this, strColorToolTip, pColorCell->rect, nResID);
  379. if ((m_clrColor == clrColor) && !bChecked)
  380. {
  381. bChecked = true;
  382. pColorCell->bChecked = true;
  383. m_nCurSel = pColorCell->nIndex;
  384. }
  386. // offset to next column.
  387. rect.OffsetRect(m_sizeButton.cx, 0);
  388. }
  390. nTop += m_sizeButton.cy;
  391. rect = CRect(nLeft, nTop, nLeft + m_sizeButton.cy, nTop + m_sizeButton.cy);
  393. if (m_dwPopup & CPS_XT_MORECOLORS)
  394. {
  395. // TSF NEU 18.01.02 - user defined colors
  396. if (m_arUserDefColors.GetSize() > 0)
  397. {
  398. rect.OffsetRect(0, 4);
  400. for (x = 0; x < min(m_arUserDefColors.GetSize(), m_nCols); x++)
  401. {
  402. nIndex++;
  404. COLORREF clrColor = m_arUserDefColors.GetAt(x);
  406. pColorCell = new COLOR_CELL;
  407. pColorCell->szText[0] = 0;
  408. pColorCell->nID = 0;
  409. pColorCell->rect = rect;
  410. pColorCell->nIndex = nIndex;
  411. pColorCell->bChecked = false;
  412. pColorCell->dwStyle = CPS_XT_PICKBOX;
  413. pColorCell->clr = clrColor;
  415. m_arCells.AddTail(pColorCell);
  416. m_tooltip.AddTool(this, CXTColorDialog::RGBtoHex(clrColor), pColorCell->rect, 1);
  418. if (m_clrColor == clrColor)
  419. {
  420. bChecked = TRUE;
  421. pColorCell->bChecked = true;
  422. if (!bChecked)
  423. m_nCurSel = pColorCell->nIndex;
  424. }
  425. // offset to next column.
  426. rect.OffsetRect(m_sizeButton.cx, 0);
  427. }
  429. nTop += rect.Height() + 4;
  430. }
  432. nTop += 4;
  434. VERIFY(XTPResourceManager()->LoadString(&strText, XTP_IDS_CLR_MORE));
  436. nIndex++;
  437. pColorCell = new COLOR_CELL;
  438. STRCPY_S(pColorCell->szText, 256, strText);
  440. pColorCell->nID = XTP_IDS_CLR_MORE;
  441. pColorCell->rect = CRect(nLeft, nTop, nRight, nTop + 23);
  442. pColorCell->nIndex = nIndex;
  443. pColorCell->bChecked = false;
  444. pColorCell->dwStyle = CPS_XT_MORECOLORS;
  445. pColorCell->clr = m_clrColor;
  447. CString strMoreColorToolTip = strText;
  449. m_arCells.AddTail(pColorCell);
  450. m_tooltip.AddTool(this, strMoreColorToolTip, pColorCell->rect, 1);
  452. if (m_clrColor != (COLORREF)-1)
  453. {
  454. if (bChecked == false)
  455. {
  456. bChecked = true;
  457. pColorCell->bChecked = true;
  458. }
  459. }
  460. }
  462. m_nCurSel = -1;
  464. return 0;
  466. }
  469. ////////////////////////////////////////////////////////////////////////////////
  470. // CXTColorSelectorCtrl Drawing
  472. BOOL CXTColorSelectorCtrl::IsColorStatic(CDC* pDC) const
  473. {
  474. if ((GetStyle() & WS_CHILD) != 0)
  475. {
  476. CWnd* pWndParent = GetParent();
  477. if (::IsWindow(pWndParent->GetSafeHwnd()))
  478. {
  479. HBRUSH hBrush = (HBRUSH)pWndParent->SendMessage(WM_CTLCOLORSTATIC,
  480. (WPARAM)pDC->GetSafeHdc(), (LPARAM)m_hWnd);
  482. return (hBrush != NULL);
  483. }
  484. }
  486. return FALSE;
  487. }
  489. void CXTColorSelectorCtrl::OnPaint()
  490. {
  491. CPaintDC dc(this); // device context for painting
  493. CXTPClientRect rc(this);
  494. CXTPBufferDC memDC(dc);
  496. GetTheme()->FillBackground(&memDC, rc, this);
  498. DrawColorSelector(&memDC);
  499. }
  501. void CXTColorSelectorCtrl::DrawColorSelector(CDC* pDC)
  502. {
  503. pDC->SetBkMode(TRANSPARENT);
  504. CFont* pOldFont = pDC->SelectObject(&XTAuxData().font);
  506. if ((m_dwPopup & CPS_XT_EXTENDED) == 0)
  507. {
  508. CString strText;
  509. VERIFY(XTPResourceManager()->LoadString(&strText, XT_IDS_STD_COLORS));
  511. int nTop = ((m_dwPopup & CPS_XT_NOAUTOMATIC) == 0) ? 27 : 0;
  512. pDC->TextOut(6, nTop + 4, strText);
  513. }
  515. POSITION pos;
  516. int nIndex = 0;
  517. for (pos = m_arCells.GetHeadPosition(); pos; m_arCells.GetNext(pos))
  518. {
  519. COLOR_CELL* pColorCell = m_arCells.GetAt(pos);
  520. ASSERT(pColorCell != NULL);
  522. BOOL bHighlighted = (((nIndex == m_nCurSel) && (m_nPressed == -1)) || (nIndex == m_nPressed));
  523. BOOL bPressed = ((nIndex == m_nPressed) && (nIndex == m_nCurSel));
  525. GetTheme()->DrawColorCell(pColorCell, pDC, bHighlighted, bPressed);
  526. nIndex++;
  527. }
  529. pDC->SelectObject(pOldFont);
  530. }
  532. ////////////////////////////////////////////////////////////////////////////////
  534. CXTColorSelectorCtrl::COLOR_CELL* CXTColorSelectorCtrl::GetCellFromIndex(int iIndex)
  535. {
  536. POSITION pos = m_arCells.FindIndex(iIndex);
  537. if (pos != NULL)
  538. return m_arCells.GetAt(pos);
  540. return NULL;
  541. }
  544. int CXTColorSelectorCtrl::OnMouseActivate(CWnd* /*pDesktopWnd*/, UINT /*nHitTest*/, UINT /*message*/)
  545. {
  546. return GetStyle() & WS_POPUP ? MA_NOACTIVATE : (int)Default();
  547. }
  549. void CXTColorSelectorCtrl::OnMouseMove(UINT nFlags, CPoint point)
  550. {
  551. if (!IsColorDlgVisible())
  552. {
  553. if (m_point != point)
  554. {
  555. m_point = point;
  557. POSITION pos;
  558. for (pos = m_arCells.GetHeadPosition(); pos; m_arCells.GetNext(pos))
  559. {
  560. COLOR_CELL* pColorCell = m_arCells.GetAt(pos);
  561. ASSERT(pColorCell != NULL);
  562. if (!pColorCell)
  563. continue;
  565. CRect rcItem = pColorCell->rect;
  566. if (rcItem.PtInRect(point))
  567. {
  568. SelectColorCell(pColorCell);
  569. TRACKMOUSEEVENT tme =
  570. {
  571. sizeof(TRACKMOUSEEVENT), TME_LEAVE, m_hWnd
  572. };
  573. _TrackMouseEvent(&tme);
  575. return;
  576. }
  577. }
  579. SelectColorCell(NULL);
  580. }
  582. CWnd::OnMouseMove(nFlags, point);
  583. }
  584. }
  586. void CXTColorSelectorCtrl::OnMouseLeave()
  587. {
  588. if (!IsColorDlgVisible())
  589. {
  590. m_nPressed = m_nCurSel = -1;
  591. Invalidate(FALSE);
  592. }
  593. }
  595. void CXTColorSelectorCtrl::SelectColorCell(COLOR_CELL* pColorCell)
  596. {
  598. m_nCurSel = pColorCell == NULL ? -1 : (int)pColorCell->nIndex;
  599. Invalidate(FALSE);
  600. }
  602. // Adds a window to send color picker notifications to.
  603. void CXTColorSelectorCtrl::AddListener(HWND hwndListener)
  604. {
  605. m_listeners.Add(hwndListener);
  606. }
  608. void CXTColorSelectorCtrl::RemoveListener(HWND hwndListener)
  609. {
  610. int i;
  611. for (i = (int)m_listeners.GetSize() - 1; i >= 0 ; i--)
  612. {
  613. if (m_listeners[i] == hwndListener)
  614. m_listeners.RemoveAt(i);
  615. }
  616. }
  619. void CXTColorSelectorCtrl::OnLButtonDown(UINT nFlags, CPoint point)
  620. {
  621. if (!IsColorDlgVisible())
  622. {
  623. CWnd::OnLButtonDown(nFlags, point);
  625. CRect rc;
  626. GetClientRect(&rc);
  628. if (rc.PtInRect(point))
  629. {
  630. m_nPressed = m_nCurSel;
  631. Invalidate(FALSE);
  632. }
  633. }
  634. }
  636. void CXTColorSelectorCtrl::OnLButtonUp(UINT nFlags, CPoint point)
  637. {
  638. if (!IsColorDlgVisible())
  639. {
  640. CWnd::OnLButtonUp(nFlags, point);
  642. if (m_nPressed == m_nCurSel && m_nCurSel != -1)
  643. {
  644. EndSelection(m_nCurSel);
  645. }
  647. m_nCurSel = m_nPressed = -1;
  648. Invalidate(FALSE);
  649. }
  650. }
  652. void CXTColorSelectorCtrl::SetCurSel(int nIndex)
  653. {
  654. if (nIndex < 0) nIndex = ((m_dwPopup & CPS_XT_NOAUTOMATIC) == 0) ? 0 : (int)m_arCells.GetCount() - 1;
  655. if (nIndex >= m_arCells.GetCount()) nIndex = (int)m_arCells.GetCount() - 1;
  657. POSITION pos = m_arCells.FindIndex(nIndex);
  658. if (pos == NULL)
  659. return;
  661. COLOR_CELL* pColorCell = m_arCells.GetAt(pos);
  662. SelectColorCell(pColorCell);
  663. }
  665. void CXTColorSelectorCtrl::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
  666. {
  667. if (IsColorDlgVisible())
  668. return;
  670. int nLastIndex = (int)m_arCells.GetCount() - 1;
  672. //          0
  673. //
  674. //  1  1  2  3  4  5  6  7  8
  675. //  2  9 10 11 12 13 14 15 16
  676. //  3 17 18 19 20 21 22 23 24
  677. //  4 25 26 27 28 29 30 31 32
  678. //
  679. //         33
  680. //
  681. //          0
  682. //
  683. //  1  1  2  3  4  5  6  7  8
  684. //  2  9 10 11 12 13 14 15 16
  685. //  3 17 18 19 20 21 22 23 24
  686. //  4 25 26 27 28 29 30 31 32
  687. //  5 33
  688. //
  689. //         34
  691. switch (nChar)
  692. {
  693. case VK_DOWN:
  694. {
  695. // Check for no current cursor yet
  696. if (m_nCurSel == -1)
  697. {
  698. m_nCurSel = 0 ;
  699. }
  700. // top button to first color cell
  701. else if (m_nCurSel == 0 && ((m_dwPopup & CPS_XT_NOAUTOMATIC) == 0))
  702. {
  703. m_nCurSel = 1 ;
  704. }
  705. // bottom button to top bottom
  706. else if (m_nCurSel == nLastIndex)
  707. {
  708. m_nCurSel = 0 ;
  709. }
  710. // a color square to the next color square below it
  711. else
  712. {
  713. m_nCurSel += m_nCols;
  714. }
  715. SetCurSel(m_nCurSel);
  716. break;
  717. }
  719. case VK_UP:
  720. {
  721. // Check for no current cursor yet
  722. if (m_nCurSel == -1)
  723. {
  724. m_nCurSel = nLastIndex ;
  725. }
  726. // top button to last button
  727. else if (m_nCurSel == 0)
  728. {
  729. m_nCurSel = nLastIndex ;
  730. }
  731. // bottom button to first color square in the last row
  732. else if (m_nCurSel == nLastIndex)
  733. {
  734. m_nCurSel = (m_dwPopup & CPS_XT_MORECOLORS) ? m_nCurSel - 1 : m_nCurSel - m_nCols;
  735. }
  736. // a color square to another color square just above it
  737. else
  738. {
  739. m_nCurSel -= m_nCols;
  740. }
  742. SetCurSel(m_nCurSel);
  743. break;
  744. }
  746. case VK_RIGHT:
  747. {
  748. // Check for no current cursor yet
  749. if (m_nCurSel == -1)
  750. {
  751. m_nCurSel = 0 ;
  752. }
  753. else
  754. {
  755. ++m_nCurSel;
  756. if (m_nCurSel > nLastIndex)
  757. {
  758. m_nCurSel = 0;
  759. }
  760. }
  761. SetCurSel(m_nCurSel);
  762. break;
  763. }
  765. case VK_LEFT:
  766. {
  767. // Check for no current cursor yet
  768. if (m_nCurSel == -1)
  769. {
  770. m_nCurSel = nLastIndex ;
  771. }
  772. else
  773. {
  774. --m_nCurSel;
  775. if (m_nCurSel < 0)
  776. {
  777. m_nCurSel = nLastIndex;
  778. }
  779. }
  780. SetCurSel(m_nCurSel);
  781. break;
  782. }
  784. case VK_ESCAPE:
  785. {
  786. EndSelection(-1);
  787. return;
  788. }
  789. case VK_RETURN:
  790. case VK_SPACE:
  791. {
  792. EndSelection(m_nCurSel);
  793. return;
  794. }
  795. }
  797. CWnd::OnKeyDown(nChar, nRepCnt, nFlags);
  798. }
  801. BOOL CXTColorSelectorCtrl::PreTranslateMessage(MSG* pMsg)
  802. {
  803. if (m_tooltip.GetSafeHwnd()) m_tooltip.RelayEvent(pMsg);
  805. return CWnd::PreTranslateMessage(pMsg);
  806. }
  808. int CXTColorSelectorCtrl::GetCurSel(COLOR_CELL* pColorCell)
  809. {
  810. pColorCell = GetCellFromIndex(m_nCurSel);
  811. ASSERT(pColorCell != NULL);
  812. return m_nCurSel;
  813. }
  815. void CXTColorSelectorCtrl::EndSelection(int nCurSel)
  816. {
  817. OnEndSelection(nCurSel, 0);
  818. }
  820. void CXTColorSelectorCtrl::OnSetFocus(CWnd* pOldWnd)
  821. {
  822. if (IsColorDlgVisible())
  823. {
  824. m_pColorDlg->SetFocus();
  825. pOldWnd = this;
  826. }
  827. CWnd::OnSetFocus(pOldWnd);
  828. }
  830. BOOL CXTColorSelectorCtrl::LookUpColor(const COLORREF crFind)
  831. {
  832. // if the color was already added, return TRUE.
  833. int i;
  834. for (i = 0; i < m_arUserDefColors.GetSize(); ++i)
  835. {
  836. if (crFind == m_arUserDefColors.GetAt(i))
  837. return TRUE;
  838. }
  840. // if the color is already displayed as a default selection return TRUE.
  841. if (m_dwPopup & CPS_XT_EXTENDED)
  842. {
  843. for (i = 0; i < _countof(extendedColors); ++i)
  844. {
  845. if (crFind == extendedColors[i].clrButton)
  846. return TRUE;
  847. }
  848. }
  849. else
  850. {
  851. for (i = 0; i < _countof(standardColors); ++i)
  852. {
  853. if (crFind == standardColors[i].clrButton)
  854. return TRUE;
  855. }
  856. }
  858. return FALSE;
  859. }
  861. void CXTColorSelectorCtrl::OnEndSelection(int nCurSel, LPARAM callerParam)
  862. {
  863. int nMessage = 0;
  865. // copy off the listeners
  866. CArray<HWND, HWND> listeners;
  867. listeners.Append(m_listeners);
  869. // copy other relevant data
  870. COLORREF clrColor = m_clrColor;
  871. DWORD dwPopup = m_dwPopup;
  873. if (nCurSel == (int)m_arCells.GetCount() - 1 && (m_dwPopup & CPS_XT_MORECOLORS))
  874. {
  875. // display dialog and send proper notifications
  876. m_pColorDlg = new CXTColorDialog(clrColor, clrColor,
  877. (dwPopup & (CPS_XT_SHOWHEXVALUE | CPS_XT_SHOW3DSELECTION)), GetParent());
  879. if (m_pColorDlg->DoModal() == IDOK)
  880. {
  881. COLORREF clrDlgColor = m_pColorDlg->GetColor();
  883. if (clrColor == clrDlgColor)
  884. {
  885. nMessage = CPN_XT_SELCHANGE;
  886. }
  887. else
  888. {
  889. nMessage = CPN_XT_SELENDOK;
  890. clrColor = clrDlgColor;
  891. }
  893. // TSF NEU 18.01.02 - user defined colors
  895. if (m_arUserDefColors.GetSize() >= m_nCols)
  896. m_arUserDefColors.RemoveAt(0);
  898. if (!LookUpColor(clrColor))
  899. m_arUserDefColors.Add(clrColor);
  901. // TSF NEU 18.01.02 - user defined colors
  902. }
  903. else
  904. {
  905. nMessage = CPN_XT_SELENDCANCEL;
  906. }
  908. SAFE_DELETE(m_pColorDlg);
  909. }
  911. else if (nCurSel == 0)
  912. {
  913. if (m_dwPopup & CPS_XT_NOFILL)
  914. {
  915. nMessage = CPN_XT_SELNOFILL;
  916. clrColor = (ULONG)-1;
  917. }
  918. else if (m_clrColor == m_clrDefault)
  919. {
  920. nMessage = CPN_XT_SELCHANGE;
  921. }
  922. else
  923. {
  924. nMessage = CPN_XT_SELENDOK;
  925. clrColor = m_clrDefault;
  926. }
  927. }
  929. else if (nCurSel == -1)
  930. {
  931. nMessage = CPN_XT_SELENDCANCEL;
  932. }
  934. else
  935. {
  936. COLOR_CELL* pColorCell = GetCellFromIndex(nCurSel);
  937. ASSERT(pColorCell != NULL);
  938. if (!pColorCell)
  939. return;
  941. COLORREF clrCellColor = pColorCell->clr;
  943. if (clrColor == clrCellColor)
  944. {
  945. nMessage = CPN_XT_SELCHANGE;
  946. }
  947. else
  948. {
  949. nMessage = CPN_XT_SELENDOK;
  950. clrColor = clrCellColor;
  951. }
  952. }
  955. // Pass this message to the registered listeners
  956. int i;
  957. for (i = 0; i < listeners.GetSize(); i++)
  958. {
  959. if (::IsWindow(listeners[i]))
  960. {
  961. ::SendMessage(listeners[i], nMessage,
  962. (WPARAM)clrColor, callerParam);
  963. }
  964. }
  965. }
  967. BOOL CXTColorSelectorCtrl::OnEraseBkgnd(CDC* /*pDC*/)
  968. {
  969. return TRUE;
  970. }
  972. void CXTColorSelectorCtrl::SelectColor(COLORREF clr)
  973. {
  974. POSITION pos;
  975. for (pos = m_arCells.GetHeadPosition(); pos; m_arCells.GetNext(pos))
  976. {
  977. COLOR_CELL* pColorCell = m_arCells.GetAt(pos);
  978. ASSERT(pColorCell != NULL);
  979. if (!pColorCell)
  980. continue;
  982. if (pColorCell->dwStyle & CPS_XT_PICKBOX)
  983. pColorCell->bChecked = clr == pColorCell->clr;
  984. }
  986. m_clrColor = clr;
  988. Invalidate(FALSE);
  989. }
  992. LRESULT CXTColorSelectorCtrl::OnNcHitTest(CPoint point)
  993. {
  994. // If we have a valid tooltip pointer, bring the tooltip control
  995. // to the top of the Z-order.
  997. if (m_tooltip.GetSafeHwnd() && !IsColorDlgVisible())
  998. {
  999. m_tooltip.SetWindowPos(&wndTop, 0, 0, 0, 0,
  1000. SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOMOVE);
  1001. }
  1003. return (LRESULT)CWnd::OnNcHitTest(point);
  1004. }
  1006. bool CXTColorSelectorCtrl::IsColorDlgVisible()
  1007. {
  1008. return (m_pColorDlg && ::IsWindow(m_pColorDlg->m_hWnd));
  1009. }
  1011. void CXTColorSelectorCtrl::SetUserColors(const CUIntArray& arUserDefColors)
  1012. {
  1013. m_arUserDefColors.RemoveAll();
  1014. m_arUserDefColors.Copy(arUserDefColors);
  1015. }
  1017. CUIntArray& CXTColorSelectorCtrl::GetUserColors()
  1018. {
  1019. return m_arUserDefColors;
  1020. }
  1022. //////////////////////////////////////////////////////////////////////////
  1023. // CXTColorSelectorCtrlTheme
  1026. //////////////////////////////////////////////////////////////////////
  1027. // CXTColorSelectorCtrlTheme
  1029. IMPLEMENT_THEME_FACTORY(CXTColorSelectorCtrlTheme)
  1031. CXTColorSelectorCtrlTheme::CXTColorSelectorCtrlTheme()
  1032. : m_crBorderHilight(COLORREF_NULL)
  1033. , m_crBorderShadow(COLORREF_NULL)
  1034. , m_crBack(COLORREF_NULL)
  1035. , m_crPressed(COLORREF_NULL)
  1036. , m_crHilight(COLORREF_NULL)
  1037. , m_crChecked(COLORREF_NULL)
  1038. {
  1039. }
  1041. void CXTColorSelectorCtrlTheme::RefreshMetrics()
  1042. {
  1043. CXTThemeManagerStyle::RefreshMetrics();
  1045. m_crBack = GetXtremeColor(COLOR_3DFACE);
  1046. m_crBorderHilight = GetXtremeColor(COLOR_3DHILIGHT);
  1047. m_crBorderShadow = GetXtremeColor(COLOR_3DSHADOW);
  1048. m_crText = GetXtremeColor(COLOR_BTNTEXT);
  1049. }
  1051. void CXTColorSelectorCtrlTheme::FillBackground(CDC* pDC, const CRect& rect, CXTColorSelectorCtrl* /*pOwner*/)
  1052. {
  1053. pDC->FillSolidRect(&rect, m_crBack);
  1054. }
  1056. void CXTColorSelectorCtrlTheme::DrawColorCell(CXTColorSelectorCtrl::COLOR_CELL* pColorCell, CDC* pDC, BOOL bHilite, BOOL bPressed)
  1057. {
  1058. pDC->SetBkMode(TRANSPARENT);
  1059. CFont* pOldFont = pDC->SelectObject(&XTAuxData().font);
  1061. CRect rcItem = pColorCell->rect;
  1063. bool bChecked = pColorCell->bChecked;
  1065. if (bChecked || bHilite || bPressed)
  1066. {
  1067. if (bPressed)
  1068. {
  1069. if (m_crPressed != COLORREF_NULL)
  1070. {
  1071. pDC->FillSolidRect(&rcItem, m_crPressed);
  1072. }
  1073. }
  1074. else if (bHilite)
  1075. {
  1076. if (m_crHilight != COLORREF_NULL)
  1077. {
  1078. pDC->FillSolidRect(&rcItem, m_crHilight);
  1079. }
  1080. }
  1081. else if (bChecked)
  1082. {
  1083. if (m_crChecked != COLORREF_NULL)
  1084. {
  1085. pDC->FillSolidRect(&rcItem, m_crChecked);
  1086. }
  1087. else
  1088. {
  1089. XTFuncDrawShadedRect(pDC, rcItem);
  1090. }
  1091. }
  1093. pDC->Draw3dRect(rcItem, (bPressed || bChecked) ? m_crBorderShadow : m_crBorderHilight,
  1094. (bPressed || bChecked) ? m_crBorderHilight : m_crBorderShadow);
  1095. }
  1097. int nLen = (int)_tcslen(pColorCell->szText);
  1098. if (nLen)
  1099. {
  1100. pDC->SetTextColor(m_crText);
  1101. pDC->DrawText(pColorCell->szText, nLen, rcItem, DT_SINGLELINE | DT_CENTER | DT_VCENTER);
  1102. }
  1104. if (pColorCell->dwStyle != CPS_XT_MORECOLORS)
  1105. {
  1106. rcItem.DeflateRect(3, 3);
  1108. if ((pColorCell->dwStyle & CPS_XT_PICKBOX) == 0)
  1109. {
  1110. if ((pColorCell->dwStyle & CPS_XT_NOFILL) == 0)
  1111. {
  1112. rcItem.DeflateRect(3, 3);
  1113. rcItem.right = rcItem.left + 12;
  1114. rcItem.bottom = rcItem.top + 11;
  1115. rcItem.OffsetRect(1, 0);
  1116. pDC->Draw3dRect(rcItem, m_crBorderShadow, m_crBorderShadow);
  1117. rcItem.DeflateRect(1, 1);
  1118. pDC->FillSolidRect(rcItem, pColorCell->clr);
  1119. }
  1120. }
  1121. else
  1122. {
  1123. pDC->Draw3dRect(rcItem, m_crBorderShadow, m_crBorderShadow);
  1124. rcItem.DeflateRect(1, 1);
  1125. pDC->FillSolidRect(rcItem, pColorCell->clr);
  1126. }
  1127. }
  1128. else
  1129. {
  1130. if (pColorCell->bChecked)
  1131. {
  1132. rcItem = pColorCell->rect;
  1133. rcItem.DeflateRect(5, 6);
  1134. rcItem.left = rcItem.right - 12;
  1135. pDC->Draw3dRect(rcItem, m_crBorderShadow, m_crBorderShadow);
  1136. rcItem.DeflateRect(1, 1);
  1137. pDC->FillSolidRect(rcItem, pColorCell->clr);
  1138. }
  1139. }
  1141. pDC->SelectObject(pOldFont);
  1142. }
  1144. //////////////////////////////////////////////////////////////////////
  1145. // CXTColorSelectorCtrlThemeOfficeXP
  1147. CXTColorSelectorCtrlThemeOfficeXP::CXTColorSelectorCtrlThemeOfficeXP()
  1148. {
  1149. }
  1151. void CXTColorSelectorCtrlThemeOfficeXP::RefreshMetrics()
  1152. {
  1153. CXTColorSelectorCtrlTheme::RefreshMetrics();
  1155. m_crBorderHilight = GetXtremeColor(XPCOLOR_HIGHLIGHT_BORDER);
  1156. m_crBorderShadow = GetXtremeColor(XPCOLOR_HIGHLIGHT_BORDER);
  1157. m_crBack = GetXtremeColor(XPCOLOR_MENUBAR_FACE);
  1158. m_crPressed = GetXtremeColor(XPCOLOR_HIGHLIGHT_PUSHED);
  1159. m_crHilight = GetXtremeColor(XPCOLOR_HIGHLIGHT);
  1160. m_crChecked = GetXtremeColor(XPCOLOR_HIGHLIGHT_CHECKED);
  1161. }
  1163. //////////////////////////////////////////////////////////////////////
  1164. // CXTColorSelectorCtrlThemeOffice2003
  1166. CXTColorSelectorCtrlThemeOffice2003::CXTColorSelectorCtrlThemeOffice2003()
  1167. {
  1168. }
  1170. void CXTColorSelectorCtrlThemeOffice2003::RefreshMetrics()
  1171. {
  1172. CXTColorSelectorCtrlThemeOfficeXP::RefreshMetrics();
  1174. m_crBorderHilight = GetMSO2003Color(XPCOLOR_HIGHLIGHT_BORDER);
  1175. m_crBorderShadow = GetMSO2003Color(XPCOLOR_HIGHLIGHT_BORDER);
  1176. m_crBack = GetMSO2003Color(XPCOLOR_MENUBAR_FACE);
  1177. m_crPressed = GetMSO2003Color(XPCOLOR_HIGHLIGHT_PUSHED);
  1178. m_crHilight = GetMSO2003Color(XPCOLOR_HIGHLIGHT);
  1179. m_crChecked = GetMSO2003Color(XPCOLOR_HIGHLIGHT_CHECKED);
  1180. }