private void DrawActor(IDrawingCanvas drawingCanvas, ActorVisualElement actor, double offsetY)
{
Rect box = new Rect(actor.OffsetX, offsetY, m_actorsWidth, m_actorsHeight);
actor.Text.SetForegroundBrush(ActorForeground);
DrawTextBox(drawingCanvas, box, actor.Text, ActorBackground, ActorBorder, s_actorMargin, s_actorPadding, true);
}
/// <summary>
/// Initializes a new instance of the <see cref="ISvgRenderer"/> class.
/// </summary>
public SvgRenderer(GraphicsRenderContext context, RectangleF bounds)
{
_innerGraphics = context.Canvas;
_bounds = bounds;
_innerGraphics.PushState();
_innerGraphics.IntersectClip(bounds);
}
private void DrawActors(IDrawingCanvas drawingCanvas)
{
if (m_actorVisualElements == null)
{
return;
}
foreach (var actor in m_actorVisualElements)
{
// Vertical line
double x = GetCenterX(actor) + actor.OffsetX;
drawingCanvas.DrawLine(
x, m_actorsHeight / 2,
x, m_annotationsBottom + m_actorsHeight / 2,
SequenceLineType.Solid,
SequenceArrowType.None
);
// Top box
DrawActor(drawingCanvas, actor, 0);
// Bottom box
DrawActor(drawingCanvas, actor, m_annotationsBottom);
}
}
private void DrawTextBox(IDrawingCanvas drawingCanvas, Rect box, FormattedText text, Brush backgroundBrush, Brush borderBrush, Thickness margin, Thickness padding, bool alignCenter)
{
var x = box.X + margin.Left;
var y = box.Y + margin.Top;
var w = box.Width - margin.Left - margin.Right;
var h = box.Height - margin.Top - margin.Bottom;
// Draw inner box
Rect rect = new Rect(x, y, w, h);
drawingCanvas.DrawRectangle(backgroundBrush, new Pen(borderBrush, 1), rect);
// Draw text (in the center)
if (alignCenter)
{
x = GetCenterX(box);
y += padding.Top;
text.TextAlignment = TextAlignment.Center;
}
else
{
x += padding.Left;
y += padding.Top;
text.TextAlignment = TextAlignment.Left;
}
drawingCanvas.DrawText(x, y, text);
}
protected override QueueDrawer <ICanvasBrush?> CreateDrawerInternal(IDrawingCanvas resourceCreator, Dissolver dissolver)
{
_drawer = new Drawers.OverlayDrawer(dissolver);
_drawer.Shape = CreateOverlayMask(resourceCreator);
return(_drawer);
}
/// <summary>
/// Renders a calendar content range to the canvas.
/// </summary>
/// <param name="content">the content to render</param>
/// <param name="canvas">the drawing canvas to use</param>
/// <param name="rect">the calendar rectangle</param>
public void Render(CalendarContentRange content, IDrawingCanvas canvas, RectangleF rect)
{
if (content == null)
{
throw new ArgumentNullException("content");
}
if (canvas == null)
{
throw new ArgumentNullException("canvas");
}
_calendarData = new CalendarData((ICalendar)content.Owner);
this._rightToLeft = ((ICalendar)content.Owner).Direction == Direction.RTL;
try
{
// store the canvas to use in rendering
_canvas = canvas;
// TODO: consider to add gaps
// allocate the area for calendar drawing
_calendarArea = rect;
// allocate the area for only one month
_monthArea = new SizeF(content.Owner.Width.ToTwips(), content.Owner.Height.ToTwips());
DrawMonths(CalendarData.GetMonthsRange(content.MonthFrom, content.MonthTo));
}
finally
{
if (_calendarData != null)
{
_calendarData.Dispose();
}
}
}
private void DrawSelfSignal(IDrawingCanvas drawingCanvas, SignalVisualElement signal)
{
// Actor line position
double aX = GetCenterX(signal.ActorA) + signal.ActorA.OffsetX;
// Left and right edges of self-signal line
double x1 = aX;
double x2 = x1 + s_selfSignalWidth;
// Top and bottom of self-signal line
double y1 = signal.OffsetY + s_signalMargin.Top;
double y2 = signal.OffsetY + signal.TextBB.Height - s_signalMargin.Bottom;
// Position of signal text
double x = x2 + s_signalPadding.Left;
double y = y1 + s_signalPadding.Top;
// Draw the text so that its left edge is along the vertical segment of the self-signal
signal.Text.TextAlignment = TextAlignment.Left;
signal.Text.SetForegroundBrush(SignalForeground);
drawingCanvas.DrawText(x, y, signal.Text);
// Draw three lines, the last one with an arrow
drawingCanvas.DrawLine(x1, y1, x2, y1, signal.LineType, SequenceArrowType.None);
drawingCanvas.DrawLine(x2, y1, x2, y2, signal.LineType, SequenceArrowType.None);
drawingCanvas.DrawLine(x2, y2, x1, y2, signal.LineType, signal.ArrowType);
}
public void CalendarRenderWithNoDataBound()
{
PageDocument report = TestHelper.GetReport("Calendar-NoData.rdlx");
TestingRenderingExtension rendererExt = new TestingRenderingExtension();
report.Render(rendererExt, null);
CalendarDataRegion calendar = rendererExt.GetReportItem("Calendar1") as CalendarDataRegion;
Assert.IsNotNull(calendar);
CalendarData calendarData = new CalendarData(calendar);
CalendarContentRange content = new CalendarContentRange(calendar, calendarData.GetFirstMonth(), calendarData.GetLastMonth());
// recalibrate graphics to twips
RectangleF rect = new RectangleF(0, 0, 4000f, 4000f);
CalendarDesigner.ScaleToTwipsGraphicsAndBound(GetGraphics(), ref rect);
// create gdi canvas wrapper to use in renderer
IDrawingCanvas canvas = GraphicsCanvasFactory.Create(GetGraphics());
// render calendar to canvas
CalendarRenderer.Instance.Render(content, canvas, rect);
}
public Rect GetRectangle(IDrawingCanvas canvas)
{
return(new Rect(
Rect.X * canvas.Size.Height + canvas.Center.X * canvas.Size.Width,
Rect.Y * canvas.Size.Height + canvas.Center.Y * canvas.Size.Height,
Rect.Width * canvas.Size.Height,
Rect.Height * canvas.Size.Height));
}
private void DrawNotes(IDrawingCanvas drawingCanvas)
{
if (m_noteVisualElements == null)
{
return;
}
foreach (var note in m_noteVisualElements)
{
DrawNote(drawingCanvas, note);
}
}
protected override void OnRender(DrawingContext drawingContext)
{
base.OnRender(drawingContext);
using (IDrawingCanvas drawingCanvas = CreateDrawingCanvas(drawingContext))
{
// Draw our sequence
DrawActors(drawingCanvas);
DrawSignals(drawingCanvas);
DrawNotes(drawingCanvas);
}
}
/// <summary>
/// Draws the rectangle by the pen on the canvas.
/// </summary>
private static void DrawRectangle(IDrawingCanvas canvas, PenEx pen, float x, float y, float width, float height)
{
PointF[] polygon = new[]
{
new PointF(x, y),
new PointF(x + width, y),
new PointF(x + width, y + height),
new PointF(x, y + height),
new PointF(x, y),
};
canvas.DrawPolygon(pen, polygon);
}
private void RenderAction(Appointment appointment, IDrawingCanvas canvas, RectangleF area)
{
if (appointment.Action == null)
{
return;
}
int pageNumber = (_layoutArea != null && _layoutArea.Page != null) ? _layoutArea.Page.PageNumber : 1;
var canvasEx = canvas as IDrawingCanvasEx;
if (canvasEx != null)
{
canvasEx.RenderAction(appointment.Action, area, pageNumber);
}
}
private void DrawSignal(IDrawingCanvas drawingCanvas, SignalVisualElement signal)
{
double aX = GetCenterX(signal.ActorA) + signal.ActorA.OffsetX;
double bX = GetCenterX(signal.ActorB) + signal.ActorB.OffsetX;
// Mid-point between actors
double x = (bX + aX) / 2;
double y = signal.OffsetY + s_signalMargin.Top + s_signalPadding.Top;
// Draw the text in the middle of the signal
signal.Text.TextAlignment = TextAlignment.Center;
signal.Text.SetForegroundBrush(SignalForeground);
drawingCanvas.DrawText(x, y, signal.Text);
// Draw the line along the bottom of the signal
y = signal.OffsetY + signal.TextBB.Height - s_signalMargin.Bottom;
drawingCanvas.DrawLine(aX, y, bX, y, signal.LineType, signal.ArrowType);
}
private void DrawNote(IDrawingCanvas drawingCanvas, NoteVisualElement note)
{
var actorA = note.Actors[0];
double aX = GetCenterX(actorA) + actorA.OffsetX;
double x = 0;
double width = note.TextBB.Width;
switch (note.Placement)
{
case SequenceNotePlacement.RightOf:
x = aX;
break;
case SequenceNotePlacement.LeftOf:
x = aX - note.TextBB.Width;
break;
case SequenceNotePlacement.Over:
if (note.Actors.Length > 1)
{
double bX = GetCenterX(note.Actors[1]) + note.Actors[1].OffsetX;
double overlapLeft = s_noteOverlap.Left + s_noteMargin.Left;
double overlapRight = s_noteOverlap.Right + s_noteMargin.Right;
x = Math.Min(aX, bX) - overlapLeft;
width = Math.Max(aX, bX) + overlapRight - x;
}
else
{
x = aX - note.TextBB.Width / 2;
}
break;
default:
throw new NotSupportedException($"Unhandled note placement: {note.Placement}");
}
// Draw note
Rect box = new Rect(x, note.OffsetY, width, note.TextBB.Height);
note.Text.SetForegroundBrush(NoteForeground);
DrawTextBox(drawingCanvas, box, note.Text, NoteBackground, NoteBorder, s_noteMargin, s_notePadding, false);
}
private void DrawSignals(IDrawingCanvas drawingCanvas)
{
if (m_signalVisualElements == null)
{
return;
}
foreach (var signal in m_signalVisualElements)
{
if (signal.IsSelfSignal)
{
DrawSelfSignal(drawingCanvas, signal);
}
else
{
DrawSignal(drawingCanvas, signal);
}
}
}
private CanvasGeometry?CreateOverlayMask(IDrawingCanvas sender)
{
var _canvas = sender;
if (_canvas == null)
{
return(null);
}
return(CanvasGeometry
.CreateCircle(sender, _canvas.Center.ToVector2() * _canvas.Size.ToVector2(), (float)(OuterRadius * _canvas.Size.Height))
.CombineWith(
CanvasGeometry.CreateRectangle(sender, Bounds.GetRectangle(_canvas)),
Matrix3x2.Identity,
CanvasGeometryCombine.Intersect)
.CombineWith(
CanvasGeometry.CreateCircle(sender, _canvas.Center.ToVector2() * _canvas.Size.ToVector2(), (float)(InnerRadius * _canvas.Size.Height)),
Matrix3x2.Identity,
CanvasGeometryCombine.Exclude
));
}
/// <summary>
/// Creates the pen to draw by specifed line style.
/// </summary>
public static PenEx CreatePen(IDrawingCanvas canvas, LineStyle style)
{
PenEx pen = canvas.CreatePen(style.LineColor, style.LineWidth.ToTwips());
switch (style.DashStyle)
{
case BorderStyle.None:
pen.Color = Color.FromArgb(0, 0, 0, 0); // Transparent color
break;
case BorderStyle.Dotted:
pen.DashStyle = PenStyleEx.Dot;
pen.StartCap = LineCap.Round;
pen.EndCap = LineCap.Round;
break;
case BorderStyle.Dashed:
pen.DashStyle = PenStyleEx.Dash;
break;
}
return(pen);
}
/// <summary>
/// Renders a calendar content range to the canvas. It is used from the calendar designer.
/// </summary>
public void Render(ICalendar calendar, MonthInfo month, IDrawingCanvas canvas, RectangleF rect)
{
if (calendar == null)
{
throw new ArgumentNullException("calendar");
}
if (month == null)
{
throw new ArgumentNullException("month");
}
if (canvas == null)
{
throw new ArgumentNullException("canvas");
}
_calendarData = new CalendarData(calendar);
this._rightToLeft = calendar.Direction == Direction.RTL;
try
{
// store the canvas to use in rendering
_canvas = canvas;
// TODO: consider to add gaps
// allocate the area for calendar drawing
_calendarArea = rect;
// allocate the area for only one month
_monthArea = new SizeF(rect.Width, rect.Height);
DrawMonths(CalendarData.GetMonthsRange(month, month));
}
finally
{
if (_calendarData != null)
{
_calendarData.Dispose();
}
}
}
public abstract Task <IDrawer> CreateDrawerAsync(IDrawingCanvas canvas, Dissolver dissolver);
protected override QueueDrawer <ICanvasImage?> CreateDrawerInternal(IDrawingCanvas resourceCreator, Dissolver dissolver)
{
return(new Drawers.BackgroundDrawer(dissolver));
}
public Rect GetRectangle(IDrawingCanvas canvas)
{
return(new Rect(new Point(), canvas.Size));
}
public Dissolver(IDrawingCanvas canvas)
{
_canvas = canvas;
canvas.PropertyChanged += canvasChanged;
}