selectionboxsprite.cpp

虚拟打印机

/*
 *
 * selectionboxsprite.cpp
 *
 *
   Copyright (C) 2006 Michael H. Overlin

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   
   Contact at [e-mail]
 */

#include "selectionboxsprite.h"
#include "mathutils.h"
#include "utils.h"

// ****************************************************************************************************
// **  class SelectionBoxSprite  **********************************************************************
// ****************************************************************************************************

// ****
// **** public:  class SelectionBoxSprite
// ****

SelectionBoxSprite::SelectionBoxSprite(const RECT& rView, const Spec& spec) {
	m_spec = spec;
	m_rView = rView;
	::SetRect(&m_rBox, 0, 0, 0, 0);

	m_vSprite.insert(m_vSprite.begin(), eBoxPartNUMBER, NULL);
	for(uint ui = 0; ui < eBoxPartNUMBER; ++ui) {
		SIZE szMax;
		GetMaxBoxPartSize(szMax, (BoxPart) ui);
		SolidColorSprite *pscs = new SolidColorSprite(szMax);
		m_vSprite[ui] = pscs;
	}
}

BOOL SelectionBoxSprite::BoxPartFromPt(IN const POINT& pt, OUT BoxPart& bp) const {
	BOOL bRetValue = FALSE;
	for(uint ui = 0; ui < eBoxPartNUMBER; ++ui) {
		SolidColorSprite *pscs = (SolidColorSprite*) m_vSprite[ui];
		if (pscs->HitTest(pt)) {
			bp = (BoxPart) ui;
			bRetValue = TRUE;
			break;
		}
	}
	return bRetValue;
}

void SelectionBoxSprite::SetNextBox(const RECT& rBox) {
	m_rBoxNext = rBox;
	for(uint ui = 0; ui < eBoxPartNUMBER; ++ui) {
		SolidColorSprite *pscs = (SolidColorSprite*) m_vSprite[ui];
		SolidColorSprite::State state;
		RECT rPart;
		GetBoxPartRect(rPart, rBox, (BoxPart) ui);
		RECT rIntersect;
		if (::IntersectRect(&rIntersect, &rPart, &m_rView)) {
			state.bVisible = TRUE;
			state.clr = m_spec.clr;
			state.r = rIntersect;
		} else {
			state.bVisible = FALSE;
		}
		pscs->SetNextState(state);
	}
}

void SelectionBoxSprite::SetNextInvisible(void) {
	for(uint ui = 0; ui < eBoxPartNUMBER; ++ui) {
		SolidColorSprite *pscs = (SolidColorSprite*) m_vSprite[ui];
		SolidColorSprite::State state = pscs->GetState();
		state.bVisible = FALSE;
		pscs->SetNextState(state);
	}
}


// ****
// **** protected:  class SelectionBoxSprite
// ****

void SelectionBoxSprite::GetBoxPartRect(OUT RECT& rPart, IN const RECT& rBox, IN BoxPart bp) const {
	SIZE szPart;
	GetBoxPartSize(szPart,  bp, rBox);

	POINT ptPartAnchor;
	BoxPart bpPartAnchor;
	switch(bp) {
	case eTopLeft:
		::GetBoxPoint(ptPartAnchor, rBox, eTopLeft);
		bpPartAnchor = eBottomRight;
		break;
	case eTop:
		::GetBoxPoint(ptPartAnchor, rBox, eTopLeft);
		bpPartAnchor = eBottomLeft;
		break;
	case eTopRight:
		::GetBoxPoint(ptPartAnchor, rBox, eTopRight);
		bpPartAnchor = eBottomLeft;
		break;
	case eRight:
		::GetBoxPoint(ptPartAnchor, rBox, eTopRight);
		bpPartAnchor = eTopLeft;
		break;
	case eBottomRight:	
		::GetBoxPoint(ptPartAnchor, rBox, eBottomRight);
		bpPartAnchor = eTopLeft;
		break;

	case eBottom:
		::GetBoxPoint(ptPartAnchor, rBox, eBottomRight);
		bpPartAnchor = eTopRight;
		break;
	case eBottomLeft:
		::GetBoxPoint(ptPartAnchor, rBox, eBottomLeft);
		bpPartAnchor = eTopRight;
		break;
	case eLeft:
		::GetBoxPoint(ptPartAnchor, rBox, eTopLeft);
		bpPartAnchor = eTopRight;
		break;
	default:
		ASSERTFAIL();
		break;
	}

	::SetRect(rPart, ptPartAnchor, bpPartAnchor, szPart);
}

void SelectionBoxSprite::GetMaxBoxPartSize(OUT SIZE& sz, IN BoxPart bp) const {
	GetBoxPartSize(sz, bp, m_rView);
}

void SelectionBoxSprite::GetBoxPartSize(OUT SIZE& sz, IN BoxPart bp, IN const RECT& rBox) const {
	switch(bp) {
	case eTopLeft:
	case eTopRight:
	case eBottomRight:
	case eBottomLeft:
		sz.cx = m_spec.nBoxSize;
		sz.cy = m_spec.nBoxSize;
		break;
	case eTop:
	case eBottom:
		sz.cx = RW(rBox);
		sz.cy = m_spec.nLineWidth;
		break;
	case eRight:
	case eLeft:
		sz.cx = m_spec.nLineWidth;
		sz.cy = RH(rBox);
		break;
	default:
		ASSERTFAIL();
		break;
	}
}

// *******************************************************************************************************
// **  MODULE PUBLIC ROUTINES  ***************************************************************************
// *******************************************************************************************************

void GetBoxPoint(OUT POINT& pt, IN const RECT& r, IN BoxPart bp) {
	switch(bp) {
	case eTopLeft:
		pt.x = r.left;
		pt.y = r.top;
		break;
	case eTopRight:
		pt.x = r.right;
		pt.y = r.top;
		break;
	case eBottomRight:	
		pt.x = r.right;
		pt.y = r.bottom;
		break;
	case eBottomLeft:
		pt.x = r.left;
		pt.y = r.bottom;
		break;
	default:
		ASSERTFAIL();
		break;
	}
}

void SetRect(OUT RECT& r, IN const POINT& pt, IN BoxPart bpPt, IN const SIZE& sz) {
	::SetRect(r, pt, sz);
	POINT ptPart;
	::GetBoxPoint(ptPart, r, bpPt);
	::OffsetRect(&r, pt.x - ptPart.x, pt.y - ptPart.y);
}

void OffsetBoxPart(IN OUT RECTD& rd, IN const POINTD& ptdOffset, IN BoxPart bp) {
	switch(bp) {
	case eTopLeft:
		rd.left += ptdOffset.x;
		rd.top += ptdOffset.y;
		break;
	case eTopRight:
		rd.right += ptdOffset.x;
		rd.top += ptdOffset.y;
		break;
	case eBottomRight:	
		rd.right += ptdOffset.x;
		rd.bottom += ptdOffset.y;
		break;
	case eBottomLeft:
		rd.left += ptdOffset.x;
		rd.bottom += ptdOffset.y;
		break;
	case eTop:
	case eRight:
	case eBottom:
	case eLeft:
		::OffsetRect(rd, ptdOffset.x, ptdOffset.y);
		break;
	default:
		ASSERTFAIL();
		break;
	}
}


//void OffsetBoxPart(IN OUT RECTD& rd, IN const POINTD& ptdOffset, IN BoxPart bp) {
//	switch(bp) {
//	case eTopLeft:
//		rd.left += ptdOffset.x;
//		rd.top += ptdOffset.y;
//		break;
//	case eTop:
//		rd.top += ptdOffset.y;
//		break;
//	case eTopRight:
//		rd.right += ptdOffset.x;
//		rd.top += ptdOffset.y;
//		break;
//	case eRight:
//		rd.right += ptdOffset.x;
//		break;
//	case eBottomRight:	
//		rd.right += ptdOffset.x;
//		rd.bottom += ptdOffset.y;
//		break;
//	case eBottom:
//		rd.bottom += ptdOffset.y;
//		break;
//	case eBottomLeft:
//		rd.left += ptdOffset.x;
//		rd.bottom += ptdOffset.y;
//		break;
//	case eLeft:
//		rd.left += ptdOffset.x;
//		break;
//	default:
//		ASSERTFAIL();
//		break;
//	}
//}