www.pudn.com > News Search3.01.rar > ColorPopup.cpp

// ColorPopup.cpp : implementation file 
// 
 
#include "stdafx.h" 
#include  
#include "ColorPicker.h" 
#include "ColorPopup.h" 
 
#ifdef _DEBUG 
#define new DEBUG_NEW 
#undef THIS_FILE 
static char THIS_FILE[] = __FILE__; 
#endif 
 
#define DEFAULT_BOX_VALUE	-3 
#define CUSTOM_BOX_VALUE	-2 
#define INVALID_COLOUR		-1 
#define MARGIN_BORDER		3 
#define MARGIN_TOP			2 
 
#define MAX_COLOURS			100 
 
ColorTable CColorPopup::m_crColors[] =  
{ 
    { RGB(0x00,0x00,0x00), _T("") }, 
    { RGB(0x90,0x30,0x00), _T("") }, 
    { RGB(0x2F,0x30,0x00), _T("") }, 
    { RGB(0x00,0x30,0x00), _T("") }, 
    { RGB(0x00,0x30,0x60), _T("") }, 
    { RGB(0x00,0x00,0x7F), _T("") }, 
    { RGB(0x2F,0x2F,0x90), _T("") }, 
    { RGB(0x2F,0x30,0x2F), _T("") }, 
 
    { RGB(0x7F,0x00,0x00), _T("") }, 
    { RGB(0xFF,0x67,0x00), _T("") }, 
    { RGB(0x7F,0x7F,0x00), _T("") }, 
    { RGB(0x00,0x7F,0x00), _T("") }, 
    { RGB(0x00,0x7F,0x7F), _T("") }, 
    { RGB(0x00,0x00,0xFF), _T("") }, 
    { RGB(0x60,0x67,0x90), _T("") }, 
    { RGB(0x7F,0x7F,0x7F), _T("") }, 
 
    { RGB(0xFF,0x00,0x00), _T("") }, 
    { RGB(0xFF,0x98,0x00), _T("") }, 
    { RGB(0x90,0xC8,0x00), _T("") }, 
    { RGB(0x2F,0x97,0x5F), _T("") }, 
    { RGB(0x30,0xC8,0xCF), _T("") }, 
    { RGB(0x2F,0x67,0xFF), _T("") }, 
    { RGB(0x7F,0x00,0x7F), _T("") }, 
    { RGB(0x90,0x97,0x90), _T("") }, 
 
    { RGB(0xFF,0x00,0xFF), _T("") }, 
    { RGB(0xFF,0x97,0x00), _T("") }, 
    { RGB(0xFF,0xFF,0x00), _T("") }, 
    { RGB(0x00,0xFF,0x00), _T("") }, 
    { RGB(0x00,0xFF,0xFF), _T("") }, 
    { RGB(0x00,0xC8,0xFF), _T("") }, 
    { RGB(0x90,0x30,0x60), _T("") }, 
    { RGB(0xBF,0xBF,0xBF), _T("") }, 
 
    { RGB(0xFF,0x98,0xCF), _T("") }, 
    { RGB(0xFF,0xC8,0x90), _T("") }, 
    { RGB(0xFF,0xFF,0x90), _T("") }, 
    { RGB(0xCF,0xFF,0xCF), _T("") }, 
    { RGB(0xC0,0xFF,0xFF), _T("") }, 
    { RGB(0x90,0xC8,0xFF), _T("") }, 
    { RGB(0xC0,0x97,0xFF), _T("") }, 
    { RGB(0xFF,0xFF,0xFF), _T("") } 
}; 
 
///////////////////////////////////////////////////////////////////////////// 
// CColorPopup 
 
CColorPopup::CColorPopup() 
{ 
    Initialise(); 
} 
 
CColorPopup::CColorPopup(CPoint p, COLORREF crColor, CWnd* pParentWnd, 
                           LPCTSTR szDefaultText /* = NULL */, 
                           LPCTSTR szCustomText  /* = NULL */) 
{ 
    Initialise(); 
 
    m_crColor       = m_crInitialColor = crColor; 
    m_pParent        = pParentWnd; 
    m_strDefaultText = (szDefaultText)? szDefaultText : _T(""); 
    m_strCustomText  = (szCustomText)?  szCustomText  : _T(""); 
 
    CColorPopup::Create(p, crColor, pParentWnd, szDefaultText, szCustomText); 
} 
 
void CColorPopup::Initialise() 
{ 
	int iTurn,iRow,j; 
	CString strSource; 
	TCHAR strSourceName[8][20]; 
	for(iRow = 0; iRow < 5; iRow++) 
	{ 
		strSource.LoadString(IDS_COLORNAME_ROW1 + iRow); 
		iTurn = _stscanf(strSource, _T("%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n"),  
				strSourceName[0],strSourceName[1],strSourceName[2], 
				strSourceName[3],strSourceName[4],strSourceName[5], 
				strSourceName[6],strSourceName[7]); 
	    ASSERT(iTurn == 8); 
		for(j = 0; j < 8; j++) 
			strcpy(m_crColors[iRow*8 + j].szName,strSourceName[j]); 
	} 
 
    m_nNumColors       = sizeof(m_crColors)/sizeof(ColorTable); 
    ASSERT(m_nNumColors <= MAX_COLOURS); 
    if (m_nNumColors > MAX_COLOURS) 
        m_nNumColors = MAX_COLOURS; 
 
    m_nNumColumns       = 0; 
    m_nNumRows          = 0; 
    m_nBoxSize          = 18; 
    m_nMargin           = ::GetSystemMetrics(SM_CXEDGE); 
    m_nCurrentSel       = INVALID_COLOUR; 
    m_nChosenColorSel  = INVALID_COLOUR; 
    m_pParent           = NULL; 
    m_crColor          = m_crInitialColor = RGB(0,0,0); 
 
    m_bChildWindowVisible = FALSE; 
 
    // Idiot check: Make sure the color square is at least 5 x 5; 
    if (m_nBoxSize - 2*m_nMargin - 2 < 5) m_nBoxSize = 5 + 2*m_nMargin + 2; 
 
    // Create the font 
    NONCLIENTMETRICS ncm; 
    ncm.cbSize = sizeof(NONCLIENTMETRICS); 
    VERIFY(SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(NONCLIENTMETRICS), &ncm, 0)); 
    m_Font.CreateFontIndirect(&(ncm.lfMessageFont)); 
 
    // Create the palette 
    struct { 
        LOGPALETTE    LogPalette; 
        PALETTEENTRY  PalEntry[MAX_COLOURS]; 
    } pal; 
 
    LOGPALETTE* pLogPalette = (LOGPALETTE*) &pal; 
    pLogPalette->palVersion    = 0x300; 
    pLogPalette->palNumEntries = (WORD) m_nNumColors;  
 
    for (int i = 0; i < m_nNumColors; i++) 
    { 
        pLogPalette->palPalEntry[i].peRed   = GetRValue(m_crColors[i].crColor); 
        pLogPalette->palPalEntry[i].peGreen = GetGValue(m_crColors[i].crColor); 
        pLogPalette->palPalEntry[i].peBlue  = GetBValue(m_crColors[i].crColor); 
        pLogPalette->palPalEntry[i].peFlags = 0; 
    } 
 
    m_Palette.CreatePalette(pLogPalette); 
} 
 
CColorPopup::~CColorPopup() 
{ 
    m_Font.DeleteObject(); 
    m_Palette.DeleteObject(); 
} 
 
BOOL CColorPopup::Create(CPoint p, COLORREF crColor, CWnd* pParentWnd, 
                          LPCTSTR szDefaultText /* = NULL */, 
                          LPCTSTR szCustomText  /* = NULL */) 
{ 
    ASSERT(pParentWnd && ::IsWindow(pParentWnd->GetSafeHwnd())); 
    ASSERT(pParentWnd->IsKindOf(RUNTIME_CLASS(CColorPicker))); 
 
    m_pParent  = pParentWnd; 
    m_crColor = m_crInitialColor = crColor; 
 
    // Get the class name and create the window 
    CString szClassName = AfxRegisterWndClass(CS_CLASSDC|CS_SAVEBITS|CS_HREDRAW|CS_VREDRAW, 
                                              0, 
                                              (HBRUSH) (COLOR_BTNFACE+1),  
                                              0); 
 
    if (!CWnd::CreateEx(0, szClassName, _T(""), WS_VISIBLE|WS_POPUP,  
                        p.x, p.y, 100, 100, // size updated soon 
                        pParentWnd->GetSafeHwnd(), 0, NULL)) 
        return FALSE; 
 
    // Store the Custom text 
    if (szCustomText != NULL)  
        m_strCustomText = szCustomText; 
 
    // Store the Default Area text 
    if (szDefaultText != NULL)  
        m_strDefaultText = szDefaultText; 
         
    // Set the window size 
    SetWindowSize(); 
 
    // Create the tooltips 
    CreateToolTips(); 
 
    // Find which cell (if any) corresponds to the initial color 
    FindCellFromColor(crColor); 
 
    // Capture all mouse events for the life of this window 
    SetCapture(); 
 
    return TRUE; 
} 
 
BEGIN_MESSAGE_MAP(CColorPopup, CWnd) 
	//{{AFX_MSG_MAP(CColorPopup) 
	ON_WM_NCDESTROY() 
	ON_WM_LBUTTONUP() 
	ON_WM_PAINT() 
	ON_WM_MOUSEMOVE() 
	ON_WM_KEYDOWN() 
	ON_WM_QUERYNEWPALETTE() 
	ON_WM_PALETTECHANGED() 
	ON_WM_KILLFOCUS() 
	ON_WM_ACTIVATEAPP() 
	//}}AFX_MSG_MAP 
END_MESSAGE_MAP() 
 
 
///////////////////////////////////////////////////////////////////////////// 
// CColorPopup message handlers 
 
BOOL CColorPopup::PreTranslateMessage(MSG* pMsg)  
{ 
	// TODO: Add your specialized code here and/or call the base class 
    m_ToolTip.RelayEvent(pMsg); 
 
    // Fix (Adrian Roman): Sometimes if the picker loses focus it is never destroyed 
    if (GetCapture()->GetSafeHwnd() != m_hWnd) 
        SetCapture();  
 
	return CWnd::PreTranslateMessage(pMsg); 
} 
 
void CColorPopup::OnNcDestroy()  
{ 
	CWnd::OnNcDestroy(); 
	 
	// TODO: Add your message handler code here 
    delete this; 
} 
 
void CColorPopup::OnLButtonUp(UINT nFlags, CPoint point)  
{ 
    CWnd::OnLButtonUp(nFlags, point); 
 
    DWORD pos = GetMessagePos(); 
    point = CPoint(LOWORD(pos), HIWORD(pos)); 
 
    if (m_WindowRect.PtInRect(point)) 
        EndSelection(CPN_SELENDOK); 
    else 
        EndSelection(CPN_SELENDCANCEL); 
} 
 
void CColorPopup::OnPaint()  
{ 
	CPaintDC dc(this); // device context for painting 
	 
	// TODO: Add your message handler code here 
    // Draw the Default Area text 
    if (m_strDefaultText.GetLength()) 
        DrawCell(&dc, DEFAULT_BOX_VALUE); 
  
    // Draw color cells 
    for (int i = 0; i < m_nNumColors; i++) 
        DrawCell(&dc, i); 
     
    // Draw custom text 
    if (m_strCustomText.GetLength()) 
        DrawCell(&dc, CUSTOM_BOX_VALUE); 
 
    // Draw raised window edge (ex-window style WS_EX_WINDOWEDGE is sposed to do this, 
    // but for some reason isn't 
    CRect rect; 
    GetClientRect(rect); 
    dc.DrawEdge(rect, EDGE_RAISED, BF_RECT); 
 
	// Do not call CWnd::OnPaint() for painting messages 
} 
 
void CColorPopup::OnMouseMove(UINT nFlags, CPoint point)  
{ 
	// TODO: Add your message handler code here and/or call default 
    int nNewSelection = INVALID_COLOUR; 
 
    // Translate points to be relative raised window edge 
    point.x -= m_nMargin; 
    point.y -= m_nMargin; 
 
    // First check we aren't in text box 
    if (m_strCustomText.GetLength() && m_CustomTextRect.PtInRect(point)) 
        nNewSelection = CUSTOM_BOX_VALUE; 
    else if (m_strDefaultText.GetLength() && m_DefaultTextRect.PtInRect(point)) 
        nNewSelection = DEFAULT_BOX_VALUE; 
    else 
    { 
        // Take into account text box 
        if (m_strDefaultText.GetLength())  
            point.y -= m_DefaultTextRect.Height();   
 
        // Get the row and column 
        nNewSelection = GetIndex(point.y / m_nBoxSize, point.x / m_nBoxSize); 
 
        // In range? If not, default and exit 
        if (nNewSelection < 0 || nNewSelection >= m_nNumColors) 
        { 
            CWnd::OnMouseMove(nFlags, point); 
            return; 
        } 
    } 
 
    // OK - we have the row and column of the current selection (may be CUSTOM_BOX_VALUE) 
    // Has the row/col selection changed? If yes, then redraw old and new cells. 
    if (nNewSelection != m_nCurrentSel) 
        ChangeSelection(nNewSelection); 
	 
	CWnd::OnMouseMove(nFlags, point); 
} 
 
void CColorPopup::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)  
{ 
	// TODO: Add your message handler code here and/or call default 
    int row = GetRow(m_nCurrentSel), 
        col = GetColumn(m_nCurrentSel); 
 
    if (nChar == VK_DOWN)  
    { 
        if (row == DEFAULT_BOX_VALUE)  
            row = col = 0;  
        else if (row == CUSTOM_BOX_VALUE) 
        { 
            if (m_strDefaultText.GetLength()) 
                row = col = DEFAULT_BOX_VALUE; 
            else 
                row = col = 0; 
        } 
        else 
        { 
            row++; 
            if (GetIndex(row,col) < 0) 
            { 
                if (m_strCustomText.GetLength()) 
                    row = col = CUSTOM_BOX_VALUE; 
                else if (m_strDefaultText.GetLength()) 
                    row = col = DEFAULT_BOX_VALUE; 
                else 
                    row = col = 0; 
            } 
        } 
        ChangeSelection(GetIndex(row, col)); 
    } 
 
    if (nChar == VK_UP)  
    { 
        if (row == DEFAULT_BOX_VALUE) 
        { 
            if (m_strCustomText.GetLength()) 
                row = col = CUSTOM_BOX_VALUE; 
            else 
           {  
                row = GetRow(m_nNumColors-1);  
                col = GetColumn(m_nNumColors-1);  
            } 
        } 
        else if (row == CUSTOM_BOX_VALUE) 
        {  
            row = GetRow(m_nNumColors-1);  
            col = GetColumn(m_nNumColors-1);  
        } 
        else if (row > 0) row--; 
        else /* row == 0 */ 
        { 
            if (m_strDefaultText.GetLength()) 
                row = col = DEFAULT_BOX_VALUE; 
            else if (m_strCustomText.GetLength()) 
                row = col = CUSTOM_BOX_VALUE; 
            else 
            {  
                row = GetRow(m_nNumColors-1);  
                col = GetColumn(m_nNumColors-1);  
            } 
        } 
        ChangeSelection(GetIndex(row, col)); 
    } 
 
    if (nChar == VK_RIGHT)  
    { 
        if (row == DEFAULT_BOX_VALUE)  
            row = col = 0;  
        else if (row == CUSTOM_BOX_VALUE) 
        { 
            if (m_strDefaultText.GetLength()) 
                row = col = DEFAULT_BOX_VALUE; 
            else 
                row = col = 0; 
        } 
        else if (col < m_nNumColumns-1)  
            col++; 
        else  
        {  
            col = 0; row++; 
        } 
 
        if (GetIndex(row,col) == INVALID_COLOUR) 
        { 
            if (m_strCustomText.GetLength()) 
                row = col = CUSTOM_BOX_VALUE; 
            else if (m_strDefaultText.GetLength()) 
                row = col = DEFAULT_BOX_VALUE; 
            else 
                row = col = 0; 
        } 
 
        ChangeSelection(GetIndex(row, col)); 
    } 
 
    if (nChar == VK_LEFT)  
    { 
        if (row == DEFAULT_BOX_VALUE) 
        { 
            if (m_strCustomText.GetLength()) 
                row = col = CUSTOM_BOX_VALUE; 
            else 
           {  
                row = GetRow(m_nNumColors-1);  
                col = GetColumn(m_nNumColors-1);  
            } 
        } 
        else if (row == CUSTOM_BOX_VALUE) 
        {  
            row = GetRow(m_nNumColors-1);  
            col = GetColumn(m_nNumColors-1);  
        } 
        else if (col > 0) col--; 
        else /* col == 0 */ 
        { 
            if (row > 0) { row--; col = m_nNumColumns-1; } 
            else  
            { 
                if (m_strDefaultText.GetLength()) 
                    row = col = DEFAULT_BOX_VALUE; 
                else if (m_strCustomText.GetLength()) 
                    row = col = CUSTOM_BOX_VALUE; 
                else 
                {  
                    row = GetRow(m_nNumColors-1);  
                    col = GetColumn(m_nNumColors-1);  
                } 
            } 
        } 
        ChangeSelection(GetIndex(row, col)); 
    } 
 
    if (nChar == VK_ESCAPE)  
    { 
        m_crColor = m_crInitialColor; 
        EndSelection(CPN_SELENDCANCEL); 
        return; 
    } 
 
    if (nChar == VK_RETURN || nChar == VK_SPACE) 
    { 
        EndSelection(CPN_SELENDOK); 
        return; 
    } 
	 
	CWnd::OnKeyDown(nChar, nRepCnt, nFlags); 
} 
 
int CColorPopup::GetIndex(int row, int col) const 
{  
    if ((row == CUSTOM_BOX_VALUE || col == CUSTOM_BOX_VALUE) && m_strCustomText.GetLength()) 
        return CUSTOM_BOX_VALUE; 
    else if ((row == DEFAULT_BOX_VALUE || col == DEFAULT_BOX_VALUE) && m_strDefaultText.GetLength()) 
        return DEFAULT_BOX_VALUE; 
    else if (row < 0 || col < 0 || row >= m_nNumRows || col >= m_nNumColumns) 
        return INVALID_COLOUR; 
    else 
    { 
        if (row*m_nNumColumns + col >= m_nNumColors) 
            return INVALID_COLOUR; 
        else 
            return row*m_nNumColumns + col; 
    } 
} 
 
int CColorPopup::GetRow(int nIndex) const                
{  
    if (nIndex == CUSTOM_BOX_VALUE && m_strCustomText.GetLength()) 
        return CUSTOM_BOX_VALUE; 
    else if (nIndex == DEFAULT_BOX_VALUE && m_strDefaultText.GetLength()) 
        return DEFAULT_BOX_VALUE; 
    else if (nIndex < 0 || nIndex >= m_nNumColors) 
        return INVALID_COLOUR; 
    else 
        return nIndex / m_nNumColumns;  
} 
 
int CColorPopup::GetColumn(int nIndex) const             
{  
    if (nIndex == CUSTOM_BOX_VALUE && m_strCustomText.GetLength()) 
        return CUSTOM_BOX_VALUE; 
    else if (nIndex == DEFAULT_BOX_VALUE && m_strDefaultText.GetLength()) 
        return DEFAULT_BOX_VALUE; 
    else if (nIndex < 0 || nIndex >= m_nNumColors) 
        return INVALID_COLOUR; 
    else 
        return nIndex % m_nNumColumns;  
} 
 
void CColorPopup::FindCellFromColor(COLORREF crColor) 
{ 
    if (crColor == CLR_DEFAULT && m_strDefaultText.GetLength()) 
    { 
        m_nChosenColorSel = DEFAULT_BOX_VALUE; 
        return; 
    } 
 
    for (int i = 0; i < m_nNumColors; i++) 
    { 
        if (GetColor(i) == crColor) 
        { 
            m_nChosenColorSel = i; 
            return; 
        } 
    } 
 
    if (m_strCustomText.GetLength()) 
        m_nChosenColorSel = CUSTOM_BOX_VALUE; 
    else 
        m_nChosenColorSel = INVALID_COLOUR; 
} 
 
// Gets the dimensions of the color cell given by (row,col) 
BOOL CColorPopup::GetCellRect(int nIndex, const LPRECT& rect) 
{ 
    if (nIndex == CUSTOM_BOX_VALUE) 
    { 
        ::SetRect(rect,  
                  m_CustomTextRect.left,  m_CustomTextRect.top, 
                  m_CustomTextRect.right, m_CustomTextRect.bottom); 
        return TRUE; 
    } 
    else if (nIndex == DEFAULT_BOX_VALUE) 
    { 
        ::SetRect(rect,  
                  m_DefaultTextRect.left,  m_DefaultTextRect.top, 
                  m_DefaultTextRect.right, m_DefaultTextRect.bottom); 
        return TRUE; 
    } 
 
    if (nIndex < 0 || nIndex >= m_nNumColors) 
        return FALSE; 
 
    rect->left = GetColumn(nIndex) * m_nBoxSize + m_nMargin + MARGIN_BORDER; 
    rect->top  = GetRow(nIndex) * m_nBoxSize + m_nMargin + MARGIN_TOP; 
 
    // Move everything down if we are displaying a default text area 
    if (m_strDefaultText.GetLength())  
        rect->top += (m_nMargin + m_DefaultTextRect.Height()); 
 
    rect->right = rect->left + m_nBoxSize; 
    rect->bottom = rect->top + m_nBoxSize; 
 
    return TRUE; 
} 
 
// Works out an appropriate size and position of this window 
void CColorPopup::SetWindowSize() 
{ 
    CSize TextSize; 
 
    // If we are showing a custom or default text area, get the font and text size. 
    if (m_strCustomText.GetLength() || m_strDefaultText.GetLength()) 
    { 
        CClientDC dc(this); 
        CFont* pOldFont = (CFont*) dc.SelectObject(&m_Font); 
 
        // Get the size of the custom text (if there IS custom text) 
        TextSize = CSize(0,0); 
        if (m_strCustomText.GetLength()) 
            TextSize = dc.GetTextExtent(m_strCustomText); 
 
        // Get the size of the default text (if there IS default text) 
        if (m_strDefaultText.GetLength()) 
        { 
            CSize DefaultSize = dc.GetTextExtent(m_strDefaultText); 
            if (DefaultSize.cx > TextSize.cx) TextSize.cx = DefaultSize.cx; 
            if (DefaultSize.cy > TextSize.cy) TextSize.cy = DefaultSize.cy; 
        } 
 
        dc.SelectObject(pOldFont); 
        TextSize += CSize(2*m_nMargin,2*m_nMargin); 
 
        // Add even more space to draw the horizontal line 
        TextSize.cy += 2*m_nMargin + 4; 
    } 
 
    // Get the number of columns and rows 
    //m_nNumColumns = (int) sqrt((double)m_nNumColors);    // for a square window (yuk) 
    m_nNumColumns = 8; 
    m_nNumRows = m_nNumColors / m_nNumColumns; 
    if (m_nNumColors % m_nNumColumns) m_nNumRows++; 
 
    // Get the current window position, and set the new size 
    CRect rect; 
    GetWindowRect(rect); 
 
    m_WindowRect.SetRect(rect.left, rect.top,  
		rect.left + m_nNumColumns*m_nBoxSize + 2*(m_nMargin + MARGIN_BORDER), 
        rect.top  + m_nNumRows*m_nBoxSize + 2*m_nMargin + MARGIN_TOP); 
 
    // if custom text, then expand window if necessary, and set text width as 
    // window width 
    if (m_strDefaultText.GetLength())  
    { 
        if (TextSize.cx > m_WindowRect.Width()) 
            m_WindowRect.right = m_WindowRect.left + TextSize.cx; 
        TextSize.cx = m_WindowRect.Width()-2*m_nMargin; 
 
        // Work out the text area 
        m_DefaultTextRect.SetRect(m_nMargin, m_nMargin,  
			m_nMargin+TextSize.cx-MARGIN_BORDER,  
			2*m_nMargin+TextSize.cy+MARGIN_TOP); 
        m_WindowRect.bottom += m_DefaultTextRect.Height() + 2*m_nMargin; 
    } 
 
    // if custom text, then expand window if necessary, and set text width as 
    // window width 
    if (m_strCustomText.GetLength())  
    { 
        if (TextSize.cx > m_WindowRect.Width()) 
            m_WindowRect.right = m_WindowRect.left + TextSize.cx; 
        TextSize.cx = m_WindowRect.Width()-2*m_nMargin; 
 
        // Work out the text area 
        m_CustomTextRect.SetRect(m_nMargin, m_WindowRect.Height(),  
            m_nMargin+TextSize.cx-MARGIN_BORDER,  
            m_WindowRect.Height()+m_nMargin+TextSize.cy+MARGIN_TOP); 
        m_WindowRect.bottom += m_CustomTextRect.Height() + 2*m_nMargin; 
   } 
 
    // Need to check it'll fit on screen: Too far right? 
    CSize ScreenSize(::GetSystemMetrics(SM_CXSCREEN), ::GetSystemMetrics(SM_CYSCREEN)); 
    if (m_WindowRect.right > ScreenSize.cx) 
        m_WindowRect.OffsetRect(-(m_WindowRect.right - ScreenSize.cx), 0); 
 
    // Too far left? 
    if (m_WindowRect.left < 0) 
        m_WindowRect.OffsetRect( -m_WindowRect.left, 0); 
 
    // Bottom falling out of screen? 
    if (m_WindowRect.bottom > ScreenSize.cy) 
    { 
        CRect ParentRect; 
        m_pParent->GetWindowRect(ParentRect); 
        m_WindowRect.OffsetRect(0, -(ParentRect.Height() + m_WindowRect.Height())); 
    } 
 
    // Set the window size and position 
    MoveWindow(m_WindowRect, TRUE); 
} 
 
void CColorPopup::CreateToolTips() 
{ 
    // Create the tool tip 
    if (!m_ToolTip.Create(this)) return; 
 
    // Add a tool for each cell 
    for (int i = 0; i < m_nNumColors; i++) 
    { 
        CRect rect; 
        if (!GetCellRect(i, rect)) continue; 
            m_ToolTip.AddTool(this, GetColorName(i), rect, 1); 
    } 
} 
 
void CColorPopup::ChangeSelection(int nIndex) 
{ 
    CClientDC dc(this);        // device context for drawing 
 
    if (nIndex > m_nNumColors) 
        nIndex = CUSTOM_BOX_VALUE;  
 
    if ((m_nCurrentSel >= 0 && m_nCurrentSel < m_nNumColors) || 
        m_nCurrentSel == CUSTOM_BOX_VALUE || m_nCurrentSel == DEFAULT_BOX_VALUE) 
    { 
        // Set Current selection as invalid and redraw old selection (this way 
        // the old selection will be drawn unselected) 
        int OldSel = m_nCurrentSel; 
        m_nCurrentSel = INVALID_COLOUR; 
        DrawCell(&dc, OldSel); 
    } 
 
    // Set the current selection as row/col and draw (it will be drawn selected) 
    m_nCurrentSel = nIndex; 
    DrawCell(&dc, m_nCurrentSel); 
 
    // Store the current color 
    if (m_nCurrentSel == CUSTOM_BOX_VALUE) 
        m_pParent->SendMessage(CPN_SELCHANGE, (WPARAM) m_crInitialColor, 0); 
    else if (m_nCurrentSel == DEFAULT_BOX_VALUE) 
    { 
        m_crColor = CLR_DEFAULT; 
        m_pParent->SendMessage(CPN_SELCHANGE, (WPARAM) CLR_DEFAULT, 0); 
    } 
    else 
    { 
        m_crColor = GetColor(m_nCurrentSel); 
        m_pParent->SendMessage(CPN_SELCHANGE, (WPARAM) m_crColor, 0); 
    } 
} 
 
void CColorPopup::EndSelection(int nMessage) 
{ 
    ReleaseCapture(); 
 
    // If custom text selected, perform a custom color selection 
    if (nMessage != CPN_SELENDCANCEL && m_nCurrentSel == CUSTOM_BOX_VALUE) 
    { 
        m_bChildWindowVisible = TRUE; 
 
        CColorDialog dlg(m_crInitialColor, CC_FULLOPEN | CC_ANYCOLOR, this); 
 
        if (dlg.DoModal() == IDOK) 
            m_crColor = dlg.GetColor(); 
        else 
            nMessage = CPN_SELENDCANCEL; 
 
        m_bChildWindowVisible = FALSE; 
    }  
 
    if (nMessage == CPN_SELENDCANCEL) 
        m_crColor = m_crInitialColor; 
 
    m_pParent->SendMessage(nMessage, (WPARAM) m_crColor, 0); 
     
    // Kill focus bug fixed by Martin Wawrusch 
    if (!m_bChildWindowVisible) 
        DestroyWindow(); 
} 
 
void CColorPopup::DrawCell(CDC* pDC, int nIndex) 
{ 
    // For the Custom Text area 
    if (m_strCustomText.GetLength() && nIndex == CUSTOM_BOX_VALUE) 
    { 
        // The extent of the actual text button 
        CRect TextButtonRect = m_CustomTextRect; 
        TextButtonRect.top += 2*m_nMargin + MARGIN_TOP; 
		TextButtonRect.left += MARGIN_BORDER; 
 
        // Fill background 
		pDC->FillSolidRect(TextButtonRect, ::GetSysColor(COLOR_3DFACE)); 
 
        // Draw horizontal line 
		pDC->FillSolidRect(m_CustomTextRect.left+2*m_nMargin+MARGIN_BORDER, 
			m_CustomTextRect.top+MARGIN_TOP, 
			m_CustomTextRect.Width()-4*m_nMargin-MARGIN_BORDER, 
			1, ::GetSysColor(COLOR_3DSHADOW)); 
		pDC->FillSolidRect(m_CustomTextRect.left+2*m_nMargin+MARGIN_BORDER, 
			m_CustomTextRect.top+1+MARGIN_TOP, 
			m_CustomTextRect.Width()-4*m_nMargin-MARGIN_BORDER, 
			1, ::GetSysColor(COLOR_3DHILIGHT)); 
 
        TextButtonRect.DeflateRect(1,1); 
 
        // fill background 
		CBrush DithBrush; 
		CBitmap bmp; 
		HBITMAP hbmDith = CreateDitherBitmap(); 
		DithBrush.CreatePatternBrush(bmp.FromHandle(hbmDith)); 
        if (m_nChosenColorSel == nIndex && m_nCurrentSel != nIndex) 
			pDC->FillRect(TextButtonRect, &DithBrush); 
        else 
            pDC->FillSolidRect(TextButtonRect, ::GetSysColor(COLOR_3DFACE)); 
		DithBrush.DeleteObject(); 
		::DeleteObject(hbmDith); 
		bmp.DeleteObject(); 
 
        // Draw button 
        if (m_nCurrentSel == nIndex && m_nChosenColorSel != nIndex)  
            pDC->DrawEdge(TextButtonRect, BDR_RAISEDINNER, BF_RECT); 
        else if (m_nChosenColorSel == nIndex) 
            pDC->DrawEdge(TextButtonRect, BDR_SUNKENOUTER, BF_RECT); 
 
        // Draw custom text 
		CFont *pOldFont = (CFont*) pDC->SelectObject(&m_Font); 
		pDC->SetBkMode(TRANSPARENT); 
		pDC->DrawText(m_strCustomText, TextButtonRect, DT_CENTER | DT_VCENTER | DT_SINGLELINE); 
		pDC->SelectObject(pOldFont); 
 
        return; 
    }         
 
    // For the Default Text area 
    if (m_strDefaultText.GetLength() && nIndex == DEFAULT_BOX_VALUE) 
    { 
        // The extent of the actual text button 
        CRect TextButtonRect = m_DefaultTextRect; 
		TextButtonRect.top += MARGIN_TOP; 
		TextButtonRect.bottom += MARGIN_TOP; 
		TextButtonRect.left += MARGIN_BORDER; 
 
        // Fill background 
		pDC->FillSolidRect(TextButtonRect, ::GetSysColor(COLOR_3DFACE)); 
 
        TextButtonRect.DeflateRect(1,1); 
 
        // fill background 
		CBrush DithBrush; 
		CBitmap bmp; 
		HBITMAP hbmDith = CreateDitherBitmap(); 
		DithBrush.CreatePatternBrush(bmp.FromHandle(hbmDith)); 
		if (m_nChosenColorSel == nIndex && m_nCurrentSel != nIndex) 
			pDC->FillRect(TextButtonRect, &DithBrush); 
		else 
			pDC->FillSolidRect(TextButtonRect, ::GetSysColor(COLOR_3DFACE)); 
		DithBrush.DeleteObject(); 
		::DeleteObject(hbmDith); 
		bmp.DeleteObject(); 
 
        // Draw thin line around text 
        CRect LineRect = TextButtonRect; 
        LineRect.DeflateRect(2*m_nMargin,2*m_nMargin); 
        CPen pen(PS_SOLID, 1, ::GetSysColor(COLOR_3DSHADOW)); 
        CPen* pOldPen = pDC->SelectObject(&pen); 
        pDC->SelectStockObject(NULL_BRUSH); 
        pDC->Rectangle(LineRect); 
        pDC->SelectObject(pOldPen); 
 
        // Draw button 
        if (m_nCurrentSel == nIndex && m_nChosenColorSel != nIndex)  
            pDC->DrawEdge(TextButtonRect, BDR_RAISEDINNER, BF_RECT); 
        else if (m_nChosenColorSel == nIndex) 
            pDC->DrawEdge(TextButtonRect, BDR_SUNKENOUTER, BF_RECT); 
 
        // Draw custom text 
		CFont *pOldFont = (CFont*) pDC->SelectObject(&m_Font); 
		pDC->SetBkMode(TRANSPARENT); 
		pDC->DrawText(m_strDefaultText, TextButtonRect, DT_CENTER | DT_VCENTER | DT_SINGLELINE); 
		pDC->SelectObject(pOldFont); 
 
        return; 
    }         
 
    CRect rect; 
    if (!GetCellRect(nIndex, rect)) return; 
 
    // Select and realize the palette 
    CPalette* pOldPalette = NULL; 
    if (pDC->GetDeviceCaps(RASTERCAPS) & RC_PALETTE) 
    { 
        pOldPalette = pDC->SelectPalette(&m_Palette, FALSE); 
        pDC->RealizePalette(); 
    } 
 
    // fill background 
	CBrush DithBrush; 
	CBitmap bmp; 
	HBITMAP hbmDith = CreateDitherBitmap(); 
	DithBrush.CreatePatternBrush(bmp.FromHandle(hbmDith)); 
	if (m_nChosenColorSel == nIndex && m_nCurrentSel != nIndex) 
		pDC->FillRect(rect, &DithBrush); 
	else 
        pDC->FillSolidRect(rect, ::GetSysColor(COLOR_3DFACE)); 
	DithBrush.DeleteObject(); 
	::DeleteObject(hbmDith); 
	bmp.DeleteObject(); 
 
    // Draw button 
	if (m_nCurrentSel == nIndex && m_nChosenColorSel != nIndex)  
		pDC->DrawEdge(rect, BDR_RAISEDINNER, BF_RECT); 
	else if (m_nChosenColorSel == nIndex) 
		pDC->DrawEdge(rect, BDR_SUNKENOUTER, BF_RECT); 
 
    CBrush brush(PALETTERGB(GetRValue(GetColor(nIndex)),  
                            GetGValue(GetColor(nIndex)),  
                            GetBValue(GetColor(nIndex)) )); 
    CPen   pen; 
    pen.CreatePen(PS_SOLID, 1, ::GetSysColor(COLOR_3DSHADOW)); 
 
    CBrush* pOldBrush = (CBrush*) pDC->SelectObject(&brush); 
    CPen*   pOldPen   = (CPen*)   pDC->SelectObject(&pen); 
 
    // Draw the cell color 
    rect.DeflateRect(m_nMargin+1, m_nMargin+1); 
	pDC->Rectangle(rect); 
 
    // restore DC and cleanup 
    pDC->SelectObject(pOldBrush); 
    pDC->SelectObject(pOldPen); 
    brush.DeleteObject(); 
    pen.DeleteObject(); 
 
    if (pOldPalette && pDC->GetDeviceCaps(RASTERCAPS) & RC_PALETTE) 
        pDC->SelectPalette(pOldPalette, FALSE); 
} 
 
BOOL CColorPopup::OnQueryNewPalette()  
{ 
	// TODO: Add your message handler code here and/or call default 
    Invalidate();     
	 
	return CWnd::OnQueryNewPalette(); 
} 
 
void CColorPopup::OnPaletteChanged(CWnd* pFocusWnd)  
{ 
	CWnd::OnPaletteChanged(pFocusWnd); 
	 
	// TODO: Add your message handler code here 
    if (pFocusWnd->GetSafeHwnd() != GetSafeHwnd()) 
        Invalidate(); 
} 
 
void CColorPopup::OnKillFocus(CWnd* pNewWnd)  
{ 
	CWnd::OnKillFocus(pNewWnd); 
	 
	// TODO: Add your message handler code here 
    ReleaseCapture(); 
    //DestroyWindow(); - causes crash when Custom color dialog appears. 
} 
 
void CColorPopup::OnActivateApp(BOOL bActive, HTASK hTask)  
{ 
	CWnd::OnActivateApp(bActive, hTask); 
	 
	// TODO: Add your message handler code here 
	// If Deactivating App, cancel this selection 
	if (!bActive) 
		 EndSelection(CPN_SELENDCANCEL); 
} 
 
HBITMAP CColorPopup::CreateDitherBitmap() 
{ 
	struct  // BITMAPINFO with 16 colors 
	{ 
		BITMAPINFOHEADER bmiHeader; 
		RGBQUAD      bmiColors[16]; 
	} bmi; 
	memset(&bmi, 0, sizeof(bmi)); 
 
	bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER); 
	bmi.bmiHeader.biWidth = 8; 
	bmi.bmiHeader.biHeight = 8; 
	bmi.bmiHeader.biPlanes = 1; 
	bmi.bmiHeader.biBitCount = 1; 
	bmi.bmiHeader.biCompression = BI_RGB; 
 
	COLORREF clr = ::GetSysColor(COLOR_BTNFACE); 
 
	bmi.bmiColors[0].rgbBlue = GetBValue(clr); 
	bmi.bmiColors[0].rgbGreen = GetGValue(clr); 
	bmi.bmiColors[0].rgbRed = GetRValue(clr); 
 
	clr = ::GetSysColor(COLOR_BTNHIGHLIGHT); 
	bmi.bmiColors[1].rgbBlue = GetBValue(clr); 
	bmi.bmiColors[1].rgbGreen = GetGValue(clr); 
	bmi.bmiColors[1].rgbRed = GetRValue(clr); 
 
	// initialize the brushes 
	long patGray[8]; 
	for (int i = 0; i < 8; i++) 
	   patGray[i] = (i & 1) ? 0xAAAA5555L : 0x5555AAAAL; 
 
	HDC hDC = ::GetDC(NULL); 
	HBITMAP hbm = CreateDIBitmap(hDC, &bmi.bmiHeader, CBM_INIT, 
		(LPBYTE)patGray, (LPBITMAPINFO)&bmi, DIB_RGB_COLORS); 
	::ReleaseDC(NULL, hDC); 
 
	return hbm; 
}