phaneron/DragonNest
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
DragonNest/Client/EtEffect2Tool/XColorSpectrumCtrl.cpp
Cussrro e4714f3f0e 初步修复
2024-12-19 09:48:26 +08:00

1636 lines
41 KiB
C++
Raw Blame History

// XColorSpectrumCtrl.cpp Version 1.1 - see article at CodeProject.com
//
// Author: Hans Dietrich
// hdietrich@gmail.com
//
// Description:
// XColorSpectrumCtrl implements CXColorSpectrumCtrl, a control that mimics the
// functionality of the "Standard Colors" color picker in MS Office
//
// History
// Version 1.1 - 2008 April 4
// - Bug fixes
//
// Version 1.0 - 2008 March 12
// - Initial public release
//
// License:
// This software is released under the Code Project Open License (CPOL),
// which may be found here: http://www.codeproject.com/info/eula.aspx
// You are free to use this software in any way you like, except that you
// may not sell this source code.
//
// This software is provided "as is" with no expressed or implied warranty.
// I accept no liability for any damage or loss of business that this
// software may cause.
//
///////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "windows.h"
#include "windowsx.h"
#include <stdio.h>
#include <tchar.h>
#include <crtdbg.h>
#include "XColorSpectrumCtrl.h"
//#include "rgbhsl.h"
#pragma warning(disable : 4127) // for _ASSERTE: conditional expression is constant
#pragma warning(disable : 4996) // disable bogus deprecation warning
#pragma warning(disable : 4244)
#pragma warning(disable : 4312)
#pragma warning(disable : 4267)
#ifndef UNUSED
#define UNUSED(x) x
#endif
#ifdef _DEBUG
// extracted from mfc\src\afxmem.cpp
static void * operator new(size_t nSize, LPCSTR lpszFileName, int nLine)
{
return ::operator new(nSize, _NORMAL_BLOCK, lpszFileName, nLine);
}
static void operator delete(void *pData, LPCSTR /*lpszFileName*/, int /*nLine*/)
{
::operator delete(pData);
}
#define DEBUG_NEW new(THIS_FILE, __LINE__)
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
#ifndef __noop
#if _MSC_VER < 1300
#define __noop ((void)0)
#endif
#endif
#undef TRACE
#define TRACE __noop
#undef TRACERECT
#define TRACERECT __noop
//=============================================================================
// if you want to see the TRACE output, uncomment this line:
//#include "XTrace.h"
//=============================================================================
// Messages sent to parent window -
// wParam = RGB color value
// lParam = control id
UINT WM_XCOLORPICKER_SELCHANGE = ::RegisterWindowMessage(_T("WM_XCOLORPICKER_SELCHANGE"));
UINT WM_XCOLORPICKER_SELENDOK = ::RegisterWindowMessage(_T("WM_XCOLORPICKER_SELENDOK"));
//=============================================================================
// constants used in drawing
static const int ARROW_WIDTH = 10; // slider arrow
static const int ARROW_HEIGHT = 17; // slider arrow
static const int HORIZONTAL_MARGIN = 2; // right margin only
static const int VERTICAL_MARGIN = ARROW_HEIGHT/2 + 3;
// this is necessary to
// make room for arrow on
// slider bar
static const int SLIDER_WIDTH = 10;
static const int ARROW_DELTA = 5; // delta for arrow keys
static const int CROSSHAIR_SIZE = 19; // spectrum crosshair:
// height = width
static const int LUMINOSITY_BAR_WIDTH = 14;
// cx - SLIDER_OFFSET = left side of slider area
static const int SLIDER_OFFSET = SLIDER_WIDTH + HORIZONTAL_MARGIN;
// cx - LUMINOSITY_BAR_OFFSET = left side of luminosity bar
static const int LUMINOSITY_BAR_OFFSET = SLIDER_OFFSET + LUMINOSITY_BAR_WIDTH + 3;
// cx - SPECTRUM_OFFSET = right side of spectrum
static const int SPECTRUM_OFFSET = LUMINOSITY_BAR_OFFSET + 6;
//=============================================================================
static double HuetoRGB(double m1, double m2, double h)
//=============================================================================
{
if (h < 0) h += 1.0;
if (h > 1) h -= 1.0;
if (6.0 * h < 1 )
return (m1 + (m2 - m1) * h * 6.0);
if (2.0 * h < 1 )
return m2;
if (3.0 * h < 2.0 )
return (m1 + (m2 - m1) * ((2.0 / 3.0) - h) * 6.0);
return m1;
}
//=============================================================================
void RGBtoHSL(COLORREF cr, double *H, double *S, double *L)
//=============================================================================
{
double delta;
double r = (double) GetRValue(cr) / 255;
double g = (double) GetGValue(cr) / 255;
double b = (double) GetBValue(cr) / 255;
double cmax = max(r, max(g,b));
double cmin = min(r, min(g,b));
*L = (cmax + cmin) / 2.0;
if (cmax == cmin)
{
*S = 0;
*H = 0; // it's really undefined
}
else
{
if (*L < 0.5)
*S = (cmax - cmin) / (cmax + cmin);
else
*S = (cmax - cmin) / (2.0 - cmax - cmin);
delta = cmax - cmin;
if (r == cmax)
*H = (g - b) / delta;
else if (g == cmax)
*H = 2.0 + (b - r) / delta;
else
*H = 4.0 + (r - g) / delta;
*H /= 6.0;
if (*H < 0.0)
*H += 1;
}
*H *= 240.0;
*S *= 240.0;
*L *= 240.0;
}
//=============================================================================
void RGBtoHSL(COLORREF cr, BYTE *h, BYTE *s, BYTE *l)
//=============================================================================
{
double H, S, L;
RGBtoHSL(cr, &H, &S, &L);
*h = (BYTE) (H + 0.5);
*s = (BYTE) (S + 0.5);
*l = (BYTE) (L + 0.5);
if (*h > 239)
*h = 239;
if (*s > 240)
*s = 240;
if (*l > 240)
*l = 240;
}
//=============================================================================
COLORREF HSLtoRGB(double H, double S, double L)
//=============================================================================
{
double r, g, b;
double m1, m2;
H /= 240.0;
S /= 240.0;
L /= 240.0;
if (S == 0)
{
r = g = b = L;
}
else
{
if (L <= 0.5)
m2 = L * (1.0 + S);
else
m2 = L + S - L * S;
m1 = 2.0 * L - m2;
r = HuetoRGB(m1, m2, H + 1.0/3.0);
g = HuetoRGB(m1, m2, H);
b = HuetoRGB(m1, m2, H - 1.0/3.0);
}
return RGB((BYTE)(r*255), (BYTE)(g*255), (BYTE)(b*255));
}
//=============================================================================
//
// CXColorSpectrumCtrl()
//
// Purpose: Construct CXColorSpectrumCtrl object.
//
// Parameters: None
//
// Returns: None
//
// Notes: Construction is a two-step process. First, construct the
// CXColorSpectrumCtrl object. Second, call CXColorSpectrumCtrl::Create()
// to create the CXColorSpectrumCtrl window.
//
CXColorSpectrumCtrl::CXColorSpectrumCtrl()
: m_hWnd(0),
m_OldBitmap(NULL),
m_nLuminosity(0),
m_Hue(0),
m_Sat(0),
m_Lum(0),
m_crLastSent(NO_COLOR),
m_crCurrent(NO_COLOR),
m_crBackground(NO_COLOR),
m_bSliderDrag(FALSE),
m_bCrosshairDrag(FALSE),
m_nDlgCode(DLGC_WANTARROWS|DLGC_WANTTAB),
m_bIsSpectrumFocused(FALSE),
m_bIsSliderFocused(FALSE)
{
TRACE(_T("in CXColorSpectrumCtrl::CXColorSpectrumCtrl\n"));
m_ptCurrent.x = 0;
m_ptCurrent.y = VERTICAL_MARGIN;
}
//=============================================================================
//
// ~CXColorSpectrumCtrl()
//
// Purpose: Destroy CXColorSpectrumCtrl object.
//
// Parameters: None
//
// Returns: None
//
CXColorSpectrumCtrl::~CXColorSpectrumCtrl()
{
DeleteAll();
}
//=============================================================================
//
// DefWindowProcX()
//
// Purpose: Initial window proc to dispatch messages to
// CXColorSpectrumCtrl::WindowProc(). This allows us to set up
// the 'this' pointer to CXColorSpectrumCtrl instance.
//
// Parameters: Standard windows message parameters.
//
// Returns: LRESULT - The return value is the result of the message
// processing and depends on the message.
//
static
LRESULT __stdcall DefWindowProcX(HWND hWnd, // handle to window
UINT message, // message identifier
WPARAM wParam, // first message parameter
LPARAM lParam) // second message parameter
{
switch (message)
{
case WM_CREATE:
{
// save 'this' pointer in windows extra memory - the lParam
// is set when ::CreateWindowEx() is called
CREATESTRUCT* pcs = (CREATESTRUCT *) lParam;
if (!pcs)
{
TRACE(_T("ERROR - CREATESTRUCT lParam is zero\n"));
_ASSERTE(pcs);
return -1; // abort creation
}
::SetWindowLongPtr(hWnd, GWLP_USERDATA, (LONG_PTR)pcs->lpCreateParams);
return 0;
}
break;
default:
{
// dispatch via saved 'this' pointer
LONG_PTR lData = ::GetWindowLongPtr(hWnd, GWLP_USERDATA);
if (lData)
{
CXColorSpectrumCtrl *pCtrl = (CXColorSpectrumCtrl *) lData;
return pCtrl->WindowProc(message, wParam, lParam);
}
else
{
// probably some WM_NCxxxx message
TRACE(_T("GWLP_USERDATA = 0 for message = 0x%04X\n"), message);
}
}
break;
}
return ::DefWindowProc(hWnd, message, wParam, lParam);
}
//=============================================================================
//
// Create()
//
// Purpose: This virtual function creates the CXColorSpectrumCtrl window.
//
// Parameters: hInstance - handle to the instance that contains
// the window procedure
// dwStyle - specifies the window style attributes
// rect - the size and position of the window
// hParent - the parent window HWND
// nID - the ID of the child window
// crInitialColor - initial color selection
//
// Returns: BOOL - TRUE = window created successfully
//
BOOL CXColorSpectrumCtrl::Create(HINSTANCE hInstance,
DWORD dwStyle,
const RECT& rect,
HWND hParent,
UINT nID,
COLORREF crInitialColor /*= RGB(0,0,0)*/)
{
TRACE(_T("in CXColorSpectrumCtrl::Create\n"));
m_hWnd = 0;
m_hParent = hParent;
_ASSERTE(IsWindow(m_hParent));
if (!IsWindow(m_hParent))
return FALSE;
m_rectCtrl = rect;
TRACERECT(m_rectCtrl);
TRACE(_T("width=%d height=%d\n"), m_rectCtrl.Width(), m_rectCtrl.Height());
m_rectSlider = m_rectCtrl;
TRACERECT(m_rectSlider);
TCHAR * pszClassName = _T("XColorSpectrumCtrl");
WNDCLASS wc =
{
CS_DBLCLKS, // class style - want WM_LBUTTONDBLCLK messages
DefWindowProcX, // window proc
0, // class extra bytes
0, // window extra bytes
hInstance, // instance handle
0, // icon
::LoadCursor(0, IDC_ARROW), // cursor
0, // background brush
0, // menu name
pszClassName // class name
};
if (!::RegisterClass(&wc))
{
DWORD dwLastError = GetLastError();
if (dwLastError != ERROR_CLASS_ALREADY_EXISTS)
{
TRACE(_T("ERROR - RegisterClass failed, GetLastError() returned %u\n"),
dwLastError);
_ASSERTE(FALSE);
return FALSE;
}
}
// we pass 'this' pointer as lpParam, so DefWindowProcX will see it
// in WM_CREATE message
m_hWnd = ::CreateWindowEx(0, pszClassName, _T(""), dwStyle,
m_rectCtrl.left, m_rectCtrl.top, m_rectCtrl.Width(), m_rectCtrl.Height(),
hParent, (HMENU)nID, hInstance, this);
if (m_hWnd == 0)
{
#ifdef _DEBUG
DWORD dwLastError = GetLastError();
UNUSED(dwLastError);
TRACE(_T("ERROR - CreateWindowEx failed, GetLastError() returned %u\n"),
dwLastError);
_ASSERTE(m_hWnd);
#endif
return FALSE;
}
// set up rect for spectrum
::GetClientRect(m_hWnd, &m_rectSpectrumClient);
m_rectSliderClient = m_rectSpectrumClient;
m_rectSpectrumClient.right -= SPECTRUM_OFFSET;
m_rectSpectrumClient.top += VERTICAL_MARGIN;
m_rectSpectrumClient.bottom -= VERTICAL_MARGIN;
// set up rect for slider
m_rectSliderClient.left = m_rectSliderClient.right - LUMINOSITY_BAR_OFFSET;
m_rectSliderClient.right -= HORIZONTAL_MARGIN;
m_rectSliderClient.top += VERTICAL_MARGIN - ARROW_HEIGHT/2;
m_rectSliderClient.bottom -= VERTICAL_MARGIN - ARROW_HEIGHT/2;
m_crLastSent = m_crCurrent = crInitialColor;
RGBtoHSL(m_crLastSent, &m_Hue, &m_Sat, &m_Lum);
TRACE(_T("m_crCurrent=%06X h=%d s=%d l=%d\n"),
m_crCurrent, m_Hue, m_Sat, m_Lum);
m_ptCurrent = GetPointFromHsl();
m_nLuminosity = GetLuminosity();
DrawCrosshair(NULL, m_ptCurrent.x, m_ptCurrent.y, FALSE, FALSE);
DrawArrow(NULL, m_nLuminosity, FALSE, FALSE);
return m_hWnd != 0;
}
//=============================================================================
//
// GetRGB()
//
// Purpose: This function retrieves the current RGB value.
//
// Parameters: None
//
// Returns: COLORREF - the RGB value
//
COLORREF CXColorSpectrumCtrl::GetRGB()
{
TRACE(_T("GetRGB: %06X\n"), m_crCurrent);
return m_crCurrent;
}
//=============================================================================
//
// SetRGB()
//
// Purpose: This function sets the RGB value.
//
// Parameters: cr - RGB value to set
//
// Returns: CXColorSpectrumCtrl& - reference to 'this'
//
CXColorSpectrumCtrl& CXColorSpectrumCtrl::SetRGB(COLORREF cr)
{
TRACE(_T("in CXColorSpectrumCtrl::SetRGB\n"));
m_crLastSent = m_crCurrent = cr;
RGBtoHSL(m_crCurrent, &m_Hue, &m_Sat, &m_Lum);
m_ptCurrent = GetPointFromHsl();
m_nLuminosity = GetLuminosity();
//TRACE(_T("SetRGB: m_ptCurrent.y=%d m_Hue=%d m_Sat=%d m_Lum=%d =====\n"), m_ptCurrent.y, m_Hue, m_Sat, m_Lum);
// update color locators, don't tell parent
DrawCrosshair(NULL, m_ptCurrent.x, m_ptCurrent.y,
IsFocused() && m_bIsSpectrumFocused, FALSE);
DrawArrow(NULL, m_nLuminosity, IsFocused() && m_bIsSliderFocused, FALSE);
return *this;
}
//=============================================================================
//
// GetHSL()
//
// Purpose: This function retrieves the current HSL values.
//
// Parameters: h - BYTE pointer to retrieved h value
// s - BYTE pointer to retrieved s value
// l - BYTE pointer to retrieved l value
//
// Returns: None
//
void CXColorSpectrumCtrl::GetHSL(BYTE* h, BYTE* s, BYTE* l)
{
*h = m_Hue;
*s = m_Sat;
*l = m_Lum;
//TRACE(_T("GetHSL: m_ptCurrent.y=%d h=%d s=%d l=%d =====\n"), m_ptCurrent.y, *h, *s, *l);
}
//=============================================================================
//
// SetHslFromPoint()
//
// Purpose: This function sets the hue and sat values from point coordinates.
//
// Parameters: point - point for color coordinates
//
// Returns: None
//
void CXColorSpectrumCtrl::SetHslFromPoint(POINT point)
{
int y = point.y - VERTICAL_MARGIN;
m_Hue = (BYTE)((point.x * 239) / (m_rectSpectrumClient.Width() - 1));
m_Sat = (BYTE)(((m_rectSpectrumClient.Height() - y - 1) * 240) /
(m_rectSpectrumClient.Height() - 1));
if (m_Hue > 239)
m_Hue = 239;
if (m_Sat > 240)
m_Sat = 240;
//TRACE(_T("SetHslFromPoint: hue=%d sat=%d height=%d y = %d =====\n"), m_Hue, m_Sat, m_rectSpectrumClient.Height(), y);
}
//=============================================================================
//
// Internal_SetHSL()
//
// Purpose: Internal function to set HSL values
//
// Parameters: h - BYTE value of h value
// s - BYTE value of s value
// l - BYTE value of l value
//
// Returns: None
//
void CXColorSpectrumCtrl::Internal_SetHSL(BYTE h, BYTE s, BYTE l)
{
if (h > 239)
h = 239;
if (s > 240)
s = 240;
if (l > 240)
l = 240;
m_Hue = h;
m_Sat = s;
m_Lum = l;
m_crCurrent = HSLtoRGB(h, s, l);
//TRACE(_T("Internal_SetHSL: m_crCurrent=%06X\n"), m_crCurrent);
m_ptCurrent = GetPointFromHsl();
m_nLuminosity = GetLuminosity();
}
//=============================================================================
//
// SetHSL()
//
// Purpose: This function sets the HSL value. Called *only* by parent.
//
// Parameters: h - BYTE h value
// s - BYTE s value
// l - BYTE l value
//
// Returns: CXColorSpectrumCtrl& - reference to 'this'
//
CXColorSpectrumCtrl& CXColorSpectrumCtrl::SetHSL(BYTE h, BYTE s, BYTE l)
{
TRACE(_T("SetHSL: y=%d %d,%d,%d =====\n"), m_ptCurrent.y, h, s, l);
Internal_SetHSL(h, s, l);
m_crLastSent = m_crCurrent;
DrawCrosshair(NULL, m_ptCurrent.x, m_ptCurrent.y, m_bIsSpectrumFocused, FALSE);
DrawArrow(NULL, m_nLuminosity, m_bIsSliderFocused, FALSE);
//TRACE(_T("SetHSL: m_ptCurrent.x=%d m_ptCurrent.y=%d =====\n"), m_ptCurrent.x, m_ptCurrent.y);
return *this;
}
//=============================================================================
//
// GoLeft()
//
// Purpose: This function processes left arrow keystrokes.
//
// Parameters: nDelta - number of pixels to move
//
// Returns: None
//
void CXColorSpectrumCtrl::GoLeft(int nDelta)
{
if (m_bIsSpectrumFocused)
{
int nHue = m_Hue - nDelta;
if (nHue < 0)
nHue = 0;
if (nHue > 239)
nHue = 239;
Internal_SetHSL((BYTE)nHue, m_Sat, m_Lum);
DrawCrosshair(NULL, m_ptCurrent.x, m_ptCurrent.y, TRUE, TRUE);
}
}
//=============================================================================
//
// GoRight()
//
// Purpose: This function processes right arrow keystrokes.
//
// Parameters: nDelta - number of pixels to move
//
// Returns: None
//
void CXColorSpectrumCtrl::GoRight(int nDelta)
{
if (m_bIsSpectrumFocused)
{
int nHue = m_Hue + nDelta;
if (nHue < 0)
nHue = 0;
if (nHue > 239)
nHue = 239;
Internal_SetHSL((BYTE)nHue, m_Sat, m_Lum);
DrawCrosshair(NULL, m_ptCurrent.x, m_ptCurrent.y, TRUE, TRUE);
}
}
//=============================================================================
//
// GoUp()
//
// Purpose: This function processes up arrow keystrokes.
//
// Parameters: nDelta - number of pixels to move
//
// Returns: None
//
void CXColorSpectrumCtrl::GoUp(int nDelta)
{
if (m_bIsSliderFocused)
{
int nLum = m_Lum + nDelta;
if (nLum < 0)
nLum = 0;
if (nLum > 240)
nLum = 240;
Internal_SetHSL(m_Hue, m_Sat, (BYTE)nLum);
DrawArrow(NULL, m_nLuminosity, TRUE, TRUE);
}
else
{
int nSat = m_Sat + nDelta;
if (nSat < 0)
nSat = 0;
if (nSat > 240)
nSat = 240;
Internal_SetHSL(m_Hue, (BYTE)nSat, m_Lum);
DrawCrosshair(NULL, m_ptCurrent.x, m_ptCurrent.y, TRUE, TRUE);
}
}
//=============================================================================
//
// GoDown()
//
// Purpose: This function processes down arrow keystrokes.
//
// Parameters: nDelta - number of pixels to move
//
// Returns: None
//
void CXColorSpectrumCtrl::GoDown(int nDelta)
{
if (m_bIsSliderFocused)
{
int nLum = m_Lum - nDelta;
if (nLum < 0)
nLum = 0;
if (nLum > 240)
nLum = 240;
Internal_SetHSL(m_Hue, m_Sat, (BYTE)nLum);
DrawArrow(NULL, m_nLuminosity, TRUE, TRUE);
}
else
{
int nSat = m_Sat - nDelta;
if (nSat < 0)
nSat = 0;
if (nSat > 240)
nSat = 240;
Internal_SetHSL(m_Hue, (BYTE)nSat, m_Lum);
DrawCrosshair(NULL, m_ptCurrent.x, m_ptCurrent.y, TRUE, TRUE);
}
}
//=============================================================================
//
// KeyDown()
//
// Purpose: This function processes WM_KEYDOWN messages.
//
// Parameters: wParam - virtual-key code
// lParam - not used
//
// Returns: LRESULT - zero = message was processed
//
LRESULT CXColorSpectrumCtrl::KeyDown(WPARAM wParam, LPARAM /*lParam*/)
{
TRACE(_T("in CXColorSpectrumCtrl::KeyDown\n"));
// for the arrow keys:
// if the Ctrl key is down, advance by 1
// if the shift key is down, advance by twice the normal delta
int nDelta = ARROW_DELTA; // standard advance for arrow keys
if (IsCtrlDown()) // Ctrl key: advance by 1
nDelta = 1;
else if (IsShiftDown()) // Shift key: advance by 2x
nDelta *= 2;
if (wParam == VK_TAB)
{
// ignore tab if we don't have focus
if (::GetFocus() != m_hWnd)
return 1;
if (IsShiftDown())
{
// shift is down, tab backwards
if (m_bIsSliderFocused)
{
// slider has focus, switch to spectrum
m_bIsSpectrumFocused = TRUE;
m_bIsSliderFocused = FALSE;
DrawCrosshair(NULL, m_ptCurrent.x, m_ptCurrent.y, TRUE, FALSE);
DrawArrow(NULL, m_nLuminosity, FALSE, FALSE);
return 0;
}
else
{
// spectrum has focus, give focus to previous control
::PostMessage(m_hParent, WM_NEXTDLGCTL, 1, 0);
}
}
else
{
// shift is up, tab forwards
if (m_bIsSliderFocused)
{
// slider has focus, give focus to next control
::PostMessage(m_hParent, WM_NEXTDLGCTL, 0, 0);
return 0;
}
else
{
// spectrum has focus, switch to slider
m_bIsSpectrumFocused = FALSE;
m_bIsSliderFocused = TRUE;
DrawCrosshair(NULL, m_ptCurrent.x, m_ptCurrent.y, FALSE, FALSE);
DrawArrow(NULL, m_nLuminosity, TRUE, FALSE);
return 0;
}
}
}
else if (wParam == VK_END)
{
if (m_bIsSliderFocused)
GoDown(20000); // position to bottom
else
GoRight(20000); // position to right
}
else if (wParam == VK_HOME)
{
if (m_bIsSliderFocused)
GoUp(20000); // position to top
else
GoLeft(20000); // position to left
}
else if (wParam == VK_NEXT)
{
GoDown(20000); // position to bottom
}
else if (wParam == VK_PRIOR)
{
GoUp(20000); // position to top
}
else if (wParam == VK_DOWN)
{
GoDown(nDelta);
}
else if (wParam == VK_UP)
{
GoUp(nDelta);
}
else if (wParam == VK_RIGHT)
{
GoRight(nDelta);
}
else if (wParam == VK_LEFT)
{
GoLeft(nDelta);
}
return 1; // let default processing continue
}
//=============================================================================
//
// IsShiftDown()
//
// Purpose: This function returns TRUE if either shift key is down.
//
// Parameters: None
//
// Returns: BOOL - TRUE = shift key is down
//
BOOL CXColorSpectrumCtrl::IsShiftDown()
{
return GetAsyncKeyState(VK_SHIFT) & 0x8000;
}
//=============================================================================
//
// IsCtrlDown()
//
// Purpose: This function returns TRUE if either Ctrl key is down.
//
// Parameters: None
//
// Returns: BOOL - TRUE = Ctrl key is down
//
BOOL CXColorSpectrumCtrl::IsCtrlDown()
{
return GetAsyncKeyState(VK_CONTROL) & 0x8000;
}
//=============================================================================
//
// IsLeftButtonDown()
//
// Purpose: This function returns TRUE if left mouse button is down.
//
// Parameters: None
//
// Returns: BOOL - TRUE = left mouse button is down
//
BOOL CXColorSpectrumCtrl::IsLeftButtonDown()
{
BOOL rc = FALSE;
SHORT state = 0;
if (GetSystemMetrics(SM_SWAPBUTTON)) // check if buttons have been swapped
state = GetAsyncKeyState(VK_RBUTTON); // buttons swapped, get right button state
else
state = GetAsyncKeyState(VK_LBUTTON);
// if the most significant bit is set, the button is down
if (state < 0)
rc = TRUE;
return rc;
}
//=============================================================================
//
// IsFocused()
//
// Purpose: This function returns TRUE if control has focus.
//
// Parameters: None
//
// Returns: BOOL - TRUE = control has focus
//
BOOL CXColorSpectrumCtrl::IsFocused()
{
BOOL rc = FALSE;
HWND hFocus = ::GetFocus();
if (hFocus == m_hWnd)
rc = TRUE;
return rc;
}
//=============================================================================
//
// GetClientCursorPos()
//
// Purpose: This function retrieves the cursor location relative to the
// control's client rect.
//
// Parameters: point - reference to the variable that receives the location
//
// Returns: BOOL - TRUE = location is valid
//
BOOL CXColorSpectrumCtrl::GetClientCursorPos(POINT& point)
{
BOOL rc = FALSE;
if (::GetCursorPos(&point)) // check if screensaver kicked in
{
::ScreenToClient(m_hWnd, &point);
rc = TRUE;
}
return rc;
}
//=============================================================================
//
// IsPointInSpectrum()
//
// Purpose: This function determines if point is in spectrum.
//
// Parameters: point = location to check
//
// Returns: BOOL - TRUE = point is in spectrum
//
BOOL CXColorSpectrumCtrl::IsPointInSpectrum(POINT point)
{
BOOL rc = m_rectSpectrumClient.PtInRect(point);
return rc;
}
//=============================================================================
//
// IsPointInSlider()
//
// Purpose: This function determines if point is in slider.
//
// Parameters: point = location to check
//
// Returns: BOOL - TRUE = point is in slider
//
BOOL CXColorSpectrumCtrl::IsPointInSlider(POINT point)
{
BOOL rc = m_rectSliderClient.PtInRect(point);
return rc;
}
//=============================================================================
//
// DeleteAll()
//
// Purpose: This function deletes the saved bitmap
//
// Parameters: None
//
// Returns: None
//
void CXColorSpectrumCtrl::DeleteAll()
{
if (m_OldBitmap)
m_dcSpectrum.SelectObject(m_OldBitmap);
m_OldBitmap = NULL;
if (m_bmpSpectrum)
::DeleteObject(m_bmpSpectrum);
}
//=============================================================================
//
// SetLuminosity()
//
// Purpose: This function sets the luminosity value for the specified
// luminosity slider position.
//
// Parameters: nLuminosity - luminosity slider position
//
// Returns: None
//
void CXColorSpectrumCtrl::SetLuminosity(int nLuminosity)
{
if (nLuminosity < 0)
nLuminosity = 0;
if (nLuminosity > (m_rectSpectrumClient.Height() -1))
nLuminosity = m_rectSpectrumClient.Height() -1;
m_nLuminosity = nLuminosity;
m_Lum = (BYTE)(((m_rectSpectrumClient.Height() - m_nLuminosity - 1) * 240) / (m_rectSpectrumClient.Height() - 1));
if (m_Lum > 240)
m_Lum = 240;
m_crCurrent = HSLtoRGB(m_Hue, m_Sat, m_Lum);
}
//=============================================================================
//
// GetLuminosity()
//
// Purpose: This function retrieves the luminosity value for the
// specified RGB value.
//
// Parameters: cr - RGB color value
//
// Returns: int - luminosity valie
//
int CXColorSpectrumCtrl::GetLuminosity()
{
UINT l = m_Lum;
int lum = m_rectSpectrumClient.Height() - ((m_rectSpectrumClient.Height() * l) / 240);
if (lum < 0)
lum = 0;
if (lum > m_rectSpectrumClient.Height() - 1)
lum = m_rectSpectrumClient.Height() - 1;
return lum;
}
//=============================================================================
//
// GetPointFromHsl()
//
// Purpose: This function retrieves the POINT location (in spectrum) for
// the specified RGB value.
//
// Parameters: cr - RGB color value
//
// Returns: POINT - location of color
//
POINT CXColorSpectrumCtrl::GetPointFromHsl()
{
POINT point = { 0 };
UINT hue = m_Hue;
UINT sat = m_Sat;
point.x = (hue * m_rectSpectrumClient.Width()) / 239;
if (point.x > (m_rectSpectrumClient.right-1))
point.x = m_rectSpectrumClient.right-1;
point.y = m_rectSpectrumClient.Height() - ((sat * m_rectSpectrumClient.Height()) / 240);
point.y += VERTICAL_MARGIN;
if (point.y > (m_rectSpectrumClient.bottom-1))
point.y = m_rectSpectrumClient.bottom-1;
return point;
}
//=============================================================================
//
// DrawSpectrum()
//
// Purpose: This function draws the spectrum and initializes the
// spectrum bitmap and memory dc.
//
// Parameters: pDC - pointer to device context used for drawing
//
// Returns: None
//
void CXColorSpectrumCtrl::DrawSpectrum(CXDC *pDC)
{
TRACE(_T("in CXColorSpectrumCtrl::DrawSpectrum\n"));
_ASSERTE(pDC);
if (!pDC)
return;
TRACERECT(m_rectCtrl);
if (m_OldBitmap == NULL)
{
// spectrum bitmap hasn't been drawn yet
if (!m_dcSpectrum.CreateCompatibleDC(pDC))
{
TRACE(_T("ERROR - CreateCompatibleDC failed\n"));
_ASSERTE(FALSE);
return;
}
m_bmpSpectrum = pDC->CreateCompatibleBitmap(m_rectCtrl.Width(), m_rectCtrl.Height());
m_OldBitmap = (HBITMAP) m_dcSpectrum.SelectObject(m_bmpSpectrum);
if (m_crBackground == NO_COLOR)
{
// no background color specified, just copy current background
m_dcSpectrum.BitBlt(0, 0, m_rectCtrl.Width(), m_rectCtrl.Height(),
pDC, 0, 0, SRCCOPY);
}
else
{
m_dcSpectrum.FillSolidRect(0, 0, m_rectCtrl.Width(), m_rectCtrl.Height(),
m_crBackground);
}
UINT cx = m_rectCtrl.Width() - SPECTRUM_OFFSET;
UINT cy = m_rectCtrl.Height() - 2*VERTICAL_MARGIN;
// The saturation and luminosity values must be in the range 0
// through 240, and the hue value must be in the range 0 through 239.
double cxd = cx;
double cyd = cy;
for (UINT y = 0; y < cy; y++)
{
for (UINT x = 0; x < cx; x++)
{
double hue = x;
hue *= 240.0;
hue /= cxd - 1.0;
double sat = y;
sat *= 240.0;
sat /= cyd - 1.0;
COLORREF cr = HSLtoRGB(hue, sat, 120.0);
m_dcSpectrum.SetPixelV(x, cy - y - 1 + VERTICAL_MARGIN, cr);
}
}
}
// write spectrum bitmap to control's dc
pDC->BitBlt(0, 0, m_rectCtrl.Width(), m_rectCtrl.Height(),
&m_dcSpectrum, 0, 0, SRCCOPY);
}
//=============================================================================
//
// SendColorToParent()
//
// Purpose: This function sends the specified color to the parent.
//
// Parameters: nMessage - message ID
// cr - color to send
//
// Returns: None
//
void CXColorSpectrumCtrl::SendColorToParent(UINT nMessage, COLORREF cr)
{
TRACE(_T("in CXColorSpectrumCtrl::SendColorToParent: cr=%06X m_crLastSent=%06X\n"), cr, m_crLastSent);
// don't send duplicate messages
//if ((nMessage == WM_XCOLORPICKER_SELENDOK) || (cr != m_crLastSent))
{
m_crLastSent = cr;
if (IsWindow(m_hParent) && (cr != NO_COLOR))
{
TRACE(_T(">>>>> sending %06X\n"), m_crLastSent);
::SendMessage(m_hParent, nMessage,
m_crLastSent, ::GetDlgCtrlID(m_hWnd));
}
}
}
//=============================================================================
//
// DrawCrosshair()
//
// Purpose: This function draws spectrum crosshair.
//
// Parameters: pDC - pointer to device context to use for drawing
// startx - x coord of center point
// starty - y coord of center point
// bHasFocus - TRUE = control has focus; this determines how the
// crosshair is drawn
// bSendColor - TRUE = send WM_XCOLORPICKER_SELCHANGE to parent
//
// Returns: None
//
void CXColorSpectrumCtrl::DrawCrosshair(CXDC *pDC,
int startx,
int starty,
BOOL bHasFocus,
BOOL bSendColor)
{
TRACE(_T("in CXColorSpectrumCtrl::DrawCrosshair\n"));
BOOL bRelease = FALSE;
if (pDC == NULL)
{
pDC = new CXDC(m_hWnd);
bRelease = TRUE;
}
// restore bitmap - get rid of previous selection
if (m_OldBitmap)
pDC->BitBlt(0, 0, m_rectCtrl.Width()-SPECTRUM_OFFSET, m_rectCtrl.Height(),
&m_dcSpectrum, 0, 0, SRCCOPY);
// for each byte in this array:
// 0 = skip
// 1 = COLOR_WINDOWTEXT (COLOR_WINDOW if bHasFocus == FALSE)
static BYTE pixels[CROSSHAIR_SIZE][CROSSHAIR_SIZE] =
{
0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0, // 1
0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0, // 2
0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0, // 3
0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0, // 4
0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0, // 5
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 6
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 7
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 8
1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1, // 9
1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1, // 10
1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1, // 11
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 12
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 13
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 14
0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0, // 15
0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0, // 16
0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0, // 17
0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0, // 18
0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0 // 19
};
COLORREF crFill = GetSysColor(COLOR_WINDOWTEXT);
if (!bHasFocus)
crFill = GetSysColor(COLOR_WINDOW);
POINT pt;
for (int row = 0; row < CROSSHAIR_SIZE; row++)
{
for (int col = 0; col < CROSSHAIR_SIZE; col++)
{
if (pixels[row][col] != 1)
continue;
pt.x = startx - CROSSHAIR_SIZE/2 + col;
pt.y = starty - CROSSHAIR_SIZE/2 + row;
if (m_rectSpectrumClient.PtInRect(pt))
{
pDC->SetPixelV(pt.x, pt.y, crFill);
}
}
}
DrawLuminosityBar(pDC);
if (bRelease)
delete pDC;
// let parent know color selection has changed
if (bSendColor)
SendColorToParent(WM_XCOLORPICKER_SELCHANGE, m_crCurrent);
}
//=============================================================================
//
// DrawLuminosityBar()
//
// Purpose: This function draws luminosity bar based on the color under
// the crosshair.
//
// Parameters: pDC - pointer to device context used for drawing
//
// Returns: None
//
void CXColorSpectrumCtrl::DrawLuminosityBar(CXDC *pDC)
{
TRACE(_T("in CXColorSpectrumCtrl::DrawLuminosityBar\n"));
BOOL bRelease = FALSE;
if (pDC == NULL)
{
pDC = new CXDC(m_hWnd);
_ASSERTE(pDC);
bRelease = TRUE;
}
// set up for double buffering
CXDC memDC;
if (!memDC.CreateCompatibleDC(pDC))
{
TRACE(_T("ERROR - CreateCompatibleDC failed\n"));
_ASSERTE(FALSE);
return;
}
HBITMAP bmp = pDC->CreateCompatibleBitmap(m_rectSlider.Width(), m_rectSlider.Height());
HBITMAP hOldBitmap = (HBITMAP) memDC.SelectObject(bmp);
memDC.BitBlt(0, 0, m_rectSlider.Width(), m_rectSlider.Height(),
pDC, 0, 0, SRCCOPY);
COLORREF cr = m_crCurrent;//GetColorUnderCrosshair(); //RGB(255,255,0);
if (cr == NO_COLOR)
return;
DOUBLE h, s, l;
RGBtoHSL(cr, &h, &s, &l);
//if (h > 239.0)
// h = 239.0;
if (h > 240.0)
h = 240.0;
if (s > 240.0)
s = 240.0;
UINT cx = m_rectSlider.Width();
UINT cy = m_rectSlider.Height() - 2*VERTICAL_MARGIN;
double cyd = cy;
for (UINT y = 0; y < cy; y++)
{
l = y;
l /= cyd - 1.0;
l *= 240.0;
COLORREF rgb = HSLtoRGB(h, s, l);
for (UINT x = cx-LUMINOSITY_BAR_OFFSET; x < cx-LUMINOSITY_BAR_OFFSET+LUMINOSITY_BAR_WIDTH; x++)
memDC.SetPixelV(x, cy - y - 1 + VERTICAL_MARGIN, rgb);
}
// end double buffering
pDC->BitBlt(0, 0, m_rectSlider.Width(), m_rectSlider.Height(),
&memDC, 0, 0, SRCCOPY);
// swap back the original bitmap
if (hOldBitmap)
memDC.SelectObject(hOldBitmap);
if (bmp)
::DeleteObject(bmp);
if (bRelease)
delete pDC;
}
//=============================================================================
//
// DrawArrow()
//
// Purpose: This function draws slider arrow.
//
// Parameters: pDC - pointer to device context to use for drawing
// starty - y coord of arror tip
// bHasFocus - TRUE = control has focus; this determines how the
// arrow is drawn
// bSendColor - TRUE = send WM_XCOLORPICKER_SELCHANGE to parent
//
// Returns: None
//
void CXColorSpectrumCtrl::DrawArrow(CXDC *pDC,
int starty,
BOOL bHasFocus,
BOOL bSendColor)
{
BOOL bRelease = FALSE;
if (pDC == NULL)
{
pDC = new CXDC(m_hWnd);
bRelease = TRUE;
}
// restore bitmap - get rid of previous selection
if (m_OldBitmap)
pDC->BitBlt(m_rectCtrl.Width()-SLIDER_OFFSET, 0, SLIDER_OFFSET,
m_rectCtrl.Height(), &m_dcSpectrum, m_rectCtrl.Width()-SLIDER_OFFSET,
0, SRCCOPY);
// for each byte in this array:
// 0 = skip
// 1 = COLOR_WINDOWTEXT
// 2 = COLOR_WINDOWTEXT (COLOR_BTNSHADOW if bHasFocus == FALSE)
static BYTE pixels[ARROW_HEIGHT][ARROW_WIDTH] =
{
0,0,0,0,0,0,0,0,1,0, // 1
0,0,0,0,0,0,0,1,1,0, // 2
0,0,0,0,0,0,1,2,1,0, // 3
0,0,0,0,0,1,2,2,1,0, // 4
0,0,0,0,1,2,2,2,1,0, // 5
0,0,0,1,2,2,2,2,1,0, // 6
0,0,1,2,2,2,2,2,1,0, // 7
0,1,2,2,2,2,2,2,1,0, // 8
1,2,2,2,2,2,2,2,1,0, // 9
0,1,2,2,2,2,2,2,1,0, // 10
0,0,1,2,2,2,2,2,1,0, // 11
0,0,0,1,2,2,2,2,1,0, // 12
0,0,0,0,1,2,2,2,1,0, // 13
0,0,0,0,0,1,2,2,1,0, // 14
0,0,0,0,0,0,1,2,1,0, // 15
0,0,0,0,0,0,0,1,1,0, // 16
0,0,0,0,0,0,0,0,1,0 // 17
};
COLORREF crWindowText = GetSysColor(COLOR_WINDOWTEXT);
COLORREF crBtnShadow = GetSysColor(COLOR_BTNSHADOW);
COLORREF crFill = crWindowText;
if (!bHasFocus)
crFill = crBtnShadow;
int startx = m_rectCtrl.Width() - SLIDER_OFFSET;
if (starty < 0)
starty = 0;
if (starty > m_rectSliderClient.Height() - 2*(ARROW_HEIGHT/2) - 1)
starty = m_rectSliderClient.Height() - 2*(ARROW_HEIGHT/2) - 1;
for (int row = 0; row < ARROW_HEIGHT; row++)
{
for (int col = 0; col < ARROW_WIDTH; col++)
{
COLORREF crFill = crWindowText;
if (pixels[row][col] == 1)
crFill = crWindowText;
else if (pixels[row][col] == 2)
if (bHasFocus)
crFill = crWindowText;
else
crFill = crBtnShadow;
else
continue;
pDC->SetPixelV(startx + col,
starty + row - ARROW_HEIGHT/2 + VERTICAL_MARGIN,
crFill);
}
}
if (bRelease)
delete pDC;
// let parent know color selection has changed
if (bSendColor)
SendColorToParent(WM_XCOLORPICKER_SELCHANGE, m_crCurrent);
}
//=============================================================================
// Helper functions extracted from mfc\src\strcore.cpp
#ifndef _UNICODE
static int _mbstowcsz(wchar_t* wcstr, const char* mbstr, size_t count)
{
if (count == 0 && wcstr != NULL)
return 0;
int result = ::MultiByteToWideChar(CP_ACP, 0, mbstr, -1,
wcstr, count);
_ASSERTE(wcstr == NULL || result <= (int)count);
if (result > 0)
wcstr[result-1] = 0;
return result;
}
#else
static int _wcstombsz(char* mbstr, const wchar_t* wcstr, size_t count)
{
if (count == 0 && mbstr != NULL)
return 0;
int result = ::WideCharToMultiByte(CP_ACP, 0, wcstr, -1,
mbstr, count, NULL, NULL);
_ASSERTE(mbstr == NULL || result <= (int)count);
if (result > 0)
mbstr[result-1] = 0;
return result;
}
#endif //_UNICODE
//=============================================================================
//
// WindowProc()
//
// Purpose: This function is the window proc for CXColorSpectrumCtrl object.
// Messages are forwarded to this function from DefWindowProcX().
//
// Parameters: message - message identifier
// wParam - first message parameter
// lParam - second message parameter
//
// Returns: LRESULT - The return value is the result of the message
// processing and depends on the message.
//
LRESULT CXColorSpectrumCtrl::WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message)
{
case WM_CREATE:
// will never see this message - it's handled by DefWindowProcX
break;
case WM_ERASEBKGND:
// nothing to erase, since we draw the entire client area
return TRUE;
case WM_PAINT:
{
TRACE(_T("in WM_PAINT\n"));
PAINTSTRUCT ps;
HDC hdc = (wParam != NULL) ? (HDC) wParam : ::BeginPaint(m_hWnd, &ps);
if (hdc == 0)
return 0;
CXDC dc(hdc);
DrawSpectrum(&dc);
DrawCrosshair(&dc, m_ptCurrent.x, m_ptCurrent.y,
IsFocused() && m_bIsSpectrumFocused, FALSE);
DrawArrow(&dc, m_nLuminosity, IsFocused() && m_bIsSliderFocused, FALSE);
if (wParam == NULL)
::EndPaint(m_hWnd, &ps);
return 0;
}
case WM_KEYDOWN:
if (!KeyDown(wParam, lParam))
return 0;
//::SendMessage(m_hParent, message, wParam, lParam);
break;
case WM_GETDLGCODE:
return m_nDlgCode;
break;
case WM_LBUTTONDOWN:
{
POINT point;
point.x = GET_X_LPARAM(lParam);
point.y = GET_Y_LPARAM(lParam);
TRACE(_T("in WM_LBUTTONDOWN: point.x=%d point.y=%d\n"), point.x, point.y);
if (IsPointInSpectrum(point))
{
SetHslFromPoint(point);
//TRACE(_T("m_Hue=%d m_Sat=%d m_Lum=%d =====\n"), m_Hue, m_Sat, m_Lum);
m_crCurrent = HSLtoRGB(m_Hue, m_Sat, m_Lum);
//TRACE(_T("m_crCurrent=%06X\n"), m_crCurrent);
m_ptCurrent = point;
}
else if (IsPointInSlider(point))
{
SetLuminosity(point.y - VERTICAL_MARGIN);
m_crCurrent = HSLtoRGB(m_Hue, m_Sat, m_Lum);
}
HWND hFocus = ::GetFocus();
if (hFocus != m_hWnd)
{
::SetFocus(m_hWnd); // WM_SETFOCUS draws crosshair
}
if (IsPointInSpectrum(point))
{
m_bIsSpectrumFocused = TRUE;
m_bIsSliderFocused = FALSE;
DrawCrosshair(NULL, m_ptCurrent.x, m_ptCurrent.y, TRUE, TRUE);
DrawArrow(NULL, m_nLuminosity, FALSE, FALSE);
m_bCrosshairDrag = TRUE;
}
else if (IsPointInSlider(point))
{
m_bIsSpectrumFocused = FALSE;
m_bIsSliderFocused = TRUE;
DrawCrosshair(NULL, m_ptCurrent.x, m_ptCurrent.y, FALSE, FALSE);
DrawArrow(NULL, m_nLuminosity, TRUE, TRUE);
m_bSliderDrag = TRUE;
}
TRACE(_T("WM_LBUTTONDOWN: m_crCurrent=%06X\n"), m_crCurrent);
break;
}
case WM_LBUTTONUP:
TRACE(_T("in WM_LBUTTONUP\n"));
m_bSliderDrag = FALSE;
m_bCrosshairDrag = FALSE;
break;
case WM_LBUTTONDBLCLK:
{
TRACE(_T("in CXColorSpectrumCtrl::OnLButtonDblClk\n"));
POINT point;
point.x = GET_X_LPARAM(lParam);
point.y = GET_Y_LPARAM(lParam);
// let parent know a color was selected
if (IsPointInSlider(point) || IsPointInSpectrum(point))
SendColorToParent(WM_XCOLORPICKER_SELENDOK, m_crCurrent);
break;
}
case WM_SETFOCUS:
{
TRACE(_T("in WM_SETFOCUS\n"));
LRESULT lResult = ::DefWindowProc(m_hWnd, message, wParam, lParam);
if (IsShiftDown())
m_bIsSliderFocused = TRUE;
else
m_bIsSpectrumFocused = TRUE;
DrawCrosshair(NULL, m_ptCurrent.x, m_ptCurrent.y,
IsFocused() && m_bIsSpectrumFocused, FALSE);
DrawArrow(NULL, m_nLuminosity, IsFocused() && m_bIsSliderFocused, FALSE);
return lResult;
}
case WM_KILLFOCUS:
{
TRACE(_T("in WM_KILLFOCUS\n"));
LRESULT lResult = ::DefWindowProc(m_hWnd, message, wParam, lParam);
DrawCrosshair(NULL, m_ptCurrent.x, m_ptCurrent.y, FALSE, FALSE);
DrawArrow(NULL, m_nLuminosity, FALSE, FALSE);
m_bIsSpectrumFocused = FALSE;
m_bIsSliderFocused = FALSE;
return lResult;
}
case WM_MOUSEMOVE:
{
POINT point;
point.x = GET_X_LPARAM(lParam);
point.y = GET_Y_LPARAM(lParam);
if (!IsLeftButtonDown())
{
m_bSliderDrag = FALSE;
m_bCrosshairDrag = FALSE;
}
if (m_bSliderDrag)
{
if (IsPointInSlider(point))
{
SetLuminosity(point.y - VERTICAL_MARGIN);
DrawArrow(NULL, m_nLuminosity, TRUE, TRUE);
}
}
else if (m_bCrosshairDrag)
{
if (IsPointInSpectrum(point))
{
m_ptCurrent = point;
SetHslFromPoint(m_ptCurrent);
m_crCurrent = HSLtoRGB(m_Hue, m_Sat, m_Lum);
DrawCrosshair(NULL, point.x, point.y, TRUE, TRUE);
}
}
break;
}
case WM_NOTIFY:
{
break;
}
}
return ::DefWindowProc(m_hWnd, message, wParam, lParam);
}
Reference in a new issue View git blame Copy permalink