/// <summary>
/// Gets the transformation of this item plus an additional transformation. Both together transform world coordinates to page coordinates.
/// </summary>
/// <param name="additionalTransformation">The additional transformation matrix.</param>
/// <returns></returns>
public MatrixD2D GetTransformation(MatrixD2D additionalTransformation)
{
var result = new MatrixD2D(_transformation);
result.PrependTransform(additionalTransformation);
return(result);
}
public HitTestRectangularData NewFromAdditionalTransformation(MatrixD2D additionalTransformation)
{
var result = new HitTestRectangularData(this);
result.Transformation.PrependTransform(additionalTransformation);
return(result);
}
/// <summary>
/// Returns the hitted point in world coordinated by applying the inverse current coordinate transformation and then the provided inverse coordinate transformation.
/// </summary>
/// <returns>Hitted point in world coordinates.</returns>
public PointD2D GetHittedPointInWorldCoord(MatrixD2D additionalTransform)
{
var result = GetHittedPointInWorldCoord();
result = additionalTransform.InverseTransformPoint(result);
return(result);
}
public bool IsCovering(RectangleD2D rect, MatrixD2D additionalTransform)
{
PointD2D pt;
pt = _transformation.TransformPoint(additionalTransform.TransformPoint(new PointD2D(rect.X, rect.Y)));
if (!_hittedAreaInPageCoord.Contains(pt))
{
return(false);
}
pt = _transformation.TransformPoint(additionalTransform.TransformPoint(new PointD2D(rect.Right, rect.Y)));
if (!_hittedAreaInPageCoord.Contains(pt))
{
return(false);
}
pt = _transformation.TransformPoint(additionalTransform.TransformPoint(new PointD2D(rect.X, rect.Bottom)));
if (!_hittedAreaInPageCoord.Contains(pt))
{
return(false);
}
pt = _transformation.TransformPoint(additionalTransform.TransformPoint(new PointD2D(rect.Right, rect.Bottom)));
if (!_hittedAreaInPageCoord.Contains(pt))
{
return(false);
}
return(true);
}
public RotationGripHandle(IHitTestObject parent, PointD2D relPos, MatrixD2D spanningHalfYRhombus)
{
_parent = parent;
_drawrPosition = relPos;
_fixrPosition = new PointD2D(0.5, 0.5);
_fixaPosition = GraphObject.RelativeLocalToAbsoluteParentCoordinates(_fixrPosition);
_spanningHalfYRhombus = spanningHalfYRhombus;
}
public ShearGripHandle(IHitTestObject parent, PointD2D relPos, MatrixD2D spanningHalfYRhombus)
{
_parent = parent;
_drawrPosition = relPos;
_fixrPosition = new PointD2D(relPos.X == 0 ? 1 : 0, relPos.Y == 0 ? 1 : 0);
_fixaPosition = GraphObject.RelativeToAbsolutePosition(_fixrPosition, true);
_spanningHalfYRhombus = spanningHalfYRhombus;
}
/// <summary>
/// Returns the hitted area in world coordinated by applying the inverse current coordinate transformation.
/// </summary>
/// <returns>Hitted point in world coordinates.</returns>
public MatrixD2D GetHittedAreaInWorldCoord()
{
var pt0 = _transformation.InverseTransformPoint(_hittedAreaInPageCoord.Location);
var pt1 = _transformation.InverseTransformVector(new PointD2D(0, _hittedAreaInPageCoord.Height));
var pt2 = _transformation.InverseTransformPoint(new PointD2D(_hittedAreaInPageCoord.Width, 0));
var result = new MatrixD2D(pt1.X, pt1.Y, pt2.X, pt2.Y, pt0.X, pt0.Y);
return(result);
}
public RescaleGripHandle(IHitTestObject parent, PointD2D relPos, MatrixD2D spanningHalfYRhombus)
{
_parent = parent;
_drawrPosition = relPos;
_drawaPosition = GraphObject.RelativeToAbsolutePosition(_drawrPosition, true);
_fixrPosition = new PointD2D(1 - relPos.X, 1 - relPos.Y);
_fixaPosition = GraphObject.RelativeLocalToAbsoluteParentCoordinates(_fixrPosition);
_spanningHalfYRhombus = spanningHalfYRhombus;
}
/// <summary>
/// Gets the absolute enclosing rectangle, taking into account ScaleX, ScaleY, Rotation and Shear (SSRS).
/// </summary>
/// <returns>The enclosing rectangle in absolute values.</returns>
public RectangleD2D GetAbsoluteEnclosingRectangle()
{
var m = new MatrixD2D();
m.SetTranslationRotationShearxScale(AbsolutePivotPositionX, AbsolutePivotPositionY, -Rotation, ShearX, ScaleX, ScaleY);
m.TranslatePrepend(AbsoluteVectorPivotToLeftUpper.X, AbsoluteVectorPivotToLeftUpper.Y);
var s = AbsoluteSize;
var p1 = m.TransformPoint(new PointD2D(0, 0));
var p2 = m.TransformPoint(new PointD2D(s.X, 0));
var p3 = m.TransformPoint(new PointD2D(0, s.Y));
var p4 = m.TransformPoint(new PointD2D(s.X, s.Y));
var r = new RectangleD2D(p1, PointD2D.Empty);
r.ExpandToInclude(p2);
r.ExpandToInclude(p3);
r.ExpandToInclude(p4);
return(r);
}
/// <summary>
/// Appends a transformation to the transformation matrix of the hit test object. Call this while walking down the hierarchie of objects.
/// </summary>
/// <param name="x">The transformation to append.</param>
public override void Transform(MatrixD2D x)
{
base.Transform(x);
_objectPath.Transform(x);
}
/// <summary>
/// Appends a transformation to the transformation matrix of the hit test object. Call this while walking down the hierarchie of objects.
/// </summary>
/// <param name="x">The transformation to append.</param>
public virtual void Transform(MatrixD2D x)
{
_matrix.AppendTransform(x);
}
/// <summary>
/// Creates a new HitTestObject.
/// </summary>
/// <param name="objectPath">Path of the object outline used for arrangement of multiple objects.
/// This path is in object world coordinates.</param>
/// <param name="transformation">Transformation matrix of the object.</param>
/// <param name="hitobject">The hitted object.</param>
public HitTestObject(GraphicsPath objectPath, MatrixD2D transformation, object hitobject)
: base(hitobject)
{
_objectPath = objectPath;
_objectPath.Transform(transformation);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="hitPointPageCoord">Page coordinates (unit: points).</param>
/// <param name="pageScale">Current zoom factor, i.e. ration between displayed size on the screen and given size.</param>
public HitTestPointData(PointD2D hitPointPageCoord, double pageScale)
{
_hittedPointInPageCoord = hitPointPageCoord;
_pageScale = pageScale;
_transformation = new MatrixD2D();
}
/// <summary>
/// Creates a new HitTestObject.
/// </summary>
/// <param name="hitobject">The hitted object.</param>
public HitTestObjectBase(object hitobject)
{
_hitobject = hitobject;
_matrix = new MatrixD2D();
}
/// <summary>
/// Copy constructor.
/// </summary>
/// <param name="from">Another HitTestData object to copy from.</param>
public HitTestPointData(HitTestPointData from)
{
_hittedPointInPageCoord = from._hittedPointInPageCoord;
_pageScale = from._pageScale;
_transformation = new MatrixD2D(from._transformation);
}
/// <summary>
/// Copy constructor.
/// </summary>
/// <param name="from">Another HitTestData object to copy from.</param>
public HitTestRectangularData(HitTestRectangularData from)
{
_hittedAreaInPageCoord = from._hittedAreaInPageCoord;
_pageScale = from._pageScale;
_transformation = new MatrixD2D(from._transformation);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="hitAreaPageCoord">Page coordinates (unit: points).</param>
/// <param name="pageScale">Current zoom factor, i.e. ration between displayed size on the screen and given size.</param>
public HitTestRectangularData(RectangleD2D hitAreaPageCoord, double pageScale)
{
_hittedAreaInPageCoord = hitAreaPageCoord;
_pageScale = pageScale;
_transformation = new MatrixD2D();
}
/// <summary>
/// Sets the value for translation, roation, shear and scale from a transformation matrix.
/// </summary>
/// <param name="transformation"></param>
public void SetFrom(MatrixD2D transformation)
{
SetTranslationRotationShearxScale(transformation.X, transformation.Y, transformation.Rotation, transformation.Shear, transformation.ScaleX, transformation.ScaleY);
}
public bool IsCovering(PointD2D pt, MatrixD2D additionalTransform)
{
pt = _transformation.TransformPoint(additionalTransform.TransformPoint(pt));
return(_hittedAreaInPageCoord.Contains(pt));
}
