bcgppowercolorpicker.cpp

远程网络监视程序的源码

		CPen* poldPen = pDC->SelectObject(&pen);

		pDC->Polygon(pt, 3);

		pDC->SelectObject(poldBrush);
		pDC->SelectObject(poldPen);
	}
}
//******************************************************************************
void CBCGPColorPickerCtrl::SetRGB (COLORREF ref)
{
	// compute conversion to HSL
	// place the rectangle on the nearest color
	CBCGPDrawManager::RGBtoHSL (ref, &m_dblHue, &m_dblSat, &m_dblLum);
	m_colorNew = ref;

	if (GetSafeHwnd () != NULL)
	{
		Invalidate();
	}
}
//******************************************************************************
void CBCGPColorPickerCtrl::SetOriginalColor (COLORREF ref)
{
	ASSERT (m_COLORTYPE == CURRENT);
	m_colorOriginal = ref;
}
//******************************************************************************
void CBCGPColorPickerCtrl::SetHLS(double hue, double luminance, double saturation, BOOL bInvalidate)
{
	if (hue != -1)
		m_dblHue			= hue;
	
	if (saturation != -1)
		m_dblSat	= saturation;
	
	if (luminance != -1)
		m_dblLum	= luminance;
	
	m_colorNew = CBCGPDrawManager::HLStoRGB_TWO(m_dblHue, m_dblSat, m_dblLum);

	if (bInvalidate && GetSafeHwnd () != NULL)
	{
		Invalidate ();
		UpdateWindow ();
	}
}
//******************************************************************************
void CBCGPColorPickerCtrl::GetHLS(double *hue, double *luminance, double *saturation)
{
	*hue		= m_dblHue;
	*luminance	= m_dblLum;
	*saturation = m_dblSat;
}
//******************************************************************************
void CBCGPColorPickerCtrl::OnLButtonDown(UINT nFlags, CPoint point) 
{
	SetCapture ();
	SetFocus();

	OnMouseMove (nFlags, point);
}
//*****************************************************************************
void CBCGPColorPickerCtrl::OnMouseMove (UINT nFlags, CPoint point) 
{
	if (GetCapture () != this)
	{
		return;
	}

	CRect rectClient;
	GetClientRect (rectClient);

	point.x = min (max (rectClient.left, point.x), rectClient.right);
	point.y = min (max (rectClient.top, point.y), rectClient.bottom);

	switch (m_COLORTYPE)
	{
	case LUMINANCE:
		{
			CRect rectCursorOld = GetCursorRect ();
			rectCursorOld.InflateRect (1, 1);

			m_dblLum = LumFromPoint (point.y);
			m_colorNew = CBCGPDrawManager::HLStoRGB_ONE(m_dblHue, m_dblLum, m_dblSat);

			InvalidateRect (rectCursorOld);
			InvalidateRect (GetCursorRect ());
		}
		break;

	case PICKER:
		{
			CRect rectCursorOld = GetCursorRect ();
			rectCursorOld.InflateRect (1, 1);

			if (nFlags & MK_CONTROL)
			{
				point.x = GetCursorPos ().x;
			}

			if (nFlags & MK_SHIFT)		
			{
				point.y = GetCursorPos ().y;
			}
			
			m_dblHue = (double) point.x / (double) rectClient.Width ();
			m_dblSat = 1. - (double) point.y / rectClient.Height ();
			m_colorNew = CBCGPDrawManager::HLStoRGB_ONE(m_dblHue, m_dblLum, m_dblSat);

			InvalidateRect (rectCursorOld);
			InvalidateRect (GetCursorRect ());
		}
		break;

	case HEX:
	case HEX_GREYSCALE:
		if (!SelectCellHexagon (point.x, point.y))
		{
			return;
		}

		Invalidate ();
		break;
	}

	NotifyParent ();
	UpdateWindow ();
}

void CBCGPColorPickerCtrl::OnLButtonUp(UINT nFlags, CPoint point) 
{
	if (GetCapture() == this)
		::ReleaseCapture();
	
	CButton::OnLButtonUp(nFlags, point);
}

// this function must be call before the first paint message
// on the picker control
void CBCGPColorPickerCtrl::SetLuminanceBarWidth(int w)
{
	CRect rectClient;
	GetClientRect (rectClient);

	w = min (w, rectClient.Width () * 3 / 4);

	m_nLumBarWidth = w;
	Invalidate();
}

void CBCGPColorPickerCtrl::OnSize(UINT nType, int cx, int cy) 
{
	CButton::OnSize(nType, cx, cy);

	if (m_bmpPicker.GetSafeHandle () != NULL)
	{
		// picker's bitmap should be rebuild!
		::DeleteObject (m_bmpPicker.Detach ());
	}

	Invalidate ();
	UpdateWindow ();
}


void CBCGPColorPickerCtrl::SetType(COLORTYPE colorType)
{
	m_COLORTYPE = colorType;
}

UINT CBCGPColorPickerCtrl::OnGetDlgCode() 
{
	return DLGC_WANTARROWS;
}

void CBCGPColorPickerCtrl::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
{
	const double dblDelta = .05;

	switch (m_COLORTYPE)
	{
	case PICKER:
		{
			CRect rectCursorOld = GetCursorRect ();
			rectCursorOld.InflateRect (1, 1);

			double dblSat = m_dblSat;
			double dblHue = m_dblHue;

			switch (nChar)
			{
			case VK_UP:
				m_dblSat += dblDelta;
				break;

			case VK_DOWN:
				m_dblSat -= dblDelta;
				break;

			case VK_LEFT:
				m_dblHue -= dblDelta;
				break;

			case VK_RIGHT:
				m_dblHue += dblDelta;
				break;
			}

			m_dblSat = min (1., max (0., m_dblSat));
			m_dblHue = min (1., max (0., m_dblHue));

			if (m_dblHue != dblHue || m_dblSat != dblSat)
			{
				m_colorNew = CBCGPDrawManager::HLStoRGB_ONE(m_dblHue, m_dblLum, m_dblSat);

				InvalidateRect (rectCursorOld);
				InvalidateRect (GetCursorRect ());

				NotifyParent ();
			}
		}
		break;

	case LUMINANCE:
		{
			CRect rectCursorOld = GetCursorRect ();
			rectCursorOld.InflateRect (1, 1);

			double dblLum = m_dblLum;

			switch (nChar)
			{
			case VK_UP:
				m_dblLum += dblDelta;
				break;

			case VK_DOWN:
				m_dblLum -= dblDelta;
				break;
			}

			m_dblLum = min (1., max (0., m_dblLum));
			if (dblLum != m_dblLum)
			{
				m_colorNew = CBCGPDrawManager::HLStoRGB_ONE(m_dblHue, m_dblLum, m_dblSat);

				InvalidateRect (rectCursorOld);
				InvalidateRect (GetCursorRect ());

				NotifyParent ();
			}
		}
		break;

	case HEX:
	case HEX_GREYSCALE:
	default:
		break;
		// TBD
	}
	
	CButton::OnKeyDown(nChar, nRepCnt, nFlags);
}

void CBCGPColorPickerCtrl::OnSetFocus(CWnd* pOldWnd) 
{
	CButton::OnSetFocus(pOldWnd);
	
	Invalidate();
}

void CBCGPColorPickerCtrl::OnKillFocus(CWnd* pNewWnd) 
{
	CButton::OnKillFocus(pNewWnd);
	
	Invalidate();
}

BOOL CBCGPColorPickerCtrl::OnQueryNewPalette() 
{
    Invalidate();    
	return CButton::OnQueryNewPalette();
}

void CBCGPColorPickerCtrl::OnPaletteChanged(CWnd* pFocusWnd) 
{
	CButton::OnPaletteChanged(pFocusWnd);
	
    if (pFocusWnd->GetSafeHwnd () != GetSafeHwnd ())
	{
        Invalidate ();
	}
}

BOOL CBCGPColorPickerCtrl::PreCreateWindow(CREATESTRUCT& cs) 
{
	cs.style |= BS_OWNERDRAW;
	cs.style &= ~BS_DEFPUSHBUTTON;
	
	return CButton::PreCreateWindow(cs);
}

void CBCGPColorPickerCtrl::PreSubclassWindow() 
{
	ModifyStyle (BS_DEFPUSHBUTTON, BS_OWNERDRAW);
	CButton::PreSubclassWindow();
}

void CBCGPColorPickerCtrl::DrawItem (LPDRAWITEMSTRUCT lpDIS)
{
	ASSERT (lpDIS != NULL);
	ASSERT (lpDIS->CtlType == ODT_BUTTON);
	ASSERT_VALID (m_pPalette);

	CDC* pDCDraw = CDC::FromHandle (lpDIS->hDC);
	ASSERT_VALID (pDCDraw);

	CPalette* pCurPalette = pDCDraw->SelectPalette (m_pPalette, FALSE);
	pDCDraw->RealizePalette();

	CRect rectClip;
	pDCDraw->GetClipBox (rectClip);

	CRect rectClient = lpDIS->rcItem;

	CDC*		pDC = pDCDraw;
	BOOL		m_bMemDC = FALSE;
	CDC			dcMem;
	CBitmap		bmp;
	CBitmap*	pOldBmp = NULL;
	CPalette*	pCurMemPalette = NULL;

	if (dcMem.CreateCompatibleDC (pDCDraw) &&
		bmp.CreateCompatibleBitmap (pDCDraw, rectClient.Width (),
								  rectClient.Height ()))
	{
		//-------------------------------------------------------------
		// Off-screen DC successfully created. Better paint to it then!
		//-------------------------------------------------------------
		m_bMemDC = TRUE;
		pOldBmp = dcMem.SelectObject (&bmp);
		pDC = &dcMem;

		pCurMemPalette = pDC->SelectPalette (m_pPalette, FALSE);
		pDC->RealizePalette ();

		globalData.DrawParentBackground (this, pDC);
	}

	switch (m_COLORTYPE)
	{
	case HEX:
		CreateHexagon ();
		DrawHex (pDC);
		break;

	case HEX_GREYSCALE:
		CreateHexGreyScaleBar ();
		DrawHex (pDC);
		break;

	case CURRENT:
		{
			COLORREF clrText = pDC->GetTextColor ();

			int nHalf = rectClient.Height () / 2;
			pDC->FillSolidRect (0, 0, rectClient.Width (), nHalf, m_colorNew);
			pDC->FillSolidRect(0, nHalf, rectClient.Width (), nHalf, m_colorOriginal);
			
			pDC->SetTextColor (clrText);	// Text color was changed by FillSolidRect

			// Draw frame
			pDC->Draw3dRect (rectClient,
				globalData.clrBtnDkShadow, globalData.clrBtnDkShadow);
		}
		break;

	case PICKER:
		DrawPicker(pDC);
		DrawCursor (pDC, GetCursorRect ());
		pDC->Draw3dRect (rectClient, globalData.clrBtnDkShadow, globalData.clrBtnHilite);
		break;

	case LUMINANCE:
		DrawLuminanceBar (pDC);

		// Draw marker:
		globalData.DrawParentBackground (this, pDC,
			CRect (m_nLumBarWidth, 0, 
			rectClient.Width () - m_nLumBarWidth, rectClient.Height ()));
		DrawCursor (pDC, GetCursorRect ());
		break;
	}

	if (m_bMemDC)
	{
		//--------------------------------------
		// Copy the results to the on-screen DC:
		//-------------------------------------- 
		pDCDraw->BitBlt (rectClip.left, rectClip.top, rectClip.Width(), rectClip.Height(),
					   &dcMem, rectClip.left, rectClip.top, SRCCOPY);

		if (pCurMemPalette != NULL)
		{
			dcMem.SelectPalette (pCurMemPalette, FALSE);
		}

		dcMem.SelectObject(pOldBmp);
	}

	if (pCurPalette != NULL)
	{
		pDCDraw->SelectPalette (pCurPalette, FALSE);
	}
}

void CBCGPColorPickerCtrl::SetPalette (CPalette* pPalette)
{
	ASSERT_VALID (pPalette);
	m_pPalette = pPalette;

	if (m_bmpPicker.GetSafeHandle () != NULL)
	{
		// picker's bitmap should be rebuild!
		::DeleteObject (m_bmpPicker.Detach ());
	}

	if (GetSafeHwnd () != NULL)
	{
		Invalidate ();
		UpdateWindow ();
	}
}

BOOL CBCGPColorPickerCtrl::OnEraseBkgnd(CDC* /*pDC*/) 
{
	return TRUE;
}

double CBCGPColorPickerCtrl::LumFromPoint (int nY)
{
	ASSERT (m_COLORTYPE == LUMINANCE);

	CRect rectClient;
	GetClientRect (rectClient);

	rectClient.DeflateRect (0, DEFAULT_OFFSET_OF_LUMINANCE_BAR);

	nY = min (max (rectClient.top, nY), rectClient.bottom);
	return ((double) rectClient.bottom - nY) / rectClient.Height ();
}

int CBCGPColorPickerCtrl::PointFromLum (double dblLum)
{
	ASSERT (m_COLORTYPE == LUMINANCE);

	CRect rectClient;
	GetClientRect (rectClient);

	rectClient.DeflateRect (0, DEFAULT_OFFSET_OF_LUMINANCE_BAR);
	return rectClient.top + (int) ((1. - dblLum) * rectClient.Height ());
}

CPoint CBCGPColorPickerCtrl::GetCursorPos ()
{
	CRect rectClient;
	GetClientRect (rectClient);

	CPoint point (0, 0);

	switch (m_COLORTYPE)
	{
	case LUMINANCE:
		point =  CPoint (rectClient.left + m_nLumBarWidth + 6, 
						PointFromLum (m_dblLum));
		break;

	case PICKER:
		point =  CPoint (	(long)((double) rectClient.Width () * m_dblHue),
						(long)((1. - m_dblSat) * rectClient.Height ()));
		break;

	case HEX:
	case HEX_GREYSCALE:
	default:
		ASSERT (FALSE);
	}

	return point;
}

CRect CBCGPColorPickerCtrl::GetCursorRect ()
{
	CRect rect;

	switch (m_COLORTYPE)
	{
	case PICKER:
		rect = CRect (GetCursorPos (), 
					CSize (PICKER_CURSOR_SIZE, PICKER_CURSOR_SIZE));
		break;

	case LUMINANCE:
		rect = CRect (GetCursorPos (),
					CSize (LUM_CURSOR_SIZE, LUM_CURSOR_SIZE));
		break;

	case HEX:
	case HEX_GREYSCALE:
	default:
		ASSERT (FALSE);
		rect.SetRectEmpty ();
	}

	rect.OffsetRect (-rect.Width () / 2, -rect.Height () / 2);
	return rect;
}

void CBCGPColorPickerCtrl::OnCancelMode() 
{
	CButton::OnCancelMode();
}

void CBCGPColorPickerCtrl::NotifyParent ()
{
	CWnd* pParent = GetParent ();
	if (pParent != NULL)
	{
		pParent->SendMessage (	WM_COMMAND,
								MAKEWPARAM (GetDlgCtrlID (), BN_CLICKED), 
								(LPARAM) GetSafeHwnd ());
	}
}

void CBCGPColorPickerCtrl::OnLButtonDblClk(UINT nFlags, CPoint point) 
{
	switch (m_COLORTYPE)
	{
	case PICKER:
	case HEX:
	case HEX_GREYSCALE:
		{
			CWnd* pParent = GetParent ();
			if (pParent != NULL)
			{
				pParent->SendMessage (	WM_COMMAND,
										MAKEWPARAM (GetDlgCtrlID (), BN_DOUBLECLICKED), 
										(LPARAM) GetSafeHwnd ());
			}
		}

		return;
	}
	
	CButton::OnLButtonDblClk(nFlags, point);
}

#endif // BCG_NO_COLOR