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

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

界面编程

开发平台：

Visual C++

ExtColorCtrl.h：源码内容
  1. // This is part of the Professional User Interface Suite library.
  2. // Copyright (C) 2001-2009 FOSS Software, Inc.
  3. // All rights reserved.
  4. //
  5. // http://www.prof-uis.com
  6. // mailto:support@prof-uis.com
  7. //
  8. // This source code can be used, modified and redistributed
  9. // under the terms of the license agreement that is included
  10. // in the Professional User Interface Suite package.
  11. //
  12. // Warranties and Disclaimers:
  13. // THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND
  14. // INCLUDING, BUT NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY,
  15. // FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  16. // IN NO EVENT WILL FOSS SOFTWARE INC. BE LIABLE FOR ANY DIRECT,
  17. // INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES,
  18. // INCLUDING DAMAGES FOR LOSS OF PROFITS, LOSS OR INACCURACY OF DATA,
  19. // INCURRED BY ANY PERSON FROM SUCH PERSON'S USAGE OF THIS SOFTWARE
  20. // EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
  22. #if (!defined __EXTCOLORCTRL_H)
  23. #define __EXTCOLORCTRL_H
  25. // 
  26. // The idea of the HSL colorspace algorithm  belongs to Patrick Prache
  27. // The idea of the hexagon pallette algorithm belongs to Jack Mesic
  28. //
  30. #if (!defined __EXT_MFC_DEF_H)
  31. #include <ExtMfcDef.h>
  32. #endif // __EXT_MFC_DEF_H
  34. #if (!defined __EXT_MOUSECAPTURESINK_H)
  35. #include <../Src/ExtMouseCaptureSink.h>
  36. #endif
  38. #if _MSC_VER > 1000
  39. #pragma once
  40. #endif // _MSC_VER > 1000
  42. #include <math.h>
  44. #if (!defined __AFXPLEX_H__)
  45. #include <AfxTempl.h>
  46. #endif
  48. /////////////////////////////////////////////////////////////////////////////
  49. // CExtColorCtrl window
  51. class __PROF_UIS_API CExtColorCtrl
  52. : public CWnd
  53. , public CExtMouseCaptureSink
  54. , public CExtPmBridge
  55. {
  56. // Construction
  57. public:
  58. enum e_mode_t
  59. {
  60. MODE_HEXAGON = 0,
  61. MODE_HSL_PANEL = 1,
  62. MODE_HSL_BASIC_HUE = 2,
  63. MODE_HSL_ROLLER = 3,
  64. MODE_RGB_CUBE = 4,
  65. MODE_RGB_MIX = 5,
  66. MODE_GRAY_SCALE_MIX = 6,
  67. MODE_CMY_CUBE = 7,
  68. MODE_CMY_MIX = 8,
  69. MODE_XYZ_R = 9,
  70. MODE_XYZ_G = 10,
  71. MODE_XYZ_B = 11,
  72. MODE_XYZ_C = 12,
  73. MODE_XYZ_M = 13,
  74. MODE_XYZ_Y = 14,
  75. MODE_DIFF = 15,
  76. MODE_VAL_MIN = 0,
  77. MODE_VAL_MAX = 15,
  78. MODE_NAMED_MIN = 0,
  79. MODE_NAMED_MAX = 14,
  80. };
  82. static CExtSafeString GetColorModeName( e_mode_t eMode );
  84. DECLARE_DYNCREATE( CExtColorCtrl );
  85. DECLARE_CExtPmBridge_MEMBERS( CExtColorCtrl );
  87. CExtColorCtrl(
  88. e_mode_t eMode = MODE_HEXAGON
  89. );
  91. struct __PROF_UIS_API selection_colors_t
  92. {
  93. COLORREF m_clrCurrent;
  94. COLORREF m_clrNew;
  95. COLORREF m_clrPrev;
  96. selection_colors_t(
  97. COLORREF clrCurrent = RGB(255,255,255),
  98. COLORREF clrNew = RGB(255,255,255),
  99. COLORREF clrPrev = RGB(255,255,255)
  100. )
  101. : m_clrCurrent( clrCurrent )
  102. , m_clrNew( clrNew )
  103. , m_clrPrev( clrPrev )
  104. {
  105. }
  106. selection_colors_t(
  107. const selection_colors_t & other
  108. )
  109. : m_clrCurrent( RGB(255,255,255) )
  110. , m_clrNew( RGB(255,255,255) )
  111. , m_clrPrev( RGB(255,255,255) )
  112. {
  113. AssignFromOther( other );
  114. }
  115. ~selection_colors_t()
  116. {
  117. }
  118. selection_colors_t & operator = (
  119. const selection_colors_t & other
  120. )
  121. {
  122. AssignFromOther( other );
  123. return *this;
  124. }
  125. private:
  126. void AssignFromOther(
  127. const selection_colors_t & other
  128. )
  129. {
  130. m_clrCurrent = other.m_clrCurrent;
  131. m_clrNew = other.m_clrNew;
  132. m_clrPrev = other.m_clrPrev;
  133. }
  134. }; // struct selection_colors_t
  136. // Attributes
  137. public:
  139. private:
  140. e_mode_t m_eMode;
  141. bool m_bMouseTracking;
  143. struct __PROF_UIS_API any_picker_data_t
  144. {
  145. enum eMoveMode_t
  146. {
  147. _MM_NONE = 0,
  148. _MM_RED = 1,
  149. _MM_GREEN = 2,
  150. _MM_BLUE = 3,
  151. _MM_SLIDER = 4,
  152. _MM_PICKER = 5,
  153. _MM_CELL_SCAN = 6,
  154. };
  155. eMoveMode_t m_eMoveMode;
  157. CSize m_sizeTotal;
  158. COLORREF m_clr;
  159. COLORREF m_clrOld;
  160. double
  161. m_fCurrLuminance,
  162. m_fCurrSaturation,
  163. m_fCurrHue;
  165. any_picker_data_t();
  166. ~any_picker_data_t();
  168. virtual void OnInit(
  169. CDC & dc,
  170. CPalette * pPalette,
  171. CSize sizeTotal,
  172. bool bOnlySizeChanged
  173. );
  174. virtual void OnDone() = 0;
  175. virtual void OnDraw(
  176. CDC & dc,
  177. CPalette * pPalette
  178. ) = 0;
  179. virtual void OnLButtonDown(
  180. UINT nFlags,
  181. CPoint point
  182. ) = 0; 
  183. virtual void OnLButtonUp(
  184. UINT nFlags,
  185. CPoint point
  186. ) = 0; 
  187. virtual void OnMouseMove(
  188. UINT nFlags,
  189. CPoint point
  190. ) = 0; 
  191. virtual void OnSetOldRGB(
  192. COLORREF clr
  193. );
  194. virtual void OnSetRGB(
  195. COLORREF clr
  196. );
  197. virtual void OnSetHLS(
  198. double hue,
  199. double luminance,
  200. double saturation
  201. );
  203. }; // struct any_picker_data_t
  205. struct __PROF_UIS_API cell_t
  206. {
  207. COLORREF m_clr;
  208. CRect m_rcPosition;
  209. int m_nBorderSize;
  210. CPoint m_vPoints[6];
  211. bool m_bAtFirstType;
  213. cell_t( COLORREF clr = RGB(255,255,255) )
  214. : m_clr( clr )
  215. , m_nBorderSize( 1 )
  216. , m_bAtFirstType( true )
  217. {
  218. for( int i = 0; i < 6; i++ )
  219. m_vPoints[i] = CPoint(0,0);
  220. }
  221. cell_t( const cell_t & other )
  222. : m_clr( RGB(255,255,255) )
  223. , m_nBorderSize( 1 )
  224. , m_bAtFirstType( true )
  225. {
  226. for( int i = 0; i < 6; i++ )
  227. m_vPoints[i] = CPoint(0,0);
  228. AssignFromOther( other );
  229. }
  230. ~cell_t()
  231. {
  232. }
  233. cell_t& operator = ( const cell_t & other )
  234. {
  235. AssignFromOther( other );
  236. return *this;
  237. }
  238. cell_t& operator = ( COLORREF clr )
  239. {
  240. m_clr = clr;
  241. return *this;
  242. }
  243. void AdjustCellPosition(
  244. int x,
  245. int y,
  246. int nWidth
  247. )
  248. {
  249. float nSideLength =
  250. (float)((float)nWidth * 0.57735026918962F);
  251. m_vPoints[0] = CPoint(MoreNear(x - (float)(nWidth / 2)),MoreNear(y - (float)(nSideLength/2)));
  252. m_vPoints[1] = CPoint(MoreNear((float)x),MoreNear(y - (float)(nWidth / 2)));
  253. m_vPoints[2] = CPoint(MoreNear(x + (float)(nWidth / 2)),MoreNear(y - (float)(nSideLength/2)));
  254. m_vPoints[3] = CPoint(MoreNear(x + (float)(nWidth / 2)),MoreNear(y + (float)(nSideLength/2))+1);
  255. m_vPoints[4] = CPoint(MoreNear((float)x),MoreNear(y + (float)(nWidth / 2))+1);
  256. m_vPoints[5] = CPoint(MoreNear(x - (float)(nWidth / 2)),MoreNear(y + (float)(nSideLength/2))+1);
  257. }
  258. static int MoreNear(float fNear)
  259. {
  260. int nRound = (int)fabs(fNear);
  261. nRound = (fabs(fNear) - (float)nRound >= 0.5) ? nRound+1 : nRound;
  262. return (fNear < 0) ? -nRound : nRound;
  263. }
  264. void SetRect( const CRect & rcPos )
  265. {
  266. m_rcPosition = rcPos;
  267. }
  268. CRect GetRect() const
  269. {
  270. if( !m_bAtFirstType )
  271. {
  272. return m_rcPosition;
  273. }
  274. CRect rcBounds;
  276. rcBounds.left = rcBounds.right  = m_vPoints[0].x;
  277. rcBounds.top  = rcBounds.bottom = m_vPoints[0].y;
  279. for (int i=1; i<6; i++)
  280. {
  281. rcBounds.left   = min(rcBounds.left,   m_vPoints[i].x);
  282. rcBounds.top    = min(rcBounds.top,    m_vPoints[i].y);
  283. rcBounds.right  = max(rcBounds.right,  m_vPoints[i].x);
  284. rcBounds.bottom = max(rcBounds.bottom, m_vPoints[i].y);
  285. }
  286. return rcBounds;
  287. }
  288. void SetCellColor(const COLORREF &cr) 
  289. { 
  290. m_clr = cr; 
  291. }
  292. void OnDraw(
  293. CDC & dc,
  294. CPalette * pPalette,
  295. bool bFocused
  296. );
  297. BOOL HitTest(CPoint point)
  298. {
  299. if( m_bAtFirstType )
  300. {
  301. CRgn rgn;
  302. rgn.CreatePolygonRgn(m_vPoints, 6, ALTERNATE);
  303. return rgn.PtInRegion (point);
  304. }
  305. else
  306. {
  307. CRgn rgn;
  308. rgn.CreateRectRgn(m_rcPosition.left,m_rcPosition.top,m_rcPosition.right,m_rcPosition.bottom);
  309. return rgn.PtInRegion (point);
  310. }
  311. }
  313. private:
  314. void AssignFromOther( const cell_t & other )
  315. {
  316. m_clr = other.m_clr;
  317. m_rcPosition = other.m_rcPosition;
  318. m_nBorderSize = other.m_nBorderSize;
  319. for( int i = 0; i < 6; i++ )
  320. m_vPoints[i] = other.m_vPoints[i];
  321. m_bAtFirstType = other.m_bAtFirstType;
  322. }
  323. }; // struct cell_t
  325. typedef
  326. CArray < cell_t, cell_t & >
  327. vCells_t;
  329. struct __PROF_UIS_API cell_based_data_t : public any_picker_data_t
  330. {
  331. vCells_t m_vCells;
  333. cell_based_data_t()
  334. {
  335. }
  336. ~cell_based_data_t()
  337. {
  338. ReleaseAll();
  339. }
  341. virtual void OnInit(
  342. CDC & dc,
  343. CPalette * pPalette,
  344. CSize sizeTotal,
  345. bool bOnlySizeChanged
  346. );
  347. virtual void OnDone();
  348. virtual void OnDraw(
  349. CDC & dc,
  350. CPalette * pPalette
  351. );
  352. virtual void OnLButtonDown(
  353. UINT nFlags,
  354. CPoint point
  355. ); 
  356. virtual void OnLButtonUp(
  357. UINT nFlags,
  358. CPoint point
  359. ); 
  360. virtual void OnMouseMove(
  361. UINT nFlags,
  362. CPoint point
  363. ); 
  365. private:
  366. void Generate(
  367. bool bOnlySizeChanged
  368. );
  369. void ReleaseAll();
  370. }; // struct cell_based_data_t
  372. struct __PROF_UIS_API grayscale_mixer_data_t : public cell_based_data_t
  373. {
  374. grayscale_mixer_data_t()
  375. {
  376. }
  377. ~grayscale_mixer_data_t()
  378. {
  379. }
  380. virtual void OnInit(
  381. CDC & dc,
  382. CPalette * pPalette,
  383. CSize sizeTotal,
  384. bool bOnlySizeChanged
  385. );
  386. virtual void OnDraw(
  387. CDC & dc,
  388. CPalette * pPalette
  389. );
  390. }; // struct grayscale_mixer_data_t
  392. struct __PROF_UIS_API rgb_mixer_data_t : public cell_based_data_t
  393. {
  394. rgb_mixer_data_t()
  395. {
  396. }
  397. ~rgb_mixer_data_t()
  398. {
  399. }
  400. virtual void OnInit(
  401. CDC & dc,
  402. CPalette * pPalette,
  403. CSize sizeTotal,
  404. bool bOnlySizeChanged
  405. );
  406. virtual void OnDraw(
  407. CDC & dc,
  408. CPalette * pPalette
  409. );
  410. virtual void OnMouseMove(
  411. UINT nFlags,
  412. CPoint point
  413. ); 
  414. }; // struct rgb_mixer_data_t
  416. struct __PROF_UIS_API rgb_cube_data_t : public any_picker_data_t
  417. {
  418. CDC m_dcCube;
  419. CSize m_sizeHalfSelBox;
  420. CRect m_rcCube;
  421. int m_nSideGap;
  422. CPoint
  423. m_ptCubeR,m_ptCubeG,m_ptCubeB,m_ptCubeC,
  424. m_ptClrR,m_ptClrG,m_ptClrB,m_ptClrCurr,
  425. m_ptPlainRG,m_ptPlainRB,m_ptPlainGB;
  427. rgb_cube_data_t();
  428. ~rgb_cube_data_t();
  430. virtual void OnInit(
  431. CDC & dc,
  432. CPalette * pPalette,
  433. CSize sizeTotal,
  434. bool bOnlySizeChanged
  435. );
  436. virtual void OnDone();
  437. virtual void OnDraw(
  438. CDC & dc,
  439. CPalette * pPalette
  440. );
  441. virtual void OnLButtonDown(
  442. UINT nFlags,
  443. CPoint point
  444. ); 
  445. virtual void OnLButtonUp(
  446. UINT nFlags,
  447. CPoint point
  448. ); 
  449. virtual void OnMouseMove(
  450. UINT nFlags,
  451. CPoint point
  452. ); 
  453. virtual void OnSetRGB(
  454. COLORREF clr
  455. );
  456. virtual void OnSetHLS(
  457. double hue,
  458. double luminance,
  459. double saturation
  460. );
  462. private:
  463. void ReleaseAll();
  464. void Generate(
  465. CDC & dc,
  466. CPalette * pPalette
  467. );
  468. void RecalcLayout();
  470. }; // struct rgb_cube_data_t
  472. struct __PROF_UIS_API cmy_mixer_data_t : public cell_based_data_t
  473. {
  474. cmy_mixer_data_t()
  475. {
  476. }
  477. ~cmy_mixer_data_t()
  478. {
  479. }
  480. virtual void OnInit(
  481. CDC & dc,
  482. CPalette * pPalette,
  483. CSize sizeTotal,
  484. bool bOnlySizeChanged
  485. );
  486. virtual void OnDraw(
  487. CDC & dc,
  488. CPalette * pPalette
  489. );
  490. virtual void OnMouseMove(
  491. UINT nFlags,
  492. CPoint point
  493. ); 
  494. }; // struct cmy_mixer_data_t
  496. struct __PROF_UIS_API cmy_cube_data_t : public any_picker_data_t
  497. {
  498. CDC m_dcCube;
  499. CSize m_sizeHalfSelBox;
  500. CRect m_rcCube;
  501. int m_nSideGap;
  502. CPoint
  503. m_ptCubeR,m_ptCubeG,m_ptCubeB,m_ptCubeC,
  504. m_ptClrR,m_ptClrG,m_ptClrB,m_ptClrCurr,
  505. m_ptPlainRG,m_ptPlainRB,m_ptPlainGB;
  507. cmy_cube_data_t();
  508. ~cmy_cube_data_t();
  510. virtual void OnInit(
  511. CDC & dc,
  512. CPalette * pPalette,
  513. CSize sizeTotal,
  514. bool bOnlySizeChanged
  515. );
  516. virtual void OnDone();
  517. virtual void OnDraw(
  518. CDC & dc,
  519. CPalette * pPalette
  520. );
  521. virtual void OnLButtonDown(
  522. UINT nFlags,
  523. CPoint point
  524. ); 
  525. virtual void OnLButtonUp(
  526. UINT nFlags,
  527. CPoint point
  528. ); 
  529. virtual void OnMouseMove(
  530. UINT nFlags,
  531. CPoint point
  532. ); 
  533. virtual void OnSetRGB(
  534. COLORREF clr
  535. );
  536. virtual void OnSetHLS(
  537. double hue,
  538. double luminance,
  539. double saturation
  540. );
  542. private:
  543. void ReleaseAll();
  544. void Generate(
  545. CDC & dc,
  546. CPalette * pPalette
  547. );
  548. void RecalcLayout();
  550. }; // struct cmy_cube_data_t
  552. struct __PROF_UIS_API hsl_panel_data_t : public any_picker_data_t
  553. {
  554. CDC m_dcPicker;
  555. CDC m_dcSlider;
  556. bool m_bBmpValidPicker;
  557. bool m_bBmpValidSlider;
  559. CPoint m_ptMousePos; // position of the picker
  561. SIZE m_sizeColorPicker;
  562. SIZE m_sizeColorSlider;
  564. int m_nLumBarDy;
  565. int m_nAreaGap;
  567. hsl_panel_data_t();
  568. ~hsl_panel_data_t();
  570. virtual void OnInit(
  571. CDC & dc,
  572. CPalette * pPalette,
  573. CSize sizeTotal,
  574. bool bOnlySizeChanged
  575. );
  576. virtual void OnDone();
  577. virtual void OnDraw(
  578. CDC & dc,
  579. CPalette * pPalette
  580. );
  581. virtual void OnLButtonDown(
  582. UINT nFlags,
  583. CPoint point
  584. ); 
  585. virtual void OnLButtonUp(
  586. UINT nFlags,
  587. CPoint point
  588. ); 
  589. virtual void OnMouseMove(
  590. UINT nFlags,
  591. CPoint point
  592. ); 
  593. virtual void OnSetRGB(
  594. COLORREF clr
  595. );
  596. virtual void OnSetHLS(
  597. double hue,
  598. double luminance,
  599. double saturation
  600. );
  601. private:
  602. void ReleaseAll();
  603. protected:
  604. virtual void GenerateSlider(
  605. CDC &dc,
  606. CPalette * pPalette
  607. );
  608. virtual void GeneratePicker(
  609. CDC &dc,
  610. CPalette * pPalette
  611. );
  612. void DrawCrossAt(
  613. CPoint & point,
  614. CDC & dc,
  615. SIZE & sz
  616. );
  617. }; // struct hsl_panel_data_t
  619. struct __PROF_UIS_API hsl_basic_hue_data_t : public hsl_panel_data_t
  620. {
  621. hsl_basic_hue_data_t()
  622. {
  623. }
  624. ~hsl_basic_hue_data_t()
  625. {
  626. }
  628. virtual void OnDraw(
  629. CDC & dc,
  630. CPalette * pPalette
  631. );
  632. virtual void OnMouseMove(
  633. UINT nFlags,
  634. CPoint point
  635. ); 
  636. virtual void OnSetRGB(
  637. COLORREF clr
  638. );
  639. virtual void OnSetHLS(
  640. double hue,
  641. double luminance,
  642. double saturation
  643. );
  644. protected:
  645. virtual void GenerateSlider(
  646. CDC &dc,
  647. CPalette * pPalette
  648. );
  649. virtual void GeneratePicker(
  650. CDC &dc,
  651. CPalette * pPalette
  652. );
  653. }; // struct hsl_basic_hue_data_t
  655. struct __PROF_UIS_API hsl_roller_data_t : public hsl_panel_data_t
  656. {
  657. hsl_roller_data_t()
  658. {
  659. m_ptCenterSpaceHueSat.x = m_ptCenterSpaceHueSat.y = 0;
  660. m_nSatTranslation = 1;
  661. }
  662. ~hsl_roller_data_t()
  663. {
  664. }
  666. virtual void OnDraw(
  667. CDC & dc,
  668. CPalette * pPalette
  669. );
  670. virtual void OnLButtonDown(
  671. UINT nFlags,
  672. CPoint point
  673. ); 
  674. virtual void OnLButtonUp(
  675. UINT nFlags,
  676. CPoint point
  677. ); 
  678. virtual void OnMouseMove(
  679. UINT nFlags,
  680. CPoint point
  681. ); 
  682. virtual void OnSetRGB(
  683. COLORREF clr
  684. );
  685. virtual void OnSetHLS(
  686. double hue,
  687. double luminance,
  688. double saturation
  689. );
  690. protected:
  691. virtual void GeneratePicker(
  692. CDC &dc,
  693. CPalette * pPalette
  694. );
  695. CPoint m_ptCenterSpaceHueSat;
  696. CRgn m_rgnSpaceHueSat,m_rgnMouseSelHueSat;
  697. INT m_nSatTranslation;
  698. }; // struct hsl_roller_data_t
  700. struct __PROF_UIS_API xyz_plain_data_t : public hsl_panel_data_t
  701. {
  702. enum eXYZmode_t
  703. {
  704. MXYZ_R = 0,
  705. MXYZ_G = 1,
  706. MXYZ_B = 2,
  707. MXYZ_C = 3,
  708. MXYZ_M = 4,
  709. MXYZ_Y = 5,
  710. MXYZ_MIN = 0,
  711. MXYZ_MAX = 5
  712. };
  713. eXYZmode_t m_eXYZmode;
  715. xyz_plain_data_t(
  716. eXYZmode_t eXYZmode
  717. )
  718. : m_eXYZmode( eXYZmode )
  719. {
  720. ASSERT(
  721. MXYZ_MIN <= m_eXYZmode
  722. && m_eXYZmode <= MXYZ_MAX
  723. );
  724. }
  725. ~xyz_plain_data_t()
  726. {
  727. }
  729. virtual void OnDraw(
  730. CDC & dc,
  731. CPalette * pPalette
  732. );
  733. virtual void OnMouseMove(
  734. UINT nFlags,
  735. CPoint point
  736. ); 
  737. virtual void OnSetRGB(
  738. COLORREF clr
  739. );
  740. virtual void OnSetHLS(
  741. double hue,
  742. double luminance,
  743. double saturation
  744. );
  745. protected:
  746. virtual void GenerateSlider(
  747. CDC &dc,
  748. CPalette * pPalette
  749. );
  750. virtual void GeneratePicker(
  751. CDC &dc,
  752. CPalette * pPalette
  753. );
  754. COLORREF CalcColorPicker( int nX, int nY );
  755. COLORREF CalcColorSlider( int nZ );
  756. void CalcPoints(
  757. int &nX,
  758. int &nY,
  759. int &nZ,
  760. bool bDcScale
  761. );
  762. void RecalcByZ(
  763. int nZ
  764. );
  765. }; // struct xyz_plain_data_t
  767. struct __PROF_UIS_API diff_data_t : public grayscale_mixer_data_t
  768. {
  769. diff_data_t()
  770. {
  771. }
  772. ~diff_data_t()
  773. {
  774. }
  775. virtual void OnInit(
  776. CDC & dc,
  777. CPalette * pPalette,
  778. CSize sizeTotal,
  779. bool bOnlySizeChanged
  780. );
  781. virtual void OnDraw(
  782. CDC & dc,
  783. CPalette * pPalette
  784. );
  785. virtual void OnSetRGB(
  786. COLORREF clr
  787. );
  788. virtual void OnSetHLS(
  789. double hue,
  790. double luminance,
  791. double saturation
  792. );
  793. private:
  794. void Generate( bool bOnlySizeChanged );
  795. }; // struct diff_data_t
  797. public:
  798. selection_colors_t m_selClrs;
  800. private:
  801. cell_based_data_t m_hexagon_data;
  802. grayscale_mixer_data_t m_grayscale_mixer_data;
  803. rgb_mixer_data_t m_rgb_mixer_data;
  804. rgb_cube_data_t m_rgb_cube_data;
  805. cmy_mixer_data_t m_cmy_mixer_data;
  806. cmy_cube_data_t m_cmy_cube_data;
  807. hsl_panel_data_t m_hsl_panel_data;
  808. hsl_basic_hue_data_t m_hsl_basic_hue_data;
  809. hsl_roller_data_t m_hsl_roller_data;
  810. xyz_plain_data_t m_xyz_r;
  811. xyz_plain_data_t m_xyz_g;
  812. xyz_plain_data_t m_xyz_b;
  813. xyz_plain_data_t m_xyz_c;
  814. xyz_plain_data_t m_xyz_m;
  815. xyz_plain_data_t m_xyz_y;
  816. diff_data_t m_diff_data;
  817. any_picker_data_t * m_algorithms[MODE_VAL_MAX+1];
  819. COLORREF m_clrBackground;
  821. // Operations
  822. public:
  823. void SetupColor(
  824. COLORREF clr,
  825. bool bNotifyChanged
  826. );
  827. void SetupOldColor( // suggested by Olaf Baeyens
  828. COLORREF clr
  829. );
  831. COLORREF SetBkColor( COLORREF clrBk );
  832. COLORREF GetBkColor() const;
  834. // get / set mode
  835. operator e_mode_t() const
  836. {
  837. return m_eMode;
  838. }
  839. CExtColorCtrl & operator = ( e_mode_t eMode )
  840. {
  841. ASSERT(
  842. MODE_VAL_MIN <= eMode
  843. && eMode <= MODE_VAL_MAX
  844. );
  845. _Cleanup();
  846. m_eMode = eMode;
  847. _Init( false );
  848. Invalidate();
  849. UpdateWindow();
  850. return *this;
  851. }
  852. private:
  853. void _Cleanup();
  854. void _Init( bool bOnlySizeChanged );
  855. void _MouseTracking( bool bStart = true );
  857. public:
  858. static UINT g_nMsgColorChanged;
  859. protected:
  860. virtual void NotifyColorChanged();
  861. virtual void DoPaint( 
  862. CDC * pDC,
  863. CRect & rcClient
  864. );
  866. // Overrides
  867. // ClassWizard generated virtual function overrides
  868. //{{AFX_VIRTUAL(CExtColorCtrl)
  869. protected:
  870. virtual void PreSubclassWindow();
  871. //}}AFX_VIRTUAL
  873. // Implementation
  874. public:
  875. virtual ~CExtColorCtrl();
  877. // Generated message map functions
  878. protected:
  879. //{{AFX_MSG(CExtColorCtrl)
  880. afx_msg void OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags);
  881. afx_msg void OnLButtonDown(UINT nFlags, CPoint point);
  882. afx_msg void OnLButtonUp(UINT nFlags, CPoint point);
  883. afx_msg void OnMouseMove(UINT nFlags, CPoint point);
  884. afx_msg void OnCancelMode();
  885. afx_msg BOOL OnEraseBkgnd(CDC* pDC);
  886. afx_msg void OnPaint();
  887. afx_msg BOOL OnQueryNewPalette();
  888. afx_msg void OnPaletteChanged(CWnd* pFocusWnd);
  889. afx_msg void OnKillFocus(CWnd* pNewWnd);
  890. afx_msg void OnCaptureChanged(CWnd *pWnd);
  891. afx_msg void OnSize(UINT nType, int cx, int cy);
  892. afx_msg void OnKeyUp(UINT nChar, UINT nRepCnt, UINT nFlags);
  893. afx_msg void OnLButtonDblClk(UINT nFlags, CPoint point);
  894. afx_msg void OnMButtonDblClk(UINT nFlags, CPoint point);
  895. afx_msg void OnMButtonDown(UINT nFlags, CPoint point);
  896. afx_msg void OnMButtonUp(UINT nFlags, CPoint point);
  897. afx_msg void OnRButtonDblClk(UINT nFlags, CPoint point);
  898. afx_msg void OnRButtonDown(UINT nFlags, CPoint point);
  899. afx_msg void OnRButtonUp(UINT nFlags, CPoint point);
  900. virtual LRESULT WindowProc(UINT message, WPARAM wParam, LPARAM lParam);
  901. //}}AFX_MSG
  902. DECLARE_MESSAGE_MAP()
  903. };
  905. __PROF_UIS_API void AFXAPI __EXT_MFC_DDX_ColorCtrl( CDataExchange * pDX, INT nIDC, COLORREF & value );
  907. /////////////////////////////////////////////////////////////////////////////
  909. //{{AFX_INSERT_LOCATION}}
  910. // Microsoft Visual C++ will insert additional declarations immediately before the previous line.
  912. #endif // __EXTCOLORCTRL_H