TextRendering.cs
- //
- // This code is part of Document Solutions for PDF demos.
- // Copyright (c) MESCIUS inc. All rights reserved.
- //
- using System;
- using System.IO;
- using System.Drawing;
- using GrapeCity.Documents.Pdf;
- using GrapeCity.Documents.Text;
- using GrapeCity.Documents.Drawing;
-
- namespace DsPdfWeb.Demos.Basics
- {
- // This sample demonstrates the basics of rendering text in DsPdf.
- // The two main approaches are:
- // - using the MeasureString/DrawString pair, or
- // - using the TextLayout directly.
- // While the first approach may be easier in simple cases,
- // the second approach (using TextLayout) is much more powerful
- // and generally speaking yields better performance.
- // Please read the comments in code below for more details.
- // See also CharacterFormatting, PaginatedText, ParagraphAlign,
- // ParagraphFormatting, TextAlign.
- public class TextRendering
- {
- public int CreatePDF(Stream stream)
- {
- var doc = new GcPdfDocument();
- var page = doc.NewPage();
- var g = page.Graphics;
- // By default, DsPdf uses 72dpi:
- const float In = 72;
-
- // TextFormat class is used throughout all DsPdf text rendering to specify
- // font and other character formatting:
- var tf = new TextFormat() { Font = StandardFonts.Times, FontSize = 12 };
-
- // 1.
- // The easiest way to render a short string on a page at an arbitrary location,
- // when you are 100% sure that the string will fit in the available space,
- // is to use the GcGraphics.DrawString() overload accepting jus the point
- // at which to draw the string:
- g.DrawString("1. Test string. Please read the extensive comments in this sample's code." +
- "(Note that line breaks are allowed even in the simplest DrawString overload.)",
- tf, new PointF(In, In));
-
- // 2.
- // Another overload taking a rectangle instead, plus alignment and wrapping
- // options, is also available and provides a bit more flexibility.
- // The parameters are:
- // - the text string;
- // - the text format;
- // - the layout rectangle;
- // - (optional) text alignment (the default is leading, left for LTR languages);
- // - (optional) paragraph alignment (the default is near, top for top-to-bottom flow);
- // - (optional) word wrapping (the default is true):
- g.DrawString("2. A longer test string which will probably need more than the allocated" +
- "4 inches so quite possibly will wrap to show that DrawString can do that.",
- tf,
- new RectangleF(In, In * 2, In * 4, In),
- TextAlignment.Leading,
- ParagraphAlignment.Near,
- true);
-
- // 3.
- // Complementary to DrawString, a MeasureString() method is available
- // (with several different overloads), and can be used in pair with
- // DrawString when more control over text layout is needed:
- string tstr3 = "3. Test string to demo MeasureString() used with DrawString().";
- // Available layout size:
- SizeF layoutSize = new SizeF(In * 3, In * 0.8f);
- SizeF s = g.MeasureString(tstr3, tf, layoutSize, out int fitCharCount);
- // Show the passed in size in red, the measured size in blue,
- // and draw the string within the returned size as bounds:
- PointF pt = new PointF(In, In * 3);
- g.DrawRectangle(new RectangleF(pt, layoutSize), Color.Red);
- g.DrawRectangle(new RectangleF(pt, s), Color.Blue);
- g.DrawString(tstr3, tf, new RectangleF(pt, s));
-
- // 4.
- // A much more powerful and with better performance, way to render text
- // is to use TextLayout. (TextLayout is used anyway by DrawString/MeasureString,
- // so when you use TextLayout directly, you basically cut the work in half.)
- // A TextLayout instance represents one or more paragraphs of text, with
- // the same paragraph formatting (character formats may be different,
- // see MultiFormattedText).
- var tl = g.CreateTextLayout();
- // To add text, use Append() or AppendLine() methods:
- tl.Append("4. First test string added to TextLayout. ", tf);
- tl.Append("Second test string added to TextLayout, continuing the same paragraph. ", tf);
- // Add a line break, effectively starting a new paragraph:
- tl.AppendLine();
- tl.Append("Third test string added to TextLayout, a new paragraph. ", tf);
- tl.Append("Fourth test string, with a different char formatting. ",
- new TextFormat(tf) { Font = StandardFonts.TimesBoldItalic, ForeColor = Color.DarkSeaGreen, });
- // Text can be added to TextLayout without explicit TextFormat:
- tl.Append("Fifth test string, using the TextLayout's default format.");
- // ...but in that case at least the Font must be specified on the
- // TextLayout's DefaultFormat, otherwise PerformLayout (below) will fail:
- tl.DefaultFormat.Font = StandardFonts.TimesItalic;
- // Specify the layout, such as max available size etc.
- // Here we only provide the max width, but many more parameters can be set:
- tl.MaxWidth = page.Size.Width - In * 2;
- // Paragraph formatting can also be set, here we set first line offset,
- // spacing between paragraphs and line spacing:
- tl.FirstLineIndent = In * 0.5f;
- tl.ParagraphSpacing = In * 0.05f;
- tl.LineSpacingScaleFactor = 0.8f;
-
- // When all text has been added, and layout options specified,
- // the TextLayout needs to calculate the glyphs needed to render
- // the text, and perform the layout. This can be done with a
- // single call:
- tl.PerformLayout(true);
-
- // Now we can draw it on the page:
- pt = new PointF(In, In * 4);
- g.DrawTextLayout(tl, pt);
- // TextLayout provides info about the text including the measured bounds
- // and much more. Here we draw the bounding box in orange red:
- g.DrawRectangle(new RectangleF(pt, tl.ContentRectangle.Size), Color.OrangeRed);
-
- // 5.
- // TextLayout can be re-used to draw different paragraph(s), this can be useful
- // when you need to render a different text with the same paragraph formatting.
- // The Clear() call removes the text but preserves paragraph formatting:
- tl.Clear();
- tl.Append("5. This is text rendered re-using the same TextLayout. ");
- tl.Append("More text added to TextLayout being re-used, continuing the same paragraph. ", tf);
- tl.Append("And finally, some more text added.", tf);
- // The necessary call to calculate the glyphs and perform layout:
- tl.PerformLayout(true);
- // Render the text:
- g.DrawTextLayout(tl, new PointF(In, In * 5));
-
- // Done:
- doc.Save(stream);
- return doc.Pages.Count;
- }
- }
- }
-