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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 对话框与窗口 > 查看源码
ColourPopup.cpp
资源名称：sourcecode.zip　[点击查看]
上传用户：wlkj888
上传日期：2022-08-01
资源大小：806k
文件大小：30k
源码类别：

对话框与窗口

开发平台：

Visual C++

ColourPopup.cpp：源码内容
  1. // ColourPopup.cpp : implementation file
  2. //
  3. // Written by Chris Maunder (chrismaunder@codeguru.com)
  4. // Extended by Alexander Bischofberger (bischofb@informatik.tu-muenchen.de)
  5. // Copyright (c) 1998.
  6. //
  7. // Updated 30 May 1998 to allow any number of colours, and to
  8. //                     make the appearance closer to Office 97. 
  9. //                     Also added "Default" text area.         (CJM)
  10. //
  11. //         13 June 1998 Fixed change of focus bug (CJM)
  12. //         30 June 1998 Fixed bug caused by focus bug fix (D'oh!!)
  13. //                      Solution suggested by Paul Wilkerson.
  14. //
  15. // ColourPopup is a helper class for the colour picker control
  16. // CColourPicker. Check out the header file or the accompanying 
  17. // HTML doc file for details.
  18. //
  19. // This code may be used in compiled form in any way you desire. This
  20. // file may be redistributed unmodified by any means PROVIDING it is 
  21. // not sold for profit without the authors written consent, and 
  22. // providing that this notice and the authors name is included. 
  23. //
  24. // This file is provided "as is" with no expressed or implied warranty.
  25. // The author accepts no liability if it causes any damage to you or your
  26. // computer whatsoever. It's free, so don't hassle me about it.
  27. //
  28. // Expect bugs.
  29. // 
  30. // Please use and enjoy. Please let me know of any bugs/mods/improvements 
  31. // that you have found/implemented and I will fix/incorporate them into this
  32. // file. 
  34. #include "stdafx.h"
  35. #include <math.h>
  36. #include "ColourPicker.h"
  37. #include "ColourPopup.h"
  39. #ifdef _DEBUG
  40. #define new DEBUG_NEW
  41. #undef THIS_FILE
  42. static char THIS_FILE[] = __FILE__;
  43. #endif
  45. #define DEFAULT_BOX_VALUE -3
  46. #define CUSTOM_BOX_VALUE  -2
  47. #define INVALID_COLOUR    -1
  49. #define MAX_COLOURS      100
  52. ColourTableEntry CColourPopup::m_crColours[] = 
  53. {
  54.     { RGB(0x00, 0x00, 0x00),    _T("Black")             },
  55.     { RGB(0xA5, 0x2A, 0x00),    _T("Brown")             },
  56.     { RGB(0x00, 0x40, 0x40),    _T("Dark Olive Green")  },
  57.     { RGB(0x00, 0x55, 0x00),    _T("Dark Green")        },
  58.     { RGB(0x00, 0x00, 0x5E),    _T("Dark Teal")         },
  59.     { RGB(0x00, 0x00, 0x8B),    _T("Dark blue")         },
  60.     { RGB(0x4B, 0x00, 0x82),    _T("Indigo")            },
  61.     { RGB(0x28, 0x28, 0x28),    _T("Dark grey")         },
  63.     { RGB(0x8B, 0x00, 0x00),    _T("Dark red")          },
  64.     { RGB(0xFF, 0x68, 0x20),    _T("Orange")            },
  65.     { RGB(0x8B, 0x8B, 0x00),    _T("Dark yellow")       },
  66.     { RGB(0x00, 0x93, 0x00),    _T("Green")             },
  67.     { RGB(0x38, 0x8E, 0x8E),    _T("Teal")              },
  68.     { RGB(0x00, 0x00, 0xFF),    _T("Blue")              },
  69.     { RGB(0x7B, 0x7B, 0xC0),    _T("Blue-grey")         },
  70.     { RGB(0x66, 0x66, 0x66),    _T("Grey - 40")         },
  72.     { RGB(0xFF, 0x00, 0x00),    _T("Red")               },
  73.     { RGB(0xFF, 0xAD, 0x5B),    _T("Light orange")      },
  74.     { RGB(0x32, 0xCD, 0x32),    _T("Lime")              }, 
  75.     { RGB(0x3C, 0xB3, 0x71),    _T("Sea green")         },
  76.     { RGB(0x7F, 0xFF, 0xD4),    _T("Aqua")              },
  77.     { RGB(0x7D, 0x9E, 0xC0),    _T("Light blue")        },
  78.     { RGB(0x80, 0x00, 0x80),    _T("Violet")            },
  79.     { RGB(0x7F, 0x7F, 0x7F),    _T("Grey - 50")         },
  81.     { RGB(0xFF, 0xC0, 0xCB),    _T("Pink")              },
  82.     { RGB(0xFF, 0xD7, 0x00),    _T("Gold")              },
  83.     { RGB(0xFF, 0xFF, 0x00),    _T("Yellow")            },    
  84.     { RGB(0x00, 0xFF, 0x00),    _T("Bright green")      },
  85.     { RGB(0x40, 0xE0, 0xD0),    _T("Turquoise")         },
  86.     { RGB(0xC0, 0xFF, 0xFF),    _T("Skyblue")           },
  87.     { RGB(0x48, 0x00, 0x48),    _T("Plum")              },
  88.     { RGB(0xC0, 0xC0, 0xC0),    _T("Light grey")        },
  90.     { RGB(0xFF, 0xE4, 0xE1),    _T("Rose")              },
  91.     { RGB(0xD2, 0xB4, 0x8C),    _T("Tan")               },
  92.     { RGB(0xFF, 0xFF, 0xE0),    _T("Light yellow")      },
  93.     { RGB(0x98, 0xFB, 0x98),    _T("Pale green ")       },
  94.     { RGB(0xAF, 0xEE, 0xEE),    _T("Pale turquoise")    },
  95.     { RGB(0x68, 0x83, 0x8B),    _T("Pale blue")         },
  96.     { RGB(0xE6, 0xE6, 0xFA),    _T("Lavender")          },
  97.     { RGB(0xFF, 0xFF, 0xFF),    _T("White")             }
  98. };
  100. /////////////////////////////////////////////////////////////////////////////
  101. // CColourPopup
  103. CColourPopup::CColourPopup()
  104. {
  105.     Initialise();
  106. }
  108. CColourPopup::CColourPopup(CPoint p, COLORREF crColour, CWnd* pParentWnd,
  109.                            LPCTSTR szDefaultText /* = NULL */,
  110.                            LPCTSTR szCustomText  /* = NULL */)
  111. {
  112.     Initialise();
  114.     m_crColour       = m_crInitialColour = crColour;
  115.     m_pParent        = pParentWnd;
  116.     m_strDefaultText = (szDefaultText)? szDefaultText : _T("");
  117.     m_strCustomText  = (szCustomText)?  szCustomText  : _T("");
  119.     CColourPopup::Create(p, crColour, pParentWnd, szDefaultText, szCustomText);
  120. }
  122. void CColourPopup::Initialise()
  123. {
  124.     m_nNumColours       = sizeof(m_crColours)/sizeof(ColourTableEntry);
  125.     ASSERT(m_nNumColours <= MAX_COLOURS);
  126.     if (m_nNumColours > MAX_COLOURS)
  127.         m_nNumColours = MAX_COLOURS;
  129.     m_nNumColumns       = 0;
  130.     m_nNumRows          = 0;
  131.     m_nBoxSize          = 18;
  132.     m_nMargin           = ::GetSystemMetrics(SM_CXEDGE);
  133.     m_nCurrentSel       = INVALID_COLOUR;
  134.     m_nChosenColourSel  = INVALID_COLOUR;
  135.     m_pParent           = NULL;
  136.     m_crColour          = m_crInitialColour = RGB(0,0,0);
  138.     m_bChildWindowVisible = FALSE;
  140.     // Idiot check: Make sure the colour square is at least 5 x 5;
  141.     if (m_nBoxSize - 2*m_nMargin - 2 < 5) m_nBoxSize = 5 + 2*m_nMargin + 2;
  143.     // Create the font
  144.     NONCLIENTMETRICS ncm;
  145.     ncm.cbSize = sizeof(NONCLIENTMETRICS);
  146.     VERIFY(SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(NONCLIENTMETRICS), &ncm, 0));
  147.     m_Font.CreateFontIndirect(&(ncm.lfMessageFont));
  149.     // Create the palette
  150.     struct {
  151.         LOGPALETTE    LogPalette;
  152.         PALETTEENTRY  PalEntry[MAX_COLOURS];
  153.     } pal;
  155.     LOGPALETTE* pLogPalette = (LOGPALETTE*) &pal;
  156.     pLogPalette->palVersion    = 0x300;
  157.     pLogPalette->palNumEntries = (WORD) m_nNumColours; 
  159.     for (int i = 0; i < m_nNumColours; i++)
  160.     {
  161.         pLogPalette->palPalEntry[i].peRed   = GetRValue(m_crColours[i].crColour);
  162.         pLogPalette->palPalEntry[i].peGreen = GetGValue(m_crColours[i].crColour);
  163.         pLogPalette->palPalEntry[i].peBlue  = GetBValue(m_crColours[i].crColour);
  164.         pLogPalette->palPalEntry[i].peFlags = 0;
  165.     }
  167.     m_Palette.CreatePalette(pLogPalette);
  168. }
  170. CColourPopup::~CColourPopup()
  171. {
  172.     m_Font.DeleteObject();
  173.     m_Palette.DeleteObject();
  174. }
  176. BOOL CColourPopup::Create(CPoint p, COLORREF crColour, CWnd* pParentWnd,
  177.                           LPCTSTR szDefaultText /* = NULL */,
  178.                           LPCTSTR szCustomText  /* = NULL */)
  179. {
  180.     ASSERT(pParentWnd && ::IsWindow(pParentWnd->GetSafeHwnd()));
  181.    // ASSERT(pParentWnd->IsKindOf(RUNTIME_CLASS(CColourPicker)));
  183.     m_pParent  = pParentWnd;
  184.     m_crColour = m_crInitialColour = crColour;
  186.     // Get the class name and create the window
  187.     CString szClassName = AfxRegisterWndClass(CS_CLASSDC|CS_SAVEBITS|CS_HREDRAW|CS_VREDRAW,
  188.                                               0,
  189.                                               (HBRUSH) (COLOR_BTNFACE+1), 
  190.                                               0);
  192.     if (!CWnd::CreateEx(0, szClassName, _T(""), WS_CHILD, 
  193.                         p.x, p.y, 100, 100, // size updated soon
  194.                         pParentWnd->GetSafeHwnd(), 0, NULL))
  195.         return FALSE;
  197.     // Store the Custom text
  198.     if (szCustomText != NULL) 
  199.         m_strCustomText = szCustomText;
  201.     // Store the Default Area text
  202.     if (szDefaultText != NULL) 
  203.         m_strDefaultText = szDefaultText;
  204.         
  205.     // Set the window size
  206.     SetWindowSize();
  208.     // Create the tooltips
  209.     CreateToolTips();
  211.     // Find which cell (if any) corresponds to the initial colour
  212.     FindCellFromColour(crColour);
  214.     // Capture all mouse events for the life of this window
  215.     SetCapture();
  217.     return TRUE;
  218. }
  220. BEGIN_MESSAGE_MAP(CColourPopup, CWnd)
  221.     //{{AFX_MSG_MAP(CColourPopup)
  222.     ON_WM_NCDESTROY()
  223.     ON_WM_LBUTTONUP()
  224.     ON_WM_PAINT()
  225.     ON_WM_MOUSEMOVE()
  226.     ON_WM_KEYDOWN()
  227.     ON_WM_QUERYNEWPALETTE()
  228.     ON_WM_PALETTECHANGED()
  229. ON_WM_KILLFOCUS()
  230. ON_WM_ACTIVATEAPP()
  231. //}}AFX_MSG_MAP
  232. END_MESSAGE_MAP()
  234. /////////////////////////////////////////////////////////////////////////////
  235. // CColourPopup message handlers
  237. // For tooltips
  238. BOOL CColourPopup::PreTranslateMessage(MSG* pMsg) 
  239. {
  240.     m_ToolTip.RelayEvent(pMsg);
  242.     // Fix (Adrian Roman): Sometimes if the picker loses focus it is never destroyed
  243.     if (GetCapture()->GetSafeHwnd() != m_hWnd)
  244.         SetCapture(); 
  246.     return CWnd::PreTranslateMessage(pMsg);
  247. }
  249. // If an arrow key is pressed, then move the selection
  250. void CColourPopup::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
  251. {
  252.     int row = GetRow(m_nCurrentSel),
  253.         col = GetColumn(m_nCurrentSel);
  255.     if (nChar == VK_DOWN) 
  256.     {
  257.         if (row == DEFAULT_BOX_VALUE) 
  258.             row = col = 0; 
  259.         else if (row == CUSTOM_BOX_VALUE)
  260.         {
  261.             if (m_strDefaultText.GetLength())
  262.                 row = col = DEFAULT_BOX_VALUE;
  263.             else
  264.                 row = col = 0;
  265.         }
  266.         else
  267.         {
  268.             row++;
  269.             if (GetIndex(row,col) < 0)
  270.             {
  271.                 if (m_strCustomText.GetLength())
  272.                     row = col = CUSTOM_BOX_VALUE;
  273.                 else if (m_strDefaultText.GetLength())
  274.                     row = col = DEFAULT_BOX_VALUE;
  275.                 else
  276.                     row = col = 0;
  277.             }
  278.         }
  279.         ChangeSelection(GetIndex(row, col));
  280.     }
  282.     if (nChar == VK_UP) 
  283.     {
  284.         if (row == DEFAULT_BOX_VALUE)
  285.         {
  286.             if (m_strCustomText.GetLength())
  287.                 row = col = CUSTOM_BOX_VALUE;
  288.             else
  289.            { 
  290.                 row = GetRow(m_nNumColours-1); 
  291.                 col = GetColumn(m_nNumColours-1); 
  292.             }
  293.         }
  294.         else if (row == CUSTOM_BOX_VALUE)
  295.         { 
  296.             row = GetRow(m_nNumColours-1); 
  297.             col = GetColumn(m_nNumColours-1); 
  298.         }
  299.         else if (row > 0) row--;
  300.         else /* row == 0 */
  301.         {
  302.             if (m_strDefaultText.GetLength())
  303.                 row = col = DEFAULT_BOX_VALUE;
  304.             else if (m_strCustomText.GetLength())
  305.                 row = col = CUSTOM_BOX_VALUE;
  306.             else
  307.             { 
  308.                 row = GetRow(m_nNumColours-1); 
  309.                 col = GetColumn(m_nNumColours-1); 
  310.             }
  311.         }
  312.         ChangeSelection(GetIndex(row, col));
  313.     }
  315.     if (nChar == VK_RIGHT) 
  316.     {
  317.         if (row == DEFAULT_BOX_VALUE) 
  318.             row = col = 0; 
  319.         else if (row == CUSTOM_BOX_VALUE)
  320.         {
  321.             if (m_strDefaultText.GetLength())
  322.                 row = col = DEFAULT_BOX_VALUE;
  323.             else
  324.                 row = col = 0;
  325.         }
  326.         else if (col < m_nNumColumns-1) 
  327.             col++;
  328.         else 
  329.         { 
  330.             col = 0; row++;
  331.         }
  333.         if (GetIndex(row,col) == INVALID_COLOUR)
  334.         {
  335.             if (m_strCustomText.GetLength())
  336.                 row = col = CUSTOM_BOX_VALUE;
  337.             else if (m_strDefaultText.GetLength())
  338.                 row = col = DEFAULT_BOX_VALUE;
  339.             else
  340.                 row = col = 0;
  341.         }
  343.         ChangeSelection(GetIndex(row, col));
  344.     }
  346.     if (nChar == VK_LEFT) 
  347.     {
  348.         if (row == DEFAULT_BOX_VALUE)
  349.         {
  350.             if (m_strCustomText.GetLength())
  351.                 row = col = CUSTOM_BOX_VALUE;
  352.             else
  353.            { 
  354.                 row = GetRow(m_nNumColours-1); 
  355.                 col = GetColumn(m_nNumColours-1); 
  356.             }
  357.         }
  358.         else if (row == CUSTOM_BOX_VALUE)
  359.         { 
  360.             row = GetRow(m_nNumColours-1); 
  361.             col = GetColumn(m_nNumColours-1); 
  362.         }
  363.         else if (col > 0) col--;
  364.         else /* col == 0 */
  365.         {
  366.             if (row > 0) { row--; col = m_nNumColumns-1; }
  367.             else 
  368.             {
  369.                 if (m_strDefaultText.GetLength())
  370.                     row = col = DEFAULT_BOX_VALUE;
  371.                 else if (m_strCustomText.GetLength())
  372.                     row = col = CUSTOM_BOX_VALUE;
  373.                 else
  374.                 { 
  375.                     row = GetRow(m_nNumColours-1); 
  376.                     col = GetColumn(m_nNumColours-1); 
  377.                 }
  378.             }
  379.         }
  380.         ChangeSelection(GetIndex(row, col));
  381.     }
  383.     if (nChar == VK_ESCAPE) 
  384.     {
  385.         m_crColour = m_crInitialColour;
  386.         EndSelection(CPN_SELENDCANCEL);
  387.         return;
  388.     }
  390.     if (nChar == VK_RETURN || nChar == VK_SPACE)
  391.     {
  392.         EndSelection(CPN_SELENDOK);
  393.         return;
  394.     }
  396.     CWnd::OnKeyDown(nChar, nRepCnt, nFlags);
  397. }
  399. // auto-deletion
  400. void CColourPopup::OnNcDestroy() 
  401. {
  402.     CWnd::OnNcDestroy();
  403.     delete this;
  404. }
  406. void CColourPopup::OnPaint() 
  407. {
  408.     CPaintDC dc(this); // device context for painting
  410.     // Draw the Default Area text
  411.     if (m_strDefaultText.GetLength())
  412.         DrawCell(&dc, DEFAULT_BOX_VALUE);
  413.  
  414.     // Draw colour cells
  415.     for (int i = 0; i < m_nNumColours; i++)
  416.         DrawCell(&dc, i);
  417.     
  418.     // Draw custom text
  419.     if (m_strCustomText.GetLength())
  420.         DrawCell(&dc, CUSTOM_BOX_VALUE);
  422.     // Draw raised window edge (ex-window style WS_EX_WINDOWEDGE is sposed to do this,
  423.     // but for some reason isn't
  424.     CRect rect;
  425.     GetClientRect(rect);
  426.     dc.DrawEdge(rect, EDGE_RAISED, BF_RECT);
  427. }
  429. void CColourPopup::OnMouseMove(UINT nFlags, CPoint point) 
  430. {
  431.     int nNewSelection = INVALID_COLOUR;
  433.     // Translate points to be relative raised window edge
  434.     point.x -= m_nMargin;
  435.     point.y -= m_nMargin;
  437.     // First check we aren't in text box
  438.     if (m_strCustomText.GetLength() && m_CustomTextRect.PtInRect(point))
  439.         nNewSelection = CUSTOM_BOX_VALUE;
  440.     else if (m_strDefaultText.GetLength() && m_DefaultTextRect.PtInRect(point))
  441.         nNewSelection = DEFAULT_BOX_VALUE;
  442.     else
  443.     {
  444.         // Take into account text box
  445.         if (m_strDefaultText.GetLength()) 
  446.             point.y -= m_DefaultTextRect.Height();  
  448.         // Get the row and column
  449.         nNewSelection = GetIndex(point.y / m_nBoxSize, point.x / m_nBoxSize);
  451.         // In range? If not, default and exit
  452.         if (nNewSelection < 0 || nNewSelection >= m_nNumColours)
  453.         {
  454.             CWnd::OnMouseMove(nFlags, point);
  455.             return;
  456.         }
  457.     }
  459.     // OK - we have the row and column of the current selection (may be CUSTOM_BOX_VALUE)
  460.     // Has the row/col selection changed? If yes, then redraw old and new cells.
  461.     if (nNewSelection != m_nCurrentSel)
  462.         ChangeSelection(nNewSelection);
  464.     CWnd::OnMouseMove(nFlags, point);
  465. }
  467. // End selection on LButtonUp
  468. void CColourPopup::OnLButtonUp(UINT nFlags, CPoint point) 
  469. {    
  470.     CWnd::OnLButtonUp(nFlags, point);
  472.     DWORD pos = GetMessagePos();
  473.     point = CPoint(LOWORD(pos), HIWORD(pos));
  475.     if (m_WindowRect.PtInRect(point))
  476.         EndSelection(CPN_SELENDOK);
  477.     else
  478.         EndSelection(CPN_SELENDCANCEL);
  479. }
  481. /////////////////////////////////////////////////////////////////////////////
  482. // CColourPopup implementation
  484. int CColourPopup::GetIndex(int row, int col) const
  485. { 
  486.     if ((row == CUSTOM_BOX_VALUE || col == CUSTOM_BOX_VALUE) && m_strCustomText.GetLength())
  487.         return CUSTOM_BOX_VALUE;
  488.     else if ((row == DEFAULT_BOX_VALUE || col == DEFAULT_BOX_VALUE) && m_strDefaultText.GetLength())
  489.         return DEFAULT_BOX_VALUE;
  490.     else if (row < 0 || col < 0 || row >= m_nNumRows || col >= m_nNumColumns)
  491.         return INVALID_COLOUR;
  492.     else
  493.     {
  494.         if (row*m_nNumColumns + col >= m_nNumColours)
  495.             return INVALID_COLOUR;
  496.         else
  497.             return row*m_nNumColumns + col;
  498.     }
  499. }
  501. int CColourPopup::GetRow(int nIndex) const               
  502. { 
  503.     if (nIndex == CUSTOM_BOX_VALUE && m_strCustomText.GetLength())
  504.         return CUSTOM_BOX_VALUE;
  505.     else if (nIndex == DEFAULT_BOX_VALUE && m_strDefaultText.GetLength())
  506.         return DEFAULT_BOX_VALUE;
  507.     else if (nIndex < 0 || nIndex >= m_nNumColours)
  508.         return INVALID_COLOUR;
  509.     else
  510.         return nIndex / m_nNumColumns; 
  511. }
  513. int CColourPopup::GetColumn(int nIndex) const            
  514. { 
  515.     if (nIndex == CUSTOM_BOX_VALUE && m_strCustomText.GetLength())
  516.         return CUSTOM_BOX_VALUE;
  517.     else if (nIndex == DEFAULT_BOX_VALUE && m_strDefaultText.GetLength())
  518.         return DEFAULT_BOX_VALUE;
  519.     else if (nIndex < 0 || nIndex >= m_nNumColours)
  520.         return INVALID_COLOUR;
  521.     else
  522.         return nIndex % m_nNumColumns; 
  523. }
  525. void CColourPopup::FindCellFromColour(COLORREF crColour)
  526. {
  527.     if (crColour == CLR_DEFAULT && m_strDefaultText.GetLength())
  528.     {
  529.         m_nChosenColourSel = DEFAULT_BOX_VALUE;
  530.         return;
  531.     }
  533.     for (int i = 0; i < m_nNumColours; i++)
  534.     {
  535.         if (GetColour(i) == crColour)
  536.         {
  537.             m_nChosenColourSel = i;
  538.             return;
  539.         }
  540.     }
  542.     if (m_strCustomText.GetLength())
  543.         m_nChosenColourSel = CUSTOM_BOX_VALUE;
  544.     else
  545.         m_nChosenColourSel = INVALID_COLOUR;
  546. }
  548. // Gets the dimensions of the colour cell given by (row,col)
  549. BOOL CColourPopup::GetCellRect(int nIndex, const LPRECT& rect)
  550. {
  551.     if (nIndex == CUSTOM_BOX_VALUE)
  552.     {
  553.         ::SetRect(rect, 
  554.                   m_CustomTextRect.left,  m_CustomTextRect.top,
  555.                   m_CustomTextRect.right, m_CustomTextRect.bottom);
  556.         return TRUE;
  557.     }
  558.     else if (nIndex == DEFAULT_BOX_VALUE)
  559.     {
  560.         ::SetRect(rect, 
  561.                   m_DefaultTextRect.left,  m_DefaultTextRect.top,
  562.                   m_DefaultTextRect.right, m_DefaultTextRect.bottom);
  563.         return TRUE;
  564.     }
  566.     if (nIndex < 0 || nIndex >= m_nNumColours)
  567.         return FALSE;
  569.     rect->left = GetColumn(nIndex) * m_nBoxSize + m_nMargin;
  570.     rect->top  = GetRow(nIndex) * m_nBoxSize + m_nMargin;
  572.     // Move everything down if we are displaying a default text area
  573.     if (m_strDefaultText.GetLength()) 
  574.         rect->top += (m_nMargin + m_DefaultTextRect.Height());
  576.     rect->right = rect->left + m_nBoxSize;
  577.     rect->bottom = rect->top + m_nBoxSize;
  579.     return TRUE;
  580. }
  582. // Works out an appropriate size and position of this window
  583. void CColourPopup::SetWindowSize()
  584. {
  585.     CSize TextSize;
  587.     // If we are showing a custom or default text area, get the font and text size.
  588.     if (m_strCustomText.GetLength() || m_strDefaultText.GetLength())
  589.     {
  590.         CClientDC dc(this);
  591.         CFont* pOldFont = (CFont*) dc.SelectObject(&m_Font);
  593.         // Get the size of the custom text (if there IS custom text)
  594.         TextSize = CSize(0,0);
  595.         if (m_strCustomText.GetLength())
  596.             TextSize = dc.GetTextExtent(m_strCustomText);
  598.         // Get the size of the default text (if there IS default text)
  599.         if (m_strDefaultText.GetLength())
  600.         {
  601.             CSize DefaultSize = dc.GetTextExtent(m_strDefaultText);
  602.             if (DefaultSize.cx > TextSize.cx) TextSize.cx = DefaultSize.cx;
  603.             if (DefaultSize.cy > TextSize.cy) TextSize.cy = DefaultSize.cy;
  604.         }
  606.         dc.SelectObject(pOldFont);
  607.         TextSize += CSize(2*m_nMargin,2*m_nMargin);
  609.         // Add even more space to draw the horizontal line
  610.         TextSize.cy += 2*m_nMargin + 2;
  611.     }
  613.     // Get the number of columns and rows
  614.     //m_nNumColumns = (int) sqrt((double)m_nNumColours);    // for a square window (yuk)
  615.     m_nNumColumns = 8;
  616.     m_nNumRows = m_nNumColours / m_nNumColumns;
  617.     if (m_nNumColours % m_nNumColumns) m_nNumRows++;
  619.     // Get the current window position, and set the new size
  620.     CRect rect;
  621.     GetWindowRect(rect);
  623.     m_WindowRect.SetRect(rect.left, rect.top, 
  624.                          rect.left + m_nNumColumns*m_nBoxSize + 2*m_nMargin,
  625.                          rect.top  + m_nNumRows*m_nBoxSize + 2*m_nMargin);
  627.     // if custom text, then expand window if necessary, and set text width as
  628.     // window width
  629.     if (m_strDefaultText.GetLength()) 
  630.     {
  631.         if (TextSize.cx > m_WindowRect.Width())
  632.             m_WindowRect.right = m_WindowRect.left + TextSize.cx;
  633.         TextSize.cx = m_WindowRect.Width()-2*m_nMargin;
  635.         // Work out the text area
  636.         m_DefaultTextRect.SetRect(m_nMargin, m_nMargin, 
  637.                                   m_nMargin+TextSize.cx, 2*m_nMargin+TextSize.cy);
  638.         m_WindowRect.bottom += m_DefaultTextRect.Height() + 2*m_nMargin;
  639.     }
  641.     // if custom text, then expand window if necessary, and set text width as
  642.     // window width
  643.     if (m_strCustomText.GetLength()) 
  644.     {
  645.         if (TextSize.cx > m_WindowRect.Width())
  646.             m_WindowRect.right = m_WindowRect.left + TextSize.cx;
  647.         TextSize.cx = m_WindowRect.Width()-2*m_nMargin;
  649.         // Work out the text area
  650.         m_CustomTextRect.SetRect(m_nMargin, m_WindowRect.Height(), 
  651.                                  m_nMargin+TextSize.cx, 
  652.                                  m_WindowRect.Height()+m_nMargin+TextSize.cy);
  653.         m_WindowRect.bottom += m_CustomTextRect.Height() + 2*m_nMargin;
  654.    }
  656.     // Need to check it'll fit on screen: Too far right?
  657.     CSize ScreenSize(::GetSystemMetrics(SM_CXSCREEN), ::GetSystemMetrics(SM_CYSCREEN));
  658.     if (m_WindowRect.right > ScreenSize.cx)
  659.         m_WindowRect.OffsetRect(-(m_WindowRect.right - ScreenSize.cx), 0);
  661.     // Too far left?
  662.     if (m_WindowRect.left < 0)
  663.         m_WindowRect.OffsetRect( -m_WindowRect.left, 0);
  665.     // Bottom falling out of screen?
  666.     if (m_WindowRect.bottom > ScreenSize.cy)
  667.     {
  668.         CRect ParentRect;
  669.         m_pParent->GetWindowRect(ParentRect);
  670.         m_WindowRect.OffsetRect(0, -(ParentRect.Height() + m_WindowRect.Height()));
  671.     }
  673.     // Set the window size and position
  674.     MoveWindow(m_WindowRect, TRUE);
  675. }
  677. void CColourPopup::CreateToolTips()
  678. {
  679.     // Create the tool tip
  680.     if (!m_ToolTip.Create(this)) return;
  682.     // Add a tool for each cell
  683.     for (int i = 0; i < m_nNumColours; i++)
  684.     {
  685.         CRect rect;
  686.         if (!GetCellRect(i, rect)) continue;
  687.             m_ToolTip.AddTool(this, GetColourName(i), rect, 1);
  688.     }
  689. }
  691. void CColourPopup::ChangeSelection(int nIndex)
  692. {
  693.     CClientDC dc(this);        // device context for drawing
  695.     if (nIndex > m_nNumColours)
  696.         nIndex = CUSTOM_BOX_VALUE; 
  698.     if ((m_nCurrentSel >= 0 && m_nCurrentSel < m_nNumColours) ||
  699.         m_nCurrentSel == CUSTOM_BOX_VALUE || m_nCurrentSel == DEFAULT_BOX_VALUE)
  700.     {
  701.         // Set Current selection as invalid and redraw old selection (this way
  702.         // the old selection will be drawn unselected)
  703.         int OldSel = m_nCurrentSel;
  704.         m_nCurrentSel = INVALID_COLOUR;
  705.         DrawCell(&dc, OldSel);
  706.     }
  708.     // Set the current selection as row/col and draw (it will be drawn selected)
  709.     m_nCurrentSel = nIndex;
  710.     DrawCell(&dc, m_nCurrentSel);
  712.     // Store the current colour
  713.     if (m_nCurrentSel == CUSTOM_BOX_VALUE)
  714.         m_pParent->SendMessage(CPN_SELCHANGE, (WPARAM) m_crInitialColour, 0);
  715.     else if (m_nCurrentSel == DEFAULT_BOX_VALUE)
  716.     {
  717.         m_crColour = CLR_DEFAULT;
  718.         m_pParent->SendMessage(CPN_SELCHANGE, (WPARAM) CLR_DEFAULT, 0);
  719.     }
  720.     else
  721.     {
  722.         m_crColour = GetColour(m_nCurrentSel);
  723.         m_pParent->SendMessage(CPN_SELCHANGE, (WPARAM) m_crColour, 0);
  724.     }
  725. }
  727. void CColourPopup::EndSelection(int nMessage)
  728. {
  729.     ReleaseCapture();
  731.     // If custom text selected, perform a custom colour selection
  732.     if (nMessage != CPN_SELENDCANCEL && m_nCurrentSel == CUSTOM_BOX_VALUE)
  733.     {
  734.         m_bChildWindowVisible = TRUE;
  736.         CColorDialog dlg(m_crInitialColour, CC_FULLOPEN | CC_ANYCOLOR, this);
  738.         if (dlg.DoModal() == IDOK)
  739.             m_crColour = dlg.GetColor();
  740.         else
  741.             nMessage = CPN_SELENDCANCEL;
  743.         m_bChildWindowVisible = FALSE;
  744.     } 
  746.     if (nMessage == CPN_SELENDCANCEL)
  747.         m_crColour = m_crInitialColour;
  749.     m_pParent->SendMessage(nMessage, (WPARAM) m_crColour, 0);
  750.     
  751.     // Kill focus bug fixed by Martin Wawrusch
  752.     if (!m_bChildWindowVisible)
  753.         DestroyWindow();
  754. }
  756. void CColourPopup::DrawCell(CDC* pDC, int nIndex)
  757. {
  758.     // For the Custom Text area
  759.     if (m_strCustomText.GetLength() && nIndex == CUSTOM_BOX_VALUE)
  760.     {
  761.         // The extent of the actual text button
  762.         CRect TextButtonRect = m_CustomTextRect;
  763.         TextButtonRect.top += 2*m_nMargin;
  765.         // Fill background
  766.         pDC->FillSolidRect(TextButtonRect, ::GetSysColor(COLOR_3DFACE));
  768.         // Draw horizontal line
  769.         pDC->FillSolidRect(m_CustomTextRect.left+2*m_nMargin, m_CustomTextRect.top,
  770.                            m_CustomTextRect.Width()-4*m_nMargin, 1, ::GetSysColor(COLOR_3DSHADOW));
  771.         pDC->FillSolidRect(m_CustomTextRect.left+2*m_nMargin, m_CustomTextRect.top+1,
  772.                            m_CustomTextRect.Width()-4*m_nMargin, 1, ::GetSysColor(COLOR_3DHILIGHT));
  774.         TextButtonRect.DeflateRect(1,1);
  776.         // fill background
  777.         if (m_nChosenColourSel == nIndex && m_nCurrentSel != nIndex)
  778.             pDC->FillSolidRect(TextButtonRect, ::GetSysColor(COLOR_3DLIGHT));
  779.         else
  780.             pDC->FillSolidRect(TextButtonRect, ::GetSysColor(COLOR_3DFACE));
  782.         // Draw button
  783.         if (m_nCurrentSel == nIndex) 
  784.             pDC->DrawEdge(TextButtonRect, BDR_RAISEDINNER, BF_RECT);
  785.         else if (m_nChosenColourSel == nIndex)
  786.             pDC->DrawEdge(TextButtonRect, BDR_SUNKENOUTER, BF_RECT);
  788.         // Draw custom text
  789.         CFont *pOldFont = (CFont*) pDC->SelectObject(&m_Font);
  790.         pDC->SetBkMode(TRANSPARENT);
  791.         pDC->DrawText(m_strCustomText, TextButtonRect, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
  792.         pDC->SelectObject(pOldFont);
  794.         return;
  795.     }        
  797.     // For the Default Text area
  798.     if (m_strDefaultText.GetLength() && nIndex == DEFAULT_BOX_VALUE)
  799.     {
  800.         // Fill background
  801.         pDC->FillSolidRect(m_DefaultTextRect, ::GetSysColor(COLOR_3DFACE));
  803.         // The extent of the actual text button
  804.         CRect TextButtonRect = m_DefaultTextRect;
  805.         TextButtonRect.DeflateRect(1,1);
  807.         // fill background
  808.         if (m_nChosenColourSel == nIndex && m_nCurrentSel != nIndex)
  809.             pDC->FillSolidRect(TextButtonRect, ::GetSysColor(COLOR_3DLIGHT));
  810.         else
  811.             pDC->FillSolidRect(TextButtonRect, ::GetSysColor(COLOR_3DFACE));
  813.         // Draw thin line around text
  814.         CRect LineRect = TextButtonRect;
  815.         LineRect.DeflateRect(2*m_nMargin,2*m_nMargin);
  816.         CPen pen(PS_SOLID, 1, ::GetSysColor(COLOR_3DSHADOW));
  817.         CPen* pOldPen = pDC->SelectObject(&pen);
  818.         pDC->SelectStockObject(NULL_BRUSH);
  819.         pDC->Rectangle(LineRect);
  820.         pDC->SelectObject(pOldPen);
  822.         // Draw button
  823.         if (m_nCurrentSel == nIndex) 
  824.             pDC->DrawEdge(TextButtonRect, BDR_RAISEDINNER, BF_RECT);
  825.         else if (m_nChosenColourSel == nIndex)
  826.             pDC->DrawEdge(TextButtonRect, BDR_SUNKENOUTER, BF_RECT);
  828.         // Draw custom text
  829.         CFont *pOldFont = (CFont*) pDC->SelectObject(&m_Font);
  830.         pDC->SetBkMode(TRANSPARENT);
  831.         pDC->DrawText(m_strDefaultText, TextButtonRect, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
  832.         pDC->SelectObject(pOldFont);
  834.         return;
  835.     }        
  837.     CRect rect;
  838.     if (!GetCellRect(nIndex, rect)) return;
  840.     // Select and realize the palette
  841.     CPalette* pOldPalette = NULL;
  842.     if (pDC->GetDeviceCaps(RASTERCAPS) & RC_PALETTE)
  843.     {
  844.         pOldPalette = pDC->SelectPalette(&m_Palette, FALSE);
  845.         pDC->RealizePalette();
  846.     }
  848.     // fill background
  849.     if (m_nChosenColourSel == nIndex && m_nCurrentSel != nIndex)
  850.         pDC->FillSolidRect(rect, ::GetSysColor(COLOR_3DHILIGHT));
  851.     else
  852.         pDC->FillSolidRect(rect, ::GetSysColor(COLOR_3DFACE));
  854.     // Draw button
  855.     if (m_nCurrentSel == nIndex) 
  856.         pDC->DrawEdge(rect, BDR_RAISEDINNER, BF_RECT);
  857.     else if (m_nChosenColourSel == nIndex)
  858.         pDC->DrawEdge(rect, BDR_SUNKENOUTER, BF_RECT);
  860.     CBrush brush(PALETTERGB(GetRValue(GetColour(nIndex)), 
  861.                             GetGValue(GetColour(nIndex)), 
  862.                             GetBValue(GetColour(nIndex)) ));
  863.     CPen   pen;
  864.     pen.CreatePen(PS_SOLID, 1, ::GetSysColor(COLOR_3DSHADOW));
  866.     CBrush* pOldBrush = (CBrush*) pDC->SelectObject(&brush);
  867.     CPen*   pOldPen   = (CPen*)   pDC->SelectObject(&pen);
  869.     // Draw the cell colour
  870.     rect.DeflateRect(m_nMargin+1, m_nMargin+1);
  871.     pDC->Rectangle(rect);
  873.     // restore DC and cleanup
  874.     pDC->SelectObject(pOldBrush);
  875.     pDC->SelectObject(pOldPen);
  876.     brush.DeleteObject();
  877.     pen.DeleteObject();
  879.     if (pOldPalette && pDC->GetDeviceCaps(RASTERCAPS) & RC_PALETTE)
  880.         pDC->SelectPalette(pOldPalette, FALSE);
  881. }
  883. BOOL CColourPopup::OnQueryNewPalette() 
  884. {
  885.     Invalidate();    
  886.     return CWnd::OnQueryNewPalette();
  887. }
  889. void CColourPopup::OnPaletteChanged(CWnd* pFocusWnd) 
  890. {
  891.     CWnd::OnPaletteChanged(pFocusWnd);
  893.     if (pFocusWnd->GetSafeHwnd() != GetSafeHwnd())
  894.         Invalidate();
  895. }
  897. void CColourPopup::OnKillFocus(CWnd* pNewWnd) 
  898. {
  899. CWnd::OnKillFocus(pNewWnd);
  901.     ReleaseCapture();
  902.     //DestroyWindow(); - causes crash when Custom colour dialog appears.
  903. }
  905. // KillFocus problem fix suggested by Paul Wilkerson.
  906. void CColourPopup::OnActivateApp(BOOL bActive, HTASK hTask) 
  907. {
  908. CWnd::OnActivateApp(bActive, hTask);
  910. // If Deactivating App, cancel this selection
  911. if (!bActive)
  912.  EndSelection(CPN_SELENDCANCEL);
  913. }