You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

797 lines
21 KiB
C++

// XTPMarkupShape.cpp: implementation of the CXTPMarkupShape class.
//
// This file is a part of the XTREME TOOLKIT PRO MFC class library.
// (c)1998-2012 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 <math.h>
#include <Common/XTPVC80Helpers.h>
#include "XTPMarkupObject.h"
#include "XTPMarkupInputElement.h"
#include "XTPMarkupUIElement.h"
#include "XTPMarkupFrameworkElement.h"
#include "XTPMarkupShape.h"
#include "XTPMarkupDrawingContext.h"
#include "XTPMarkupBuilder.h"
#include "XTPMarkupThickness.h"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
//////////////////////////////////////////////////////////////////////////
// CXTPMarkupShape
CXTPMarkupDependencyProperty* CXTPMarkupShape::m_pFillProperty = NULL;
CXTPMarkupDependencyProperty* CXTPMarkupShape::m_pStrokeProperty = NULL;
CXTPMarkupDependencyProperty* CXTPMarkupShape::m_pStrokeThicknessProperty = NULL;
CXTPMarkupDependencyProperty* CXTPMarkupShape::m_pStretchProperty = NULL;
CXTPMarkupDependencyProperty* CXTPMarkupShape::m_pStrokeDashArrayProperty = NULL;
CXTPMarkupDependencyProperty* CXTPMarkupShape::m_pStrokeStartLineCapProperty = NULL;
CXTPMarkupDependencyProperty* CXTPMarkupShape::m_pStrokeEndLineCapProperty = NULL;
CXTPMarkupDependencyProperty* CXTPMarkupShape::m_pStrokeLineJoinProperty = NULL;
IMPLEMENT_MARKUPCLASS(L"Shape", CXTPMarkupShape, CXTPMarkupFrameworkElement)
void CXTPMarkupShape::RegisterMarkupClass()
{
m_pFillProperty = CXTPMarkupDependencyProperty::Register(L"Fill", MARKUP_TYPE(CXTPMarkupBrush), MARKUP_TYPE(CXTPMarkupShape),
new CXTPMarkupPropertyMetadata(NULL, CXTPMarkupPropertyMetadata::flagAffectsRender));
m_pStrokeProperty = CXTPMarkupDependencyProperty::Register(L"Stroke", MARKUP_TYPE(CXTPMarkupBrush), MARKUP_TYPE(CXTPMarkupShape),
new CXTPMarkupPropertyMetadata(NULL, CXTPMarkupPropertyMetadata::flagAffectsRender));
m_pStrokeThicknessProperty = CXTPMarkupDependencyProperty::Register(L"StrokeThickness", MARKUP_TYPE(CXTPMarkupInt), MARKUP_TYPE(CXTPMarkupShape),
new CXTPMarkupPropertyMetadata(NULL, CXTPMarkupPropertyMetadata::flagAffectsRender));
m_pStretchProperty = CXTPMarkupDependencyProperty::Register(L"Stretch", MARKUP_TYPE(CXTPMarkupEnum), MARKUP_TYPE(CXTPMarkupShape),
new CXTPMarkupPropertyMetadata(CXTPMarkupEnum::CreateValue(xtpMarkupStretchNone), &CXTPMarkupBuilder::ConvertStretch, CXTPMarkupPropertyMetadata::flagAffectsRender));
m_pStrokeDashArrayProperty = CXTPMarkupDependencyProperty::Register(L"StrokeDashArray", MARKUP_TYPE(CXTPMarkupDoubleCollection), MARKUP_TYPE(CXTPMarkupShape),
new CXTPMarkupPropertyMetadata(NULL, CXTPMarkupPropertyMetadata::flagAffectsMeasure));
m_pStrokeStartLineCapProperty = CXTPMarkupDependencyProperty::Register(L"StrokeStartLineCap", MARKUP_TYPE(CXTPMarkupEnum), MARKUP_TYPE(CXTPMarkupShape),
new CXTPMarkupPropertyMetadata(CXTPMarkupEnum::CreateValue(xtpMarkupLineCapFlat), &CXTPMarkupShape::ConvertLineCap, CXTPMarkupPropertyMetadata::flagAffectsRender));
m_pStrokeEndLineCapProperty = CXTPMarkupDependencyProperty::Register(L"StrokeEndLineCap", MARKUP_TYPE(CXTPMarkupEnum), MARKUP_TYPE(CXTPMarkupShape),
new CXTPMarkupPropertyMetadata(CXTPMarkupEnum::CreateValue(xtpMarkupLineCapFlat), &CXTPMarkupShape::ConvertLineCap, CXTPMarkupPropertyMetadata::flagAffectsRender));
m_pStrokeLineJoinProperty = CXTPMarkupDependencyProperty::Register(L"StrokeLineJoin", MARKUP_TYPE(CXTPMarkupEnum), MARKUP_TYPE(CXTPMarkupShape),
new CXTPMarkupPropertyMetadata(CXTPMarkupEnum::CreateValue(xtpMarkupLineJoinMiter), &CXTPMarkupShape::ConvertLineJoin, CXTPMarkupPropertyMetadata::flagAffectsRender));
}
CXTPMarkupShape::CXTPMarkupShape()
{
}
CXTPMarkupShape::~CXTPMarkupShape()
{
}
CXTPMarkupBrush* CXTPMarkupShape::GetFill() const
{
return MARKUP_STATICCAST(CXTPMarkupBrush, GetValue(m_pFillProperty));
}
void CXTPMarkupShape::SetFill(CXTPMarkupBrush* brush)
{
SetValue(m_pFillProperty, brush);
}
CXTPMarkupBrush* CXTPMarkupShape::GetStroke() const
{
return MARKUP_STATICCAST(CXTPMarkupBrush, GetValue(m_pStrokeProperty));
}
void CXTPMarkupShape::SetStroke(CXTPMarkupBrush* brush)
{
SetValue(m_pStrokeProperty, brush);
}
void CXTPMarkupShape::GetStrokeStyle(CXTPMarkupStrokeStyle* pStrokeStyle) const
{
pStrokeStyle->pStrokeBrush = GetStroke();
pStrokeStyle->nStrokeThickness = pStrokeStyle->pStrokeBrush ? GetStrokeThickness() : 0;
pStrokeStyle->pStrokeDashArray = GetStrokeDashArray();
pStrokeStyle->nStrokeStartLineCap = GetStrokeStartLineCap();
pStrokeStyle->nStrokeEndLineCap = GetStrokeEndLineCap();
pStrokeStyle->nStrokeLineJoin = GetStrokeLineJoin();
}
CXTPMarkupObject* CXTPMarkupShape::ConvertLineCap(CXTPMarkupBuilder* /*pBuilder*/, CXTPMarkupObject* pObject)
{
if (IsStringObject(pObject))
{
LPCWSTR lpszValue = *((CXTPMarkupString*)pObject);
int nLength = ((CXTPMarkupString*)pObject)->GetLength();
if (nLength == 4 && _wcsicmp(lpszValue, L"Flat") == 0) return CXTPMarkupEnum::CreateValue(xtpMarkupLineCapFlat);
if (nLength == 6 && _wcsicmp(lpszValue, L"Square") == 0) return CXTPMarkupEnum::CreateValue(xtpMarkupLineCapSquare);
if (nLength == 5 && _wcsicmp(lpszValue, L"Round") == 0) return CXTPMarkupEnum::CreateValue(xtpMarkupLineCapRound);
if (nLength == 8 && _wcsicmp(lpszValue, L"Triangle") == 0) return CXTPMarkupEnum::CreateValue(xtpMarkupLineCapTriangle);
}
return NULL;
}
CXTPMarkupObject* CXTPMarkupShape::ConvertLineJoin(CXTPMarkupBuilder* /*pBuilder*/, CXTPMarkupObject* pObject)
{
if (IsStringObject(pObject))
{
LPCWSTR lpszValue = *((CXTPMarkupString*)pObject);
int nLength = ((CXTPMarkupString*)pObject)->GetLength();
if (nLength == 5 && _wcsicmp(lpszValue, L"Miter") == 0) return CXTPMarkupEnum::CreateValue(xtpMarkupLineJoinMiter);
if (nLength == 5 && _wcsicmp(lpszValue, L"Bevel") == 0) return CXTPMarkupEnum::CreateValue(xtpMarkupLineJoinBevel);
if (nLength == 5 && _wcsicmp(lpszValue, L"Round") == 0) return CXTPMarkupEnum::CreateValue(xtpMarkupLineJoinRound);
}
return NULL;
}
//////////////////////////////////////////////////////////////////////////
// CXTPMarkupPointCollection
IMPLEMENT_MARKUPCLASS(NULL, CXTPMarkupPointCollection, CXTPMarkupObject)
void CXTPMarkupPointCollection::RegisterMarkupClass()
{
}
CXTPMarkupPointCollection::CXTPMarkupPointCollection()
{
m_rcBounds.SetRectEmpty();
}
CXTPMarkupPointCollection::CXTPMarkupPointCollection(CPointArray& arr)
{
m_rcBounds.SetRectEmpty();
m_arrPoints.Copy(arr);
int nCount = (int)m_arrPoints.GetSize();
if (nCount > 0)
{
m_rcBounds.SetRect(INT_MAX, INT_MAX, -INT_MAX, -INT_MAX);
for (int i = 0; i < nCount; i++)
{
POINT& pt = m_arrPoints[i];
if (pt.x > m_rcBounds.right) m_rcBounds.right = pt.x;
if (pt.y > m_rcBounds.bottom) m_rcBounds.bottom = pt.y;
if (pt.x < m_rcBounds.left) m_rcBounds.left = pt.x;
if (pt.y < m_rcBounds.top) m_rcBounds.top = pt.y;
}
}
}
BOOL CXTPMarkupPointCollection::GetNextValue(LPCWSTR& lpszValue, int& nValue)
{
while (*lpszValue == ' ') lpszValue++;
LPCWSTR lpszNext = lpszValue;
nValue = 0;
int nSign = 1;
if (*lpszNext == '-')
{
nSign = -1;
lpszNext++;
}
if (*lpszNext == 0)
return FALSE;
while (*lpszNext != 0)
{
WCHAR c = *lpszNext;
if (c == ' ' || c == ',')
{
if (lpszNext == lpszValue)
return FALSE;
lpszNext++;
break;
}
if (c <'0' || c > '9')
return FALSE;
nValue = 10 * nValue + (c - '0');
lpszNext++;
}
lpszValue = lpszNext;
nValue *= nSign;
return TRUE;
}
BOOL CXTPMarkupPointCollection::ConvertFromString(LPCWSTR lpszValue, CPointArray& arr)
{
if (!lpszValue)
return FALSE;
while (*lpszValue != 0)
{
int x, y;
if (!GetNextValue(lpszValue, x))
return FALSE;
if (!GetNextValue(lpszValue, y))
return FALSE;
while (*lpszValue == ' ') lpszValue++;
POINT pt = {x, y};
arr.Add(pt);
}
return TRUE;
}
CXTPMarkupObject* CXTPMarkupPointCollection::ConvertFrom(CXTPMarkupBuilder* /*pBuilder*/, CXTPMarkupObject* pObject) const
{
if (IsStringObject(pObject))
{
CPointArray arr;
if (ConvertFromString(*((CXTPMarkupString*)pObject), arr))
{
return new CXTPMarkupPointCollection(arr);
}
}
return NULL;
}
//////////////////////////////////////////////////////////////////////////
// CXTPMarkupPolygon
CXTPMarkupDependencyProperty* CXTPMarkupPolygon::m_pPointsProperty = NULL;
IMPLEMENT_MARKUPCLASS(L"Polygon", CXTPMarkupPolygon, CXTPMarkupShape)
void CXTPMarkupPolygon::RegisterMarkupClass()
{
m_pPointsProperty = CXTPMarkupDependencyProperty::Register(L"Points", MARKUP_TYPE(CXTPMarkupPointCollection), MARKUP_TYPE(CXTPMarkupPolygon),
new CXTPMarkupPropertyMetadata(NULL, CXTPMarkupPropertyMetadata::flagAffectsMeasure));
}
CXTPMarkupPolygon::CXTPMarkupPolygon()
{
}
CXTPMarkupPolygon::~CXTPMarkupPolygon()
{
}
void CXTPMarkupPolygon::SetPoints(CXTPMarkupPointCollection* pPoints)
{
SetValue(m_pPointsProperty, pPoints);
}
CXTPMarkupPointCollection* CXTPMarkupPolygon::GetPoints() const
{
return MARKUP_STATICCAST(CXTPMarkupPointCollection, GetValue(m_pPointsProperty));
}
CSize CXTPMarkupPolygon::MeasureOverride(CXTPMarkupDrawingContext* /*pDC*/, CSize szAvailableSize)
{
CXTPMarkupPointCollection* pPoints = GetPoints();
if (!pPoints)
return CSize(0, 0);
CRect rcBounds = pPoints->GetBounds();
CSize szBound(max(rcBounds.Width(), rcBounds.right), max(rcBounds.Height(),rcBounds.bottom));
if (GetStretch() != xtpMarkupStretchNone)
{
if (szAvailableSize.cx < INT_MAX)
szBound.cx = szAvailableSize.cx;
if (szAvailableSize.cy < INT_MAX)
szBound.cy = szAvailableSize.cy;
}
return szBound;
}
void CXTPMarkupPolygon::OnRender(CXTPMarkupDrawingContext* pDC)
{
CXTPMarkupStrokeStyle strokeStyle;
GetStrokeStyle(&strokeStyle);
CXTPMarkupBrush* pFillBrush = GetFill();
if (!strokeStyle.pStrokeBrush && !pFillBrush)
return;
CXTPMarkupPointCollection* pPoints = GetPoints();
if (!pPoints)
return;
const CXTPMarkupPointCollection::CPointArray& arr = pPoints->GetPoints();
if (GetStretch() != xtpMarkupStretchNone)
{
CXTPMarkupPointCollection::CPointArray arrStretch;
pPoints->Stretch(arrStretch, GetRenderSize());
pDC->Polygon(arrStretch.GetData(), (int)arrStretch.GetSize(), &strokeStyle, pFillBrush);
}
else
{
pDC->Polygon(arr.GetData(), (int)arr.GetSize(), &strokeStyle, pFillBrush);
}
}
//////////////////////////////////////////////////////////////////////////
// CXTPMarkupPolyline
CXTPMarkupDependencyProperty* CXTPMarkupPolyline::m_pPointsProperty = NULL;
IMPLEMENT_MARKUPCLASS(L"Polyline", CXTPMarkupPolyline, CXTPMarkupShape)
void CXTPMarkupPolyline::RegisterMarkupClass()
{
m_pPointsProperty = CXTPMarkupDependencyProperty::Register(L"Points", MARKUP_TYPE(CXTPMarkupPointCollection), MARKUP_TYPE(CXTPMarkupPolyline),
new CXTPMarkupPropertyMetadata(NULL, CXTPMarkupPropertyMetadata::flagAffectsMeasure));
}
CXTPMarkupPolyline::CXTPMarkupPolyline()
{
}
CXTPMarkupPolyline::~CXTPMarkupPolyline()
{
}
void CXTPMarkupPolyline::SetPoints(CXTPMarkupPointCollection* pPoints)
{
SetValue(m_pPointsProperty, pPoints);
}
CXTPMarkupPointCollection* CXTPMarkupPolyline::GetPoints() const
{
return MARKUP_STATICCAST(CXTPMarkupPointCollection, GetValue(m_pPointsProperty));
}
CSize CXTPMarkupPolyline::MeasureOverride(CXTPMarkupDrawingContext* /*pDC*/, CSize szAvailableSize)
{
CXTPMarkupPointCollection* pPoints = GetPoints();
if (!pPoints)
return CSize(0, 0);
CRect rcBounds = pPoints->GetBounds();
CSize szBound(max(rcBounds.Width(), rcBounds.right), max(rcBounds.Height(),rcBounds.bottom));
if ((szBound.cx == 0 || szBound.cy == 0) && GetStroke())
{
int nStroke = (GetStrokeThickness() + 1) / 2;
if (szBound.cy == 0) szBound.cy += nStroke;
if (szBound.cx == 0) szBound.cx += nStroke;
}
if (GetStretch() != xtpMarkupStretchNone)
{
if (szAvailableSize.cx < INT_MAX)
szBound.cx = szAvailableSize.cx;
if (szAvailableSize.cy < INT_MAX)
szBound.cy = szAvailableSize.cy;
}
return szBound;
}
void CXTPMarkupPointCollection::Stretch(CPointArray& arrStretch, CSize sz)
{
const CPointArray& arr = GetPoints();
arrStretch.Copy(arr);
int nCount = (int)arrStretch.GetSize();
CRect rc = GetBounds();
if (rc.Width() == 0 && rc.Height() == 0)
return;
for (int i = 0; i < nCount; i++)
{
POINT& pt = arrStretch[i];
if (rc.Width() != 0) pt.x = (pt.x - rc.left) * sz.cx / rc.Width();
if (rc.Height() != 0) pt.y = (pt.y - rc.top) * sz.cy / rc.Height();
}
}
void CXTPMarkupPolyline::OnRender(CXTPMarkupDrawingContext* pDC)
{
CXTPMarkupStrokeStyle strokeStyle;
GetStrokeStyle(&strokeStyle);
if (strokeStyle.nStrokeThickness <= 0)
return;
CXTPMarkupPointCollection* pPoints = GetPoints();
if (!pPoints)
return;
const CXTPMarkupPointCollection::CPointArray& arr = pPoints->GetPoints();
if (GetStretch() != xtpMarkupStretchNone)
{
CXTPMarkupPointCollection::CPointArray arrStretch;
pPoints->Stretch(arrStretch, GetRenderSize());
pDC->Polyline(arrStretch.GetData(), (int)arrStretch.GetSize(), &strokeStyle);
}
else
{
pDC->Polyline(arr.GetData(), (int)arr.GetSize(), &strokeStyle);
}
}
//////////////////////////////////////////////////////////////////////////
// CXTPMarkupRectangle
IMPLEMENT_MARKUPCLASS(L"Rectangle", CXTPMarkupRectangle, CXTPMarkupShape)
CXTPMarkupDependencyProperty* CXTPMarkupRectangle::m_pRadiusXProperty = NULL;
CXTPMarkupDependencyProperty* CXTPMarkupRectangle::m_pRadiusYProperty = NULL;
void CXTPMarkupRectangle::RegisterMarkupClass()
{
m_pRadiusXProperty = CXTPMarkupDependencyProperty::Register(L"RadiusX", MARKUP_TYPE(CXTPMarkupInt), MARKUP_TYPE(CXTPMarkupRectangle),
new CXTPMarkupPropertyMetadata(NULL, CXTPMarkupPropertyMetadata::flagAffectsRender));
m_pRadiusYProperty = CXTPMarkupDependencyProperty::Register(L"RadiusY", MARKUP_TYPE(CXTPMarkupInt), MARKUP_TYPE(CXTPMarkupRectangle),
new CXTPMarkupPropertyMetadata(NULL, CXTPMarkupPropertyMetadata::flagAffectsRender));
}
CXTPMarkupRectangle::CXTPMarkupRectangle()
{
}
CXTPMarkupRectangle::~CXTPMarkupRectangle()
{
}
CSize CXTPMarkupRectangle::MeasureOverride(CXTPMarkupDrawingContext* /*pDC*/, CSize szAvailableSize)
{
CSize szBound(0, 0);
if (GetStretch() != xtpMarkupStretchNone)
{
if (szAvailableSize.cx < INT_MAX)
szBound.cx = szAvailableSize.cx;
if (szAvailableSize.cy < INT_MAX)
szBound.cy = szAvailableSize.cy;
}
return szBound;
}
void CXTPMarkupRectangle::OnRender(CXTPMarkupDrawingContext* pDC)
{
CXTPMarkupBrush* pStrokeBrush = GetStroke();
CXTPMarkupBrush* pFillBrush = GetFill();
if (!pStrokeBrush && !pFillBrush)
return;
int nStroke = pStrokeBrush ? GetStrokeThickness() : 0;
CRect rc(0, 0, GetRenderSize().cx, GetRenderSize().cy);
if (rc.Width() == 0 || rc.Height() == 0)
return;
double nRadiusX = GetRadiusX(), nRadiusY = GetRadiusY();
nRadiusX = min((double)(rc.Width() - nStroke) / 2, nRadiusX);
nRadiusY = min((double)(rc.Height() - nStroke) / 2, nRadiusY);
double* pnCorners = NULL;
if (nRadiusX > 0 && nRadiusY > 0)
{
pnCorners = new double[8];
pnCorners[0] = pnCorners[3] = pnCorners[4] = pnCorners[7] = (double)nRadiusY;
pnCorners[1] = pnCorners[2] = pnCorners[5] = pnCorners[6] = (double)nRadiusX;
}
if (pFillBrush)
{
CRect rcFill(rc);
rcFill.DeflateRect(nStroke / 2, nStroke / 2);
pDC->FillRectangle(rcFill, pFillBrush, pnCorners);
}
if (nStroke > 0)
{
CXTPMarkupThickness strokeThickness(nStroke);
pDC->DrawRectangle(rc, pStrokeBrush, &strokeThickness, pnCorners);
}
if (pnCorners) delete[] pnCorners;
}
//////////////////////////////////////////////////////////////////////////
// CXTPMarkupEllipse
IMPLEMENT_MARKUPCLASS(L"Ellipse", CXTPMarkupEllipse, CXTPMarkupShape)
void CXTPMarkupEllipse::RegisterMarkupClass()
{
}
CXTPMarkupEllipse::CXTPMarkupEllipse()
{
}
CXTPMarkupEllipse::~CXTPMarkupEllipse()
{
}
CSize CXTPMarkupEllipse::MeasureOverride(CXTPMarkupDrawingContext* /*pDC*/, CSize szAvailableSize)
{
CSize szBound(0, 0);
if (GetStretch() != xtpMarkupStretchNone)
{
if (szAvailableSize.cx < INT_MAX)
szBound.cx = szAvailableSize.cx;
if (szAvailableSize.cy < INT_MAX)
szBound.cy = szAvailableSize.cy;
}
return szBound;
}
void CXTPMarkupEllipse::OnRender(CXTPMarkupDrawingContext* pDC)
{
CXTPMarkupStrokeStyle strokeStyle;
GetStrokeStyle(&strokeStyle);
CXTPMarkupBrush* pFillBrush = GetFill();
if (!strokeStyle.pStrokeBrush && !pFillBrush)
return;
pDC->Ellipse(CRect(0, 0, GetRenderSize().cx, GetRenderSize().cy), &strokeStyle, pFillBrush);
}
CXTPMarkupInputElement* CXTPMarkupEllipse::InputHitTestOverride(CPoint point) const
{
if (m_szRenderSize.cx < 1 || m_szRenderSize.cy < 1)
return (CXTPMarkupInputElement*)this;
// Determine radii
double a = m_szRenderSize.cx / 2;
double b = m_szRenderSize.cy / 2;
double x = point.x - a;
double y = point.y - b;
return ((x * x) / (a * a) + (y * y) / (b * b) <= 1) ? (CXTPMarkupInputElement*)this : NULL;
}
//////////////////////////////////////////////////////////////////////////
// CXTPMarkupLine
CXTPMarkupDependencyProperty* CXTPMarkupLine::m_pX1Property = NULL;
CXTPMarkupDependencyProperty* CXTPMarkupLine::m_pY1Property = NULL;
CXTPMarkupDependencyProperty* CXTPMarkupLine::m_pX2Property = NULL;
CXTPMarkupDependencyProperty* CXTPMarkupLine::m_pY2Property = NULL;
IMPLEMENT_MARKUPCLASS(L"Line", CXTPMarkupLine, CXTPMarkupShape)
void CXTPMarkupLine::RegisterMarkupClass()
{
m_pX1Property = CXTPMarkupDependencyProperty::Register(L"X1", MARKUP_TYPE(CXTPMarkupInt), MARKUP_TYPE(CXTPMarkupLine),
new CXTPMarkupPropertyMetadata(NULL, CXTPMarkupPropertyMetadata::flagAffectsMeasure));
m_pY1Property = CXTPMarkupDependencyProperty::Register(L"Y1", MARKUP_TYPE(CXTPMarkupInt), MARKUP_TYPE(CXTPMarkupLine),
new CXTPMarkupPropertyMetadata(NULL, CXTPMarkupPropertyMetadata::flagAffectsMeasure));
m_pX2Property = CXTPMarkupDependencyProperty::Register(L"X2", MARKUP_TYPE(CXTPMarkupInt), MARKUP_TYPE(CXTPMarkupLine),
new CXTPMarkupPropertyMetadata(NULL, CXTPMarkupPropertyMetadata::flagAffectsMeasure));
m_pY2Property = CXTPMarkupDependencyProperty::Register(L"Y2", MARKUP_TYPE(CXTPMarkupInt), MARKUP_TYPE(CXTPMarkupLine),
new CXTPMarkupPropertyMetadata(NULL, CXTPMarkupPropertyMetadata::flagAffectsMeasure));
}
CXTPMarkupLine::CXTPMarkupLine()
{
}
CXTPMarkupLine::~CXTPMarkupLine()
{
}
int CXTPMarkupLine::GetX1() const
{
CXTPMarkupInt* pValue = MARKUP_STATICCAST(CXTPMarkupInt, GetValue(m_pX1Property));
return pValue != NULL ? (int)*pValue : 0;
}
int CXTPMarkupLine::GetX2() const
{
CXTPMarkupInt* pValue = MARKUP_STATICCAST(CXTPMarkupInt, GetValue(m_pX2Property));
return pValue != NULL ? (int)*pValue : 0;
}
int CXTPMarkupLine::GetY1() const
{
CXTPMarkupInt* pValue = MARKUP_STATICCAST(CXTPMarkupInt, GetValue(m_pY1Property));
return pValue != NULL ? (int)*pValue : 0;
}
int CXTPMarkupLine::GetY2() const
{
CXTPMarkupInt* pValue = MARKUP_STATICCAST(CXTPMarkupInt, GetValue(m_pY2Property));
return pValue != NULL ? (int)*pValue : 0;
}
CSize CXTPMarkupLine::MeasureOverride(CXTPMarkupDrawingContext* /*pDC*/, CSize szAvailableSize)
{
int x1 = GetX1();
int x2 = GetX2();
int y1 = GetY1();
int y2 = GetY2();
int x = max(x1, x2);
int y = max(y1, y2);
if ((x1 == x2 || y1 == y2) && GetStroke())
{
int nStroke = (GetStrokeThickness() + 1) / 2;
if (x1 == x2) x += nStroke;
if (y1 == y2) y += nStroke;
}
CSize szBound(x, y);
if (GetStretch() != xtpMarkupStretchNone)
{
if (szAvailableSize.cx < INT_MAX)
szBound.cx = szAvailableSize.cx;
if (szAvailableSize.cy < INT_MAX)
szBound.cy = szAvailableSize.cy;
}
return szBound;
}
void CXTPMarkupLine::GetPoints(int& x1, int& y1, int& x2, int& y2) const
{
x1 = GetX1();
x2 = GetX2();
y1 = GetY1();
y2 = GetY2();
if (GetStretch() != xtpMarkupStretchNone)
{
int x = max(x1, x2);
int y = max(y1, y2);
CSize sz = GetRenderSize();
if (x1 == x2)
x1 = x2 = sz.cx / 2;
else
{
x1 = (x1 == x ? sz.cx : 0);
x2 = (x2 == x ? sz.cx : 0);
}
if (y1 == y2)
y1 = y2 = sz.cy / 2;
else
{
y1 = (y1 == y ? sz.cy : 0);
y2 = (y2 == y ? sz.cy : 0);
}
}
}
void CXTPMarkupLine::OnRender(CXTPMarkupDrawingContext* pDC)
{
CXTPMarkupStrokeStyle strokeStyle;
GetStrokeStyle(&strokeStyle);
if (strokeStyle.nStrokeThickness <= 0)
return;
int x1, x2, y1, y2;
GetPoints(x1, y1, x2, y2);
if (x1 == 0 && x2 == 0 && y1 == 0 && y2 == 0)
return;
pDC->DrawLine(x1, y1, x2, y2, &strokeStyle);
}
CXTPMarkupInputElement* CXTPMarkupLine::InputHitTestOverride(CPoint point) const
{
if (!GetStroke())
return NULL;
int nStroke = GetStrokeThickness();
if (nStroke == 0)
return NULL;
int x1, x2, y1, y2;
GetPoints(x1, y1, x2, y2);
double x = x2 - x1;
double y = y2 - y1;
double xp = point.x - x1;
double yp = point.y - y1;
double s = (double)nStroke / 2.0;
if (xp + s < min(x, 0) || xp - s > max(x, 0) || yp + s < min(y, 0) || yp - s > max(y, 0))
return NULL;
if (x == 0)
return fabs(xp) <= s ? (CXTPMarkupInputElement*)this : NULL;
double yStroke = fabs(s / cos(atan(y / x)));
double y0 = y * xp / (double)x;
return fabs(y0 - yp) <= yStroke ? (CXTPMarkupInputElement*)this : NULL;
}