// GaugeRectTracker.cpp : implementation file
//
// (c)1998-2025 Codejock Software, All Rights Reserved.
//
// THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE
// RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN
// CONSENT OF CODEJOCK SOFTWARE.
//
// THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED
// IN THE XTREME TOOLKIT PRO LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO
// YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A
// SINGLE COMPUTER.
//
// CONTACT INFORMATION:
// support@codejock.com
// http://www.codejock.com
//
/////////////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "GaugeRectTracker.h"

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

/////////////////////////////////////////////////////////////////////////////
// CGaugeRectTracker

CGaugeRectTracker::CGaugeRectTracker()
{
	m_pWnd		  = NULL;
	m_nMask		  = 0x0;
	m_nStyle	  = resizeOutside | solidLine;
	m_nHandleSize = 7;
	m_rect.SetRectEmpty();
}

void CGaugeRectTracker::SetTrackRect(CWnd* pWnd, CRect* pRect)
{
	ASSERT(pWnd != NULL && pRect != NULL);

	m_pWnd = pWnd;
	m_rect.CopyRect(pRect);

	m_sizeMin	= m_rect.Size();
	m_sizeMin.cx = XTP_DPI_X(150);
	m_sizeMin.cy = XTP_DPI_Y(150);
}

void CGaugeRectTracker::Draw(CDC* pDC, COLORREF crBorder, COLORREF crHandle) const
{
	// set initial DC state
	VERIFY(pDC->SaveDC() != 0);
	pDC->SetMapMode(MM_TEXT);
	pDC->SetViewportOrg(0, 0);
	pDC->SetWindowOrg(0, 0);

	// get normalized rectangle
	CRect rect = m_rect;
	rect.NormalizeRect();

	CPen* pOldPen	 = NULL;
	CBrush* pOldBrush = NULL;
	CPen penSolid(PS_SOLID, 1, crBorder);

	// draw lines
	pOldPen		= (CPen*)pDC->SelectObject(&penSolid);
	pOldBrush   = (CBrush*)pDC->SelectStockObject(NULL_BRUSH);
	int nOldROP = pDC->SetROP2(R2_COPYPEN);
	rect.InflateRect(+1, +1); // borders are one pixel outside

	CString strBuffer;
	strBuffer.Format(_T("TRACKER: l:%i t:%i r:%i b:%i, cx:%i, cy:%i\n"), rect.left, rect.top,
					 rect.right, rect.bottom, rect.Width(), rect.Height());
	TRACE(strBuffer);

	pDC->Rectangle(rect.left, rect.top, rect.right, rect.bottom);
	pDC->SetROP2(nOldROP);

	// draw resize handles
	UINT mask = GetHandleMask();
	for (int i = 0; i < 8; ++i)
	{
		if (mask & (1 << i))
		{
			GetHandleRect((TrackerHit)i, &rect);
			pDC->FillSolidRect(rect, crHandle);
		}
	}

	// cleanup pDC state
	if (pOldPen != NULL)
		pDC->SelectObject(pOldPen);
	if (pOldBrush != NULL)
		pDC->SelectObject(pOldBrush);

	VERIFY(pDC->RestoreDC(-1));
}

BOOL CGaugeRectTracker::SetCursor(CWnd* pWnd)
{
	CPoint point;
	GetCursorPos(&point);
	pWnd->ScreenToClient(&point);

	switch (HitTest(point))
	{
		case hitTopLeft:
			if (HasHandle(thTopLeft))
			{
				::SetCursor(::LoadCursor(0, IDC_SIZENWSE));
				return TRUE;
			}
			break;
		case hitTopRight:
			if (HasHandle(thTopRight))
			{
				::SetCursor(::LoadCursor(0, IDC_SIZENESW));
				return TRUE;
			}
			break;
		case hitBottomRight:
			if (HasHandle(thBottomRight))
			{
				::SetCursor(::LoadCursor(0, IDC_SIZENWSE));
				return TRUE;
			}
			break;
		case hitBottomLeft:
			if (HasHandle(thBottomLeft))
			{
				::SetCursor(::LoadCursor(0, IDC_SIZENESW));
				return TRUE;
			}
			break;
		case hitTop:
			if (HasHandle(thTop))
			{
				::SetCursor(::LoadCursor(0, IDC_SIZENS));
				return TRUE;
			}
			break;
		case hitRight:
			if (HasHandle(thRight))
			{
				::SetCursor(::LoadCursor(0, IDC_SIZEWE));
				return TRUE;
			}
			break;
		case hitBottom:
			if (HasHandle(thBottom))
			{
				::SetCursor(::LoadCursor(0, IDC_SIZENS));
				return TRUE;
			}
			break;
		case hitLeft:
			if (HasHandle(thLeft))
			{
				::SetCursor(::LoadCursor(0, IDC_SIZEWE));
				return TRUE;
			}
			break;
		case hitMiddle:
			if (HasHandle(thMiddle))
			{
				::SetCursor(::LoadCursor(0, IDC_SIZEALL));
				return TRUE;
			}
			break;
	}

	return FALSE;
}

BOOL CGaugeRectTracker::HasHandle(UINT nHandle)
{
	return ((GetHandleMask() & nHandle) == nHandle);
}

void CGaugeRectTracker::SetHandleMask(UINT nMask)
{
	m_nMask = nMask;
}

UINT CGaugeRectTracker::GetHandleMask() const
{
	if (m_nMask)
	{
		return m_nMask;
	}

	return CRectTracker::GetHandleMask();
}

void CGaugeRectTracker::AdjustRect(int nHandle, LPRECT lpRect)
{
	CRectTracker::AdjustRect(nHandle, lpRect);

	if (m_pWnd)
	{
		CXTPClientRect rcClient(m_pWnd);
		rcClient.DeflateRect(10, 10);

		CSize size = CSize(lpRect->right - lpRect->left, lpRect->bottom - lpRect->top);
		CSize sizeClient(rcClient.Size());

		// limit width to client area width.
		if (size.cx > sizeClient.cx)
			size.cx = sizeClient.cx;

		// limit height to client area height.
		if (size.cy > sizeClient.cy)
			size.cy = sizeClient.cy;

		lpRect->bottom = lpRect->top + size.cy;
		lpRect->right  = lpRect->left + size.cx;
	}
}

void CGaugeRectTracker::OnChangedRect(const CRect& rectOld)
{
	CRectTracker::OnChangedRect(rectOld);

	if (m_pWnd)
	{
		//-- notify view tracker size has changed.
		m_pWnd->SendMessage(WM_ONCHANGEDRECT, (WPARAM)&m_rect);
	}
}