Navigation¶

Main Page
Create Account
Quick Search
»
Visit the new Website for PDFsharp & MigraDoc Foundation 6.0 for .NET 6 and find information about the new version for Windows, Linux, and other platforms.
Back
PDFsharp Sample: Graphics

Modified on 2015/09/14 10:25 by Thomas Hövel Categorized as PDFsharp Samples, Samples
{s:navigationPrevUpNext|HelloWorld-sample-VB|PDFsharpSamples|Annotations-sample}
This sample shows some of the capabilities of the {s:className|XGraphics} class.

You'll find code snippets for the following graphical primitives:
* Lines and curves
* Shapes
* Graphical paths
* Text and fonts
* Images and external PDF forms 

==PDF Output File==

See the PDF files created by this sample: {s:PdfLink|Graphics-sample/Graphics-gdi.pdf|GDI+ version} or {s:PdfLink|Graphics-sample/Graphics-wpf.pdf|WPF version}

==Source Code==

{toc}

===Main programm===

This is the Main function. It creates a PDF document and adds some sample pages listed below.
{s:beginCsharp}
static void Main()
{
  // Create a temporary file
  string filename = String.Format("{0}_tempfile.pdf", Guid.NewGuid().ToString("D").ToUpper());
  s_document = new PdfDocument();
  s_document.Info.Title = "PDFsharp XGraphic Sample";
  s_document.Info.Author = "Stefan Lange";
  s_document.Info.Subject = "Created with code snippets that show the use of graphical functions";
  s_document.Info.Keywords = "PDFsharp, XGraphics";
 
  // Create demonstration pages
  new LinesAndCurves().DrawPage(s_document.AddPage());
  new Shapes().DrawPage(s_document.AddPage());
  new Paths().DrawPage(s_document.AddPage());
  new Text().DrawPage(s_document.AddPage());
  new Images().DrawPage(s_document.AddPage());
 
  // Save the s_document...
  s_document.Save(filename);
  // ...and start a viewer
  Process.Start(filename);
}
{s:endCsharp}

===Lines and Curves===
Shows how to draw lines and curves.
{s:beginCsharp}
public void DrawPage(PdfPage page)
{
  XGraphics gfx = XGraphics.FromPdfPage(page);
&nbsp;
  DrawTitle(page, gfx, "Lines & Curves");
&nbsp;
  DrawLine(gfx, 1);
  DrawLines(gfx, 2);
  DrawBezier(gfx, 3);
  DrawBeziers(gfx, 4);
  DrawCurve(gfx, 5);
  DrawArc(gfx, 6);
}
{s:endCsharp}
====Draw simple lines====
{s:beginCsharp}
void DrawLine(XGraphics gfx, int number)
{
  BeginBox(gfx, number, "DrawLine");
&nbsp;
  gfx.DrawLine(XPens.DarkGreen, 0, 0, 250, 0);
&nbsp;
  gfx.DrawLine(XPens.Gold, 15, 7, 230, 15);
&nbsp;
  XPen pen = new XPen(XColors.Navy, 4);
  gfx.DrawLine(pen, 0, 20, 250, 20);
&nbsp;
  pen = new XPen(XColors.Firebrick, 6);
  pen.DashStyle = XDashStyle.Dash;
  gfx.DrawLine(pen, 0, 40, 250, 40);
  pen.Width = 7.3;
  pen.DashStyle = XDashStyle.DashDotDot;
  gfx.DrawLine(pen, 0, 60, 250, 60);
&nbsp;
  pen = new XPen(XColors.Goldenrod, 10);
  pen.LineCap = XLineCap.Flat;
  gfx.DrawLine(pen, 10, 90, 240, 90);
  gfx.DrawLine(XPens.Black, 10, 90, 240, 90);
&nbsp;
  pen = new XPen(XColors.Goldenrod, 10);
  pen.LineCap = XLineCap.Square;
  gfx.DrawLine(pen, 10, 110, 240, 110);
  gfx.DrawLine(XPens.Black, 10, 110, 240, 110);
&nbsp;
  pen = new XPen(XColors.Goldenrod, 10);
  pen.LineCap = XLineCap.Round;
  gfx.DrawLine(pen, 10, 130, 240, 130);
  gfx.DrawLine(XPens.Black, 10, 130, 240, 130);
&nbsp;
  EndBox(gfx);
}
{s:endCsharp}
====Draw a polyline====
{s:beginCsharp}
void DrawLines(XGraphics gfx, int number)
{
  BeginBox(gfx, number, "DrawLines");
&nbsp;
  XPen pen = new XPen(XColors.DarkSeaGreen, 6);
  pen.LineCap = XLineCap.Round;
  pen.LineJoin = XLineJoin.Bevel;
  XPoint&#0091;] points =
    new XPoint&#0091;] { new XPoint(20, 30), new XPoint(60, 120), new XPoint(90, 20), new XPoint(170, 90), new XPoint(230, 40) };
  gfx.DrawLines(pen, points);
&nbsp;
  EndBox(gfx);
}
{s:endCsharp}
====Draw a single Bézier curve====
{s:beginCsharp}
void DrawBezier(XGraphics gfx, int number)
{
  BeginBox(gfx, number, "DrawBezier");
&nbsp;
  gfx.DrawBezier(new XPen(XColors.DarkRed, 5), 20, 110, 40, 10, 170, 90, 230, 20);
&nbsp;
  EndBox(gfx);
}
{s:endCsharp}
====Draw two Bézier curves====
{s:beginCsharp}
void DrawBeziers(XGraphics gfx, int number)
{
  BeginBox(gfx, number, "DrawBeziers");
&nbsp;
  XPoint&#0091;] points = new XPoint&#0091;]{new XPoint(20, 30), new XPoint(40, 120), new XPoint(80, 20), new XPoint(110, 90), 
                                 new XPoint(180, 40), new XPoint(210, 40), new XPoint(220, 80)};
  XPen pen = new XPen(XColors.Firebrick, 4);
  gfx.DrawBeziers(pen, points);
&nbsp;
  EndBox(gfx);
}
{s:endCsharp}
====Draw a cardinal spline====
{s:beginCsharp}
void DrawCurve(XGraphics gfx, int number)
{
  BeginBox(gfx, number, "DrawCurve");
&nbsp;
  XPoint&#0091;] points =
    new XPoint&#0091;] { new XPoint(20, 30), new XPoint(60, 120), new XPoint(90, 20), new XPoint(170, 90), new XPoint(230, 40) };
  XPen pen = new XPen(XColors.RoyalBlue, 3.5);
  gfx.DrawCurve(pen, points, 1);
&nbsp;
  EndBox(gfx);
}
{s:endCsharp}
====Draw an arc====
{s:beginCsharp}
void DrawArc(XGraphics gfx, int number)
{
  BeginBox(gfx, number, "DrawArc");
&nbsp;
  XPen pen = new XPen(XColors.Plum, 4.7);
  gfx.DrawArc(pen, 0, 0, 250, 140, 190, 200);
&nbsp;
  EndBox(gfx);
}
{s:endCsharp}

===Shapes===

Shows how to draw graphical shapes.
{s:beginCsharp}
public void DrawPage(PdfPage page)
{
  XGraphics gfx = XGraphics.FromPdfPage(page);
&nbsp;
  DrawTitle(page, gfx, "Shapes");
&nbsp;
  DrawRectangle(gfx, 1);
  DrawRoundedRectangle(gfx, 2);
  DrawEllipse(gfx, 3);
  DrawPolygon(gfx, 4);
  DrawPie(gfx, 5);
  DrawClosedCurve(gfx, 6);
}
{s:endCsharp}
====Draw rectangles====
{s:beginCsharp}
void DrawRectangle(XGraphics gfx, int number)
{
  BeginBox(gfx, number, "DrawRectangle");
&nbsp;
  XPen pen = new XPen(XColors.Navy, Math.PI);
&nbsp;
  gfx.DrawRectangle(pen, 10, 0, 100, 60);
  gfx.DrawRectangle(XBrushes.DarkOrange, 130, 0, 100, 60);
  gfx.DrawRectangle(pen, XBrushes.DarkOrange, 10, 80, 100, 60);
  gfx.DrawRectangle(pen, XBrushes.DarkOrange, 150, 80, 60, 60);
&nbsp;
  EndBox(gfx);
}
{s:endCsharp}
====Draw rounded rectangles====
{s:beginCsharp}
void DrawRoundedRectangle(XGraphics gfx, int number)
{
  BeginBox(gfx, number, "DrawRoundedRectangle");
&nbsp;
  XPen pen = new XPen(XColors.RoyalBlue, Math.PI);
&nbsp;
  gfx.DrawRoundedRectangle(pen, 10, 0, 100, 60, 30, 20);
  gfx.DrawRoundedRectangle(XBrushes.Orange, 130, 0, 100, 60, 30, 20);
  gfx.DrawRoundedRectangle(pen, XBrushes.Orange, 10, 80, 100, 60, 30, 20);
  gfx.DrawRoundedRectangle(pen, XBrushes.Orange, 150, 80, 60, 60, 20, 20);
&nbsp;
  EndBox(gfx);
}
{s:endCsharp}
====Draw ellipses====
{s:beginCsharp}
void DrawEllipse(XGraphics gfx, int number)
{
  BeginBox(gfx, number, "DrawEllipse");
&nbsp;
  XPen pen = new XPen(XColors.DarkBlue, 2.5);
&nbsp;
  gfx.DrawEllipse(pen, 10, 0, 100, 60);
  gfx.DrawEllipse(XBrushes.Goldenrod, 130, 0, 100, 60);
  gfx.DrawEllipse(pen, XBrushes.Goldenrod, 10, 80, 100, 60);
  gfx.DrawEllipse(pen, XBrushes.Goldenrod, 150, 80, 60, 60);
&nbsp;
  EndBox(gfx);
}
{s:endCsharp}
====Draw polygons====
{s:beginCsharp}
void DrawPolygon(XGraphics gfx, int number)
{
  BeginBox(gfx, number, "DrawPolygon");
&nbsp;
  XPen pen = new XPen(XColors.DarkBlue, 2.5);
&nbsp;
  gfx.DrawPolygon(pen, XBrushes.LightCoral, GetPentagram(50, new XPoint(60, 70)), XFillMode.Winding);
  gfx.DrawPolygon(pen, XBrushes.LightCoral, GetPentagram(50, new XPoint(180, 70)), XFillMode.Alternate);
&nbsp;
  EndBox(gfx);
}
{s:endCsharp}
====Draw pies====
{s:beginCsharp}
void DrawPie(XGraphics gfx, int number)
{
  BeginBox(gfx, number, "DrawPie");
&nbsp;
  XPen pen = new XPen(XColors.DarkBlue, 2.5);
&nbsp;
  gfx.DrawPie(pen, 10, 0, 100, 90, -120, 75);
  gfx.DrawPie(XBrushes.Gold, 130, 0, 100, 90, -160, 150);
  gfx.DrawPie(pen, XBrushes.Gold, 10, 50, 100, 90, 80, 70);
  gfx.DrawPie(pen, XBrushes.Gold, 150, 80, 60, 60, 35, 290);
&nbsp;
  EndBox(gfx);
}
{s:endCsharp}
====Draw a closed cardinal spline====
{s:beginCsharp}
void DrawClosedCurve(XGraphics gfx, int number)
{
  BeginBox(gfx, number, "DrawClosedCurve");
&nbsp;
  XPen pen = new XPen(XColors.DarkBlue, 2.5);
  gfx.DrawClosedCurve(pen, XBrushes.SkyBlue,
    new XPoint[] { new XPoint(10, 120), new XPoint(80, 30), new XPoint(220, 20), new XPoint(170, 110), new XPoint(100, 90) },
    XFillMode.Winding, 0.7);
&nbsp;
  EndBox(gfx);
}
{s:endCsharp}

===Paths class===

Shows how to draw graphical paths.
{s:beginCsharp}
public void DrawPage(PdfPage page)
{
  XGraphics gfx = XGraphics.FromPdfPage(page);
&nbsp;
  DrawTitle(page, gfx, "Paths");
&nbsp;
  DrawPathOpen(gfx, 1);
  DrawPathClosed(gfx, 2);
  DrawPathAlternateAndWinding(gfx, 3);
  DrawGlyphs(gfx, 5);
  DrawClipPath(gfx, 6);
}
{s:endCsharp}
====Stroke an open path====
{s:beginCsharp}
void DrawPathOpen(XGraphics gfx, int number)
{
  BeginBox(gfx, number, "DrawPath (open)");
&nbsp;
  XPen pen = new XPen(XColors.Navy, Math.PI);
  pen.DashStyle = XDashStyle.Dash;
&nbsp;
  XGraphicsPath path = new XGraphicsPath();
  path.AddLine(10, 120, 50, 60);
  path.AddArc(50, 20, 110, 80, 180, 180);
  path.AddLine(160, 60, 220, 100);
  gfx.DrawPath(pen, path);
&nbsp;
  EndBox(gfx);
}
{s:endCsharp}
====Stroke a closed path====
{s:beginCsharp}
void DrawPathClosed(XGraphics gfx, int number)
{
  BeginBox(gfx, number, "DrawPath (closed)");
&nbsp;
  XPen pen = new XPen(XColors.Navy, Math.PI);
  pen.DashStyle = XDashStyle.Dash;
&nbsp;
  XGraphicsPath path = new XGraphicsPath();
  path.AddLine(10, 120, 50, 60);
  path.AddArc(50, 20, 110, 80, 180, 180);
  path.AddLine(160, 60, 220, 100);
  path.CloseFigure();
  gfx.DrawPath(pen, path);
&nbsp;
  EndBox(gfx);
}
{s:endCsharp}
====Draw an alternating and a winding path====
{s:beginCsharp}
void DrawPathAlternateAndWinding(XGraphics gfx, int number)
{
  BeginBox(gfx, number, "DrawPath (alternate / winding)");
&nbsp;
  XPen pen = new XPen(XColors.Navy, 2.5);
&nbsp;
  // Alternate fill mode
  XGraphicsPath path = new XGraphicsPath();
  path.FillMode = XFillMode.Alternate;
  path.AddLine(10, 130, 10, 40);
  path.AddBeziers(new XPoint[]{new XPoint(10, 40), new XPoint(30, 0), new XPoint(40, 20), new XPoint(60, 40), 
                               new XPoint(80, 60), new XPoint(100, 60), new XPoint(120, 40)});
  path.AddLine(120, 40, 120, 130);
  path.CloseFigure();
  path.AddEllipse(40, 80, 50, 40);
  gfx.DrawPath(pen, XBrushes.DarkOrange, path);
&nbsp;
  // Winding fill mode
  path = new XGraphicsPath();
  path.FillMode = XFillMode.Winding;
  path.AddLine(130, 130, 130, 40);
  path.AddBeziers(new XPoint[]{new XPoint(130, 40), new XPoint(150, 0), new XPoint(160, 20), new XPoint(180, 40), 
                               new XPoint(200, 60), new XPoint(220, 60), new XPoint(240, 40)});
  path.AddLine(240, 40, 240, 130);
  path.CloseFigure();
  path.AddEllipse(160, 80, 50, 40);
  gfx.DrawPath(pen, XBrushes.DarkOrange, path);
&nbsp;
  EndBox(gfx);
}
{s:endCsharp}
====Convert text to path====
{s:note}The result of the GDI+ and WPF version of '''AddString''' are not completely identical.
{s:beginCsharp}
void DrawGlyphs(XGraphics gfx, int number)
{
  BeginBox(gfx, number, "Draw Glyphs");
&nbsp;
  XGraphicsPath path = new XGraphicsPath();
  path.AddString("Hello!", new XFontFamily("Times New Roman"), XFontStyle.BoldItalic, 100, new XRect(0, 0, 250, 140),
    XStringFormats.Center);
&nbsp;
  gfx.DrawPath(new XPen(XColors.Purple, 2.3), XBrushes.DarkOrchid, path);
&nbsp;
  EndBox(gfx);
}
{s:endCsharp}
====Clip through path====
{s:beginCsharp}
void DrawClipPath(XGraphics gfx, int number)
{
  BeginBox(gfx, number, "Clip through Path");
&nbsp;
  XGraphicsPath path = new XGraphicsPath();
  path.AddString("Clip!", new XFontFamily("Verdana"), XFontStyle.Bold, 90, new XRect(0, 0, 250, 140),
    XStringFormats.Center);
&nbsp;
  gfx.IntersectClip(path);
&nbsp;
  // Draw a beam of dotted lines
  XPen pen = XPens.DarkRed.Clone();
  pen.DashStyle = XDashStyle.Dot;
  for (double r = 0; r <= 90; r += 0.5)
    gfx.DrawLine(pen, 0, 0, 250 * Math.Cos(r / 90 * Math.PI), 250 * Math.Sin(r / 90 * Math.PI));
&nbsp;
  EndBox(gfx);
}
{s:endCsharp}

===Text class===

Shows how to handle text.
{s:beginCsharp}
public void DrawPage(PdfPage page)
{
  XGraphics gfx = XGraphics.FromPdfPage(page);
&nbsp;
  DrawTitle(page, gfx, "Text");
&nbsp;
  DrawText(gfx, 1);
  DrawTextAlignment(gfx, 2);
  MeasureText(gfx, 3);
}
{s:endCsharp}
====Draw text in different styles====
{s:beginCsharp}
void DrawText(XGraphics gfx, int number)
{
  BeginBox(gfx, number, "Text Styles");
&nbsp;
  const string facename = "Times New Roman";
&nbsp;
  //XPdfFontOptions options = new XPdfFontOptions(PdfFontEncoding.Unicode, PdfFontEmbedding.Always);
  XPdfFontOptions options = new XPdfFontOptions(PdfFontEncoding.WinAnsi, PdfFontEmbedding.Default);
&nbsp;
  XFont fontRegular = new XFont(facename, 20, XFontStyle.Regular, options);
  XFont fontBold = new XFont(facename, 20, XFontStyle.Bold, options);
  XFont fontItalic = new XFont(facename, 20, XFontStyle.Italic, options);
  XFont fontBoldItalic = new XFont(facename, 20, XFontStyle.BoldItalic, options);
&nbsp;
  // The default alignment is baseline left (that differs from GDI+)
  gfx.DrawString("Times (regular)", fontRegular, XBrushes.DarkSlateGray, 0, 30);
  gfx.DrawString("Times (bold)", fontBold, XBrushes.DarkSlateGray, 0, 65);
  gfx.DrawString("Times (italic)", fontItalic, XBrushes.DarkSlateGray, 0, 100);
  gfx.DrawString("Times (bold italic)", fontBoldItalic, XBrushes.DarkSlateGray, 0, 135);
&nbsp;
  EndBox(gfx);
}
{s:endCsharp}
====Show how to align text in the layout rectangle====
{s:beginCsharp}
void DrawTextAlignment(XGraphics gfx, int number)
{
  BeginBox(gfx, number, "Text Alignment");
  XRect rect = new XRect(0, 0, 250, 140);
&nbsp;
  XFont font = new XFont("Verdana", 10);
  XBrush brush = XBrushes.Purple;
  XStringFormat format = new XStringFormat();
&nbsp;
  gfx.DrawRectangle(XPens.YellowGreen, rect);
  gfx.DrawLine(XPens.YellowGreen, rect.Width / 2, 0, rect.Width / 2, rect.Height);
  gfx.DrawLine(XPens.YellowGreen, 0, rect.Height / 2, rect.Width, rect.Height / 2);
&nbsp;
  gfx.DrawString("TopLeft", font, brush, rect, format);
&nbsp;
  format.Alignment = XStringAlignment.Center;
  gfx.DrawString("TopCenter", font, brush, rect, format);
&nbsp;
  format.Alignment = XStringAlignment.Far;
  gfx.DrawString("TopRight", font, brush, rect, format);
&nbsp;
  format.LineAlignment = XLineAlignment.Center;
  format.Alignment = XStringAlignment.Near;
  gfx.DrawString("CenterLeft", font, brush, rect, format);
&nbsp;
  format.Alignment = XStringAlignment.Center;
  gfx.DrawString("Center", font, brush, rect, format);
&nbsp;
  format.Alignment = XStringAlignment.Far;
  gfx.DrawString("CenterRight", font, brush, rect, format);
&nbsp;
  format.LineAlignment = XLineAlignment.Far;
  format.Alignment = XStringAlignment.Near;
  gfx.DrawString("BottomLeft", font, brush, rect, format);
&nbsp;
  format.Alignment = XStringAlignment.Center;
  gfx.DrawString("BottomCenter", font, brush, rect, format);
&nbsp;
  format.Alignment = XStringAlignment.Far;
  gfx.DrawString("BottomRight", font, brush, rect, format);
&nbsp;
  EndBox(gfx);
}
{s:endCsharp}
====Show how to get text metric information====
{s:beginCsharp}
void MeasureText(XGraphics gfx, int number)
{
  BeginBox(gfx, number, "Measure Text");
&nbsp;
  const XFontStyle style = XFontStyle.Regular;
  XFont font = new XFont("Times New Roman", 95, style);
&nbsp;
  const string text = "Hallo";
  const double x = 20, y = 100;
  XSize size = gfx.MeasureString(text, font);
&nbsp;
  double lineSpace = font.GetHeight(gfx);
  int cellSpace = font.FontFamily.GetLineSpacing(style);
  int cellAscent = font.FontFamily.GetCellAscent(style);
  int cellDescent = font.FontFamily.GetCellDescent(style);
  int cellLeading = cellSpace - cellAscent - cellDescent;
&nbsp;
  // Get effective ascent
  double ascent = lineSpace * cellAscent / cellSpace;
  gfx.DrawRectangle(XBrushes.Bisque, x, y - ascent, size.Width, ascent);
&nbsp;
  // Get effective descent
  double descent = lineSpace * cellDescent / cellSpace;
  gfx.DrawRectangle(XBrushes.LightGreen, x, y, size.Width, descent);
&nbsp;
  // Get effective leading
  double leading = lineSpace * cellLeading / cellSpace;
  gfx.DrawRectangle(XBrushes.Yellow, x, y + descent, size.Width, leading);
&nbsp;
  // Draw text half transparent
  XColor color = XColors.DarkSlateBlue;
  color.A = 0.6;
  gfx.DrawString(text, font, new XSolidBrush(color), x, y);
&nbsp;
  EndBox(gfx);
}
{s:endCsharp}

===Images===

Shows how to draw images.
{s:beginCsharp}
public void DrawPage(PdfPage page)
{
  XGraphics gfx = XGraphics.FromPdfPage(page);
&nbsp;
  DrawTitle(page, gfx, "Images");
&nbsp;
  DrawImage(gfx, 1);
  DrawImageScaled(gfx, 2);
  DrawImageRotated(gfx, 3);
  DrawImageSheared(gfx, 4);
  DrawGif(gfx, 5);
  DrawPng(gfx, 6);
  DrawTiff(gfx, 7);
  DrawFormXObject(gfx, 8);
}
{s:endCsharp}
====Draw an image in original size====
{s:beginCsharp}
void DrawImage(XGraphics gfx, int number)
{
  BeginBox(gfx, number, "DrawImage (original)");
&nbsp;
  XImage image = XImage.FromFile(jpegSamplePath);
&nbsp;
  // Left position in point
  double x = (250 - image.PixelWidth * 72 / image.HorizontalResolution) / 2;
  gfx.DrawImage(image, x, 0);
&nbsp;
  EndBox(gfx);
}
{s:endCsharp}
====Draw an image scaled====
{s:beginCsharp}
void DrawImageScaled(XGraphics gfx, int number)
{
  BeginBox(gfx, number, "DrawImage (scaled)");
&nbsp;
  XImage image = XImage.FromFile(jpegSamplePath);
  gfx.DrawImage(image, 0, 0, 250, 140);
&nbsp;
  EndBox(gfx);
}
{s:endCsharp}
====Draw an image transformed====
{s:beginCsharp}
void DrawImageRotated(XGraphics gfx, int number)
{
  BeginBox(gfx, number, "DrawImage (rotated)");
&nbsp;
  XImage image = XImage.FromFile(jpegSamplePath);
&nbsp;
  const double dx = 250, dy = 140;
&nbsp;
  gfx.TranslateTransform(dx / 2, dy / 2);
  gfx.ScaleTransform(0.7);
  gfx.RotateTransform(-25);
  gfx.TranslateTransform(-dx / 2, -dy / 2);
&nbsp;
  //XMatrix matrix = new XMatrix();  //XMatrix.Identity;
&nbsp;
  double width = image.PixelWidth * 72 / image.HorizontalResolution;
  double height = image.PixelHeight * 72 / image.HorizontalResolution;
&nbsp;
  gfx.DrawImage(image, (dx - width) / 2, 0, width, height);
&nbsp;
  EndBox(gfx);
}
{s:endCsharp}
====Draw an image transformed====
{s:beginCsharp}
void DrawImageSheared(XGraphics gfx, int number)
{
  BeginBox(gfx, number, "DrawImage (sheared)");
&nbsp;
  XImage image = XImage.FromFile(jpegSamplePath);
&nbsp;
  const double dx = 250, dy = 140;
&nbsp;
  gfx.TranslateTransform(dx / 2, dy / 2);
  gfx.ScaleTransform(-0.7, 0.7);
  gfx.ShearTransform(-0.4, -0.3);
  gfx.TranslateTransform(-dx / 2, -dy / 2);
&nbsp;
  double width = image.PixelWidth * 72 / image.HorizontalResolution;
  double height = image.PixelHeight * 72 / image.HorizontalResolution;
&nbsp;
  gfx.DrawImage(image, (dx - width) / 2, 0, width, height);
&nbsp;
  EndBox(gfx);
}
{s:endCsharp}
====Draw a GIF image with transparency====
{s:beginCsharp}
void DrawGif(XGraphics gfx, int number)
{
  this.backColor = XColors.LightGoldenrodYellow;
  this.borderPen = new XPen(XColor.FromArgb(202, 121, 74), this.borderWidth);
  BeginBox(gfx, number, "DrawImage (GIF)");
&nbsp;
  XImage image = XImage.FromFile(gifSamplePath);
&nbsp;
  const double dx = 250, dy = 140;
&nbsp;
  double width = image.PixelWidth * 72 / image.HorizontalResolution;
  double height = image.PixelHeight * 72 / image.HorizontalResolution;
&nbsp;
  gfx.DrawImage(image, (dx - width) / 2, (dy - height) / 2, width, height);
&nbsp;
  EndBox(gfx);
}
{s:endCsharp}
====Draw a PNG image with transparency====
{s:beginCsharp}
void DrawPng(XGraphics gfx, int number)
{
  BeginBox(gfx, number, "DrawImage (PNG)");
&nbsp;
  XImage image = XImage.FromFile(pngSamplePath);
&nbsp;
  const double dx = 250, dy = 140;
&nbsp;
  double width = image.PixelWidth * 72 / image.HorizontalResolution;
  double height = image.PixelHeight * 72 / image.HorizontalResolution;
&nbsp;
  gfx.DrawImage(image, (dx - width) / 2, (dy - height) / 2, width, height);
&nbsp;
  EndBox(gfx);
}
{s:endCsharp}
====Draw a TIFF image with transparency====
{s:beginCsharp}
void DrawTiff(XGraphics gfx, int number)
{
  XColor oldBackColor = this.backColor;
  this.backColor = XColors.LightGoldenrodYellow;
  BeginBox(gfx, number, "DrawImage (TIFF)");
&nbsp;
  XImage image = XImage.FromFile(tiffSamplePath);
&nbsp;
  const double dx = 250, dy = 140;
&nbsp;
  double width = image.PixelWidth * 72 / image.HorizontalResolution;
  double height = image.PixelHeight * 72 / image.HorizontalResolution;
&nbsp;
  gfx.DrawImage(image, (dx - width) / 2, (dy - height) / 2, width, height);
&nbsp;
  EndBox(gfx);
  this.backColor = oldBackColor;
}
{s:endCsharp}
====Draw a form XObject (a page from an external PDF file)====
{s:beginCsharp}
void DrawFormXObject(XGraphics gfx, int number)
{
  //this.backColor = XColors.LightSalmon;
  BeginBox(gfx, number, "DrawImage (Form XObject)");
&nbsp;
  XImage image = XImage.FromFile(pdfSamplePath);
&nbsp;
  const double dx = 250, dy = 140;
&nbsp;
  gfx.TranslateTransform(dx / 2, dy / 2);
  gfx.ScaleTransform(0.35);
  gfx.TranslateTransform(-dx / 2, -dy / 2);
&nbsp;
  double width = image.PixelWidth * 72 / image.HorizontalResolution;
  double height = image.PixelHeight * 72 / image.HorizontalResolution;
&nbsp;
  gfx.DrawImage(image, (dx - width) / 2, (dy - height) / 2, width, height);
&nbsp;
  EndBox(gfx);
}
{s:endCsharp}

===Helper Functions===

Shows how to draw the page title and the rounded boxes.

====Draw the page title and footer====
{s:beginCsharp}
public void DrawTitle(PdfPage page, XGraphics gfx, string title)
{
  XRect rect = new XRect(new XPoint(), gfx.PageSize);
  rect.Inflate(-10, -15);
  XFont font = new XFont("Verdana", 14, XFontStyle.Bold);
  gfx.DrawString(title, font, XBrushes.MidnightBlue, rect, XStringFormats.TopCenter);
&nbsp;
  rect.Offset(0, 5);
  font = new XFont("Verdana", 8, XFontStyle.Italic);
  XStringFormat format = new XStringFormat();
  format.Alignment = XStringAlignment.Near;
  format.LineAlignment = XLineAlignment.Far;
  gfx.DrawString("Created with " + PdfSharp.ProductVersionInfo.Producer, font, XBrushes.DarkOrchid, rect, format);
&nbsp;
  font = new XFont("Verdana", 8);
  format.Alignment = XStringAlignment.Center;
  gfx.DrawString(Program.s_document.PageCount.ToString(), font, XBrushes.DarkOrchid, rect, format);
&nbsp;
  Program.s_document.Outlines.Add(title, page, true);
}
{s:endCsharp}
====Draw the box around the samples====
{s:beginCsharp}
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);
&nbsp;
  XFont font = new XFont("Verdana", 12, XFontStyle.Regular);
  gfx.DrawString(title, font, XBrushes.Navy, rect, XStringFormats.TopCenter);
&nbsp;
  rect.Inflate(-10, -5);
  rect.Y += 20;
  rect.Height -= 20;
&nbsp;
  this.state = gfx.Save();
  gfx.TranslateTransform(rect.X, rect.Y);
}
&nbsp;
public void EndBox(XGraphics gfx)
{
  gfx.Restore(this.state);
}
{s:endCsharp}

{s:sampleSourceCode}
Meta Keywords:
Meta Description:
Change Comment:
Visit the new Website for PDFsharp & MigraDoc Foundation 6.0 for .NET 6 and find information about the new version for Windows, Linux, and other platforms.
Miscellaneous
Home
PDFsharp
FAQ
Samples
Articles
MigraDoc
FAQ
Samples
Articles
PDFsharp and MigraDoc Wiki

Navigation¶

PDFsharp Sample: Graphics
