/// <summary>
/// Extracts text fragments from the 3rd page and highlights the glyphs in the fragment.
/// </summary>
/// <param name="document"></param>
private static void ExtractImagesAndHighlight(PDFFixedDocument document)
{
PDFPen pen = new PDFPen(new PDFRgbColor(255, 0, 192), 0.5);
PDFBrush brush = new PDFBrush(new PDFRgbColor(0, 0, 0));
PDFStandardFont helvetica = new PDFStandardFont(PDFStandardFontFace.Helvetica, 8);
PDFStringAppearanceOptions sao = new PDFStringAppearanceOptions();
sao.Brush = brush;
sao.Font = helvetica;
PDFStringLayoutOptions slo = new PDFStringLayoutOptions();
slo.Width = 1000;
PDFContentExtractor ce = new PDFContentExtractor(document.Pages[2]);
PDFVisualImageCollection eic = ce.ExtractImages(false);
for (int i = 0; i < eic.Count; i++)
{
string imageProperties = string.Format("Image ID: {0}\nPixel width: {1} pixels\nPixel height: {2} pixels\n" +
"Display width: {3} points\nDisplay height: {4} points\nHorizonal Resolution: {5} dpi\nVertical Resolution: {6} dpi",
eic[i].ImageID, eic[i].Width, eic[i].Height, eic[i].DisplayWidth, eic[i].DisplayHeight, eic[i].DpiX, eic[i].DpiY);
PDFPath boundingPath = new PDFPath();
boundingPath.StartSubpath(eic[i].ImageCorners[0].X, eic[i].ImageCorners[0].Y);
boundingPath.AddLineTo(eic[i].ImageCorners[1].X, eic[i].ImageCorners[1].Y);
boundingPath.AddLineTo(eic[i].ImageCorners[2].X, eic[i].ImageCorners[2].Y);
boundingPath.AddLineTo(eic[i].ImageCorners[3].X, eic[i].ImageCorners[3].Y);
boundingPath.CloseSubpath();
document.Pages[2].Canvas.DrawPath(pen, boundingPath);
slo.X = eic[i].ImageCorners[3].X + 1;
slo.Y = eic[i].ImageCorners[3].Y + 1;
document.Pages[2].Canvas.DrawString(imageProperties, sao, slo);
}
}
/// <summary>
/// Extracts text fragments from the 2nd page and highlights the glyphs in the fragment.
/// </summary>
/// <param name="document"></param>
private static void ExtractTextAndHighlightGlyphs(PDFFixedDocument document)
{
PDFRgbColor penColor = new PDFRgbColor();
PDFPen pen = new PDFPen(penColor, 0.5);
Random rnd = new Random();
byte[] rgb = new byte[3];
PDFContentExtractor ce = new PDFContentExtractor(document.Pages[1]);
PDFTextRunCollection trc = ce.ExtractTextRuns();
PDFTextRun tr = trc[1];
for (int i = 0; i < tr.Glyphs.Count; i++)
{
rnd.NextBytes(rgb);
penColor.R = rgb[0];
penColor.G = rgb[1];
penColor.B = rgb[2];
PDFPath boundingPath = new PDFPath();
boundingPath.StartSubpath(tr.Glyphs[i].GlyphCorners[0].X, tr.Glyphs[i].GlyphCorners[0].Y);
boundingPath.AddLineTo(tr.Glyphs[i].GlyphCorners[1].X, tr.Glyphs[i].GlyphCorners[1].Y);
boundingPath.AddLineTo(tr.Glyphs[i].GlyphCorners[2].X, tr.Glyphs[i].GlyphCorners[2].Y);
boundingPath.AddLineTo(tr.Glyphs[i].GlyphCorners[3].X, tr.Glyphs[i].GlyphCorners[3].Y);
boundingPath.CloseSubpath();
document.Pages[1].Canvas.DrawPath(pen, boundingPath);
}
}
private static void DrawBezierCurves(PDFPage page, PDFFont titleFont, PDFFont sectionFont)
{
PDFBrush brush = new PDFBrush();
PDFPen blackPen = new PDFPen(PDFRgbColor.Black, 1);
PDFPen redPen = new PDFPen(PDFRgbColor.Red, 1);
PDFBrush blueBrush = new PDFBrush(PDFRgbColor.DarkBlue);
PDFRgbColor randomPenColor = new PDFRgbColor();
PDFPen randomPen = new PDFPen(randomPenColor, 1);
page.Canvas.DrawString("Bezier curves", titleFont, brush, 20, 50);
page.Canvas.DrawLine(blackPen, 20, 210, 600, 210);
page.Canvas.DrawLine(blackPen, 306, 70, 306, 350);
page.Canvas.DrawRectangle(blueBrush, 39, 339, 2, 2);
page.Canvas.DrawRectangle(blueBrush, 279, 79, 2, 2);
page.Canvas.DrawRectangle(blueBrush, 499, 299, 2, 2);
page.Canvas.DrawRectangle(blueBrush, 589, 69, 2, 2);
page.Canvas.DrawBezier(redPen, 40, 340, 280, 80, 500, 300, 590, 70);
page.Canvas.DrawString("Random bezier curves clipped to view", sectionFont, brush, 20, 385);
PDFPath rectPath = new PDFPath();
rectPath.AddRectangle(20, 400, 570, 300);
page.Canvas.SaveGraphicsState();
page.Canvas.SetClip(rectPath);
Random rnd = new Random();
for (int i = 0; i < 100; i++)
{
randomPenColor.R = (byte)rnd.Next(256);
randomPenColor.G = (byte)rnd.Next(256);
randomPenColor.B = (byte)rnd.Next(256);
double x1 = rnd.NextDouble() * page.Width;
double y1 = 380 + rnd.NextDouble() * 350;
double x2 = rnd.NextDouble() * page.Width;
double y2 = 380 + rnd.NextDouble() * 350;
double x3 = rnd.NextDouble() * page.Width;
double y3 = 380 + rnd.NextDouble() * 350;
double x4 = rnd.NextDouble() * page.Width;
double y4 = 380 + rnd.NextDouble() * 350;
page.Canvas.DrawBezier(randomPen, x1, y1, x2, y2, x3, y3, x4, y4);
}
page.Canvas.RestoreGraphicsState();
blackPen.DashPattern = null;
page.Canvas.DrawPath(blackPen, rectPath);
page.Canvas.CompressAndClose();
}
private static void HighlightSearchResults(PDFPage page, PDFTextSearchResultCollection searchResults, PDFColor color)
{
PDFPen pen = new PDFPen(color, 0.5);
for (int i = 0; i < searchResults.Count; i++)
{
PDFTextFragmentCollection tfc = searchResults[i].TextFragments;
for (int j = 0; j < tfc.Count; j++)
{
PDFPath path = new PDFPath();
path.StartSubpath(tfc[j].FragmentCorners[0].X, tfc[j].FragmentCorners[0].Y);
path.AddPolygon(tfc[j].FragmentCorners);
page.Canvas.DrawPath(pen, path);
}
}
}
/// <summary>
/// Draws the Bezier connected lines on the page.
/// </summary>
/// <param name="page">Page where to draw the lines.</param>
/// <param name="points">List of points representing the connected lines.</param>
/// <param name="pen">Pen to draw the final path.</param>
/// <param name="smoothFactor">Smooth factor for computing the Bezier curve</param>
/// <param name="font"></param>
private static void DrawBezierConnectedLines(PDFPage page, PDFPoint[] points, PDFPen pen, double smoothFactor, PDFFont font)
{
PDFPath path = new PDFPath();
path.StartSubpath(points[0].X, points[0].Y);
for (int i = 0; i < points.Length - 2; i++)
{
PDFPoint[] pts = ComputeBezierConnectedLines(points[i], points[i + 1], points[i + 2], smoothFactor, i == 0, i == points.Length - 3);
switch (pts.Length)
{
case 2: // Intermediate/last section - straight lines
path.AddLineTo(pts[0].X, pts[0].Y);
path.AddLineTo(pts[1].X, pts[1].Y);
break;
case 3: // First section - straight lines
path.AddLineTo(pts[0].X, pts[0].Y);
path.AddLineTo(pts[1].X, pts[1].Y);
path.AddLineTo(pts[2].X, pts[2].Y);
break;
case 4: // Intermediate/last section
path.AddLineTo(pts[0].X, pts[0].Y);
path.AddBezierTo(pts[1].X, pts[1].Y, pts[1].X, pts[1].Y, pts[2].X, pts[2].Y);
path.AddLineTo(pts[3].X, pts[3].Y);
break;
case 5: // First section
path.AddLineTo(pts[0].X, pts[0].Y);
path.AddLineTo(pts[1].X, pts[1].Y);
path.AddBezierTo(pts[2].X, pts[2].Y, pts[2].X, pts[2].Y, pts[3].X, pts[3].Y);
path.AddLineTo(pts[4].X, pts[4].Y);
break;
}
}
page.Canvas.DrawPath(pen, path);
page.Canvas.DrawString($"Smooth factor = {smoothFactor}", font, new PDFBrush(), points[points.Length - 1].X, points[0].Y);
}
protected override void Execute(NativeActivityContext context)
{
try
{
string workbookFullName = FilePath.Get(context);
string workbookName = string.Empty;
string strPDF = PDFPath.Get(context);;
if (!workbookFullName.Contains("."))
{
workbookFullName = workbookFullName + ".xlsx";
}
if (File.Exists(workbookFullName))
{
ExcelHelper.Shared.Close_OpenedFile(workbookFullName);
workbookName = Path.GetFileName(workbookFullName);
ExcelHelper.Shared.GetApp().DisplayAlerts = false;
if (NeedToOpen == true)
{
ExcelHelper.Shared.GetApp().Workbooks.Open(workbookFullName);
}
if (File.Exists(strPDF))
{
Log.Logger.LogData("PDF file is already exist:" + strPDF + " in activity Excel_Workbook_ToPDF", LogLevel.Error);
if (!ContinueOnError)
{
context.Abort();
}
}
else
{
if ((workbookFullName.Contains(".xlsx")) || (workbookFullName.Contains(".xls")))
{
ExcelHelper.Shared.GetApp().ActiveWorkbook.ExportAsFixedFormat(XlFixedFormatType.xlTypePDF, strPDF);
}
else
{
Log.Logger.LogData("File should be .xlsx or .xls", LogLevel.Error);
}
}
if (NeedToClose == true)
{
ExcelHelper.Shared.GetWorkbookByName(workbookName, true).Close();
}
if (false == NeedToClose)
{
ExcelHelper.Shared.GetWorkbookByName(workbookName, true).Close();
ExcelHelper.Shared.GetApp().Workbooks.Open(workbookFullName);
}
if (ExcelHelper.Shared.GetApp().Workbooks.Count == 0)
{
ExcelHelper.Shared.Dispose();
}
}
else
{
Log.Logger.LogData("Excel file does not exist:" + workbookFullName + " in activity Excel_Workbook_ToPDF", LogLevel.Error);
if (!ContinueOnError)
{
context.Abort();
}
}
}
catch (Exception ex)
{
Log.Logger.LogData(ex.Message + " in activity Excel_Workbook_ToPDF", LogLevel.Error);
if (!ContinueOnError)
{
context.Abort();
}
}
}
/// <summary>
/// Main method for running the sample.
/// </summary>
public static SampleOutputInfo[] Run(Stream input)
{
PDFBrush brush = new PDFBrush();
PDFPen redPen = new PDFPen(PDFRgbColor.Red, 1);
PDFStandardFont helvetica = new PDFStandardFont(PDFStandardFontFace.Helvetica, 10);
PDFFixedDocument document = new PDFFixedDocument(input);
PDFContentExtractor ce = new PDFContentExtractor(document.Pages[0]);
PDFVisualObjectCollection voc = ce.ExtractVisualObjects(false);
PDFPath contour = null;
for (int i = 0; i < voc.Count; i++)
{
switch (voc[i].Type)
{
case PDFVisualObjectType.Image:
PDFImageVisualObject ivo = voc[i] as PDFImageVisualObject;
contour = new PDFPath();
contour.StartSubpath(ivo.Image.ImageCorners[0].X - 5, ivo.Image.ImageCorners[0].Y + 5);
contour.AddLineTo(ivo.Image.ImageCorners[1].X + 5, ivo.Image.ImageCorners[1].Y + 5);
contour.AddLineTo(ivo.Image.ImageCorners[2].X + 5, ivo.Image.ImageCorners[2].Y - 5);
contour.AddLineTo(ivo.Image.ImageCorners[3].X - 5, ivo.Image.ImageCorners[3].Y - 5);
contour.CloseSubpath();
document.Pages[0].Canvas.DrawPath(redPen, contour);
document.Pages[0].Canvas.DrawString("Image", helvetica, brush,
ivo.Image.ImageCorners[0].X - 5, ivo.Image.ImageCorners[0].Y + 5);
break;
case PDFVisualObjectType.Text:
PDFTextVisualObject tvo = voc[i] as PDFTextVisualObject;
contour = new PDFPath();
contour.StartSubpath(tvo.TextFragment.FragmentCorners[0].X - 5, tvo.TextFragment.FragmentCorners[0].Y + 5);
contour.AddLineTo(tvo.TextFragment.FragmentCorners[1].X + 5, tvo.TextFragment.FragmentCorners[1].Y + 5);
contour.AddLineTo(tvo.TextFragment.FragmentCorners[2].X + 5, tvo.TextFragment.FragmentCorners[2].Y - 5);
contour.AddLineTo(tvo.TextFragment.FragmentCorners[3].X - 5, tvo.TextFragment.FragmentCorners[3].Y - 5);
contour.CloseSubpath();
document.Pages[0].Canvas.DrawPath(redPen, contour);
document.Pages[0].Canvas.DrawString("Text", helvetica, brush,
tvo.TextFragment.FragmentCorners[0].X - 5, tvo.TextFragment.FragmentCorners[0].Y + 5);
break;
case PDFVisualObjectType.Path:
PDFPathVisualObject pvo = voc[i] as PDFPathVisualObject;
// Examine all the path points and determine the minimum rectangle that bounds the path.
double minX = 999999, minY = 999999, maxX = -999999, maxY = -999999;
for (int j = 0; j < pvo.PathItems.Count; j++)
{
PDFPathItem pi = pvo.PathItems[j];
if (pi.Points != null)
{
for (int k = 0; k < pi.Points.Length; k++)
{
if (minX >= pi.Points[k].X)
{
minX = pi.Points[k].X;
}
if (minY >= pi.Points[k].Y)
{
minY = pi.Points[k].Y;
}
if (maxX <= pi.Points[k].X)
{
maxX = pi.Points[k].X;
}
if (maxY <= pi.Points[k].Y)
{
maxY = pi.Points[k].Y;
}
}
}
}
contour = new PDFPath();
contour.StartSubpath(minX - 5, minY - 5);
contour.AddLineTo(maxX + 5, minY - 5);
contour.AddLineTo(maxX + 5, maxY + 5);
contour.AddLineTo(minX - 5, maxY + 5);
contour.CloseSubpath();
document.Pages[0].Canvas.DrawPath(redPen, contour);
document.Pages[0].Canvas.DrawString("Path", helvetica, brush, minX - 5, maxY + 5);
// Skip the rest of path objects, they are the evaluation message
i = voc.Count;
break;
}
}
SampleOutputInfo[] output = new SampleOutputInfo[] { new SampleOutputInfo(document, "pageobjects.pdf") };
return(output);
}
private static void DrawTextWrap(PDFPage page, PDFStandardFont titleFont)
{
PDFBrush brush = new PDFBrush();
PDFPen redPen = new PDFPen(PDFRgbColor.Red, 0.5);
PDFStandardFont helvetica = new PDFStandardFont(PDFStandardFontFace.Helvetica, 12);
page.Canvas.DrawString("Text wrapping", titleFont, brush, 20, 50);
page.Canvas.DrawLine(redPen, 20, 70, 20, 150);
page.Canvas.DrawLine(redPen, 300, 70, 300, 150);
page.Canvas.DrawLine(redPen, 20, 70, 300, 70);
PDFStringAppearanceOptions sao = new PDFStringAppearanceOptions();
sao.Brush = brush;
sao.Font = helvetica;
// Height is not set, text has no vertical limit.
PDFStringLayoutOptions slo = new PDFStringLayoutOptions();
slo.HorizontalAlign = PDFStringHorizontalAlign.Justified;
slo.VerticalAlign = PDFStringVerticalAlign.Top;
slo.X = 20;
slo.Y = 70;
slo.Width = 280;
string text = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. " +
"Sed vel euismod risus. Fusce viverra, nisi auctor ullamcorper porttitor, " +
"ipsum lacus lobortis metus, sit amet dictum lacus velit nec diam. " +
"Morbi arcu diam, euismod a auctor nec, aliquam in lectus." +
"Ut ultricies iaculis augue sit amet adipiscing. Aenean blandit tortor a nisi " +
"dignissim fermentum id adipiscing mauris. Aenean libero turpis, varius nec ultricies " +
"faucibus, pretium quis lectus. Morbi mollis lorem vel erat condimentum mattis mollis " +
"nulla sollicitudin. Nunc ut massa id felis laoreet feugiat eget at eros.";
page.Canvas.DrawString(text, sao, slo);
page.Canvas.DrawLine(redPen, 310, 70, 310, 147);
page.Canvas.DrawLine(redPen, 590, 70, 590, 147);
page.Canvas.DrawLine(redPen, 310, 70, 590, 70);
page.Canvas.DrawLine(redPen, 310, 147, 590, 147);
// Height is set, text is limited on vertical.
slo.X = 310;
slo.Y = 70;
slo.Width = 280;
slo.Height = 77;
page.Canvas.DrawString(text, sao, slo);
PDFPath clipPath = new PDFPath();
clipPath.AddRectangle(310, 160, 280, 77);
page.Canvas.DrawPath(redPen, clipPath);
page.Canvas.SaveGraphicsState();
page.Canvas.SetClip(clipPath);
// Height is not set but text is cliped on vertical.
slo.X = 310;
slo.Y = 160;
slo.Width = 280;
slo.Height = 0;
page.Canvas.DrawString(text, sao, slo);
page.Canvas.RestoreGraphicsState();
page.Canvas.DrawLine(redPen, 10, 400, 300, 400);
page.Canvas.DrawLine(redPen, 20, 300, 20, 500);
// Wrapped text is always rotated around top left corner, no matter the text alignment
page.Canvas.DrawRectangle(redPen, 20, 400, 280, 80, 30);
slo.X = 20;
slo.Y = 400;
slo.Width = 280;
slo.Height = 80;
slo.Rotation = 30;
page.Canvas.DrawString(text, sao, slo);
page.Canvas.DrawLine(redPen, 310, 600, 590, 600);
page.Canvas.DrawLine(redPen, 450, 450, 450, 750);
// Rotation around the center of the box requires some affine transformations.
page.Canvas.SaveGraphicsState();
page.Canvas.TranslateTransform(450, 600);
page.Canvas.RotateTransform(30);
page.Canvas.DrawRectangle(redPen, -140, -40, 280, 80);
slo.X = -140;
slo.Y = -40;
slo.Width = 280;
slo.Height = 80;
slo.Rotation = 0;
page.Canvas.DrawString(text, sao, slo);
page.Canvas.RestoreGraphicsState();
}
private static void DrawPatterns(PDFPage page, PDFFont titleFont, PDFFont sectionFont)
{
PDFBrush brush = new PDFBrush();
PDFPen blackPen = new PDFPen(PDFRgbColor.Black, 1);
PDFPen darkRedPen = new PDFPen(new PDFRgbColor(0xFF, 0x40, 0x40), 0.8);
PDFPen darkOrangePen = new PDFPen(new PDFRgbColor(0xA6, 0x4B, 0x00), 0.8);
PDFPen darkCyanPen = new PDFPen(new PDFRgbColor(0x00, 0x63, 0x63), 0.8);
PDFPen darkGreenPen = new PDFPen(new PDFRgbColor(0x00, 0x85, 0x00), 0.8);
PDFBrush lightRedBrush = new PDFBrush(new PDFRgbColor(0xFF, 0x73, 0x73));
PDFBrush lightOrangeBrush = new PDFBrush(new PDFRgbColor(0xFF, 0x96, 0x40));
PDFBrush lightCyanBrush = new PDFBrush(new PDFRgbColor(0x33, 0xCC, 0xCC));
PDFBrush lightGreenBrush = new PDFBrush(new PDFRgbColor(0x67, 0xE6, 0x67));
page.Canvas.DrawString("Patterns", titleFont, brush, 20, 50);
page.Canvas.DrawString("Colored patterns", sectionFont, brush, 25, 70);
// Create the pattern visual appearance.
PDFColoredTilingPattern ctp = new PDFColoredTilingPattern(20, 20);
// Red circle
ctp.Canvas.DrawEllipse(darkRedPen, lightRedBrush, 1, 1, 8, 8);
// Cyan square
ctp.Canvas.DrawRectangle(darkCyanPen, lightCyanBrush, 11, 1, 8, 8);
// Green diamond
PDFPath diamondPath = new PDFPath();
diamondPath.StartSubpath(1, 15);
diamondPath.AddPolyLineTo(new PDFPoint[] { new PDFPoint(5, 11), new PDFPoint(9, 15), new PDFPoint(5, 19) });
diamondPath.CloseSubpath();
ctp.Canvas.DrawPath(darkGreenPen, lightGreenBrush, diamondPath);
// Orange triangle
PDFPath trianglePath = new PDFPath();
trianglePath.StartSubpath(11, 19);
trianglePath.AddPolyLineTo(new PDFPoint[] { new PDFPoint(15, 11), new PDFPoint(19, 19) });
trianglePath.CloseSubpath();
ctp.Canvas.DrawPath(darkOrangePen, lightOrangeBrush, trianglePath);
// Create a pattern colorspace from the pattern object.
PDFPatternColorSpace coloredPatternColorSpace = new PDFPatternColorSpace(ctp);
// Create a color based on the pattern colorspace.
PDFPatternColor coloredPatternColor = new PDFPatternColor(coloredPatternColorSpace);
// The pen and brush use the pattern color like any other color.
PDFPatternBrush patternBrush = new PDFPatternBrush(coloredPatternColor);
PDFPatternPen patternPen = new PDFPatternPen(coloredPatternColor, 40);
page.Canvas.DrawEllipse(patternBrush, 25, 90, 250, 200);
page.Canvas.DrawRoundRectangle(patternPen, 310, 110, 250, 160, 100, 100);
page.Canvas.DrawString("Uncolored patterns", sectionFont, brush, 25, 300);
// Create the pattern visual appearance.
PDFUncoloredTilingPattern uctp = new PDFUncoloredTilingPattern(20, 20);
// A pen without color is used to create the pattern content.
PDFPen noColorPen = new PDFPen(null, 0.8);
// Circle
uctp.Canvas.DrawEllipse(noColorPen, 1, 1, 8, 8);
// Square
uctp.Canvas.DrawRectangle(noColorPen, 11, 1, 8, 8);
// Diamond
diamondPath = new PDFPath();
diamondPath.StartSubpath(1, 15);
diamondPath.AddPolyLineTo(new PDFPoint[] { new PDFPoint(5, 11), new PDFPoint(9, 15), new PDFPoint(5, 19) });
diamondPath.CloseSubpath();
uctp.Canvas.DrawPath(noColorPen, diamondPath);
// Triangle
trianglePath = new PDFPath();
trianglePath.StartSubpath(11, 19);
trianglePath.AddPolyLineTo(new PDFPoint[] { new PDFPoint(15, 11), new PDFPoint(19, 19) });
trianglePath.CloseSubpath();
uctp.Canvas.DrawPath(noColorPen, trianglePath);
// Create a pattern colorspace from the pattern object.
PDFPatternColorSpace uncoloredPatternColorSpace = new PDFPatternColorSpace(uctp);
// Create a color based on the pattern colorspace.
PDFPatternColor uncoloredPatternColor = new PDFPatternColor(uncoloredPatternColorSpace);
// The pen and brush use the pattern color like any other color.
patternBrush = new PDFPatternBrush(uncoloredPatternColor);
// Before using the uncolored pattern set the color that will be used to paint the pattern.
patternBrush.UncoloredPatternPaintColor = new PDFRgbColor(0xFF, 0x40, 0x40);
page.Canvas.DrawEllipse(patternBrush, 25, 320, 125, 200);
patternBrush.UncoloredPatternPaintColor = new PDFRgbColor(0xA6, 0x4B, 0x00);
page.Canvas.DrawEllipse(patternBrush, 175, 320, 125, 200);
patternBrush.UncoloredPatternPaintColor = new PDFRgbColor(0x00, 0x63, 0x63);
page.Canvas.DrawEllipse(patternBrush, 325, 320, 125, 200);
patternBrush.UncoloredPatternPaintColor = new PDFRgbColor(0x00, 0x85, 0x00);
page.Canvas.DrawEllipse(patternBrush, 475, 320, 125, 200);
page.Canvas.DrawString("Shading patterns", sectionFont, brush, 25, 550);
// Create the pattern visual appearance.
PDFAxialShading horizontalShading = new PDFAxialShading();
horizontalShading.StartColor = new PDFRgbColor(255, 0, 0);
horizontalShading.EndColor = new PDFRgbColor(0, 0, 255);
horizontalShading.StartPoint = new PDFPoint(25, 600);
horizontalShading.EndPoint = new PDFPoint(575, 600);
PDFShadingPattern sp = new PDFShadingPattern(horizontalShading);
// Create a pattern colorspace from the pattern object.
PDFPatternColorSpace shadingPatternColorSpace = new PDFPatternColorSpace(sp);
// Create a color based on the pattern colorspace.
PDFPatternColor shadingPatternColor = new PDFPatternColor(shadingPatternColorSpace);
// The pen and brush use the pattern color like any other color.
patternPen = new PDFPatternPen(shadingPatternColor, 40);
page.Canvas.DrawEllipse(patternPen, 50, 600, 500, 150);
page.Canvas.CompressAndClose();
}
private static void DrawShadings(PDFPage page, PDFFont titleFont, PDFFont sectionFont)
{
PDFBrush brush = new PDFBrush();
PDFPen blackPen = new PDFPen(PDFRgbColor.Black, 1);
PDFRgbColor randomPenColor = new PDFRgbColor();
PDFPen randomPen = new PDFPen(randomPenColor, 1);
PDFRgbColor randomBrushColor = new PDFRgbColor();
PDFBrush randomBrush = new PDFBrush(randomBrushColor);
page.Canvas.DrawString("Shadings", titleFont, brush, 20, 50);
page.Canvas.DrawString("Horizontal", sectionFont, brush, 25, 70);
PDFAxialShading horizontalShading = new PDFAxialShading();
horizontalShading.StartColor = new PDFRgbColor(255, 0, 0);
horizontalShading.EndColor = new PDFRgbColor(0, 0, 255);
horizontalShading.StartPoint = new PDFPoint(25, 90);
horizontalShading.EndPoint = new PDFPoint(175, 90);
// Clip the shading to desired area.
PDFPath hsArea = new PDFPath();
hsArea.AddRectangle(25, 90, 150, 150);
page.Canvas.SaveGraphicsState();
page.Canvas.SetClip(hsArea);
page.Canvas.DrawShading(horizontalShading);
page.Canvas.RestoreGraphicsState();
page.Canvas.DrawString("Vertical", sectionFont, brush, 225, 70);
PDFAxialShading verticalShading = new PDFAxialShading();
verticalShading.StartColor = new PDFRgbColor(255, 0, 0);
verticalShading.EndColor = new PDFRgbColor(0, 0, 255);
verticalShading.StartPoint = new PDFPoint(225, 90);
verticalShading.EndPoint = new PDFPoint(225, 240);
// Clip the shading to desired area.
PDFPath vsArea = new PDFPath();
vsArea.AddRectangle(225, 90, 150, 150);
page.Canvas.SaveGraphicsState();
page.Canvas.SetClip(vsArea);
page.Canvas.DrawShading(verticalShading);
page.Canvas.RestoreGraphicsState();
page.Canvas.DrawString("Diagonal", sectionFont, brush, 425, 70);
PDFAxialShading diagonalShading = new PDFAxialShading();
diagonalShading.StartColor = new PDFRgbColor(255, 0, 0);
diagonalShading.EndColor = new PDFRgbColor(0, 0, 255);
diagonalShading.StartPoint = new PDFPoint(425, 90);
diagonalShading.EndPoint = new PDFPoint(575, 240);
// Clip the shading to desired area.
PDFPath dsArea = new PDFPath();
dsArea.AddRectangle(425, 90, 150, 150);
page.Canvas.SaveGraphicsState();
page.Canvas.SetClip(dsArea);
page.Canvas.DrawShading(diagonalShading);
page.Canvas.RestoreGraphicsState();
page.Canvas.DrawString("Extended shading", sectionFont, brush, 25, 260);
PDFAxialShading extendedShading = new PDFAxialShading();
extendedShading.StartColor = new PDFRgbColor(255, 0, 0);
extendedShading.EndColor = new PDFRgbColor(0, 0, 255);
extendedShading.StartPoint = new PDFPoint(225, 280);
extendedShading.EndPoint = new PDFPoint(375, 280);
extendedShading.ExtendStart = true;
extendedShading.ExtendEnd = true;
// Clip the shading to desired area.
PDFPath esArea = new PDFPath();
esArea.AddRectangle(25, 280, 550, 30);
page.Canvas.SaveGraphicsState();
page.Canvas.SetClip(esArea);
page.Canvas.DrawShading(extendedShading);
page.Canvas.RestoreGraphicsState();
page.Canvas.DrawPath(blackPen, esArea);
page.Canvas.DrawString("Limited shading", sectionFont, brush, 25, 330);
PDFAxialShading limitedShading = new PDFAxialShading();
limitedShading.StartColor = new PDFRgbColor(255, 0, 0);
limitedShading.EndColor = new PDFRgbColor(0, 0, 255);
limitedShading.StartPoint = new PDFPoint(225, 350);
limitedShading.EndPoint = new PDFPoint(375, 350);
limitedShading.ExtendStart = false;
limitedShading.ExtendEnd = false;
// Clip the shading to desired area.
PDFPath lsArea = new PDFPath();
lsArea.AddRectangle(25, 350, 550, 30);
page.Canvas.SaveGraphicsState();
page.Canvas.SetClip(lsArea);
page.Canvas.DrawShading(limitedShading);
page.Canvas.RestoreGraphicsState();
page.Canvas.DrawPath(blackPen, lsArea);
page.Canvas.DrawString("Multi-stop shading", sectionFont, brush, 25, 400);
// Multi-stop shadings use a stitching function to combine the functions that define each gradient part.
// Function for red to blue shading.
PDFExponentialFunction redToBlueFunc = new PDFExponentialFunction();
// Linear function
redToBlueFunc.Exponent = 1;
redToBlueFunc.Domain = new double[] { 0, 1 };
// Red color for start
redToBlueFunc.C0 = new double[] { 1, 0, 0 };
// Blue color for start
redToBlueFunc.C1 = new double[] { 0, 0, 1 };
// Function for blue to green shading.
PDFExponentialFunction blueToGreenFunc = new PDFExponentialFunction();
// Linear function
blueToGreenFunc.Exponent = 1;
blueToGreenFunc.Domain = new double[] { 0, 1 };
// Blue color for start
blueToGreenFunc.C0 = new double[] { 0, 0, 1 };
// Green color for start
blueToGreenFunc.C1 = new double[] { 0, 1, 0 };
//Stitching function for the shading.
PDFStitchingFunction shadingFunction = new PDFStitchingFunction();
shadingFunction.Functions.Add(redToBlueFunc);
shadingFunction.Functions.Add(blueToGreenFunc);
shadingFunction.Domain = new double[] { 0, 1 };
shadingFunction.Encode = new double[] { 0, 1, 0, 1 };
// Entire shading goes from 0 to 1 (100%).
// We set the first shading (red->blue) to cover 30% (0 - 0.3) and
// the second shading to cover 70% (0.3 - 1).
shadingFunction.Bounds = new double[] { 0.3 };
// The multistop shading
PDFAxialShading multiStopShading = new PDFAxialShading();
multiStopShading.StartPoint = new PDFPoint(25, 420);
multiStopShading.EndPoint = new PDFPoint(575, 420);
// The colorspace must match the colors specified in C0 & C1
multiStopShading.ColorSpace = new PDFRgbColorSpace();
multiStopShading.Function = shadingFunction;
// Clip the shading to desired area.
PDFPath mssArea = new PDFPath();
mssArea.AddRectangle(25, 420, 550, 30);
page.Canvas.SaveGraphicsState();
page.Canvas.SetClip(mssArea);
page.Canvas.DrawShading(multiStopShading);
page.Canvas.RestoreGraphicsState();
page.Canvas.DrawPath(blackPen, lsArea);
page.Canvas.DrawString("Radial shading", sectionFont, brush, 25, 470);
PDFRadialShading rs1 = new PDFRadialShading();
rs1.StartColor = new PDFRgbColor(0, 255, 0);
rs1.EndColor = new PDFRgbColor(255, 0, 255);
rs1.StartCircleCenter = new PDFPoint(50, 500);
rs1.StartCircleRadius = 10;
rs1.EndCircleCenter = new PDFPoint(500, 570);
rs1.EndCircleRadius = 100;
page.Canvas.DrawShading(rs1);
PDFRadialShading rs2 = new PDFRadialShading();
rs2.StartColor = new PDFRgbColor(0, 255, 0);
rs2.EndColor = new PDFRgbColor(255, 0, 255);
rs2.StartCircleCenter = new PDFPoint(80, 600);
rs2.StartCircleRadius = 10;
rs2.EndCircleCenter = new PDFPoint(110, 690);
rs2.EndCircleRadius = 100;
page.Canvas.DrawShading(rs2);
page.Canvas.CompressAndClose();
}
private static void DrawLines(PDFPage page, PDFFont titleFont, PDFFont sectionFont)
{
PDFBrush brush = new PDFBrush();
PDFPen blackPen = new PDFPen(PDFRgbColor.Black, 1);
PDFPen bluePen = new PDFPen(PDFRgbColor.LightBlue, 16);
page.Canvas.DrawString("Lines", titleFont, brush, 20, 50);
page.Canvas.DrawString("Line styles:", sectionFont, brush, 20, 70);
page.Canvas.DrawString("Solid", sectionFont, brush, 20, 90);
page.Canvas.DrawLine(blackPen, 100, 95, 400, 95);
page.Canvas.DrawString("Dashed", sectionFont, brush, 20, 110);
blackPen.DashPattern = new double[] { 3, 3 };
page.Canvas.DrawLine(blackPen, 100, 115, 400, 115);
page.Canvas.DrawString("Line cap styles:", sectionFont, brush, 20, 150);
page.Canvas.DrawString("Flat", sectionFont, brush, 20, 175);
page.Canvas.DrawLine(bluePen, 100, 180, 400, 180);
blackPen.DashPattern = null;
page.Canvas.DrawLine(blackPen, 100, 180, 400, 180);
page.Canvas.DrawString("Square", sectionFont, brush, 20, 195);
bluePen.LineCap = PDFLineCap.Square;
page.Canvas.DrawLine(bluePen, 100, 200, 400, 200);
blackPen.DashPattern = null;
page.Canvas.DrawLine(blackPen, 100, 200, 400, 200);
page.Canvas.DrawString("Round", sectionFont, brush, 20, 215);
bluePen.LineCap = PDFLineCap.Round;
page.Canvas.DrawLine(bluePen, 100, 220, 400, 220);
blackPen.DashPattern = null;
page.Canvas.DrawLine(blackPen, 100, 220, 400, 220);
page.Canvas.DrawString("Line join styles:", sectionFont, brush, 20, 250);
page.Canvas.DrawString("Miter", sectionFont, brush, 20, 280);
PDFPath miterPath = new PDFPath();
miterPath.StartSubpath(150, 320);
miterPath.AddLineTo(250, 260);
miterPath.AddLineTo(350, 320);
bluePen.LineCap = PDFLineCap.Flat;
bluePen.LineJoin = PDFLineJoin.Miter;
page.Canvas.DrawPath(bluePen, miterPath);
page.Canvas.DrawString("Bevel", sectionFont, brush, 20, 360);
PDFPath bevelPath = new PDFPath();
bevelPath.StartSubpath(150, 400);
bevelPath.AddLineTo(250, 340);
bevelPath.AddLineTo(350, 400);
bluePen.LineCap = PDFLineCap.Flat;
bluePen.LineJoin = PDFLineJoin.Bevel;
page.Canvas.DrawPath(bluePen, bevelPath);
page.Canvas.DrawString("Round", sectionFont, brush, 20, 440);
PDFPath roundPath = new PDFPath();
roundPath.StartSubpath(150, 480);
roundPath.AddLineTo(250, 420);
roundPath.AddLineTo(350, 480);
bluePen.LineCap = PDFLineCap.Flat;
bluePen.LineJoin = PDFLineJoin.Round;
page.Canvas.DrawPath(bluePen, roundPath);
page.Canvas.DrawString("Random lines clipped to rectangle", sectionFont, brush, 20, 520);
PDFPath clipPath = new PDFPath();
clipPath.AddRectangle(20, 550, 570, 230);
page.Canvas.SaveGraphicsState();
page.Canvas.SetClip(clipPath);
PDFRgbColor randomColor = new PDFRgbColor();
PDFPen randomPen = new PDFPen(randomColor, 1);
Random rnd = new Random();
for (int i = 0; i < 100; i++)
{
randomColor.R = (byte)rnd.Next(256);
randomColor.G = (byte)rnd.Next(256);
randomColor.B = (byte)rnd.Next(256);
page.Canvas.DrawLine(randomPen, rnd.NextDouble() * page.Width, 550 + rnd.NextDouble() * 250, rnd.NextDouble() * page.Width, 550 + rnd.NextDouble() * 250);
}
page.Canvas.RestoreGraphicsState();
page.Canvas.DrawPath(blackPen, clipPath);
page.Canvas.CompressAndClose();
}
private static void DrawArcsAndPies(PDFPage page, PDFFont titleFont, PDFFont sectionFont)
{
PDFBrush brush = new PDFBrush();
PDFPen blackPen = new PDFPen(PDFRgbColor.Black, 1);
PDFPen redPen = new PDFPen(PDFRgbColor.Red, 1);
PDFRgbColor randomPenColor = new PDFRgbColor();
PDFPen randomPen = new PDFPen(randomPenColor, 1);
PDFRgbColor randomBrushColor = new PDFRgbColor();
PDFBrush randomBrush = new PDFBrush(randomBrushColor);
page.Canvas.DrawString("Arcs", titleFont, brush, 20, 50);
page.Canvas.DrawString("Pies", titleFont, brush, 310, 50);
page.Canvas.DrawLine(blackPen, 20, 210, 300, 210);
page.Canvas.DrawLine(blackPen, 160, 70, 160, 350);
page.Canvas.DrawLine(blackPen, 310, 210, 590, 210);
page.Canvas.DrawLine(blackPen, 450, 70, 450, 350);
blackPen.DashPattern = new double[] { 2, 2 };
page.Canvas.DrawLine(blackPen, 20, 70, 300, 350);
page.Canvas.DrawLine(blackPen, 20, 350, 300, 70);
page.Canvas.DrawLine(blackPen, 310, 70, 590, 350);
page.Canvas.DrawLine(blackPen, 310, 350, 590, 70);
page.Canvas.DrawArc(redPen, 30, 80, 260, 260, 0, 135);
page.Canvas.DrawPie(redPen, 320, 80, 260, 260, 45, 270);
page.Canvas.DrawString("Random arcs and pies clipped to view", sectionFont, brush, 20, 385);
PDFPath rectPath = new PDFPath();
rectPath.AddRectangle(20, 400, 570, 300);
page.Canvas.SaveGraphicsState();
page.Canvas.SetClip(rectPath);
Random rnd = new Random();
for (int i = 0; i < 100; i++)
{
randomPenColor.R = (byte)rnd.Next(256);
randomPenColor.G = (byte)rnd.Next(256);
randomPenColor.B = (byte)rnd.Next(256);
randomBrushColor.R = (byte)rnd.Next(256);
randomBrushColor.G = (byte)rnd.Next(256);
randomBrushColor.B = (byte)rnd.Next(256);
int mode = rnd.Next(4);
double left = rnd.NextDouble() * page.Width;
double top = 380 + rnd.NextDouble() * 350;
double width = rnd.NextDouble() * page.Width;
double height = rnd.NextDouble() * 250;
double startAngle = rnd.Next(360);
double sweepAngle = rnd.Next(360);
switch (mode)
{
case 0:
// Stroke arc outline
page.Canvas.DrawArc(randomPen, left, top, width, height, startAngle, sweepAngle);
break;
case 1:
// Stroke pie outline
page.Canvas.DrawPie(randomPen, left, top, width, height, startAngle, sweepAngle);
break;
case 2:
// Fill pie interior
page.Canvas.DrawPie(randomBrush, left, top, width, height, startAngle, sweepAngle);
break;
case 3:
// Stroke and fill pie
page.Canvas.DrawPie(randomPen, randomBrush, left, top, width, height, startAngle, sweepAngle);
break;
}
}
page.Canvas.RestoreGraphicsState();
blackPen.DashPattern = null;
page.Canvas.DrawPath(blackPen, rectPath);
page.Canvas.CompressAndClose();
}
private static void DrawEllipses(PDFPage page, PDFFont titleFont, PDFFont sectionFont)
{
PDFBrush brush = new PDFBrush();
PDFPen blackPen = new PDFPen(PDFRgbColor.Black, 1);
PDFPen redPen = new PDFPen(PDFRgbColor.Red, 1);
PDFRgbColor randomPenColor = new PDFRgbColor();
PDFPen randomPen = new PDFPen(randomPenColor, 1);
PDFRgbColor randomBrushColor = new PDFRgbColor();
PDFBrush randomBrush = new PDFBrush(randomBrushColor);
page.Canvas.DrawString("Ellipses", titleFont, brush, 20, 50);
page.Canvas.DrawLine(blackPen, 20, 150, 300, 150);
page.Canvas.DrawLine(blackPen, 80, 70, 80, 350);
page.Canvas.DrawEllipse(redPen, 80, 150, 180, 100);
page.Canvas.DrawLine(blackPen, 320, 150, 600, 150);
page.Canvas.DrawLine(blackPen, 380, 70, 380, 350);
page.Canvas.DrawEllipse(redPen, 380, 150, 180, 100, 30);
page.Canvas.DrawString("Random ellipses clipped to view", sectionFont, brush, 20, 385);
PDFPath ellipsePath = new PDFPath();
ellipsePath.AddEllipse(20, 400, 570, 300);
page.Canvas.SaveGraphicsState();
page.Canvas.SetClip(ellipsePath);
Random rnd = new Random();
for (int i = 0; i < 100; i++)
{
randomPenColor.R = (byte)rnd.Next(256);
randomPenColor.G = (byte)rnd.Next(256);
randomPenColor.B = (byte)rnd.Next(256);
randomBrushColor.R = (byte)rnd.Next(256);
randomBrushColor.G = (byte)rnd.Next(256);
randomBrushColor.B = (byte)rnd.Next(256);
int mode = rnd.Next(3);
double left = rnd.NextDouble() * page.Width;
double top = 380 + rnd.NextDouble() * 350;
double width = rnd.NextDouble() * page.Width;
double height = rnd.NextDouble() * 250;
double orientation = rnd.Next(360);
switch (mode)
{
case 0:
// Stroke ellipse outline
page.Canvas.DrawEllipse(randomPen, left, top, width, height, orientation);
break;
case 1:
// Fill ellipse interior
page.Canvas.DrawEllipse(randomBrush, left, top, width, height, orientation);
break;
case 2:
// Stroke and fill ellipse
page.Canvas.DrawEllipse(randomPen, randomBrush, left, top, width, height, orientation);
break;
}
}
page.Canvas.RestoreGraphicsState();
page.Canvas.DrawPath(blackPen, ellipsePath);
page.Canvas.CompressAndClose();
}
