bcgphotspotimagectrl.cpp

远程网络监视程序的源码

//*******************************************************************************
// COPYRIGHT NOTES
// ---------------
// This is a part of the BCGControlBar Library
// Copyright (C) 1998-2000 BCGSoft Ltd.
// All rights reserved.
//
// This source code can be used, distributed or modified
// only under terms and conditions 
// of the accompanying license agreement.
//*******************************************************************************
//
// BCGPHotSpotImageCtrl.cpp : implementation file
//

#include "stdafx.h"
#include "bcgprores.h"
#include "bcgglobals.h"
#include "BCGPLocalResource.h"
#include "BCGPHotSpotImageCtrl.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CBCGPHotSpot

IMPLEMENT_SERIAL(CBCGPHotSpot, CObject, 1)

CBCGPHotSpot::CBCGPHotSpot(UINT nID) :
	m_nID (nID)
{
	m_rect.SetRectEmpty ();
}
//*******************************************************************************
CBCGPHotSpot::~CBCGPHotSpot()
{
}
//*******************************************************************************
void CBCGPHotSpot::CreateRect (CRect rect)
{
	m_rect = rect;
}
//*******************************************************************************
BOOL CBCGPHotSpot::IsPointWithin (CPoint pt) const
{
	return m_rect.PtInRect (pt);
}
//********************************************************************************
void CBCGPHotSpot::Serialize(CArchive& ar)
{
	CObject::Serialize (ar);

	if (ar.IsLoading ())
	{
		ar >> (ULONG&) m_nID;
		ar >> m_rect;
	}
	else
	{
		ar << m_nID;
		ar << m_rect;
	}
}

/////////////////////////////////////////////////////////////////////////////
// CBCGPHotSpotImageCtrl

CBCGPHotSpotImageCtrl::CBCGPHotSpotImageCtrl()
{
	m_bAutoDestroyImage	= FALSE;
	m_hbmpImage			= NULL;
	m_hbmpHot			= NULL;
	m_sizeImage			= CSize (0, 0);
	m_clrBack			= RGB (255, 255, 255);

	m_pHot				= NULL;
	m_pClicked			= NULL;

	m_nSelectedNum		= 0;

	m_lineDev			= CSize (0, 0);
	m_pageDev			= CSize (0, 0);
}
//*******************************************************************************
CBCGPHotSpotImageCtrl::~CBCGPHotSpotImageCtrl()
{
	CleanUp ();
}

BEGIN_MESSAGE_MAP(CBCGPHotSpotImageCtrl, CButton)
	//{{AFX_MSG_MAP(CBCGPHotSpotImageCtrl)
	ON_WM_ERASEBKGND()
	ON_WM_SETCURSOR()
	ON_WM_MOUSEMOVE()
	ON_WM_MOUSEWHEEL()
	ON_WM_LBUTTONDOWN()
	ON_WM_LBUTTONUP()
	ON_WM_CANCELMODE()
	ON_WM_SIZE()
	ON_WM_VSCROLL()
	ON_WM_HSCROLL()
	ON_WM_CREATE()

	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CBCGPHotSpotImageCtrl message handlers

BOOL CBCGPHotSpotImageCtrl::Create(const RECT& rect, CWnd* pParentWnd, UINT nID)
{
	return CButton::Create(_T(""), WS_CHILD | WS_VISIBLE, rect, pParentWnd, nID);
}
//*******************************************************************************
BOOL CBCGPHotSpotImageCtrl::PreCreateWindow(CREATESTRUCT& cs) 
{
	cs.style |= (BS_OWNERDRAW | WS_HSCROLL | WS_VSCROLL);
	cs.style &= ~BS_DEFPUSHBUTTON;

	return CButton::PreCreateWindow(cs);
}
//********************************************************************************
void CBCGPHotSpotImageCtrl::PreSubclassWindow() 
{
	ModifyStyle (BS_DEFPUSHBUTTON, BS_OWNERDRAW | WS_HSCROLL | WS_VSCROLL);
	CButton::PreSubclassWindow();

	UpdateScrollBars ();
}
//*******************************************************************************
void CBCGPHotSpotImageCtrl::DrawItem(LPDRAWITEMSTRUCT lpDIS) 
{
	ASSERT (lpDIS != NULL);
	ASSERT (lpDIS->CtlType == ODT_BUTTON);

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

	OnPrepareDC (pDCPaint);

	CRect rect = lpDIS->rcItem;

	rect.right += GetScrollPos (SB_HORZ);
	rect.bottom += GetScrollPos (SB_VERT);

	CRect rectClip;
	int nClipType = pDCPaint->GetClipBox (rectClip);
	if (nClipType != SIMPLEREGION)
	{
		rectClip = rect;
	}

	CDC*		pDC = pDCPaint;
	BOOL		m_bMemDC = FALSE;
	CDC			dcMem;
	CBitmap		bmp;
	CBitmap*	pOldBmp = NULL;

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

	pDC->FillSolidRect (rectClip, m_clrBack);

	OnDrawImage (pDC, rect);

	CBCGPHotSpot* pHot = m_pHot;
	if (m_pClicked != NULL)
	{
		pHot = m_pClicked;
	}

	if (pHot != NULL)
	{
		CRect rectHotSpot = pHot->m_rect;
		pDC->LPtoDP (&rectHotSpot);

		CRgn rgn;
		rgn.CreateRectRgnIndirect (rectHotSpot);

		pDC->SelectClipRgn (&rgn);

		OnDrawHotSpot (pDC, rect, pHot);

		pDC->SelectClipRgn (NULL);
	}

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

		dcMem.SelectObject(pOldBmp);
	}
}
//*******************************************************************************
void CBCGPHotSpotImageCtrl::OnPrepareDC(CDC* pDC)
{
	ASSERT_VALID(pDC);

	pDC->SetMapMode(MM_TEXT);

	CPoint ptVpOrg(0, 0);       // assume no shift for printing
	ASSERT(pDC->GetWindowOrg() == CPoint(0,0));

	// by default shift viewport origin in negative direction of scroll
	ptVpOrg = -GetDeviceScrollPosition();

	pDC->SetViewportOrg(ptVpOrg);
}
//*******************************************************************************
void CBCGPHotSpotImageCtrl::OnDrawImage (CDC* pDC, CRect rectImage)
{
	ASSERT_VALID (pDC);

	if (m_hbmpImage == NULL)
	{
		return;
	}

	rectImage.right = min (rectImage.right, m_sizeImage.cx);
	rectImage.bottom = min (rectImage.bottom, m_sizeImage.cy);

	pDC->DrawState (rectImage.TopLeft (), rectImage.Size (), m_hbmpImage, DSS_NORMAL);
}
//*******************************************************************************
void CBCGPHotSpotImageCtrl::OnDrawHotSpot (CDC* pDC, CRect rectImage, CBCGPHotSpot* /*pHotSpot*/)
{
	ASSERT_VALID (pDC);

	if (m_hbmpHot == NULL)
	{
		return;
	}

	rectImage.right = min (rectImage.right, m_sizeImage.cx);
	rectImage.bottom = min (rectImage.bottom, m_sizeImage.cy);

	pDC->DrawState (rectImage.TopLeft (), rectImage.Size (), m_hbmpHot, DSS_NORMAL);
}
//********************************************************************************
BOOL CBCGPHotSpotImageCtrl::SetImage (UINT uiBmpResId, UINT uiBmpHotResId/* = 0*/)
{
	CleanUp ();

	if (uiBmpResId == 0)
	{
		UpdateScrollBars ();
		return TRUE;
	}

	HBITMAP hbmp = (HBITMAP) ::LoadImage (
		AfxGetResourceHandle (),
		MAKEINTRESOURCE (uiBmpResId),
		IMAGE_BITMAP,
		0, 0,
		LR_CREATEDIBSECTION | LR_LOADMAP3DCOLORS);
	ASSERT (hbmp != NULL);

	HBITMAP hbmpHot = NULL;
	if (uiBmpHotResId != 0)
	{
		hbmpHot = (HBITMAP) ::LoadImage (
			AfxGetResourceHandle (),
			MAKEINTRESOURCE (uiBmpHotResId),
			IMAGE_BITMAP,
			0, 0,
			LR_CREATEDIBSECTION | LR_LOADMAP3DCOLORS);
		ASSERT (hbmpHot != NULL);
	}

	return SetImage (hbmp, hbmpHot, TRUE /* Auto-destoy */);
}
//*******************************************************************************
BOOL CBCGPHotSpotImageCtrl::SetImage (HBITMAP hbmpImage, HBITMAP hbmpImageHot/* = NULL*/, BOOL bAutoDestroy/* = FALSE*/)
{
	CleanUp ();

	ASSERT (hbmpImage != NULL);

	m_hbmpImage = hbmpImage;
	m_hbmpHot = hbmpImageHot;

	BITMAP bmp;
	::GetObject (m_hbmpImage, sizeof (BITMAP), (LPVOID) &bmp);

	m_sizeImage.cx = bmp.bmWidth;
	m_sizeImage.cy = bmp.bmHeight;

	m_pageDev.cx = m_sizeImage.cx / 10;
	m_pageDev.cy = m_sizeImage.cy / 10;
	m_lineDev.cx = m_pageDev.cx / 10;
	m_lineDev.cy = m_pageDev.cy / 10;

	if (m_hbmpHot != NULL)
	{
		// Hot and cold bitmaps should have the same size!
		::GetObject (m_hbmpHot, sizeof (BITMAP), (LPVOID) &bmp);

		ASSERT (m_sizeImage.cx == bmp.bmWidth);
		ASSERT (m_sizeImage.cy == bmp.bmHeight);
	}

	m_bAutoDestroyImage = bAutoDestroy;

	if (GetSafeHwnd () != NULL)
	{
		UpdateScrollBars ();
		RedrawWindow ();
	}

	return TRUE;
}
//*******************************************************************************
void CBCGPHotSpotImageCtrl::CleanUp ()
{
	if (m_bAutoDestroyImage)
	{
		if (m_hbmpImage != NULL)
		{
			::DeleteObject (m_hbmpImage);
		}

		if (m_hbmpHot != NULL)
		{
			::DeleteObject (m_hbmpHot);
		}
	}

	while (!m_lstHotSpots.IsEmpty ())
	{
		delete m_lstHotSpots.RemoveHead ();
	}

	m_hbmpImage = NULL;
	m_hbmpHot = NULL;
	m_sizeImage = CSize (0, 0);

	m_lineDev = CSize (0, 0);
	m_pageDev = CSize (0, 0);

	UpdateScrollBars ();
}
//********************************************************************************
BOOL CBCGPHotSpotImageCtrl::OnEraseBkgnd(CDC* /*pDC*/) 
{
	return TRUE;
}
//********************************************************************************
void CBCGPHotSpotImageCtrl::SetBackgroundColor (COLORREF color)
{
	m_clrBack = color;

	if (GetSafeHwnd () != NULL)
	{
		RedrawWindow ();
	}
}
//********************************************************************************
CBCGPHotSpot* CBCGPHotSpotImageCtrl::FindHotSpot (UINT nID) const
{
	for (POSITION pos = m_lstHotSpots.GetHeadPosition (); pos != NULL;)
	{
		CBCGPHotSpot* pHotSpot = m_lstHotSpots.GetNext (pos);
		ASSERT_VALID (pHotSpot);

		if (pHotSpot->m_nID == nID)
		{
			return pHotSpot;
		}
	}

	return NULL;
}
//*******************************************************************************
BOOL CBCGPHotSpotImageCtrl::AddHotSpot (UINT nID, CRect rect)
{
	if (FindHotSpot (nID) != NULL)
	{
		// nID should be unique!
		ASSERT (FALSE);
		return FALSE;
	}

	ASSERT (nID != 0);

	CBCGPHotSpot* pHotSpot = new CBCGPHotSpot (nID);
	pHotSpot->CreateRect (rect);

	m_lstHotSpots.AddTail (pHotSpot);

	return TRUE;
}
//********************************************************************************
BOOL CBCGPHotSpotImageCtrl::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message) 
{
	CPoint point;
	GetCursorPos (&point);
	ScreenToClient (&point);

	if (HitTest (point) != NULL)
	{
		if (globalData.m_hcurHand == NULL)
		{
			CBCGPLocalResource locaRes;
			globalData.m_hcurHand = AfxGetApp ()->LoadCursor (IDC_BCGBARRES_HAND);
		}

		::SetCursor (globalData.m_hcurHand);
		return TRUE;
	}
	
	return CButton::OnSetCursor(pWnd, nHitTest, message);
}
//*********************************************************************************
CBCGPHotSpot* CBCGPHotSpotImageCtrl::HitTest (CPoint pt)
{
	CClientDC dc (this);
	OnPrepareDC (&dc);

	CPoint ptScreen = pt;
	ClientToScreen (&ptScreen);