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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > ActiveX/DCOM/ATL > 查看源码
ColourPopup.cpp
资源名称：propgrid.zip　[点击查看]
上传用户：yangzi5763
上传日期：2007-01-02
资源大小：239k
文件大小：29k
源码类别：

ActiveX/DCOM/ATL

开发平台：

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
  50. #define SENDMESSAGE(pWnd, message, wParam, lParam) if (pWnd) if (::IsWindow(pWnd->m_hWnd)) pWnd->SendMessage(message, wParam, lParam);
  53. ColourTableEntry CColourPopup::m_crColours[] = 
  54. {
  55.     { RGB(0x00, 0x00, 0x00),    _T("Black")             },
  56.     { RGB(0xA5, 0x2A, 0x00),    _T("Brown")             },
  57.     { RGB(0x00, 0x40, 0x40),    _T("Dark Olive Green")  },
  58.     { RGB(0x00, 0x55, 0x00),    _T("Dark Green")        },
  59.     { RGB(0x00, 0x00, 0x5E),    _T("Dark Teal")         },
  60.     { RGB(0x00, 0x00, 0x8B),    _T("Dark blue")         },
  61.     { RGB(0x4B, 0x00, 0x82),    _T("Indigo")            },
  62.     { RGB(0x28, 0x28, 0x28),    _T("Dark grey")         },
  64.     { RGB(0x8B, 0x00, 0x00),    _T("Dark red")          },
  65.     { RGB(0xFF, 0x68, 0x20),    _T("Orange")            },
  66.     { RGB(0x8B, 0x8B, 0x00),    _T("Dark yellow")       },
  67.     { RGB(0x00, 0x93, 0x00),    _T("Green")             },
  68.     { RGB(0x38, 0x8E, 0x8E),    _T("Teal")              },
  69.     { RGB(0x00, 0x00, 0xFF),    _T("Blue")              },
  70.     { RGB(0x7B, 0x7B, 0xC0),    _T("Blue-grey")         },
  71.     { RGB(0x66, 0x66, 0x66),    _T("Grey - 40")         },
  73.     { RGB(0xFF, 0x00, 0x00),    _T("Red")               },
  74.     { RGB(0xFF, 0xAD, 0x5B),    _T("Light orange")      },
  75.     { RGB(0x32, 0xCD, 0x32),    _T("Lime")              }, 
  76.     { RGB(0x3C, 0xB3, 0x71),    _T("Sea green")         },
  77.     { RGB(0x7F, 0xFF, 0xD4),    _T("Aqua")              },
  78.     { RGB(0x7D, 0x9E, 0xC0),    _T("Light blue")        },
  79.     { RGB(0x80, 0x00, 0x80),    _T("Violet")            },
  80.     { RGB(0x7F, 0x7F, 0x7F),    _T("Grey - 50")         },
  82.     { RGB(0xFF, 0xC0, 0xCB),    _T("Pink")              },
  83.     { RGB(0xFF, 0xD7, 0x00),    _T("Gold")              },
  84.     { RGB(0xFF, 0xFF, 0x00),    _T("Yellow")            },    
  85.     { RGB(0x00, 0xFF, 0x00),    _T("Bright green")      },
  86.     { RGB(0x40, 0xE0, 0xD0),    _T("Turquoise")         },
  87.     { RGB(0xC0, 0xFF, 0xFF),    _T("Skyblue")           },
  88.     { RGB(0x48, 0x00, 0x48),    _T("Plum")              },
  89.     { RGB(0xC0, 0xC0, 0xC0),    _T("Light grey")        },
  91.     { RGB(0xFF, 0xE4, 0xE1),    _T("Rose")              },
  92.     { RGB(0xD2, 0xB4, 0x8C),    _T("Tan")               },
  93.     { RGB(0xFF, 0xFF, 0xE0),    _T("Light yellow")      },
  94.     { RGB(0x98, 0xFB, 0x98),    _T("Pale green ")       },
  95.     { RGB(0xAF, 0xEE, 0xEE),    _T("Pale turquoise")    },
  96.     { RGB(0x68, 0x83, 0x8B),    _T("Pale blue")         },
  97.     { RGB(0xE6, 0xE6, 0xFA),    _T("Lavender")          },
  98.     { RGB(0xFF, 0xFF, 0xFF),    _T("White")             }
  99. };
  101. int CColourPopup::m_nNumColours  = sizeof(m_crColours)/sizeof(ColourTableEntry);
  103. /////////////////////////////////////////////////////////////////////////////
  104. // CColourPopup
  106. CColourPopup::CColourPopup()
  107. {
  108.     Initialise();
  109. }
  111. CColourPopup::CColourPopup(CPoint p, COLORREF crColour, CWnd* pParentWnd,
  112.                            LPCTSTR szDefaultText /* = NULL */,
  113.                            LPCTSTR szCustomText  /* = NULL */)
  114. {
  115.     Initialise();
  117.     m_crColour       = m_crInitialColour = crColour;
  118.     m_pParent        = pParentWnd;
  119.     m_strDefaultText = (szDefaultText)? szDefaultText : _T("");
  120.     m_strCustomText  = (szCustomText)?  szCustomText  : _T("");
  122.     CColourPopup::Create(p, crColour, pParentWnd, szDefaultText, szCustomText);
  123. }
  125. void CColourPopup::Initialise()
  126. {
  127.     ASSERT(m_nNumColours <= MAX_COLOURS);
  128.     if (m_nNumColours > MAX_COLOURS)
  129.         m_nNumColours = MAX_COLOURS;
  131.     m_nNumColumns       = 0;
  132.     m_nNumRows          = 0;
  133.     m_nBoxSize          = 18;
  134.     m_nMargin           = ::GetSystemMetrics(SM_CXEDGE);
  135.     m_nCurrentSel       = INVALID_COLOUR;
  136.     m_nChosenColourSel  = INVALID_COLOUR;
  137.     m_pParent           = NULL;
  138.     m_crColour          = m_crInitialColour = RGB(0,0,0);
  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, (HBRUSH)GetStockObject(LTGRAY_BRUSH),0);
  190.     if (!CWnd::CreateEx(WS_EX_TOOLWINDOW, szClassName, _T(""), WS_POPUP, 
  191.                         p.x, p.y, 100, 100, // size updated soon
  192.                         pParentWnd->GetSafeHwnd(), 0, NULL))
  193.         return FALSE;
  195.     // Store the Custom text
  196.     if (szCustomText != NULL) 
  197.         m_strCustomText = szCustomText;
  199.     // Store the Default Area text
  200.     if (szDefaultText != NULL) 
  201.         m_strDefaultText = szDefaultText;
  202.         
  203.     // Set the window size
  204.     SetWindowSize();
  206.     // Create the tooltips
  207.     CreateToolTips();
  209.     // Find which cell (if any) corresponds to the initial colour
  210.     FindCellFromColour(crColour);
  212.     // Capture all mouse events for the life of this window
  213.     SetCapture();
  215.     return TRUE;
  216. }
  218. BEGIN_MESSAGE_MAP(CColourPopup, CWnd)
  219.     //{{AFX_MSG_MAP(CColourPopup)
  220.     ON_WM_NCDESTROY()
  221.     ON_WM_LBUTTONUP()
  222.     ON_WM_PAINT()
  223.     ON_WM_MOUSEMOVE()
  224.     ON_WM_KEYDOWN()
  225.     ON_WM_QUERYNEWPALETTE()
  226.     ON_WM_PALETTECHANGED()
  227. ON_WM_KILLFOCUS()
  228. ON_WM_ACTIVATEAPP()
  229. //}}AFX_MSG_MAP
  230. END_MESSAGE_MAP()
  232. /////////////////////////////////////////////////////////////////////////////
  233. // CColourPopup message handlers
  235. // For tooltips
  236. BOOL CColourPopup::PreTranslateMessage(MSG* pMsg) 
  237. {
  238.     m_ToolTip.RelayEvent(pMsg);
  239.     return CWnd::PreTranslateMessage(pMsg);
  240. }
  242. // If an arrow key is pressed, then move the selection
  243. void CColourPopup::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
  244. {
  245.     int row = GetRow(m_nCurrentSel),
  246.         col = GetColumn(m_nCurrentSel);
  247.     int nSelection = m_nCurrentSel;
  249.     if (nChar == VK_DOWN) 
  250.     {
  251.         if (row == DEFAULT_BOX_VALUE) 
  252.             row = col = 0; 
  253.         else if (row == CUSTOM_BOX_VALUE)
  254.         {
  255.             if (m_strDefaultText.GetLength())
  256.                 row = col = DEFAULT_BOX_VALUE;
  257.             else
  258.                 row = col = 0;
  259.         }
  260.         else
  261.         {
  262.             row++;
  263.             if (GetIndex(row,col) < 0)
  264.             {
  265.                 if (m_strCustomText.GetLength())
  266.                     row = col = CUSTOM_BOX_VALUE;
  267.                 else if (m_strDefaultText.GetLength())
  268.                     row = col = DEFAULT_BOX_VALUE;
  269.                 else
  270.                     row = col = 0;
  271.             }
  272.         }
  273.         ChangeSelection(GetIndex(row, col));
  274.     }
  276.     if (nChar == VK_UP) 
  277.     {
  278.         if (row == DEFAULT_BOX_VALUE)
  279.         {
  280.             if (m_strCustomText.GetLength())
  281.                 row = col = CUSTOM_BOX_VALUE;
  282.             else
  283.            { 
  284.                 row = GetRow(m_nNumColours-1); 
  285.                 col = GetColumn(m_nNumColours-1); 
  286.             }
  287.         }
  288.         else if (row == CUSTOM_BOX_VALUE)
  289.         { 
  290.             row = GetRow(m_nNumColours-1); 
  291.             col = GetColumn(m_nNumColours-1); 
  292.         }
  293.         else if (row > 0) row--;
  294.         else /* row == 0 */
  295.         {
  296.             if (m_strDefaultText.GetLength())
  297.                 row = col = DEFAULT_BOX_VALUE;
  298.             else if (m_strCustomText.GetLength())
  299.                 row = col = CUSTOM_BOX_VALUE;
  300.             else
  301.             { 
  302.                 row = GetRow(m_nNumColours-1); 
  303.                 col = GetColumn(m_nNumColours-1); 
  304.             }
  305.         }
  306.         ChangeSelection(GetIndex(row, col));
  307.     }
  309.     if (nChar == VK_RIGHT) 
  310.     {
  311.         if (row == DEFAULT_BOX_VALUE) 
  312.             row = col = 0; 
  313.         else if (row == CUSTOM_BOX_VALUE)
  314.         {
  315.             if (m_strDefaultText.GetLength())
  316.                 row = col = DEFAULT_BOX_VALUE;
  317.             else
  318.                 row = col = 0;
  319.         }
  320.         else if (col < m_nNumColumns-1) 
  321.             col++;
  322.         else 
  323.         { 
  324.             col = 0; row++;
  325.         }
  327.         if (GetIndex(row,col) == INVALID_COLOUR)
  328.         {
  329.             if (m_strCustomText.GetLength())
  330.                 row = col = CUSTOM_BOX_VALUE;
  331.             else if (m_strDefaultText.GetLength())
  332.                 row = col = DEFAULT_BOX_VALUE;
  333.             else
  334.                 row = col = 0;
  335.         }
  337.         ChangeSelection(GetIndex(row, col));
  338.     }
  340.     if (nChar == VK_LEFT) 
  341.     {
  342.         if (row == DEFAULT_BOX_VALUE)
  343.         {
  344.             if (m_strCustomText.GetLength())
  345.                 row = col = CUSTOM_BOX_VALUE;
  346.             else
  347.            { 
  348.                 row = GetRow(m_nNumColours-1); 
  349.                 col = GetColumn(m_nNumColours-1); 
  350.             }
  351.         }
  352.         else if (row == CUSTOM_BOX_VALUE)
  353.         { 
  354.             row = GetRow(m_nNumColours-1); 
  355.             col = GetColumn(m_nNumColours-1); 
  356.         }
  357.         else if (col > 0) col--;
  358.         else /* col == 0 */
  359.         {
  360.             if (row > 0) { row--; col = m_nNumColumns-1; }
  361.             else 
  362.             {
  363.                 if (m_strDefaultText.GetLength())
  364.                     row = col = DEFAULT_BOX_VALUE;
  365.                 else if (m_strCustomText.GetLength())
  366.                     row = col = CUSTOM_BOX_VALUE;
  367.                 else
  368.                 { 
  369.                     row = GetRow(m_nNumColours-1); 
  370.                     col = GetColumn(m_nNumColours-1); 
  371.                 }
  372.             }
  373.         }
  374.         ChangeSelection(GetIndex(row, col));
  375.     }
  377.     if (nChar == VK_ESCAPE) 
  378.     {
  379.         m_crColour = m_crInitialColour;
  380.         EndSelection(CPN_SELENDCANCEL);
  381.         return;
  382.     }
  384.     if (nChar == VK_RETURN || nChar == VK_SPACE)
  385.     {
  386.         EndSelection(CPN_SELENDOK);
  387.         return;
  388.     }
  390.     CWnd::OnKeyDown(nChar, nRepCnt, nFlags);
  391. }
  393. // auto-deletion
  394. void CColourPopup::OnNcDestroy() 
  395. {
  396.     CWnd::OnNcDestroy();
  397.     delete this;
  398. }
  400. void CColourPopup::OnPaint() 
  401. {
  402.     CPaintDC dc(this); // device context for painting
  404.     // Draw the Default Area text
  405.     if (m_strDefaultText.GetLength())
  406.         DrawCell(&dc, DEFAULT_BOX_VALUE);
  407.  
  408.     // Draw colour cells
  409.     for (int i = 0; i < m_nNumColours; i++)
  410.         DrawCell(&dc, i);
  411.     
  412.     // Draw custom text
  413.     if (m_strCustomText.GetLength())
  414.         DrawCell(&dc, CUSTOM_BOX_VALUE);
  416.     // Draw raised window edge (ex-window style WS_EX_WINDOWEDGE is sposed to do this,
  417.     // but for some reason isn't
  418.     CRect rect;
  419.     GetClientRect(rect);
  420.     dc.DrawEdge(rect, EDGE_RAISED, BF_RECT);
  421. }
  423. void CColourPopup::OnMouseMove(UINT nFlags, CPoint point) 
  424. {
  425.     int nNewSelection = INVALID_COLOUR;
  427.     // Translate points to be relative raised window edge
  428.     point.x -= m_nMargin;
  429.     point.y -= m_nMargin;
  431.     // First check we aren't in text box
  432.     if (m_strCustomText.GetLength() && m_CustomTextRect.PtInRect(point))
  433.         nNewSelection = CUSTOM_BOX_VALUE;
  434.     else if (m_strDefaultText.GetLength() && m_DefaultTextRect.PtInRect(point))
  435.         nNewSelection = DEFAULT_BOX_VALUE;
  436.     else
  437.     {
  438.         // Take into account text box
  439.         if (m_strDefaultText.GetLength()) 
  440.             point.y -= m_DefaultTextRect.Height();  
  442.         // Get the row and column
  443.         nNewSelection = GetIndex(point.y / m_nBoxSize, point.x / m_nBoxSize);
  445.         // In range? If not, default and exit
  446.         if (nNewSelection < 0 || nNewSelection >= m_nNumColours)
  447.         {
  448.             CWnd::OnMouseMove(nFlags, point);
  449.             return;
  450.         }
  451.     }
  453.     // OK - we have the row and column of the current selection (may be CUSTOM_BOX_VALUE)
  454.     // Has the row/col selection changed? If yes, then redraw old and new cells.
  455.     if (nNewSelection != m_nCurrentSel)
  456.         ChangeSelection(nNewSelection);
  458.     CWnd::OnMouseMove(nFlags, point);
  459. }
  461. // End selection on LButtonUp
  462. void CColourPopup::OnLButtonUp(UINT nFlags, CPoint point) 
  463. {    
  464.     CWnd::OnLButtonUp(nFlags, point);
  466.     GetCursorPos(&point);
  468. if (m_WindowRect.PtInRect(point))
  469.         EndSelection(CPN_SELENDOK);
  470.     else
  471.         EndSelection(CPN_SELENDCANCEL);
  472. }
  474. /////////////////////////////////////////////////////////////////////////////
  475. // CColourPopup implementation
  477. int CColourPopup::GetIndex(int row, int col) const
  478. { 
  479.     if ((row == CUSTOM_BOX_VALUE || col == CUSTOM_BOX_VALUE) && m_strCustomText.GetLength())
  480.         return CUSTOM_BOX_VALUE;
  481.     else if ((row == DEFAULT_BOX_VALUE || col == DEFAULT_BOX_VALUE) && m_strDefaultText.GetLength())
  482.         return DEFAULT_BOX_VALUE;
  483.     else if (row < 0 || col < 0 || row >= m_nNumRows || col >= m_nNumColumns)
  484.         return INVALID_COLOUR;
  485.     else
  486.     {
  487.         if (row*m_nNumColumns + col >= m_nNumColours)
  488.             return INVALID_COLOUR;
  489.         else
  490.             return row*m_nNumColumns + col;
  491.     }
  492. }
  494. int CColourPopup::GetRow(int nIndex) const               
  495. { 
  496.     if (nIndex == CUSTOM_BOX_VALUE && m_strCustomText.GetLength())
  497.         return CUSTOM_BOX_VALUE;
  498.     else if (nIndex == DEFAULT_BOX_VALUE && m_strDefaultText.GetLength())
  499.         return DEFAULT_BOX_VALUE;
  500.     else if (nIndex < 0 || nIndex >= m_nNumColours)
  501.         return INVALID_COLOUR;
  502.     else
  503.         return nIndex / m_nNumColumns; 
  504. }
  506. int CColourPopup::GetColumn(int nIndex) const            
  507. { 
  508.     if (nIndex == CUSTOM_BOX_VALUE && m_strCustomText.GetLength())
  509.         return CUSTOM_BOX_VALUE;
  510.     else if (nIndex == DEFAULT_BOX_VALUE && m_strDefaultText.GetLength())
  511.         return DEFAULT_BOX_VALUE;
  512.     else if (nIndex < 0 || nIndex >= m_nNumColours)
  513.         return INVALID_COLOUR;
  514.     else
  515.         return nIndex % m_nNumColumns; 
  516. }
  518. void CColourPopup::FindCellFromColour(COLORREF crColour)
  519. {
  520.     if (crColour == CLR_DEFAULT && m_strDefaultText.GetLength())
  521.     {
  522.         m_nChosenColourSel = DEFAULT_BOX_VALUE;
  523.         return;
  524.     }
  526.     for (int i = 0; i < m_nNumColours; i++)
  527.     {
  528.         if (GetColour(i) == crColour)
  529.         {
  530.             m_nChosenColourSel = i;
  531.             return;
  532.         }
  533.     }
  535.     if (m_strCustomText.GetLength())
  536.         m_nChosenColourSel = CUSTOM_BOX_VALUE;
  537.     else
  538.         m_nChosenColourSel = INVALID_COLOUR;
  539. }
  541. // Gets the dimensions of the colour cell given by (row,col)
  542. BOOL CColourPopup::GetCellRect(int nIndex, const LPRECT& rect)
  543. {
  544.     if (nIndex == CUSTOM_BOX_VALUE)
  545.     {
  546.         ::SetRect(rect, 
  547.                   m_CustomTextRect.left,  m_CustomTextRect.top,
  548.                   m_CustomTextRect.right, m_CustomTextRect.bottom);
  549.         return TRUE;
  550.     }
  551.     else if (nIndex == DEFAULT_BOX_VALUE)
  552.     {
  553.         ::SetRect(rect, 
  554.                   m_DefaultTextRect.left,  m_DefaultTextRect.top,
  555.                   m_DefaultTextRect.right, m_DefaultTextRect.bottom);
  556.         return TRUE;
  557.     }
  559.     if (nIndex < 0 || nIndex >= m_nNumColours)
  560.         return FALSE;
  562.     rect->left = GetColumn(nIndex) * m_nBoxSize + m_nMargin;
  563.     rect->top  = GetRow(nIndex) * m_nBoxSize + m_nMargin;
  565.     // Move everything down if we are displaying a default text area
  566.     if (m_strDefaultText.GetLength()) 
  567.         rect->top += (m_nMargin + m_DefaultTextRect.Height());
  569.     rect->right = rect->left + m_nBoxSize;
  570.     rect->bottom = rect->top + m_nBoxSize;
  572.     return TRUE;
  573. }
  575. // Works out an appropriate size and position of this window
  576. void CColourPopup::SetWindowSize()
  577. {
  578.     CSize TextSize;
  580.     // If we are showing a custom or default text area, get the font and text size.
  581.     if (m_strCustomText.GetLength() || m_strDefaultText.GetLength())
  582.     {
  583.         CClientDC dc(this);
  584.         CFont* pOldFont = (CFont*) dc.SelectObject(&m_Font);
  586.         // Get the size of the custom text (if there IS custom text)
  587.         TextSize = CSize(0,0);
  588.         if (m_strCustomText.GetLength())
  589.             TextSize = dc.GetTextExtent(m_strCustomText);
  591.         // Get the size of the default text (if there IS default text)
  592.         if (m_strDefaultText.GetLength())
  593.         {
  594.             CSize DefaultSize = dc.GetTextExtent(m_strDefaultText);
  595.             if (DefaultSize.cx > TextSize.cx) TextSize.cx = DefaultSize.cx;
  596.             if (DefaultSize.cy > TextSize.cy) TextSize.cy = DefaultSize.cy;
  597.         }
  599.         dc.SelectObject(pOldFont);
  600.         TextSize += CSize(2*m_nMargin,2*m_nMargin);
  602.         // Add even more space to draw the horizontal line
  603.         TextSize.cy += 2*m_nMargin + 2;
  604.     }
  606.     // Get the number of columns and rows
  607.     //m_nNumColumns = (int) sqrt((double)m_nNumColours);    // for a square window (yuk)
  608.     m_nNumColumns = 8;
  609.     m_nNumRows = m_nNumColours / m_nNumColumns;
  610.     if (m_nNumColours % m_nNumColumns) m_nNumRows++;
  612.     // Get the current window position, and set the new size
  613.     CRect rect;
  614.     GetWindowRect(rect);
  616.     m_WindowRect.SetRect(rect.left, rect.top, 
  617.                          rect.left + m_nNumColumns*m_nBoxSize + 2*m_nMargin,
  618.                          rect.top  + m_nNumRows*m_nBoxSize + 2*m_nMargin);
  620.     // if custom text, then expand window if necessary, and set text width as
  621.     // window width
  622.     if (m_strDefaultText.GetLength()) 
  623.     {
  624.         if (TextSize.cx > m_WindowRect.Width())
  625.             m_WindowRect.right = m_WindowRect.left + TextSize.cx;
  626.         TextSize.cx = m_WindowRect.Width()-2*m_nMargin;
  628.         // Work out the text area
  629.         m_DefaultTextRect.SetRect(m_nMargin, m_nMargin, 
  630.                                   m_nMargin+TextSize.cx, 2*m_nMargin+TextSize.cy);
  631.         m_WindowRect.bottom += m_DefaultTextRect.Height() + 2*m_nMargin;
  632.     }
  634.     // if custom text, then expand window if necessary, and set text width as
  635.     // window width
  636.     if (m_strCustomText.GetLength()) 
  637.     {
  638.         if (TextSize.cx > m_WindowRect.Width())
  639.             m_WindowRect.right = m_WindowRect.left + TextSize.cx;
  640.         TextSize.cx = m_WindowRect.Width()-2*m_nMargin;
  642.         // Work out the text area
  643.         m_CustomTextRect.SetRect(m_nMargin, m_WindowRect.Height(), 
  644.                                  m_nMargin+TextSize.cx, 
  645.                                  m_WindowRect.Height()+m_nMargin+TextSize.cy);
  646.         m_WindowRect.bottom += m_CustomTextRect.Height() + 2*m_nMargin;
  647.    }
  649.     // Need to check it'll fit on screen: Too far right?
  650.     CSize ScreenSize(::GetSystemMetrics(SM_CXSCREEN), ::GetSystemMetrics(SM_CYSCREEN));
  651.     if (m_WindowRect.right > ScreenSize.cx)
  652.         m_WindowRect.OffsetRect(-(m_WindowRect.right - ScreenSize.cx), 0);
  654.     // Too far left?
  655.     if (m_WindowRect.left < 0)
  656.         m_WindowRect.OffsetRect( -m_WindowRect.left, 0);
  658.     // Bottom falling out of screen?
  659.     if (m_WindowRect.bottom > ScreenSize.cy)
  660.     {
  661.         CRect ParentRect;
  662.         m_pParent->GetWindowRect(ParentRect);
  663.         m_WindowRect.OffsetRect(0, -(ParentRect.Height() + m_WindowRect.Height()));
  664.     }
  666.     // Set the window size and position
  667.     MoveWindow(m_WindowRect, TRUE);
  668. }
  670. void CColourPopup::CreateToolTips()
  671. {
  672.     // Create the tool tip
  673.     if (!m_ToolTip.Create(this)) return;
  675.     // Add a tool for each cell
  676.     for (int i = 0; i < m_nNumColours; i++)
  677.     {
  678.         CRect rect;
  679.         if (!GetCellRect(i, rect)) continue;
  680.             m_ToolTip.AddTool(this, GetColourName(i), rect, 1);
  681.     }
  682. }
  684. void CColourPopup::ChangeSelection(int nIndex)
  685. {
  686.     CClientDC dc(this);        // device context for drawing
  688.     if (nIndex > m_nNumColours)
  689.         nIndex = CUSTOM_BOX_VALUE; 
  691.     if ((m_nCurrentSel >= 0 && m_nCurrentSel < m_nNumColours) ||
  692.         m_nCurrentSel == CUSTOM_BOX_VALUE || m_nCurrentSel == DEFAULT_BOX_VALUE)
  693.     {
  694.         // Set Current selection as invalid and redraw old selection (this way
  695.         // the old selection will be drawn unselected)
  696.         int OldSel = m_nCurrentSel;
  697.         m_nCurrentSel = INVALID_COLOUR;
  698.         DrawCell(&dc, OldSel);
  699.     }
  701.     // Set the current selection as row/col and draw (it will be drawn selected)
  702.     m_nCurrentSel = nIndex;
  703.     DrawCell(&dc, m_nCurrentSel);
  705.     // Store the current colour
  706.     if (m_nCurrentSel == CUSTOM_BOX_VALUE)
  707. {
  708. SENDMESSAGE(m_pParent,CPN_SELCHANGE, (WPARAM) m_crInitialColour, 0);
  709. }
  710.     else if (m_nCurrentSel == DEFAULT_BOX_VALUE)
  711.     {
  712.         m_crColour = CLR_DEFAULT;
  713. SENDMESSAGE(m_pParent,CPN_SELCHANGE, (WPARAM) CLR_DEFAULT, 0);
  714.     }
  715.     else
  716.     {
  717.         m_crColour = GetColour(m_nCurrentSel);
  718. SENDMESSAGE(m_pParent,CPN_SELCHANGE, (WPARAM) m_crColour, 0);
  719.     }
  720. }
  722. void CColourPopup::EndSelection(int nMessage)
  723. {
  724.     ReleaseCapture();
  726.     // If custom text selected, perform a custom colour selection
  727.     if (nMessage != CPN_SELENDCANCEL && m_nCurrentSel == CUSTOM_BOX_VALUE)
  728.     {
  729.         CColorDialog dlg(m_crInitialColour, CC_FULLOPEN | CC_ANYCOLOR, this);
  731.         if (dlg.DoModal() == IDOK)
  732.             m_crColour = dlg.GetColor();
  733.         else
  734.             m_crColour = m_crInitialColour;
  735.    } 
  737.     if (nMessage == CPN_SELENDCANCEL)
  738.         m_crColour = m_crInitialColour;
  740. SENDMESSAGE(m_pParent,nMessage, (WPARAM) m_crColour, 0);
  741.     
  742.     DestroyWindow();
  743. }
  745. void CColourPopup::DrawCell(CDC* pDC, int nIndex)
  746. {
  747.     // For the Custom Text area
  748.     if (m_strCustomText.GetLength() && nIndex == CUSTOM_BOX_VALUE)
  749.     {
  750.         // The extent of the actual text button
  751.         CRect TextButtonRect = m_CustomTextRect;
  752.         TextButtonRect.top += 2*m_nMargin;
  754.         // Fill background
  755.         pDC->FillSolidRect(TextButtonRect, ::GetSysColor(COLOR_3DFACE));
  757.         // Draw horizontal line
  758.         pDC->FillSolidRect(m_CustomTextRect.left+2*m_nMargin, m_CustomTextRect.top,
  759.                            m_CustomTextRect.Width()-4*m_nMargin, 1, ::GetSysColor(COLOR_3DSHADOW));
  760.         pDC->FillSolidRect(m_CustomTextRect.left+2*m_nMargin, m_CustomTextRect.top+1,
  761.                            m_CustomTextRect.Width()-4*m_nMargin, 1, ::GetSysColor(COLOR_3DHILIGHT));
  763.         TextButtonRect.DeflateRect(1,1);
  765.         // fill background
  766.         if (m_nChosenColourSel == nIndex && m_nCurrentSel != nIndex)
  767.             pDC->FillSolidRect(TextButtonRect, ::GetSysColor(COLOR_3DLIGHT));
  768.         else
  769.             pDC->FillSolidRect(TextButtonRect, ::GetSysColor(COLOR_3DFACE));
  771.         // Draw button
  772.         if (m_nCurrentSel == nIndex) 
  773.             pDC->DrawEdge(TextButtonRect, EDGE_RAISED, BF_RECT);
  774.         else if (m_nChosenColourSel == nIndex)
  775.             pDC->DrawEdge(TextButtonRect, EDGE_SUNKEN, BF_RECT);
  777.         // Draw custom text
  778.         CFont *pOldFont = (CFont*) pDC->SelectObject(&m_Font);
  779.         pDC->SetBkMode(TRANSPARENT);
  780.         pDC->DrawText(m_strCustomText, TextButtonRect, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
  781.         pDC->SelectObject(pOldFont);
  783.         return;
  784.     }        
  786.     // For the Default Text area
  787.     if (m_strDefaultText.GetLength() && nIndex == DEFAULT_BOX_VALUE)
  788.     {
  789.         // Fill background
  790.         pDC->FillSolidRect(m_DefaultTextRect, ::GetSysColor(COLOR_3DFACE));
  792.         // The extent of the actual text button
  793.         CRect TextButtonRect = m_DefaultTextRect;
  794.         TextButtonRect.DeflateRect(1,1);
  796.         // fill background
  797.         if (m_nChosenColourSel == nIndex && m_nCurrentSel != nIndex)
  798.             pDC->FillSolidRect(TextButtonRect, ::GetSysColor(COLOR_3DLIGHT));
  799.         else
  800.             pDC->FillSolidRect(TextButtonRect, ::GetSysColor(COLOR_3DFACE));
  802.         // Draw thin line around text
  803.         CRect LineRect = TextButtonRect;
  804.         LineRect.DeflateRect(2*m_nMargin,2*m_nMargin);
  805.         CPen pen(PS_SOLID, 1, ::GetSysColor(COLOR_3DSHADOW));
  806.         CPen* pOldPen = pDC->SelectObject(&pen);
  807.         pDC->SelectStockObject(NULL_BRUSH);
  808.         pDC->Rectangle(LineRect);
  809.         pDC->SelectObject(pOldPen);
  811.         // Draw button
  812.         if (m_nCurrentSel == nIndex) 
  813.             pDC->DrawEdge(TextButtonRect, EDGE_RAISED, BF_RECT);
  814.         else if (m_nChosenColourSel == nIndex)
  815.             pDC->DrawEdge(TextButtonRect, EDGE_SUNKEN, BF_RECT);
  817.         // Draw custom text
  818.         CFont *pOldFont = (CFont*) pDC->SelectObject(&m_Font);
  819.         pDC->SetBkMode(TRANSPARENT);
  820.         pDC->DrawText(m_strDefaultText, TextButtonRect, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
  821.         pDC->SelectObject(pOldFont);
  823.         return;
  824.     }        
  826.     CRect rect;
  827.     if (!GetCellRect(nIndex, rect)) return;
  829.     // Select and realize the palette
  830.     CPalette* pOldPalette;
  831.     if (pDC->GetDeviceCaps(RASTERCAPS) & RC_PALETTE)
  832.     {
  833.         pOldPalette = pDC->SelectPalette(&m_Palette, FALSE);
  834.         pDC->RealizePalette();
  835.     }
  837.     // fill background
  838.     if (m_nChosenColourSel == nIndex && m_nCurrentSel != nIndex)
  839.         pDC->FillSolidRect(rect, ::GetSysColor(COLOR_3DHILIGHT));
  840.     else
  841.         pDC->FillSolidRect(rect, ::GetSysColor(COLOR_3DFACE));
  843.     // Draw button
  844.     if (m_nCurrentSel == nIndex) 
  845.         pDC->DrawEdge(rect, EDGE_RAISED, BF_RECT);
  846.     else if (m_nChosenColourSel == nIndex)
  847.         pDC->DrawEdge(rect, EDGE_SUNKEN, BF_RECT);
  849.     CBrush brush(PALETTERGB(GetRValue(GetColour(nIndex)), 
  850.                             GetGValue(GetColour(nIndex)), 
  851.                             GetBValue(GetColour(nIndex)) ));
  852.     CPen   pen;
  853.     pen.CreatePen(PS_SOLID, 1, ::GetSysColor(COLOR_3DSHADOW));
  855.     CBrush* pOldBrush = (CBrush*) pDC->SelectObject(&brush);
  856.     CPen*   pOldPen   = (CPen*)   pDC->SelectObject(&pen);
  858.     // Draw the cell colour
  859.     rect.DeflateRect(m_nMargin+1, m_nMargin+1);
  860.     pDC->Rectangle(rect);
  862.     // restore DC and cleanup
  863.     pDC->SelectObject(pOldBrush);
  864.     pDC->SelectObject(pOldPen);
  865.     brush.DeleteObject();
  866.     pen.DeleteObject();
  868.     if (pDC->GetDeviceCaps(RASTERCAPS) & RC_PALETTE)
  869.         pDC->SelectPalette(pOldPalette, FALSE);
  870. }
  872. BOOL CColourPopup::OnQueryNewPalette() 
  873. {
  874.     Invalidate();    
  875.     return CWnd::OnQueryNewPalette();
  876. }
  878. void CColourPopup::OnPaletteChanged(CWnd* pFocusWnd) 
  879. {
  880.     CWnd::OnPaletteChanged(pFocusWnd);
  882.     if (pFocusWnd->GetSafeHwnd() != GetSafeHwnd())
  883.         Invalidate();
  884. }
  886. void CColourPopup::OnKillFocus(CWnd* pNewWnd) 
  887. {
  888. CWnd::OnKillFocus(pNewWnd);
  890.     ReleaseCapture();
  891.     //DestroyWindow(); - causes crash when Custom colour dialog appears.
  892. }
  894. // KillFocus problem fix suggested by Paul Wilkerson.
  895. void CColourPopup::OnActivateApp(BOOL bActive, HTASK hTask) 
  896. {
  897. CWnd::OnActivateApp(bActive, hTask);
  899. // If Deactivating App, cancel this selection
  900. if (!bActive)
  901.  EndSelection(CPN_SELENDCANCEL);
  902. }
  904. // Function name : CColourPopup::FindColor
  905. // Description     : 
  906. // Return type : int 
  907. // Argument         : COLORREF crColor
  908. int CColourPopup::FindColor(COLORREF crColor)
  909. {
  910.     for (int i = 0; i < m_nNumColours; i++)
  911.         if (GetColour(i) == crColor)
  912. return i;
  913. return 0;
  914. }