/// <summary>
/// Renders the matrix code.
/// </summary>
protected internal override void Render(XGraphics gfx, XBrush brush, XPoint position)
{
XGraphicsState state = gfx.Save();
switch (Direction)
{
case CodeDirection.RightToLeft:
gfx.RotateAtTransform(180, position);
break;
case CodeDirection.TopToBottom:
gfx.RotateAtTransform(90, position);
break;
case CodeDirection.BottomToTop:
gfx.RotateAtTransform(-90, position);
break;
}
XPoint pos = position + CalcDistance(Anchor, AnchorType.TopLeft, Size);
if (MatrixImage == null)
MatrixImage = DataMatrixImage.GenerateMatrixImage(Text, Encoding, Rows, Columns);
if (QuietZone > 0)
{
XSize sizeWithZone = new XSize(Size.Width, Size.Height);
sizeWithZone.Width = sizeWithZone.Width / (Columns + 2 * QuietZone) * Columns;
sizeWithZone.Height = sizeWithZone.Height / (Rows + 2 * QuietZone) * Rows;
XPoint posWithZone = new XPoint(pos.X, pos.Y);
posWithZone.X += Size.Width / (Columns + 2 * QuietZone) * QuietZone;
posWithZone.Y += Size.Height / (Rows + 2 * QuietZone) * QuietZone;
gfx.DrawRectangle(XBrushes.White, pos.X, pos.Y, Size.Width, Size.Height);
gfx.DrawImage(MatrixImage, posWithZone.X, posWithZone.Y, sizeWithZone.Width, sizeWithZone.Height);
}
else
gfx.DrawImage(MatrixImage, pos.X, pos.Y, Size.Width, Size.Height);
gfx.Restore(state);
}
private static XPoint DrawLineArrowInternal(XGraphics gfx, XPen pen, XSolidBrush brush, double x, double y, double angle, Core2D.Style.ArrowStyle style)
{
XPoint pt;
var rt = new XMatrix();
var c = new XPoint(x, y);
rt.RotateAtPrepend(angle, c);
double rx = style.RadiusX;
double ry = style.RadiusY;
double sx = 2.0 * rx;
double sy = 2.0 * ry;
switch (style.ArrowType)
{
default:
case Core2D.Style.ArrowType.None:
{
pt = new XPoint(x, y);
}
break;
case Core2D.Style.ArrowType.Rectangle:
{
pt = rt.Transform(new XPoint(x - sx, y));
var rect = new XRect(x - sx, y - ry, sx, sy);
gfx.Save();
gfx.RotateAtTransform(angle, c);
DrawRectangleInternal(gfx, brush, pen, style.IsStroked, style.IsFilled, ref rect);
gfx.Restore();
}
break;
case Core2D.Style.ArrowType.Ellipse:
{
pt = rt.Transform(new XPoint(x - sx, y));
gfx.Save();
gfx.RotateAtTransform(angle, c);
var rect = new XRect(x - sx, y - ry, sx, sy);
DrawEllipseInternal(gfx, brush, pen, style.IsStroked, style.IsFilled, ref rect);
gfx.Restore();
}
break;
case Core2D.Style.ArrowType.Arrow:
{
pt = rt.Transform(new XPoint(x, y));
var p11 = rt.Transform(new XPoint(x - sx, y + sy));
var p21 = rt.Transform(new XPoint(x, y));
var p12 = rt.Transform(new XPoint(x - sx, y - sy));
var p22 = rt.Transform(new XPoint(x, y));
DrawLineInternal(gfx, pen, style.IsStroked, ref p11, ref p21);
DrawLineInternal(gfx, pen, style.IsStroked, ref p12, ref p22);
}
break;
}
return(pt);
}
void Box(XGraphics gfx, XRect rect, double startAngle, double sweepAngle)
{
double xc = rect.X + rect.Width / 2;
double yc = rect.Y + rect.Height / 2;
double a = startAngle * 0.017453292519943295;
double b = (startAngle + sweepAngle) * 0.017453292519943295;
XGraphicsState state = gfx.Save();
gfx.IntersectClip(rect);
#if true
#if true_
for (double deg = 0; deg < 360; deg += 10)
{
gfx.DrawLine(XPens.Yellow, xc, yc,
(xc + rect.Width / 2 * Math.Cos(deg * 0.017453292519943295)),
(yc + rect.Height / 2 * Math.Sin(deg * 0.017453292519943295)));
}
#endif
double f = Math.Max(rect.Width / 2, rect.Height / 2);
for (double deg = 0; deg < 360; deg += 10)
{
gfx.DrawLine(XPens.Goldenrod, xc, yc,
(xc + f * Math.Cos(deg * 0.017453292519943295)),
(yc + f * Math.Sin(deg * 0.017453292519943295)));
}
gfx.DrawLine(XPens.PaleGreen, xc, rect.Y, xc, rect.Y + rect.Height);
gfx.DrawLine(XPens.PaleGreen, rect.X, yc, rect.X + rect.Width, yc);
//gfx.DrawLine(XPens.DarkGray, xc, yc, (xc + rect.Width / 2 * Math.Cos(a)), (yc + rect.Height / 2 * Math.Sin(a)));
//gfx.DrawLine(XPens.DarkGray, xc, yc, (xc + rect.Width / 2 * Math.Cos(b)), (yc + rect.Height / 2 * Math.Sin(b)));
#endif
gfx.Restore(state);
gfx.DrawRectangle(properties.Pen1.Pen, rect);
}
private static void DrawQrCode(int imageSize, int qrCodeSize, int offsetLeft, int offsetTop, XRect rectangle, Uri uri, string iconPath)
{
var icon = new Bitmap(Image.FromFile(iconPath));
var bitmap = new QrCode().GenerateImage(uri, icon);
var ms = new MemoryStream();
bitmap.Save(ms, ImageFormat.Bmp);
var image = XImage.FromStream(ms);
var state = gfx.Save();
gfx.RotateAtTransform(-90, new XPoint(rectangle.Left + offsetLeft, rectangle.Top + offsetTop));
gfx.DrawImage(image, rectangle.Left + offsetLeft, rectangle.Top + offsetTop, qrCodeSize, qrCodeSize);
gfx.Restore(state);
}
public void BeginBox(XGraphics gfx, int number, string title)
{
const int dEllipse = 15;
XRect rect = new XRect(0, 20, 300, 200);
if (number % 2 == 0)
{
rect.X = 300 - 5;
}
rect.Y = 40 + ((number - 1) / 2) * (200 - 5);
rect.Inflate(-10, -10);
XRect rect2 = rect;
rect2.Offset(this.BorderWidth, this.BorderWidth);
gfx.DrawRoundedRectangle(new XSolidBrush(this.ShadowColor), rect2, new XSize(dEllipse + 8, dEllipse + 8));
XLinearGradientBrush brush = new XLinearGradientBrush(rect, this.BackColor, this.BackColor2, XLinearGradientMode.Vertical);
gfx.DrawRoundedRectangle(this.BorderPen, brush, rect, new XSize(dEllipse, dEllipse));
rect.Inflate(-5, -5);
XFont font = new XFont("Verdana", 12, XFontStyle.Regular);
gfx.DrawString(title, font, XBrushes.Navy, rect, XStringFormats.TopCenter);
rect.Inflate(-10, -5);
rect.Y += 20;
rect.Height -= 20;
this.state = gfx.Save();
gfx.TranslateTransform(rect.X, rect.Y);
}
protected void PreRender(ref XGraphics gfx, double offsetLeft, double offsetTop, double scaleX, double scaleY)
{
gfx.Save();
gfx.RotateAtTransform(Angle, new XPoint(Util.MillimeterToPoint(offsetLeft + Left + (Width / 2.0)),
Util.MillimeterToPoint(offsetTop + Top + (Height / 2.0))));
hasExecutedPreRender = true;
}
/// <summary>
/// Renders the bar code.
/// </summary>
protected internal override void Render(XGraphics gfx, XBrush brush, XFont font, XPoint position)
{
XGraphicsState state = gfx.Save();
BarCodeRenderInfo info = new BarCodeRenderInfo(gfx, brush, font, position);
InitRendering(info);
info.CurrPosInString = 0;
//info.CurrPos = info.Center - Size / 2;
info.CurrPos = position - CodeBase.CalcDistance(AnchorType.TopLeft, Anchor, Size);
if (TurboBit)
{
RenderTurboBit(info, true);
}
RenderStart(info);
while (info.CurrPosInString < Text.Length)
{
RenderNextPair(info);
}
RenderStop(info);
if (TurboBit)
{
RenderTurboBit(info, false);
}
if (TextLocation != TextLocation.None)
{
RenderText(info);
}
gfx.Restore(state);
}
public void DrawBox(XGraphics gfx, XRect rect, XPen borderPen)
{
//int dEllipse = 15;
//XRect rect = new XRect(75, 130, 400, 300);
//if (number % 2 == 0)
// rect.X = 300 - 5;
//rect.Y = 40 + ((number - 1) / 2) * (200 - 5);
//rect.Inflate(-10, -10);
//XRect rect2 = rect;
//rect2.Offset(this.borderWidth, this.borderWidth);
gfx.DrawRectangle(borderPen, rect);
//gfx.DrawRoundedRectangle(this.borderPen, new XSolidBrush(this.backColor), rect, new XSize(dEllipse, dEllipse));
//rect.Inflate(-5, -5);
//XFont font = new XFont("Verdana", 12, XFontStyle.Regular);
//gfx.DrawString(title, font, XBrushes.Black, rect, XStringFormat.CenterTop);
//rect.Inflate(-10, -5);
//rect.Y += 20;
//rect.Height -= 20;
//gfx.DrawRectangle(XPens.Red, rect);
this._state = gfx.Save();
gfx.TranslateTransform(rect.X, rect.Y);
SetBoxX(0);
SetBoxY(0);
}
public override void SetTransformation(double translateX, double translateY, double rotate, double scaleX, double scaleY)
{
// Revert to original state, and immediately put this state on the stack again.
XGraphics.Restore();
XGraphics.Save();
XGraphics.TranslateTransform(translateX, translateY);
if (rotate != 0.0)
{
XGraphics.RotateTransform(rotate / System.Math.PI * 180.0);
}
if (scaleX != 1.0 || scaleY != 1.0)
{
XGraphics.ScaleTransform(scaleX, scaleY);
}
}
private byte[] GetDocumentToByteArray(ref Document pdf)
{
var renderer = new PdfDocumentRenderer(true, PdfFontEmbedding.Automatic)
{
Document = pdf
};
renderer.RenderDocument();
var stream = new MemoryStream();
if (String.IsNullOrWhiteSpace(_getLogoUrl.Get()) &&
!String.IsNullOrWhiteSpace(_ecommerceSettings.ReportLogoImage))
{
XGraphics gfx = XGraphics.FromPdfPage(renderer.PdfDocument.Pages[0]);
XImage image = FromUri(_ecommerceSettings.ReportLogoImage);
if (image != null)
{
gfx.DrawImage(image, 70, 50, image.PixelWidth, image.PixelHeight);
gfx.Save();
}
}
renderer.PdfDocument.Save(stream);
return(stream.ToArray());
}
private void BeginBox(XGraphics gfx, int number, string title)
{
const int dEllipse = 15;
XRect rect = new XRect(0, 20, 300, 200);
if (number % 2 == 0)
{
rect.X = 300 - 5;
}
rect.Y = 40 + ((number - 1) / 2) * (200 - 5);
rect.Inflate(-10, -10);
XRect rect2 = rect;
rect2.Offset(2, 2);
XColor xColor1 = XColors.DarkGoldenrod;
XColor xColor2 = XColors.Chocolate;
gfx.DrawRoundedRectangle(new XSolidBrush(XColor.FromArgb(9, XColors.DarkGoldenrod)), rect2, new XSize(dEllipse + 8, dEllipse + 8));
XLinearGradientBrush brush = new XLinearGradientBrush(rect, xColor1, xColor2, XLinearGradientMode.Vertical);
gfx.DrawRoundedRectangle(brush, rect, new XSize(dEllipse, dEllipse));
rect.Inflate(-5, -5);
XFont font = new XFont("Verdana", 14, XFontStyle.Bold);
gfx.DrawString(title, font, XBrushes.Black, rect, XStringFormats.TopCenter);
rect.Inflate(-10, -5);
rect.Y += 20;
rect.Height -= 20;
gfx.Save();
gfx.TranslateTransform(rect.X, rect.Y);
}
public void BeginBox(XGraphics gfx, int number, string title)
{
XRect xRect = new XRect(0.0, 20.0, 300.0, 200.0);
bool flag = number % 2 == 0;
if (flag)
{
xRect.X = 295.0;
}
xRect.Y = (double)(40 + (number - 1) / 2 * 195);
xRect.Inflate(-10.0, -10.0);
XRect rect = xRect;
rect.Offset(this.borderWidth, this.borderWidth);
gfx.DrawRoundedRectangle(new XSolidBrush(this.shadowColor), rect, new XSize(23.0, 23.0));
XLinearGradientBrush brush = new XLinearGradientBrush(xRect, this.backColor, this.backColor2, XLinearGradientMode.Vertical);
gfx.DrawRoundedRectangle(this.borderPen, brush, xRect, new XSize(15.0, 15.0));
xRect.Inflate(-5.0, -5.0);
XFont font = new XFont("Verdana", 12.0, XFontStyle.Regular);
gfx.DrawString(title, font, XBrushes.Navy, xRect, XStringFormats.TopCenter);
xRect.Inflate(-10.0, -5.0);
xRect.Y += 20.0;
xRect.Height -= 20.0;
this.state = gfx.Save();
gfx.TranslateTransform(xRect.X, xRect.Y);
}
public static void DrawBeziers()
{
string fn = @"input.pdf";
using (PdfSharp.Pdf.PdfDocument document = PdfSharp.Pdf.IO.PdfReader.Open(fn))
{
// Create an empty XForm object with the specified width and height
// A form is bound to its target document when it is created. The reason is that the form can
// share fonts and other objects with its target document.
using (XForm form = new XForm(document, XUnit.FromMillimeter(70), XUnit.FromMillimeter(55)))
{
// Create an XGraphics object for drawing the contents of the form.
using (XGraphics formGfx = XGraphics.FromForm(form))
{
// Draw a large transparent rectangle to visualize the area the form occupies
XColor back = XColors.Orange;
back.A = 0.2;
XSolidBrush brush = new XSolidBrush(back);
formGfx.DrawRectangle(brush, -10000, -10000, 20000, 20000);
// On a form you can draw...
// ... text
formGfx.DrawString("Text, Graphics, Images, and Forms", new XFont("Verdana", 10, XFontStyle.Regular), XBrushes.Navy, 3, 0, XStringFormats.TopLeft);
XPen pen = XPens.LightBlue.Clone();
pen.Width = 2.5;
// ... graphics like Bézier curves
formGfx.DrawBeziers(pen, XPoint.ParsePoints("30,120 80,20 100,140 175,33.3"));
// ... raster images like GIF files
XGraphicsState state = formGfx.Save();
formGfx.RotateAtTransform(17, new XPoint(30, 30));
formGfx.DrawImage(XImage.FromFile("../../../../../../dev/XGraphicsLab/images/Test.gif"), 20, 20);
formGfx.Restore(state);
// ... and forms like XPdfForm objects
state = formGfx.Save();
formGfx.RotateAtTransform(-8, new XPoint(165, 115));
formGfx.DrawImage(XPdfForm.FromFile("../../../../../PDFs/SomeLayout.pdf"), new XRect(140, 80, 50, 50 * System.Math.Sqrt(2)));
formGfx.Restore(state);
// When you finished drawing on the form, dispose the XGraphic object.
} // End Using formGfx
} // End Using form
} // End Using document
}
public static void PDFExport(string Paydate)
{
string InvoiceNumber = "" + SelectedInvoiceNumber + "";
PdfDocument document = new PdfDocument();
document.Info.Title = "Invoice";
document.Info.Author = "Jack Huckins";
document.Info.Subject = "Service Invoice";
PdfPage page = new PdfPage();
page = document.AddPage();
page.Width = XUnit.FromInch(8.5);
page.Height = XUnit.FromInch(11);
XGraphics gfx = default(XGraphics);
gfx = XGraphics.FromPdfPage(page);
XForm form = new XForm(document, XUnit.FromMillimeter(300), XUnit.FromMillimeter(300));
XGraphics formGfx = default(XGraphics);
formGfx = XGraphics.FromForm(form);
XGraphicsState state = default(XGraphicsState);
state = formGfx.Save();
//..... Invoice Results
GetInvResults(Paydate);
PrepareInvoiceTop(formGfx, state, InvoiceNumber);
PrepareInvoiceData(6, 217, formGfx);
PrepareFooter(formGfx);
state = formGfx.Save();
formGfx.Dispose();
gfx.DrawImage(form, 0, 0);
//document.Save("c:\\Invoices\\Inv " + InvoiceNumber + ".pdf")
SetReportPath();
document.Save(ReportPath);
TimeConnector.Data.ActionLog.Insert("PDF Export", "" + InvoiceNumber + "");
//UpdatePDFLabel("30 second Check", Form1.lblPDFStatus);
//var _with1 = ViewPDF;
//_with1.PdfName = Export.ReportPath;
//_with1.Show();
}
/// <summary>
/// Draw a multi-line string as it would be drawn by GDI+.
/// Compensates for issues and draw-vs-PDF differences in PDFsharp.
/// </summary>
/// <param name="graphics">The graphics with which to draw.</param>
/// <param name="font">The font with which to draw.</param>
/// <param name="brush">The brush with which to draw.</param>
/// <param name="pos">The position at which to draw.</param>
/// <param name="size">The size to which to limit the drawn text; or Vector.Zero for no limit.</param>
/// <param name="format">The string format to use.</param>
/// <param name="maxObjects"></param>
/// <param name="text">The text to draw, which may contain line breaks.</param>
/// <remarks>
/// PDFsharp cannot currently render multi-line text to PDF files; it comes out as single line.
/// This method simulates standard Graphics.DrawString() over PDFsharp.
/// It always has the effect of StringFormatFlags.LineLimit (which PDFsharp does not support).
/// </remarks>
public Rect Draw(XGraphics graphics, Font font, Brush brush, Vector pos, Vector size, XStringFormat format)
{
// do a quick test to see if text is going to get drawn at the same size as last time;
// if so, assume we don't need to recompute our layout for that reason.
var sizeChecker = graphics.MeasureString("M q", font);
if (sizeChecker != m_sizeChecker || pos != m_pos || m_size != size || m_requestedFormat.Alignment != format.Alignment || m_requestedFormat.LineAlignment != format.LineAlignment || m_requestedFormat.FormatFlags != format.FormatFlags)
{
m_invalidLayout = true;
}
m_sizeChecker = sizeChecker;
if (m_invalidLayout)
{
// something vital has changed; rebuild our cached layout data
RebuildCachedLayout(graphics, font, ref pos, ref size, format);
m_invalidLayout = false;
}
var state = graphics.Save();
var textRect = new RectangleF(pos.X, pos.Y, size.X, size.Y);
if (size != Vector.Zero)
{
graphics.IntersectClip(textRect);
}
// disable smoothing whilst rendering text;
// visually this is no different, but is faster
var smoothingMode = graphics.SmoothingMode;
graphics.SmoothingMode = XSmoothingMode.HighSpeed;
var origin = m_origin;
foreach (string t in m_lines)
{
if (size.Y > 0 && size.Y < m_lineHeight)
{
break; // not enough remaining vertical space for a whole line
}
var line = t;
graphics.SmoothingMode = XSmoothingMode.HighQuality;
graphics.DrawString(line, font, brush, origin.X, origin.Y, m_actualFormat);
origin += m_delta;
size.Y -= m_lineHeight;
}
graphics.SmoothingMode = smoothingMode;
graphics.Restore(state);
var actualTextRect = new Rect(pos.X, m_origin.Y, size.X, m_lineHeight * m_lines.Count);
return(actualTextRect);
}
void DrawSecondHand(XGraphics gfx, XPen pen)
{
XGraphicsState gs = gfx.Save();
gfx.RotateTransform(360 * Time.Second / 60 + 6 * Time.Millisecond / 1000);
gfx.DrawEllipse(new XSolidBrush(pen.Color), -15, -15, 30, 30);
gfx.DrawLine(pen, 0, 40, 0, -800);
gfx.Restore(gs);
}
/// <summary>
/// Demonstrates the use of XGraphics.SetClip.
/// </summary>
public override void RenderPage(XGraphics gfx)
{
base.RenderPage(gfx);
gfx.Save();
gfx.TranslateTransform(50, 50);
gfx.IntersectClip(new Rectangle(0, 0, 400, 250));
gfx.TranslateTransform(50, 50);
//gfx.Clear(XColor.GhostWhite);
gfx.DrawEllipse(XPens.Green, XBrushes.Yellow, 40, 40, 500, 500);
gfx.Restore();
gfx.Save();
//gfx.Transform = new XMatrix(); //XMatrix.Identity;
gfx.TranslateTransform(200, 200);
gfx.IntersectClip(new Rectangle(0, 0, 400, 250));
gfx.DrawEllipse(XPens.Green, XBrushes.Yellow, 40, 40, 500, 500);
gfx.Restore();
}
void DrawHourHand(XGraphics gfx, XPen pen, XBrush brush)
{
XGraphicsState gs = gfx.Save();
gfx.RotateTransform(360 * Time.Hour / 12 + 30 * Time.Minute / 60);
gfx.DrawPolygon(pen, brush,
new XPoint[] { new XPoint(0, 150), new XPoint(100, 0),
new XPoint(0, -600), new XPoint(-100, 0) },
XFillMode.Winding);
gfx.Restore(gs);
}
protected void DrawMinuteHand(XGraphics gfx, XPen pen, XBrush brush)
{
XGraphicsState gs = gfx.Save();
gfx.RotateTransform(360 * Time.Minute / 60 + 6 * Time.Second / 60);
gfx.DrawPolygon(pen, brush,
new XPoint[] { new XPoint(0, 200), new XPoint(50, 0), new XPoint(0, -800), new XPoint(-50, 0) },
XFillMode.Winding);
gfx.Restore(gs);
}
private void BeginAddress(XGraphics gfx, int number, string address)
{
XRect rect = new XRect(40, 60 + 6 * 60, 104 * 3.5, 16);
XFont font = new XFont("Verdana", 12, XFontStyle.Regular);
rect.X += (104 * 3.5 + 20) * (number % 2);
rect.Y += 17 * (number / 2);
gfx.DrawString(address, font, XBrushes.Navy, rect, XStringFormats.TopCenter);
state = gfx.Save();
}
/// <summary>
/// Demonstrates the use of XGraphics.Transform.
/// </summary>
public override void RenderPage(XGraphics gfx)
{
base.RenderPage(gfx);
gfx.Save();
gfx.IntersectClip(new XRect(20, 20, 300, 500));
gfx.DrawRectangle(XBrushes.Yellow, 0, 0, gfx.PageSize.Width, gfx.PageSize.Height);
gfx.IntersectClip(new XRect(100, 200, 300, 500));
gfx.DrawRectangle(XBrushes.LightBlue, 0, 0, gfx.PageSize.Width, gfx.PageSize.Height);
gfx.DrawLine(XPens.MediumSlateBlue, 0, 0, 150, 200);
gfx.DrawPolygon(properties.Pen1.Pen, GetPentagram(75, new PointF(150, 200)));
Matrix matrix = new Matrix();
//matrix.Scale(2f, 1.5f);
//matrix.Translate(-200, -400);
//matrix.Rotate(45);
//matrix.Translate(200, 400);
//gfx.Transform = matrix;
//gfx.TranslateTransform(50, 30);
#if true
gfx.TranslateTransform(30, 40, XMatrixOrder.Prepend);
gfx.ScaleTransform(2.0f, 2.0f, XMatrixOrder.Prepend);
gfx.RotateTransform(15, XMatrixOrder.Prepend);
#else
gfx.TranslateTransform(30, 40, XMatrixOrder.Append);
gfx.ScaleTransform(2.0f, 2.0f, XMatrixOrder.Append);
gfx.RotateTransform(15, XMatrixOrder.Append);
#endif
bool id = matrix.IsIdentity;
matrix.Scale(2.0f, 2.0f, MatrixOrder.Prepend);
//matrix.Translate(30, -50);
matrix.Rotate(15, MatrixOrder.Prepend);
//Matrix mtx = gfx.Transform.ToGdipMatrix();
//gfx.Transform = matrix;
gfx.DrawLine(XPens.MediumSlateBlue, 0, 0, 150, 200);
gfx.DrawPolygon(properties.Pen2.Pen, GetPentagram(75, new PointF(150, 200)));
//gfx.ResetClip();
gfx.Restore();
gfx.DrawLine(XPens.Red, 0, 0, 1000, 1000);
gfx.DrawPolygon(XPens.SandyBrown, GetPentagram(75, new PointF(150, 200)));
}
public void PdfDraw(XGraphics g)
{
XStringFormat formatDec = new XStringFormat();
formatDec.Alignment = XStringAlignment.Near;
formatDec.LineAlignment = XLineAlignment.Center;
XSolidBrush b = new XSolidBrush(Color.Black);
for (int i = 0; i < ParentTest.Paper.Blocks.X - 1; i += 7)
{
g.DrawEllipse(b, new Rectangle(DesignZone.Left + ((Settings.blockWidth - Settings.blockHeight) / 2) + (i * Settings.blockWidth),
DesignZone.Bottom - 1 - Settings.blockHeight, Settings.blockHeight, Settings.blockHeight));
}
for (int i = 0; i < ParentTest.Paper.Blocks.Y - 1; i += 7)
{
g.DrawEllipse(b, new Rectangle(DesignZone.Right - 1 - Settings.blockHeight, DesignZone.Top + (i * Settings.blockHeight),
Settings.blockHeight, Settings.blockHeight));
}
g.DrawEllipse(b, new Rectangle(DesignZone.Right - 1 - Settings.blockHeight, DesignZone.Bottom - 1 - Settings.blockHeight,
Settings.blockHeight, Settings.blockHeight));
XGraphicsState gs = g.Save();
g.RotateAtTransform(90, new XPoint(DesignZone.Right - 1 - (int)(Settings.blockHeight / 2), DesignZone.Top + (2 * Settings.blockHeight)));
XStringFormat pageNumFormat = new XStringFormat();
pageNumFormat.LineAlignment = XLineAlignment.Far;
g.Restore(gs);
var barcode = BarCode.CreateArray(Hash());
Point start = new Point(DesignZone.Left + (4 * Settings.blockWidth) - 57, DesignZone.Bottom - 25);
XBrush bGray = new XSolidBrush(XColor.FromArgb(Program.Test.BarCodeGray, Program.Test.BarCodeGray, Program.Test.BarCodeGray));
for (int i = 0; i < 19; i++)
{
for (int j = 0; j < 4; j++)
{
if (barcode[i, j] == 0)
{
g.DrawRectangle(bGray, start.X + (i * 6), start.Y + (j * 6), 6, 6);
}
}
}
foreach (TestElement testElement in TestElements)
{
testElement.PdfDraw(g);
}
}
private void DrawBody(XGraphics gfx)
{
for (int x = 0; x < 15; x++)
{
XGraphicsState state1 = gfx.Save();
gfx.RotateAtTransform(-70, new XPoint(200 + (x * 20), 250));
gfx.DrawString("Long Text Here : Always expect more " + (x + 1), FontUtility.HeaderContentNormal, XBrushes.Black, new XPoint(200 + (x * 20), 250));
gfx.Restore(state1);
}
for (int x = 0; x < 15; x++)
{
XPen pen = new XPen(XColors.Gray, 1);
gfx.DrawRectangle(pen, XBrushes.White, new XRect(195 + (x * 20), 260, 8, 25));
if (x % 2 == 0)
{
gfx.DrawRectangle(XBrushes.LightGray, new XRect(195 + (x * 20), 270, 8, 15));
}
}
int lineHeight = 20;
int topHeight = 0;
for (int x = 0; x < 20; x++)
{
topHeight = 300 + lineHeight * x;
gfx.DrawLine(XPens.LightGray, 50, topHeight, 490, topHeight);
if (x % 2 == 0)
{
gfx.DrawString("&", FontUtility.BodyContentTick, XBrushes.Green, new XRect(50, topHeight + 8, 10, 0));
}
else
{
gfx.DrawString("#", FontUtility.BodyContentTick, XBrushes.Green, new XRect(50, topHeight + 8, 10, 0));
}
gfx.DrawString("Associate Consultant " + (x + 1), FontUtility.BodyContentNormal, XBrushes.Black, new XRect(60, topHeight + 8, 100, 0));
gfx.DrawString("8/2011 - present", FontUtility.BodyContentNormal, XBrushes.Black, new XRect(50, topHeight + 16, 100, 0));
for (int y = 0; y < 16; y++)
{
XPen pen = new XPen(XColors.Gray, 1);
gfx.DrawLine(pen, new XPoint(190 + (y * 20), topHeight), new XPoint(190 + (y * 20), (topHeight + 20)));
if (y % 2 == 0)
{
gfx.DrawImage(XImage.FromFile("../Images/Green-Tick.png"), new XRect(190 + (y * 20) + 5, topHeight + 6, 10, 10));
}
}
}
gfx.DrawLine(XPens.LightGray, 50, topHeight + lineHeight, 490, topHeight + lineHeight);
}
private void Draw8UpPageFor8PageBooklet(XGraphics gfx, int pageNumber, double xorigin, double yorigin)
{
var state = gfx.Save();
_inputPdf.PageNumber = pageNumber;
var box = new XRect(xorigin, yorigin, _paperWidth / 4, _paperHeight / 2);
if (yorigin == 0)
{
var pagePoint = new XPoint(xorigin + _paperWidth / 8, yorigin + _paperHeight / 4);
gfx.RotateAtTransform(180, pagePoint);
}
gfx.DrawImage(_inputPdf, box);
gfx.Restore(state);
}
public PdfSharpCanvas(PdfPage page, string fontFamily)
{
FontFamily = fontFamily;
SetupFontMetrics(FontFamily);
XGraphics = XGraphics.FromPdfPage(page, XGraphicsPdfPageOptions.Append, XGraphicsUnit.Millimeter, XPageDirection.Downwards);
// The origin of an XGraphics canvas is in the top left corner, with the y axis pointing downwards.
// This transform mirrors the y axis. Unfortunately this also mirrors text output (see workaround in PutText).
// XGraphics.FromPdfPage can be called with XPageDirection.Upwards, which is marked as obsolete because it is not implemented properly
// it suffers from the same problem as our matrix below.
XGraphics.MultiplyTransform(new XMatrix(1.0, 0.0, 0.0, -1.0, 0.0, XGraphics.PageSize.Height));
// Save the current state so that we can always revert any transformations we apply.
XGraphics.Save();
}
/// <summary>
/// Draws the content of the line plot area.
/// </summary>
internal override void Draw()
{
ChartRendererInfo cri = (ChartRendererInfo)this.rendererParms.RendererInfo;
XRect plotAreaRect = cri.plotAreaRendererInfo.Rect;
if (plotAreaRect.IsEmpty)
{
return;
}
XGraphics gfx = this.rendererParms.Graphics;
XGraphicsState state = gfx.Save();
//gfx.SetClip(plotAreaRect, XCombineMode.Intersect);
gfx.IntersectClip(plotAreaRect);
//TODO null-Values müssen berücksichtigt werden.
// Verbindungspunkte können fehlen, je nachdem wie null-Values behandelt werden sollen.
// (NotPlotted, Interpolate etc.)
// Draw lines and markers for each data series.
XMatrix matrix = cri.plotAreaRendererInfo.matrix;
double xMajorTick = cri.xAxisRendererInfo.MajorTick;
foreach (SeriesRendererInfo sri in cri.seriesRendererInfos)
{
int count = sri.series.Elements.Count;
XPoint[] points = new XPoint[count];
for (int idx = 0; idx < count; idx++)
{
double v = sri.series.Elements[idx].Value;
if (double.IsNaN(v))
{
v = 0;
}
points[idx] = new XPoint(idx + xMajorTick / 2, v);
}
matrix.TransformPoints(points);
gfx.DrawLines(sri.LineFormat, points);
DrawMarker(gfx, points, sri);
}
//gfx.ResetClip();
gfx.Restore(state);
}
/// <summary>
/// Renders the matrix code.
/// </summary>
protected internal override void Render(XGraphics gfx, XBrush brush, XPoint position)
{
XGraphicsState state = gfx.Save();
switch (Direction)
{
case CodeDirection.RightToLeft:
gfx.RotateAtTransform(180, position);
break;
case CodeDirection.TopToBottom:
gfx.RotateAtTransform(90, position);
break;
case CodeDirection.BottomToTop:
gfx.RotateAtTransform(-90, position);
break;
}
XPoint pos = position + CalcDistance(Anchor, AnchorType.TopLeft, Size);
if (MatrixImage == null)
{
MatrixImage = DataMatrixImage.GenerateMatrixImage(Text, Encoding, Rows, Columns);
}
if (QuietZone > 0)
{
XSize sizeWithZone = new XSize(Size.Width, Size.Height);
sizeWithZone.Width = sizeWithZone.Width / (Columns + 2 * QuietZone) * Columns;
sizeWithZone.Height = sizeWithZone.Height / (Rows + 2 * QuietZone) * Rows;
XPoint posWithZone = new XPoint(pos.X, pos.Y);
posWithZone.X += Size.Width / (Columns + 2 * QuietZone) * QuietZone;
posWithZone.Y += Size.Height / (Rows + 2 * QuietZone) * QuietZone;
gfx.DrawRectangle(XBrushes.White, pos.X, pos.Y, Size.Width, Size.Height);
gfx.DrawImage(MatrixImage, posWithZone.X, posWithZone.Y, sizeWithZone.Width, sizeWithZone.Height);
}
else
{
gfx.DrawImage(MatrixImage, pos.X, pos.Y, Size.Width, Size.Height);
}
gfx.Restore(state);
}
/// <summary>
/// Renders the OMR code.
/// </summary>
protected internal override void Render(XGraphics gfx, XBrush brush, XFont font, XPoint position)
{
XGraphicsState state = gfx.Save();
switch (this.direction)
{
case CodeDirection.RightToLeft:
gfx.RotateAtTransform(180, position);
break;
case CodeDirection.TopToBottom:
gfx.RotateAtTransform(90, position);
break;
case CodeDirection.BottomToTop:
gfx.RotateAtTransform(-90, position);
break;
}
//XPoint pt = center - this.size / 2;
XPoint pt = position - CodeBase.CalcDistance(AnchorType.TopLeft, this.anchor, this.size);
uint value;
uint.TryParse(this.text, out value);
#if true
// HACK: Project Wallenwein: set LK
value |= 1;
this.synchronizeCode = true;
#endif
if (this.synchronizeCode)
{
XRect rect = new XRect(pt.x, pt.y, this.makerThickness, this.size.height);
gfx.DrawRectangle(brush, rect);
pt.x += 2 * this.makerDistance;
}
for (int idx = 0; idx < 32; idx++)
{
if ((value & 1) == 1)
{
XRect rect = new XRect(pt.x + idx * this.makerDistance, pt.y, this.makerThickness, this.size.height);
gfx.DrawRectangle(brush, rect);
}
value = value >> 1;
}
gfx.Restore(state);
}
/// <summary>
/// Draws the content of the line plot area.
/// </summary>
internal override void Draw()
{
ChartRendererInfo cri = (ChartRendererInfo)_rendererParms.RendererInfo;
XRect plotAreaRect = cri.plotAreaRendererInfo.Rect;
if (plotAreaRect.IsEmpty)
{
return;
}
XGraphics gfx = _rendererParms.Graphics;
XGraphicsState state = gfx.Save();
//gfx.SetClip(plotAreaRect, XCombineMode.Intersect);
gfx.IntersectClip(plotAreaRect);
//TODO Treat null values correctly.
// Points can be missing. Treat null values accordingly (NotPlotted, Interpolate etc.)
// Draw lines and markers for each data series.
XMatrix matrix = cri.plotAreaRendererInfo._matrix;
double xMajorTick = cri.xAxisRendererInfo.MajorTick;
foreach (SeriesRendererInfo sri in cri.seriesRendererInfos)
{
int count = sri._series.Elements.Count;
XPoint[] points = new XPoint[count];
for (int idx = 0; idx < count; idx++)
{
double v = sri._series.Elements[idx].Value;
if (double.IsNaN(v))
{
v = 0;
}
points[idx] = new XPoint(idx + xMajorTick / 2, v);
}
matrix.TransformPoints(points);
gfx.DrawLines(sri.LineFormat, points);
DrawMarker(gfx, points, sri);
}
//gfx.ResetClip();
gfx.Restore(state);
}
/// <summary>
/// Renders the OMR code.
/// </summary>
protected internal override void Render(XGraphics gfx, XBrush brush, XFont font, XPoint position)
{
XGraphicsState state = gfx.Save();
switch (Direction)
{
case CodeDirection.RightToLeft:
gfx.RotateAtTransform(180, position);
break;
case CodeDirection.TopToBottom:
gfx.RotateAtTransform(90, position);
break;
case CodeDirection.BottomToTop:
gfx.RotateAtTransform(-90, position);
break;
}
//XPoint pt = center - size / 2;
XPoint pt = position - CodeBase.CalcDistance(AnchorType.TopLeft, Anchor, Size);
uint value;
uint.TryParse(Text, out value);
#if true
// HACK: Project Wallenwein: set LK
value |= 1;
_synchronizeCode = true;
#endif
if (_synchronizeCode)
{
XRect rect = new XRect(pt.X, pt.Y, _makerThickness, Size.Height);
gfx.DrawRectangle(brush, rect);
pt.X += 2 * _makerDistance;
}
for (int idx = 0; idx < 32; idx++)
{
if ((value & 1) == 1)
{
XRect rect = new XRect(pt.X + idx * _makerDistance, pt.Y, _makerThickness, Size.Height);
gfx.DrawRectangle(brush, rect);
}
value = value >> 1;
}
gfx.Restore(state);
}
public void DrawBox(XGraphics gfx, XRect rect, XBrush brush)
{
gfx.DrawRectangle(brush, rect);
//gfx.DrawRoundedRectangle(this.borderPen, new XSolidBrush(this.backColor), rect, new XSize(dEllipse, dEllipse));
//rect.Inflate(-5, -5);
//XFont font = new XFont("Verdana", 12, XFontStyle.Regular);
//gfx.DrawString(title, font, XBrushes.Black, rect, XStringFormat.CenterTop);
//rect.Inflate(-10, -5);
//rect.Y += 20;
//rect.Height -= 20;
//gfx.DrawRectangle(XPens.Red, rect);
this._state = gfx.Save();
gfx.TranslateTransform(rect.X, rect.Y);
SetBoxX(0);
SetBoxY(0);
}
public static void DrawChevron(XGraphics graphics, PointF pos, float angle, float size, Brush fillBrush)
{
if (m_chevronPath == null)
{
var apex = new PointF(0.5f, 0);
var leftCorner = new PointF(-0.5f, 0.5f);
var rightCorner = new PointF(-0.5f, -0.5f);
m_chevronPath = new XGraphicsPath();
m_chevronPath.AddLine(apex, rightCorner);
m_chevronPath.AddLine(rightCorner, leftCorner);
m_chevronPath.AddLine(leftCorner, apex);
}
var state = graphics.Save();
graphics.TranslateTransform(pos.X, pos.Y);
graphics.RotateTransform(angle);
graphics.ScaleTransform(size, size);
graphics.DrawPath(fillBrush, m_chevronPath);
graphics.Restore(state);
}
/// <summary>
/// Renders the bar code.
/// </summary>
protected internal override void Render(XGraphics gfx, XBrush brush, XFont font, XPoint position)
{
XGraphicsState state = gfx.Save();
BarCodeRenderInfo info = new BarCodeRenderInfo(gfx, brush, font, position);
InitRendering(info);
info.CurrPosInString = 0;
//info.CurrPos = info.Center - this.size / 2;
info.CurrPos = position - CodeBase.CalcDistance(AnchorType.TopLeft, this.anchor, this.size);
if (TurboBit)
RenderTurboBit(info, true);
RenderStart(info);
while (info.CurrPosInString < this.text.Length)
{
RenderNextChar(info);
RenderGap(info, false);
}
RenderStop(info);
if (TurboBit)
RenderTurboBit(info, false);
if (TextLocation != TextLocation.None)
RenderText(info);
gfx.Restore(state);
}
/// <summary>
/// Renders the content found in Text
/// </summary>
/// <param name="gfx">
/// XGraphics - Instance of the drawing surface
/// </param>
/// <param name="brush">
/// XBrush - Line and Color to draw the bar code
/// </param>
/// <param name="font">
/// XFont - Font to use to draw the text string
/// </param>
/// <param name="position">
/// XPoint - Location to render the bar code
/// </param>
protected internal override void Render(XGraphics gfx, XBrush brush, XFont font, XPoint position)
{
// Create the array to hold the values to be rendered
this.Values = this.Code128Code == Code128Type.C ? new byte[this.text.Length / 2] : new byte[this.text.Length];
String buffer = String.Empty;
for (Int32 index = 0; index < text.Length; index++)
switch (this.Code128Code)
{
case Code128Type.A:
if (text[index] < 32)
this.Values[index] = (byte)(text[index] + 64);
else if ((text[index] >= 32) && (text[index] < 64))
this.Values[index] = (byte)(text[index] - 32);
else
this.Values[index] = (byte)text[index];
break;
case Code128Type.B:
this.Values[index] = (byte)(text[index] - 32);
break;
case Code128Type.C:
if ((text[index] >= '0') && (text[index] <= '9'))
{
buffer += text[index];
if (buffer.Length == 2)
{
this.Values[index / 2] = byte.Parse(buffer);
buffer = String.Empty;
}
}
else
throw new ArgumentOutOfRangeException("Parameter text (string) can only contain numeric characters for Code 128 - Code C");
break;
}
if (this.Values == null)
throw new InvalidOperationException("Text or Values must be set");
if (this.Values.Length == 0)
throw new InvalidOperationException("Text or Values must have content");
for (int x = 0; x < this.Values.Length; x++)
if (this.Values[x] > 102)
throw new ArgumentOutOfRangeException(BcgSR.InvalidCode128(x));
XGraphicsState state = gfx.Save();
BarCodeRenderInfo info = new BarCodeRenderInfo(gfx, brush, font, position);
this.InitRendering(info);
info.CurrPosInString = 0;
info.CurrPos = position - CodeBase.CalcDistance(AnchorType.TopLeft, this.anchor, this.size);
this.RenderStart(info);
foreach (byte c in this.Values)
this.RenderValue(info, c);
this.RenderStop(info);
if (this.TextLocation != TextLocation.None)
this.RenderText(info);
gfx.Restore(state);
}
