//---------------------------------------------------------------------------------------------------------
/// <summary>
/// Чтение свойств и данных графического примитива из формата атрибутов XML
/// </summary>
/// <param name="prefix">Префикс имени атрибута</param>
/// <param name="xml_reader">Средство чтения данных формата XML</param>
//---------------------------------------------------------------------------------------------------------
public virtual void ReadPrimitivFromAttribute(String prefix, XmlReader xml_reader)
{
mBoundsRect = xml_reader.ReadMathRect2DfFromAttribute(prefix + "BoundsRect");
mZIndex = xml_reader.ReadIntegerFromAttribute(prefix + "ZIndex", mZIndex);
mIsStroked = xml_reader.ReadBooleanFromAttribute(prefix + "IsStroked", mIsStroked);
mIsFilled = xml_reader.ReadBooleanFromAttribute(prefix + "IsFilled", mIsFilled);
}
//---------------------------------------------------------------------------------------------------------
/// <summary>
/// Проверка на попадание ВСЕЙ ГЕОМЕТРИИ графического объекта внутрь прямоугольной области
/// </summary>
/// <param name="rect">Прямоугольник</param>
/// <returns>Статус проверки</returns>
//---------------------------------------------------------------------------------------------------------
public override Boolean CheckInsideRect(ref Rect2Df rect)
{
return(rect.Contains(BoundsRect.PointTopLeft) &&
rect.Contains(BoundsRect.PointTopRight) &&
rect.Contains(BoundsRect.PointBottomLeft) &&
rect.Contains(BoundsRect.PointBottomRight));
}
//---------------------------------------------------------------------------------------------------------
/// <summary>
/// Проверка на попадание ВСЕЙ ИЛИ ЧАСТИ ГЕОМЕТРИИ графического объекта внутрь прямоугольной области
/// </summary>
/// <param name="rect">Прямоугольник</param>
/// <returns>Статус проверки</returns>
//---------------------------------------------------------------------------------------------------------
public override Boolean CheckInsideOrIntersectRect(ref Rect2Df rect)
{
return(rect.Contains(mPrimitive.BoundsRect.PointTopLeft) ||
rect.Contains(mPrimitive.BoundsRect.PointTopRight) ||
rect.Contains(mPrimitive.BoundsRect.PointBottomLeft) ||
rect.Contains(mPrimitive.BoundsRect.PointBottomRight));
}
//---------------------------------------------------------------------------------------------------------
/// <summary>
/// Вычисление базовой точки отрисовки текста
/// </summary>
/// <param name="id">Идентификатор текста</param>
/// <param name="h_align">Вертикальное выравнивание</param>
/// <param name="v_align">Горизонтальное выравнивание</param>
/// <param name="rect">Прямоугольник</param>
/// <returns>Базовая точка</returns>
//---------------------------------------------------------------------------------------------------------
public Vector2Df ComputeTextIDPoint(Int32 id, TCadTextHorizontalAlignment h_align,
TCadTextVerticalAlignment v_align, Rect2Df rect)
{
Vector2Df point = Vector2Df.Zero;
return(point);
}
//---------------------------------------------------------------------------------------------------------
/// <summary>
/// Проверка на попадание ВСЕЙ ИЛИ ЧАСТИ ГЕОМЕТРИИ графического объекта внутрь прямоугольной области
/// </summary>
/// <param name="rect">Прямоугольник</param>
/// <returns>Статус проверки</returns>
//---------------------------------------------------------------------------------------------------------
public virtual Boolean CheckInsideOrIntersectRect(ref Rect2Df rect)
{
return(rect.Contains(mBoundsRect.PointTopLeft) ||
rect.Contains(mBoundsRect.PointTopRight) ||
rect.Contains(mBoundsRect.PointBottomLeft) ||
rect.Contains(mBoundsRect.PointBottomRight));
}
//---------------------------------------------------------------------------------------------------------
/// <summary>
/// Трансформирование прямоугольника
/// </summary>
/// <param name="rect">Исходный прямоугольник</param>
/// <returns>Трансформированый прямоугольник </returns>
//---------------------------------------------------------------------------------------------------------
public Rect2Df TransformBounds(Rect2Df rect)
{
#if USE_WINDOWS
Rect2Df result = new Rect2Df(mWindowsTransform.TransformBounds(rect));
return(result);
#endif
return(Rect2Df.Default);
}
//---------------------------------------------------------------------------------------------------------
/// <summary>
/// Копирование параметров с графического примитива
/// </summary>
/// <param name="primitiv">Графический примитив</param>
//---------------------------------------------------------------------------------------------------------
public virtual void CopyParamemtrs(CCadPrimitive primitiv)
{
mBoundsRect = primitiv.mBoundsRect;
mZIndex = primitiv.mZIndex;
mIsStroked = primitiv.mIsStroked;
mIsFilled = primitiv.mIsFilled;
mStroke = primitiv.mStroke;
mFill = primitiv.mFill;
}
//---------------------------------------------------------------------------------------------------------
/// <summary>
/// Конструктор копирования
/// </summary>
/// <param name="source">Источник копии</param>
//---------------------------------------------------------------------------------------------------------
public CCadObject(CCadObject source)
{
mName = source.Name;
//mGroup = source.Group;
//mID = GenerateID();
mIsCanvas = false;
mIsPrinting = source.IsPrinting;
mZIndex = source.ZIndex;
mBoundsRect = source.mBoundsRect;
}
//---------------------------------------------------------------------------------------------------------
/// <summary>
/// Рисование прямоугольника ручки
/// </summary>
/// <param name="rect">Прямоугольник ручки</param>
/// <param name="is_selected">Статус выбора фигуры</param>
//---------------------------------------------------------------------------------------------------------
public void DrawHandleRect(ref Rect2Df rect, Boolean is_selected)
{
if (is_selected)
{
//mDrawingDevice.FillRectangle(XCadBrushManager.Red.DrawingBrush, rect);
}
else
{
mCurrentPen.Width = 2 * mCanvasViewer.ZoomInverse;
//mDrawingDevice.DrawRectangle(mCurrentPen, rect);
}
}
//---------------------------------------------------------------------------------------------------------
/// <summary>
/// Рисование эллипса
/// </summary>
/// <param name="rect">Прямоугольник</param>
/// <param name="brush">Кисть для отрисовки</param>
/// <param name="thickness">Толщина линии</param>
//---------------------------------------------------------------------------------------------------------
public void DrawEllipse(ref Rect2Df rect, CCadBrush brush, Single thickness = 1.0f)
{
Brush old_brush = mCurrentPen.Brush;
Single old_thickness = mCurrentPen.Width;
mCurrentPen.Brush = brush.DrawingBrush;
mCurrentPen.Width = thickness;
//mDrawingDevice.DrawEllipse(mCurrentPen, rect);
mCurrentPen.Brush = old_brush;
mCurrentPen.Width = old_thickness;
}
//---------------------------------------------------------------------------------------------------------
/// <summary>
/// Обновление данных дуги
/// </summary>
//---------------------------------------------------------------------------------------------------------
public override void Update()
{
using (StreamGeometryContext sgc = mGeometryArc.Open())
{
sgc.BeginFigure(mStartPoint, mIsFilled, mIsClosed);
sgc.ArcTo(mEndPoint, new Size(mRadiusX, mRadiusY), mRotationAngle, mIsLargeArc,
mIsClockwiseDirection ? SweepDirection.Clockwise : SweepDirection.Counterclockwise, mIsStroked, true);
sgc.Close();
}
mBoundsRect = new Rect2Df(mGeometryArc.Bounds);
}
//---------------------------------------------------------------------------------------------------------
/// <summary>
/// Рисование дуги
/// </summary>
//---------------------------------------------------------------------------------------------------------
public override void Draw()
{
if (!mIsVisibleElement)
{
return;
}
mPrimitive.Draw();
if (mIsSelect)
{
for (Int32 i = 0; i < mHandleRects.Count; i++)
{
XCadManager.Canvas.DrawHandleRect(mHandleRects[i], mHandleIndex == i);
}
Rect2Df rect = mPrimitive.BoundsRect;
XCadManager.Canvas.DrawRectangle(ref rect);
}
}
//---------------------------------------------------------------------------------------------------------
/// <summary>
/// Конструктор инициализирует объект класса указанными параметрами
/// </summary>
/// <param name="rect">Прямоугольник</param>
//---------------------------------------------------------------------------------------------------------
public CCadDirect2DPrimitiveRect(Rect2Df rect)
{
mBoundsRect = rect;
}
//---------------------------------------------------------------------------------------------------------
/// <summary>
/// Создание прямоугольника с указанными параметрами
/// </summary>
/// <param name="rect">Прямоугольник</param>
/// <returns>Геометрический примитив прямоугольника</returns>
//---------------------------------------------------------------------------------------------------------
public CCadPrimitiveRect CreateRect(Rect2Df rect)
{
return(new CCadDrawingPrimitiveRect(rect));
}
//---------------------------------------------------------------------------------------------------------
/// <summary>
/// Конструктор инициализирует объект класса указанными параметрами
/// </summary>
/// <param name="rect">Прямоугольник</param>
//---------------------------------------------------------------------------------------------------------
public CCadWindowsPrimitiveRect(Rect2Df rect)
{
mBoundsRect = rect;
}
//---------------------------------------------------------------------------------------------------------
/// <summary>
/// Вычисление ограничивающего прямоугольника графического примитива
/// </summary>
/// <param name="dest_bounds_rect">Прямоугольник</param>
//---------------------------------------------------------------------------------------------------------
public override void ComputeBounds(ref Rect2Df dest_bounds_rect)
{
dest_bounds_rect = mBoundsRect;
}
//---------------------------------------------------------------------------------------------------------
/// <summary>
/// Преобразование прямоугольника WPF прямоугольник RawRectangle
/// </summary>
/// <param name="rect">Прямоугольника WPF</param>
/// <returns>Прямоугольник RawRectangle</returns>
//---------------------------------------------------------------------------------------------------------
public static RawRectangleF ToRawRectF(this Rect2Df rect)
{
return(new RawRectangleF(rect.X, rect.Y, rect.Right, rect.Bottom));
}
//---------------------------------------------------------------------------------------------------------
/// <summary>
/// Рисование эллипса
/// </summary>
/// <param name="rect">Прямоугольник</param>
/// <param name="stroke">Перо для отображения</param>
//---------------------------------------------------------------------------------------------------------
public void DrawEllipse(ref Rect2Df rect, CCadPen stroke)
{
//mDrawingDevice.DrawEllipse(stroke.DrawingPen, rect);
}
//---------------------------------------------------------------------------------------------------------
/// <summary>
/// Конструктор инициализирует объект класса указанными параметрами
/// </summary>
/// <param name="rect">Прямоугольник</param>
//---------------------------------------------------------------------------------------------------------
public CCadDrawingPrimitiveRect(Rect2Df rect)
{
mBoundsRect = rect;
}
//---------------------------------------------------------------------------------------------------------
/// <summary>
/// Обновление данных геометрии
/// </summary>
//---------------------------------------------------------------------------------------------------------
public override void Update()
{
using (StreamGeometryContext sgc = mGeometry.Open())
{
CCadSegment current_figure = mSegments[0];
sgc.BeginFigure(current_figure.BasePoint, current_figure.IsFilled, current_figure.IsClosed);
Int32 current_new_figure = 0;
for (Int32 i = 0; i < mSegments.Count; i++)
{
CCadSegment current_segment = mSegments[i];
// Если новая фигура
if (current_segment.IsNewFigure && current_new_figure != i)
{
// Закрывает текущую фигуру
// Открываем новую фигуру
sgc.BeginFigure(current_segment.BasePoint, current_segment.IsFilled, current_segment.IsClosed);
current_figure = current_segment;
current_new_figure = i;
}
switch (current_segment.SegmentType)
{
case TCadSegmentType.Points:
{
CCadSegmentPoints points = current_segment as CCadSegmentPoints;
sgc.PolyLineTo(points.Points.ConvertToWindowsPoints(), mIsStroked, true);
}
break;
case TCadSegmentType.Line:
{
CCadSegmentLine line = current_segment as CCadSegmentLine;
sgc.LineTo(line.EndPoint, mIsStroked, true);
}
break;
case TCadSegmentType.Arc:
{
CCadSegmentArc arc = current_segment as CCadSegmentArc;
sgc.ArcTo(arc.EndPoint, new Size(arc.RadiusX, arc.RadiusY),
arc.RotationAngle, arc.IsLargeArc, arc.IsClockwiseDirection ? SweepDirection.Clockwise :
SweepDirection.Counterclockwise, mIsStroked, true);
}
break;
case TCadSegmentType.Bezier:
break;
default:
break;
}
}
// Закрывает текущую фигуру
sgc.Close();
}
mBoundsRect = new Rect2Df(mGeometry.Bounds);
}
//---------------------------------------------------------------------------------------------------------
/// <summary>
/// Рисование прямоугольника с параметрами отображения по умолчанию
/// </summary>
/// <param name="rect">Прямоугольник</param>
//---------------------------------------------------------------------------------------------------------
public void DrawRectangle(ref Rect2Df rect)
{
//mDrawingDevice.DrawRectangle(mCurrentPen, rect);
}
//---------------------------------------------------------------------------------------------------------
/// <summary>
/// Вычисление ограничивающего прямоугольника графического примитива
/// </summary>
/// <param name="dest_bounds_rect">Прямоугольник</param>
//---------------------------------------------------------------------------------------------------------
public virtual void ComputeBounds(ref Rect2Df dest_bounds_rect)
{
}
//---------------------------------------------------------------------------------------------------------
/// <summary>
/// Проверка на попадание ВСЕЙ ГЕОМЕТРИИ графического объекта внутрь прямоугольной области
/// </summary>
/// <param name="rect">Прямоугольник</param>
/// <returns>Статус проверки</returns>
//---------------------------------------------------------------------------------------------------------
public override Boolean CheckInsideRect(ref Rect2Df rect)
{
return(rect.Contains(ref mStartPoint) && rect.Contains(ref mEndPoint));
}
//---------------------------------------------------------------------------------------------------------
/// <summary>
/// Рисование эллипса с параметрами отображения по умолчанию
/// </summary>
/// <param name="rect">Прямоугольник</param>
//---------------------------------------------------------------------------------------------------------
public void DrawEllipse(ref Rect2Df rect)
{
//mDrawingDevice.DrawEllipse(mCurrentPen, rect);
}
//---------------------------------------------------------------------------------------------------------
/// <summary>
/// Вычисление ограничивающего прямоугольника графического примитива
/// </summary>
/// <param name="dest_bounds_rect">Прямоугольник</param>
//---------------------------------------------------------------------------------------------------------
public override void ComputeBounds(ref Rect2Df dest_bounds_rect)
{
dest_bounds_rect = new Rect2Df(mGeometry.Bounds);
}
//---------------------------------------------------------------------------------------------------------
/// <summary>
/// Проверка на попадание ВСЕЙ ИЛИ ЧАСТИ ГЕОМЕТРИИ графического объекта внутрь прямоугольной области
/// </summary>
/// <param name="rect">Прямоугольник</param>
/// <returns>Статус проверки</returns>
//---------------------------------------------------------------------------------------------------------
public override Boolean CheckInsideOrIntersectRect(ref Rect2Df rect)
{
return(rect.Contains(ref mStartPoint) || rect.Contains(Location) || rect.Contains(ref mEndPoint));
}
public static List <ICollisionable> QueryArea(Rect2Df area)
{
List <ICollisionable> results = new List <ICollisionable>();
return(results);
}
//---------------------------------------------------------------------------------------------------------
/// <summary>
/// Перевод прямоугольника в аппаратно-независимых единицах в миллиметры
/// </summary>
/// <param name="device_unit">Прямоугольник в аппаратно-независимых единицах</param>
/// <returns>Прямоугольник в миллиметрах</returns>
//---------------------------------------------------------------------------------------------------------
public static Rect2Df ToMilliliters(ref Rect2Df device_unit)
{
return(new Rect2Df(device_unit.X * UnitToMM, device_unit.Y * UnitToMM,
device_unit.Width * UnitToMM, device_unit.Height * UnitToMM));
}
//---------------------------------------------------------------------------------------------------------
/// <summary>
/// Перевод прямоугольника в миллиметрах в аппаратно-независимые единицы
/// </summary>
/// <param name="millimeter">Прямоугольник в миллиметрах</param>
/// <returns>Прямоугольник в аппаратно-независимых единицах</returns>
//---------------------------------------------------------------------------------------------------------
public static Rect2Df ToDeviceUnits(ref Rect2Df millimeter)
{
return(new Rect2Df(millimeter.X * MMToUnit, millimeter.Y * MMToUnit,
millimeter.Width * MMToUnit, millimeter.Height * MMToUnit));
}
//---------------------------------------------------------------------------------------------------------
/// <summary>
/// Преобразование прямоугольника WPF прямоугольник RawRectangle
/// </summary>
/// <param name="rect">Прямоугольника WPF</param>
/// <returns>Прямоугольник RawRectangle</returns>
//---------------------------------------------------------------------------------------------------------
public static RawRectangle ToRawRect(this Rect2Df rect)
{
return(new RawRectangle((Int32)rect.X, (Int32)rect.Y, (Int32)rect.Right, (Int32)rect.Bottom));
}
