private static void EscreverVerso(PdfDocument outputDocument, XPdfForm form,
                                          UsuarioCertificadoCertame certificadoUsuario,
                                          XFont font, XStringFormat format)
        {
            if (form.PageCount > 1)
            {
                var paginaVerso = outputDocument.AddPage();
                paginaVerso.Orientation = PageOrientation.Landscape;
                paginaVerso.Size        = PageSize.A4;

                form.PageNumber = 2;

                var posicaoId = new BMPosicaoDadoCertificadoCertame().ObterPorDadoAno("id",
                                                                                      certificadoUsuario.CertificadoCertame.Ano);

                if (posicaoId == null)
                {
                    throw new Exception("Posição de dado obrigatório não informada no verso");
                }

                var gfx = XGraphics.FromPdfPage(paginaVerso);
                gfx.DrawImage(form, new XRect(0, 0, form.PointWidth, form.PointHeight));

                EscreverDado(paginaVerso, posicaoId, gfx, font, format, certificadoUsuario.Chave);
            }
        }
Exemple #2
0
        void AddTitleAndFooter(PdfPage page, XGraphics gfx, string title, PdfDocument document, PdfData pdfData)
        {
            Log l = new Log();

            try
            {
                XRect rect = new XRect(new XPoint(), gfx.PageSize);
                rect.Inflate(-10, -15);
                XFont font = new XFont("OpenSans", 14, XFontStyle.Bold);
                gfx.DrawString(title, font, XBrushes.MidnightBlue, rect, XStringFormats.TopCenter);



                rect.Offset(0, 5);
                font = new XFont("OpenSans", 8, XFontStyle.Italic);
                XStringFormat format = new XStringFormat();
                format.Alignment     = XStringAlignment.Near;
                format.LineAlignment = XLineAlignment.Far;
                gfx.DrawString(pdfData.CreatedBy, font, XBrushes.Black, rect, format);

                font             = new XFont("OpenSans", 8);
                format.Alignment = XStringAlignment.Center;
                gfx.DrawString(document.PageCount.ToString(), font, XBrushes.DarkOrchid, rect, format);

                document.Outlines.Add(title, page, true);
            }
            catch (Exception ex)
            {
                l.CreatedOn        = System.DateTime.UtcNow;
                l.ShortDescription = ex.Message;
                l.FullDescription  = ex.InnerException.ToString();
                _ILog.InsertLog(l);
                throw ex;
            }
        }
Exemple #3
0
        /// <summary>
        /// prints into the current line, absolute x position with width and alignment
        /// </summary>
        /// <returns>true if something was printed</returns>
        public override Boolean PrintString(String ATxt, eFont AFont, float AXPos, float AWidth, eAlignment AAlign)
        {
            RectangleF rect = CalculatePrintStringRectangle(AXPos, CurrentYPos, AWidth, AFont);

            if (PrintingMode == ePrintingMode.eDoPrint)
            {
                if (FPrinterBehaviour == ePrinterBehaviour.eReport)
                {
                    ATxt = GetFittedText(ATxt, AFont, rect.Width);
                }

                if ((AAlign == eAlignment.eCenter) && Environment.OSVersion.ToString().StartsWith("Unix"))
                {
                    // it seems on Mono/Unix, the string aligning to the center does not work properly. so we do it manually
                    rect = new RectangleF(rect.Left + (AWidth - GetWidthString(ATxt, AFont)) / 2.0f, rect.Top, rect.Height, rect.Width);
                    FXGraphics.DrawString(ATxt, GetXFont(AFont), Brushes.Black, rect, GetXStringFormat(eAlignment.eLeft));
                }
                else
                {
                    XStringFormat f = GetXStringFormat(AAlign);
                    f.FormatFlags = XStringFormatFlags.MeasureTrailingSpaces;

                    //TLogging.Log("curr ypos " + CurrentYPos.ToString() + " " + AXPos.ToString() + " " + ATxt + AWidth.ToString());
                    FXGraphics.DrawString(ATxt, GetXFont(AFont), Brushes.Black, rect, f);
                }
            }

            return((ATxt != null) && (ATxt.Length != 0));
        }
Exemple #4
0
        public void DrawTitle(PdfPage page, XGraphics gr, Order order, PdfDocument doc)
        {
            // build header
            gr.DrawRectangle(new XSolidBrush(XColors.MidnightBlue), new XRect(40, 05, page.Width - 80, 07));

            // logo image
            XImage image = XImage.FromFile(server.MapPath("/Content/MyImages/haze.png"));

            gr.DrawImage(image, 40, 15, 100, 30);

            // transaction status
            XRect rect = new XRect(40, 90, page.Width - 80, 0);
            XFont font = new XFont("Verdana", 12, XFontStyle.Bold);

            gr.DrawString("Transaction receipt: " + order.RequestPaymentStatus, font, XBrushes.MidnightBlue, rect);

            // transaction time
            font = new XFont("Verdana", 10, XFontStyle.Regular);
            rect = new XRect(400, 90, page.Width - 80, 0);
            gr.DrawString(order.RequestPaymentDate, font, XBrushes.MidnightBlue, rect);

            // build footer
            XStringFormat format = new XStringFormat();

            format.Alignment = XStringAlignment.Near;
            font             = new XFont("Verdana", 8);
            rect             = new XRect(10, page.Height - 20, page.Width - 20, 0);
            gr.DrawString(getCompAddress(), font, XBrushes.MidnightBlue, rect, format);
        }
        PdfPage CreateWaterMark(PdfPage page, string watermark)
        {
            // Variation 1: Draw watermark as text string
            Gfx.Dispose();
            // Get an XGraphics object for drawing beneath the existing content
            XGraphics gfx = XGraphics.FromPdfPage(page, XGraphicsPdfPageOptions.Prepend);

            // Get the size (in point) of the text
            XSize size = gfx.MeasureString(watermark, font);

            // Define a rotation transformation at the center of the page
            gfx.TranslateTransform(10, -400);

            // Create a string format
            XStringFormat format = new XStringFormat();

            format.Alignment     = XStringAlignment.Near;
            format.LineAlignment = XLineAlignment.Near;

            // Create a dimmed red brush
            XBrush brush = new XSolidBrush(XColor.FromArgb(128, 255, 0, 0));

            // Draw the string
            gfx.DrawString(watermark, font, brush,
                           new XPoint((page.Width - size.Width) / 2, (page.Height - size.Height) / 2),
                           format);
            gfx.Dispose();
            Gfx = XGraphics.FromPdfPage(Page);

            return(page);
        }
Exemple #6
0
        /// <summary>
        /// </summary>
        public static XSize MeasureStringWpf(string text, XFont font, XStringFormat stringFormat)
        {
            FormattedText formattedText = FontHelper.CreateFormattedText(text, font.typeface, font.Size, System.Windows.Media.Brushes.Black);
            XSize         wpfSize       = new XSize(formattedText.WidthIncludingTrailingWhitespace, formattedText.Height);

            return(wpfSize);
        }
Exemple #7
0
        public static bool SetAlignmentFromCardinalOrOrdinalDirection(XStringFormat format, CompassPoint compassPoint, RoomShape?rs = null)
        {
            switch (compassPoint)
            {
            case CompassPoint.North:
            case CompassPoint.NorthEast:
                format.LineAlignment = XLineAlignment.Far;
                format.Alignment     = XStringAlignment.Near;
                break;

            case CompassPoint.East:
            case CompassPoint.SouthEast:
            case CompassPoint.South:
                format.LineAlignment = XLineAlignment.Near;
                format.Alignment     = XStringAlignment.Near;
                break;

            case CompassPoint.West:
            case CompassPoint.SouthWest:
                format.LineAlignment = XLineAlignment.Near;
                format.Alignment     = XStringAlignment.Far;
                break;

            case CompassPoint.NorthWest:
            case CompassPoint.NorthNorthWest:
                format.LineAlignment = XLineAlignment.Far;
                format.Alignment     = XStringAlignment.Far;
                break;

            default:
                return(false);
            }
            return(true);
        }
Exemple #8
0
        private static void drawShot(Shot shot, XGraphics it, int xLoc, int yLoc, int targetSize, decimal zoomFactor)
        {
            //transform shot coordinates to imagebox coordinates

            XPoint x = transform((float)getShotX(shot), (float)getShotY(shot), targetSize, zoomFactor, xLoc, yLoc);

            //draw shot on target
            XBrush b     = new XSolidBrush(XColor.FromArgb(200, 135, 206, 250)); //semitransparent shots
            XPen   p     = new XPen(XColor.FromKnownColor(XKnownColor.Blue), 0.5);
            XBrush bText = new XSolidBrush(XColor.FromKnownColor(XKnownColor.Blue));


            it.SmoothingMode = XSmoothingMode.AntiAlias;

            float peletSize = getDimension(targetSize, ISSF.pelletCaliber, zoomFactor);

            x.X -= peletSize / 2;
            x.Y -= peletSize / 2;

            it.DrawEllipse(b, new XRect(x, new XSize(peletSize, peletSize)));
            it.DrawEllipse(p, new XRect(x, new XSize(peletSize, peletSize)));

            XStringFormat format = new XStringFormat();

            format.LineAlignment = (XLineAlignment)XStringAlignment.Center;
            format.Alignment     = XStringAlignment.Center;

            Font f = new Font("Arial", peletSize / 3, GraphicsUnit.World);

            it.DrawString((shot.index + 1).ToString(), f, bText, new XRect(x, new XSize(peletSize, peletSize)), format);
        }
Exemple #9
0
        private static void createTableHeader(XGraphics gfx)
        {
            XPdfFontOptions options = new XPdfFontOptions(PdfFontEncoding.Unicode, PdfFontEmbedding.Always);
            XBrush          brush   = XBrushes.Black;
            XStringFormat   format  = new XStringFormat();

            format.LineAlignment = XLineAlignment.Center;

            XPen   xpen   = new XPen(XColors.Black, 1.5);
            XBrush xbrush = XBrushes.Bisque;

            XRect rect;
            XFont font;

            int currX = X_START;

            string headerLastName = RES_MANAGER.GetString("lastname");

            rect             = new XRect(currX, CURR_Y, COL_WIDTH[0], 16);
            font             = new XFont("Arial", 12, XFontStyle.Bold, options);
            format.Alignment = XStringAlignment.Near;
            //gfx.DrawRectangle(xpen, xbrush, rect);
            gfx.DrawString(headerLastName, font, brush, rect, format);

            currX += COL_WIDTH[0] + COL_GAP;

            string headerName = RES_MANAGER.GetString("name");

            rect = new XRect(currX, CURR_Y, COL_WIDTH[1], 16);
            //gfx.DrawRectangle(xpen, xbrush, rect);
            gfx.DrawString(headerName, font, brush, rect, format);

            currX += COL_WIDTH[1] + COL_GAP;

            string headerTitle = RES_MANAGER.GetString("title");

            rect = new XRect(currX, CURR_Y, COL_WIDTH[2], 16);
            //gfx.DrawRectangle(xpen, xbrush, rect);
            gfx.DrawString(headerTitle, font, brush, rect, format);

            currX += COL_WIDTH[2] + COL_GAP;

            string headerEduRank = RES_MANAGER.GetString("edurank");

            rect = new XRect(currX, CURR_Y, COL_WIDTH[3], 16);
            //gfx.DrawRectangle(xpen, xbrush, rect);
            gfx.DrawString(headerEduRank, font, brush, rect, format);

            currX += COL_WIDTH[3] + COL_GAP;

            string headerExtID = RES_MANAGER.GetString("extid");

            rect = new XRect(currX, CURR_Y, COL_WIDTH[4], 16);
            //gfx.DrawRectangle(xpen, xbrush, rect);
            gfx.DrawString(headerExtID, font, brush, rect, format);

            gfx.DrawLine(xpen, X_START - 20, CURR_Y + 18, X_START + 475, CURR_Y + 18);

            CURR_Y += 20;
        }
Exemple #10
0
 /// <summary>
 /// Resembles the MeasureString function of GDI+.
 /// </summary>
 public XSize MeasureString(XGraphics gfx, string text, XFont font, XStringFormat stringFormat)
 {
     //Debug.Assert(font.GlyphTypeface != null);
     TextBlock textBlock = new TextBlock();  //FontHelper.CreateTextBlock(text, font.GlyphTypeface, font.Size, null);
     // Looks very much like a hack, but is the recommended way documented by Microsoft.
     return new XSize(textBlock.ActualWidth, textBlock.ActualHeight);
 }
Exemple #11
0
        /// <summary>
        /// Defines page setup, headers, and footers.
        /// </summary>
        public static void SetPageNumber(PdfDocument document)
        {
            // Make a font and a brush to draw the page counter.
            XFont  font  = new XFont("Verdana", 8, XFontStyle.Regular);
            XBrush brush = XBrushes.Black;

            // Add the page counter.
            string pageTotalCount = document.Pages.Count.ToString();

            XStringFormat pageNumberFormat = new XStringFormat
            {
                Alignment     = XStringAlignment.Far,
                LineAlignment = XLineAlignment.Near
            };

            for (int i = 0; i < document.Pages.Count; ++i)
            {
                PdfPage page = document.Pages[i];

                // Make a layout rectangle.
                XRect layoutRectangle = new XRect(0 /*X*/, page.Height - font.Height /*Y*/, page.Width - 15 /*Width*/, font.Height /*Height*/);

                using (XGraphics gfx = XGraphics.FromPdfPage(page))
                {
                    gfx.DrawString(
                        "Page " + (i + 1).ToString() + " of " + pageTotalCount,
                        font,
                        brush,
                        layoutRectangle,
                        pageNumberFormat);
                }
            }
        }
Exemple #12
0
        /// <summary>
        /// Draws the data labels of the pie chart.
        /// </summary>
        internal override void Draw()
        {
            ChartRendererInfo cri = (ChartRendererInfo)this.rendererParms.RendererInfo;

            if (cri.seriesRendererInfos.Length == 0)
            {
                return;
            }

            SeriesRendererInfo sri = cri.seriesRendererInfos[0];

            if (sri.dataLabelRendererInfo == null)
            {
                return;
            }

            if (sri != null)
            {
                XGraphics     gfx       = this.rendererParms.Graphics;
                XFont         font      = sri.dataLabelRendererInfo.Font;
                XBrush        fontColor = sri.dataLabelRendererInfo.FontColor;
                XStringFormat format    = XStringFormats.Center;
                format.LineAlignment = XLineAlignment.Center;
                foreach (DataLabelEntryRendererInfo dataLabel in sri.dataLabelRendererInfo.Entries)
                {
                    if (dataLabel.Text != null)
                    {
                        gfx.DrawString(dataLabel.Text, font, fontColor, dataLabel.Rect, format);
                    }
                }
            }
        }
Exemple #13
0
        public void PostaviWathermark(string nazivKompanije, PdfPage strana)
        {
            XGraphics      gfx           = XGraphics.FromPdfPage(strana, XGraphicsPdfPageOptions.Prepend);
            XFont          font          = new XFont("Times New Roman", 26, XFontStyle.Bold);
            XTextFormatter textFormatter = new XTextFormatter(gfx);

            var size = gfx.MeasureString("PDFSharp", font);

            gfx.TranslateTransform(strana.Width / 2, strana.Height / 2);
            gfx.RotateTransform(-Math.Atan(strana.Height / strana.Width) * 180 / Math.PI);
            gfx.TranslateTransform(-strana.Width / 2, -strana.Height / 2);

            var format = new XStringFormat();

            format.Alignment     = XStringAlignment.Near;
            format.LineAlignment = XLineAlignment.Near;

            XBrush brush = new XSolidBrush(XColor.FromArgb(128, 141, 184, 224));

            gfx.DrawString(nazivKompanije.ToUpper(),
                           font,
                           brush,
                           new XPoint((strana.Width - size.Width) / 2, (strana.Height - size.Height) / 2), format);

            gfx.Dispose();
        }
Exemple #14
0
        private void DrawWaterMarkDiagonal(int wx, int wy, string wText, XFont wFont, Color wColor)
        {
            XSize sf = gfx.MeasureString(wText, wFont);

            gfx.TranslateTransform(wx / 2, wy / 2);

            double Agle = -Math.Atan(wy / wx) * 90 / Math.PI;

            gfx.RotateTransform((float)Agle);
            gfx.TranslateTransform(-wx / 2, -wy / 2);

            XStringFormat wformat = new XStringFormat();

            wformat.Alignment     = XStringAlignment.Near;
            wformat.LineAlignment = XLineAlignment.Near;

            XBrush wbrush = new XSolidBrush(Color.FromArgb(20, wColor));

            wx = (int)(wx - sf.Width) / 2;
            wy = (int)(wy - sf.Height) / 2;

            XPoint Point_xy = new XPoint(wx, wy);

            gfx.DrawString(wText, wFont, wbrush, Point_xy, wformat);
        }
Exemple #15
0
 static GraphicsAdapter()
 {
     _stringFormat               = new XStringFormat();
     _stringFormat.Alignment     = XStringAlignment.Near;
     _stringFormat.LineAlignment = XLineAlignment.Near;
     _stringFormat.FormatFlags   = XStringFormatFlags.MeasureTrailingSpaces;
 }
Exemple #16
0
        public static void CreateBarcodeAsText()
        {
            using (PdfDocument document = new PdfDocument())
            {
                //create pdf header
                document.Info.Title        = "My barcode";
                document.Info.Author       = "Me";
                document.Info.Subject      = "Barcode";
                document.Info.Keywords     = "Barcode, Ean13";
                document.Info.CreationDate = DateTime.Now;

                //create new pdf page
                PdfPage page = document.AddPage();
                page.Width  = XUnit.FromMillimeter(210);
                page.Height = XUnit.FromMillimeter(297);

                using (XGraphics gfx = XGraphics.FromPdfPage(page))
                {
                    //make sure the font is embedded
                    var options = new XPdfFontOptions(PdfFontEncoding.Unicode);

                    //declare a font for drawing in the PDF
                    XFont          fontEan      = new XFont("mrvcode39s", 75, XFontStyle.Regular, options);
                    XTextFormatter tf           = new XTextFormatter(gfx);
                    var            stringFormat = new XStringFormat();
                    stringFormat.Alignment = XStringAlignment.Center;

                    //create the barcode from string
                    gfx.DrawString("12234", fontEan, XBrushes.Black, new XRect(15, 40, page.Width, page.Height), stringFormat);
                }


                document.Save("BarCodeTest3.pdf");
            }
        }
        private static void DesenharCelula(XGraphics gfx, int inicioCelula, double topoTabela, int larguraCelula,
                                           double alturaLinha, XPen pen, string texto, bool titulo = false, bool tituloCentralizado = false)
        {
            var baseCelula = topoTabela + alturaLinha;

            gfx.DrawLine(pen, inicioCelula, topoTabela, larguraCelula, topoTabela);
            gfx.DrawLine(pen, inicioCelula, topoTabela, inicioCelula, baseCelula);
            gfx.DrawLine(pen, inicioCelula, baseCelula, larguraCelula, baseCelula);
            gfx.DrawLine(pen, larguraCelula, topoTabela, larguraCelula, baseCelula);

            if (string.IsNullOrWhiteSpace(texto) == false)
            {
                var font = new XFont("Verdana", 12, (titulo ? XFontStyle.Bold : XFontStyle.Regular));

                var format = new XStringFormat
                {
                    Alignment     = (tituloCentralizado ? XStringAlignment.Center : XStringAlignment.Near),
                    LineAlignment = XLineAlignment.BaseLine
                };

                var tx = new XTextFormatter(gfx);

                if (tituloCentralizado)
                {
                    var textMeasure = gfx.MeasureString(texto, font);

                    gfx.DrawString(texto, font, XBrushes.Black, ((double)larguraCelula / 2), topoTabela + textMeasure.Height, format);
                }
                else
                {
                    tx.DrawString(texto, font, XBrushes.Black, new XRect(new XPoint(inicioCelula + 5, topoTabela + 5), new XPoint(larguraCelula, baseCelula)));
                }
            }
        }
        private static void DrawTextRectangle(XGraphics g, XStringFormat rectFormat, string str, XRect rcf, XFont f)
        {
            int    startL   = 0;
            int    startP   = 0;
            int    endP     = 0;
            int    lastEndP = 0;
            XPoint point    = rcf.Location;

            XSize textSize;

            str = str.Trim();
            while (endP < str.Length - 1)
            {
                endP = FindNextSpaceFit(g, str, rcf, f, startP);
                if (endP <= startP)
                {
                    return;
                }
                string subs = str.Substring(startP, endP - startP);
                textSize = g.MeasureString(subs, f);
                g.DrawString(subs, f, Brushes.Black, point.X, point.Y + textSize.Height);
                point.Y += textSize.Height * 1.2;
                startP   = endP + 1;
            }
        }
Exemple #19
0
        static void Main(string[] args)
        {
            var filepath = new DirectoryInfo(Directory.GetCurrentDirectory());

            var pdfFiles = filepath.EnumerateFiles("*.pdf").OrderBy(f => f.CreationTimeUtc).ToList();

            if (pdfFiles.Count < 2)
            {
                Console.WriteLine($"Found {pdfFiles.Count} files... nothing to do.");
            }
            else
            {
                Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
                var pdfResult = new PdfDocument();
                var font      = new XFont("Consolas", 10, XFontStyle.Bold);
                var format    = new XStringFormat
                {
                    Alignment     = XStringAlignment.Center,
                    LineAlignment = XLineAlignment.Far
                };

                foreach (var file in pdfFiles)
                {
                    using (var pdfFile = PdfReader.Open(file.FullName, PdfDocumentOpenMode.Import))
                    {
                        pdfResult.Pages.Add(pdfFile.Pages[0]);

                        var page = pdfResult.Pages[^ 1];
        public static void Variant1(PdfPage page, XFont font, string watermark)
        {
            // Variation 1: Draw a watermark as a text string.

            // Get an XGraphics object for drawing beneath the existing content.
            var gfx = XGraphics.FromPdfPage(page, XGraphicsPdfPageOptions.Prepend);

            // Get the size (in points) of the text.
            var size = gfx.MeasureString(watermark, font);

            // Define a rotation transformation at the center of the page.
            gfx.TranslateTransform(page.Width / 2, page.Height / 2);
            gfx.RotateTransform(-System.Math.Atan(page.Height / page.Width) * 180 / System.Math.PI);
            gfx.TranslateTransform(-page.Width / 2, -page.Height / 2);

            // Create a string format.
            var format = new XStringFormat();

            format.Alignment     = XStringAlignment.Near;
            format.LineAlignment = XLineAlignment.Near;

            // Create a dimmed red brush.
            XBrush brush = new XSolidBrush(XColor.FromArgb(128, 255, 0, 0));

            // Draw the string.
            gfx.DrawString(watermark, font, brush,
                           new XPoint((page.Width - size.Width) / 2, (page.Height - size.Height) / 2),
                           format);
        }
Exemple #21
0
 internal void DrawToPDF(PdfRectangle rect, PdfPage elementPage, XFont font, XStringFormat format)
 {
     if (!rect.IsEmpty)
     {
         using (var gfx = XGraphics.FromPdfPage(elementPage))
         {
             // Note: Page origin [0,0] is bottom left !
             var text = Text;
             if (text.Length > 0)
             {
                 var xRect = new XRect(rect.X1, elementPage.Height.Point - rect.Y2, rect.Width, rect.Height);
                 if ((Flags & PdfAcroFieldFlags.Comb) != 0 && MaxLength > 0)
                 {
                     var combWidth = xRect.Width / MaxLength;
                     format.Comb      = true;
                     format.CombWidth = combWidth;
                     gfx.Save();
                     gfx.IntersectClip(xRect);
                     gfx.DrawString(text, font, new XSolidBrush(ForeColor), xRect + new XPoint(0, 1.5), format);
                     gfx.Restore();
                 }
                 else
                 {
                     gfx.Save();
                     gfx.IntersectClip(xRect);
                     gfx.DrawString(text, font, new XSolidBrush(ForeColor), xRect + new XPoint(2, 2), format);
                     gfx.Restore();
                 }
             }
         }
     }
 }
Exemple #22
0
        private void DrawTextAlignment(XGraphics gfx, int number)
        {
            base.BeginBox(gfx, number, "Text Alignment");
            XRect         xRect         = new XRect(0.0, 0.0, 250.0, 140.0);
            XFont         font          = new XFont("Verdana", 10.0);
            XBrush        purple        = XBrushes.Purple;
            XStringFormat xStringFormat = new XStringFormat();

            gfx.DrawRectangle(XPens.YellowGreen, xRect);
            gfx.DrawLine(XPens.YellowGreen, xRect.Width / 2.0, 0.0, xRect.Width / 2.0, xRect.Height);
            gfx.DrawLine(XPens.YellowGreen, 0.0, xRect.Height / 2.0, xRect.Width, xRect.Height / 2.0);
            gfx.DrawString("TopLeft", font, purple, xRect, xStringFormat);
            xStringFormat.Alignment = XStringAlignment.Center;
            gfx.DrawString("TopCenter", font, purple, xRect, xStringFormat);
            xStringFormat.Alignment = XStringAlignment.Far;
            gfx.DrawString("TopRight", font, purple, xRect, xStringFormat);
            xStringFormat.LineAlignment = XLineAlignment.Center;
            xStringFormat.Alignment     = XStringAlignment.Near;
            gfx.DrawString("CenterLeft", font, purple, xRect, xStringFormat);
            xStringFormat.Alignment = XStringAlignment.Center;
            gfx.DrawString("Center", font, purple, xRect, xStringFormat);
            xStringFormat.Alignment = XStringAlignment.Far;
            gfx.DrawString("CenterRight", font, purple, xRect, xStringFormat);
            xStringFormat.LineAlignment = XLineAlignment.Far;
            xStringFormat.Alignment     = XStringAlignment.Near;
            gfx.DrawString("BottomLeft", font, purple, xRect, xStringFormat);
            xStringFormat.Alignment = XStringAlignment.Center;
            gfx.DrawString("BottomCenter", font, purple, xRect, xStringFormat);
            xStringFormat.Alignment = XStringAlignment.Far;
            gfx.DrawString("BottomRight", font, purple, xRect, xStringFormat);
            base.EndBox(gfx);
        }
Exemple #23
0
        private void DrawText(XGraphics gfx, TextItem text)
        {
            XPdfFontOptions options = new XPdfFontOptions(PdfFontEncoding.Unicode, PdfFontEmbedding.Always);
            XFont           font    = new XFont("Calibri", Y(text.Size), XFontStyle.Regular, options);

            XStringFormat format = new XStringFormat();
            XRect         rect   = new XRect(X(text.X), Y(text.Y), X(text.Width), Y(text.Height));

            switch (text.HAlign)
            {
            case 0: format.Alignment = XStringAlignment.Near; break;

            case 1: format.Alignment = XStringAlignment.Center; break;

            case 2: format.Alignment = XStringAlignment.Far; break;
            }

            switch (text.VAlign)
            {
            case 0: format.LineAlignment = XLineAlignment.Near; break;

            case 1: format.LineAlignment = XLineAlignment.Center; break;

            case 2: format.LineAlignment = XLineAlignment.Far; break;
            }

            //var brushBackground = new XSolidBrush(XColor.FromArgb(text.Backgroud.Alpha, text.Backgroud.Red, text.Backgroud.Green, text.Backgroud.Blue));
            //gfx.DrawRectangle(brushBackground, rect);

            var brushForeground = new XSolidBrush(XColor.FromArgb(text.Foreground.Alpha, text.Foreground.Red, text.Foreground.Green, text.Foreground.Blue));

            gfx.DrawString(text.Text, font, brushForeground, rect, format);
        }
Exemple #24
0
 public PdfBuilder DrawString(string text, XFont font, int x, int y, XStringFormat stringFormat)
 {
     _gfx.DrawString(text, font, XBrushes.Black,
                     new XRect(x, y, _page.Width, y),
                     stringFormat);
     return(this);
 }
Exemple #25
0
        public void DrawString(string s, Font font, Brush brush, RectangleF layoutRectangle, StringFormat format)
        {
            XStringFormat xFormat = StringFormatToXStringFormat(format);
            XFont         xFont   = FontToXFont(font);
            XBrush        xBrush  = BrushToXBrush(brush);

            if (format.FormatFlags == StringFormatFlags.NoWrap)
            {
                //Single line
                string line = TrimString(s, layoutRectangle.Width, xFont, format.Trimming);
                _graphics.DrawString(line, xFont, xBrush, layoutRectangle, xFormat);
            }
            else
            {
                //Multiline
                int           lineHeight = xFont.Height;
                List <string> lines      = SetText(s, layoutRectangle.Width, (int)(layoutRectangle.Height / lineHeight), xFont);

                for (int i = 0; i < lines.Count; i++)
                {
                    RectangleF rect = new RectangleF(layoutRectangle.X, layoutRectangle.Y + i * lineHeight,
                                                     layoutRectangle.Width, lineHeight);
                    _graphics.DrawString(lines[i], xFont, xBrush, rect, xFormat);
                }
            }
        }
Exemple #26
0
        public override void PdfDraw(XGraphics g)
        {
            XStringFormat format = new XStringFormat();

            format.Alignment     = XStringAlignment.Near;
            format.LineAlignment = XLineAlignment.Center;

            XBrush b    = new XSolidBrush(Color.Black);
            int    line = 0;

            for (int i = 0; i < textSplit.Count; i++)
            {
                for (int j = 0; j < textSplit[i].Count; j++)
                {
                    if (line < GridSize.Height)
                    {
                        g.DrawString(textSplit[i][j], Settings.xfont, b, new Point(Left + 2, Top + (int)((line + .5) * ParentPage.ParentTest.Paper.BlockSize.Height)), format);
                        line++;
                    }
                    else
                    {
                        break;
                    }
                }
            }
            base.PdfDraw(g);
        }
        /// <summary>
        /// Draws the data labels of the column chart.
        /// </summary>
        internal override void Draw()
        {
            ChartRendererInfo cri = (ChartRendererInfo)_rendererParms.RendererInfo;

            foreach (SeriesRendererInfo sri in cri.seriesRendererInfos)
            {
                if (sri._dataLabelRendererInfo == null)
                {
                    continue;
                }

                XGraphics     gfx       = _rendererParms.Graphics;
                XFont         font      = sri._dataLabelRendererInfo.Font;
                XBrush        fontColor = sri._dataLabelRendererInfo.FontColor;
                XStringFormat format    = XStringFormats.Center;
                format.LineAlignment = XLineAlignment.Center;
                foreach (DataLabelEntryRendererInfo dataLabel in sri._dataLabelRendererInfo.Entries)
                {
                    if (dataLabel.Text != null)
                    {
                        gfx.DrawString(dataLabel.Text, font, fontColor, dataLabel.Rect, format);
                    }
                }
            }
        }
Exemple #28
0
        static void watermarkprint(XGraphics gfx, PdfPage page, XFont font)
        {
            string watermark = "TestME";


            // Get the size (in point) of the text
            XSize size = gfx.MeasureString(watermark, font);

            // Define a rotation transformation at the center of the page
            gfx.TranslateTransform(page.Width / 2, page.Height / 2);
            gfx.RotateTransform(-Math.Atan(page.Height / page.Width) * 180 / Math.PI);
            gfx.TranslateTransform(-page.Width / 2, -page.Height / 2);

            // Create a string format
            XStringFormat format = new XStringFormat();

            format.Alignment     = XStringAlignment.Near;
            format.LineAlignment = XLineAlignment.Near;

            // Create a dimmed red brush
            XBrush brush = new XSolidBrush(XColor.FromArgb(60, 128, 125, 123));

            // Draw the string
            gfx.DrawString(watermark, font, brush,
                           new XPoint((page.Width - size.Width) / 2, (page.Height - size.Height) / 2),
                           format);
        }
        private static void EscreverFrente(PdfDocument outputDocument, XPdfForm form,
                                           UsuarioCertificadoCertame certificadoUsuario,
                                           XFont font, XStringFormat format)
        {
            var paginaFrente = outputDocument.AddPage();

            paginaFrente.Orientation = PageOrientation.Landscape;
            paginaFrente.Size        = PageSize.A4;

            form.PageNumber = 1;

            var manterPosicaoDado = new BMPosicaoDadoCertificadoCertame();

            var posicaoNome = manterPosicaoDado.ObterPorDadoAno("nome", certificadoUsuario.CertificadoCertame.Ano);
            var posicaoCpf1 = manterPosicaoDado.ObterPorDadoAno("cpf1", certificadoUsuario.CertificadoCertame.Ano);
            var posicaoCpf2 = manterPosicaoDado.ObterPorDadoAno("cpf2", certificadoUsuario.CertificadoCertame.Ano);

            if (posicaoNome == null || posicaoCpf1 == null || posicaoCpf2 == null)
            {
                throw new Exception("Posição de dado obrigatório não informada na frente");
            }

            var gfx = XGraphics.FromPdfPage(paginaFrente);

            gfx.DrawImage(form, new XRect(0, 0, form.PointWidth, form.PointHeight));

            EscreverDado(paginaFrente, posicaoNome, gfx, font, format, certificadoUsuario.Usuario.Nome);
            EscreverDado(paginaFrente, posicaoCpf1, gfx, font, format,
                         certificadoUsuario.Usuario.CPF.Substring(0, 9).Insert(3, ".").Insert(7, "."));
            EscreverDado(paginaFrente, posicaoCpf2, gfx, font, format, certificadoUsuario.Usuario.CPF.Substring(9, 2));

            if (certificadoUsuario.CertificadoCertame.Data.HasValue)
            {
                var data = certificadoUsuario.CertificadoCertame.Data.Value;

                var dataFormatada = string.Format("{0} de {1} de {2}", data.Day.ToString().PadLeft(2, '0'),
                                                  data.ObterNomeMes(), data.Year);

                var posicaoData = manterPosicaoDado.ObterPorDadoAno("data", certificadoUsuario.CertificadoCertame.Ano);

                EscreverDado(paginaFrente, posicaoData, gfx, font, format, dataFormatada);
            }

            if (!string.IsNullOrWhiteSpace(certificadoUsuario.CertificadoCertame.NomeCertificado))
            {
                var posicaoNomeCertificado = manterPosicaoDado.ObterPorDadoAno("nomecertificado",
                                                                               certificadoUsuario.CertificadoCertame.Ano);

                // Somente nesse caso, só insere o nome no PDF caso tenha o dado, pois alguns PDFs possuem o
                // nome neles, mas o campo "Nome" é obrigatório em todos os certificados.
                if (posicaoNomeCertificado != null)
                {
                    var fontNomeCertificado = new XFont("Verdana", 13, XFontStyle.Bold);

                    EscreverDado(paginaFrente, posicaoNomeCertificado, gfx, fontNomeCertificado, format,
                                 certificadoUsuario.CertificadoCertame.NomeCertificado.ToUpper());
                }
            }
        }
Exemple #30
0
        public static XStringFormat GetFormat(StringFormatEx stringFormat)
        {
            var format = new XStringFormat();

            format.Alignment     = (XStringAlignment)Enum.Parse(typeof(XStringAlignment), stringFormat.Alignment.ToString());
            format.LineAlignment = (XLineAlignment)Enum.Parse(typeof(XLineAlignment), stringFormat.LineAlignment.ToString());
            return(format);
        }
Exemple #31
0
        /// <summary>
        /// Draws the text.
        /// </summary>
        /// <param name="text">The text to be drawn.</param>
        /// <param name="font">The font.</param>
        /// <param name="brush">The text brush.</param>
        /// <param name="layoutRectangle">The layout rectangle.</param>
        /// <param name="format">The format. Must be <c>XStringFormat.TopLeft</c></param>
        public void DrawString(string text, XFont font, XBrush brush, XRect layoutRectangle, XStringFormat format)
        {
            if (text == null)
                throw new ArgumentNullException("text");
            if (font == null)
                throw new ArgumentNullException("font");
            if (brush == null)
                throw new ArgumentNullException("brush");
            if (format.Alignment != XStringAlignment.Near || format.LineAlignment != XLineAlignment.Near)
                throw new ArgumentException("Only TopLeft alignment is currently implemented.");

            Text = text;
            Font = font;
            LayoutRectangle = layoutRectangle;

            if (text.Length == 0)
                return;

            CreateBlocks();

            CreateLayout();

            double dx = layoutRectangle.Location.X;
            double dy = layoutRectangle.Location.Y + _cyAscent;
            int count = _blocks.Count;
            for (int idx = 0; idx < count; idx++)
            {
                Block block = _blocks[idx];
                if (block.Stop)
                    break;
                if (block.Type == BlockType.LineBreak)
                    continue;
                _gfx.DrawString(block.Text, font, brush, dx + block.Location.X, dy + block.Location.Y);
            }
        }
Exemple #32
0
 public override void DrawText(string text, TextType font, Vector2D pt, HAlignment hAlignment, VAlignment vAlignment, float fAngle)
 {
     XStringFormat format = new XStringFormat();
     switch (hAlignment)
     {
         case HAlignment.HA_CENTER: format.Alignment = XStringAlignment.Center; break;
         case HAlignment.HA_LEFT: format.Alignment = XStringAlignment.Near; break;
         case HAlignment.HA_RIGHT: format.Alignment = XStringAlignment.Far; break;
         default: break;
     }
     switch (vAlignment)
     {
         case VAlignment.VA_BOTTOM: format.LineAlignment = XLineAlignment.Far; break;
         case VAlignment.VA_MIDDLE: format.LineAlignment = XLineAlignment.Center; break;
         case VAlignment.VA_TOP: format.LineAlignment = XLineAlignment.Near; break;
         default: break;
     }
     this.pdfGfx.DrawString(
         text
         , ToFont(font)
         , LineTypeToPdfBrush(PicGraphics.LT.LT_COTATION)
         , new XPoint(DX(pt.X), DY(pt.Y))
         , format);
 }
        // ----- DrawString ---------------------------------------------------------------------------

        public void DrawString(string s, XFont font, XBrush brush, XRect rect, XStringFormat format)
        {
            double x = rect.X;
            double y = rect.Y;

            double lineSpace = font.GetHeight();
            double cyAscent = lineSpace * font.CellAscent / font.CellSpace;
            double cyDescent = lineSpace * font.CellDescent / font.CellSpace;
            double width = _gfx.MeasureString(s, font).Width;

            //bool bold = (font.Style & XFontStyle.Bold) != 0;
            //bool italic = (font.Style & XFontStyle.Italic) != 0;
            bool italicSimulation = (font.GlyphTypeface.StyleSimulations & XStyleSimulations.ItalicSimulation) != 0;
            bool boldSimulation = (font.GlyphTypeface.StyleSimulations & XStyleSimulations.BoldSimulation) != 0;
            bool strikeout = (font.Style & XFontStyle.Strikeout) != 0;
            bool underline = (font.Style & XFontStyle.Underline) != 0;

            Realize(font, brush, boldSimulation ? 2 : 0);

            switch (format.Alignment)
            {
                case XStringAlignment.Near:
                    // nothing to do
                    break;

                case XStringAlignment.Center:
                    x += (rect.Width - width) / 2;
                    break;

                case XStringAlignment.Far:
                    x += rect.Width - width;
                    break;
            }
            if (Gfx.PageDirection == XPageDirection.Downwards)
            {
                switch (format.LineAlignment)
                {
                    case XLineAlignment.Near:
                        y += cyAscent;
                        break;

                    case XLineAlignment.Center:
                        // TODO: Use CapHeight. PDFlib also uses 3/4 of ascent
                        y += (cyAscent * 3 / 4) / 2 + rect.Height / 2;
                        break;

                    case XLineAlignment.Far:
                        y += -cyDescent + rect.Height;
                        break;

                    case XLineAlignment.BaseLine:
                        // Nothing to do.
                        break;
                }
            }
            else
            {
                switch (format.LineAlignment)
                {
                    case XLineAlignment.Near:
                        y += cyDescent;
                        break;

                    case XLineAlignment.Center:
                        // TODO: Use CapHeight. PDFlib also uses 3/4 of ascent
                        y += -(cyAscent * 3 / 4) / 2 + rect.Height / 2;
                        break;

                    case XLineAlignment.Far:
                        y += -cyAscent + rect.Height;
                        break;

                    case XLineAlignment.BaseLine:
                        // Nothing to do.
                        break;
                }
            }

            PdfFont realizedFont = _gfxState._realizedFont;
            Debug.Assert(realizedFont != null);
            realizedFont.AddChars(s);

            const string format2 = Config.SignificantFigures4;
            OpenTypeDescriptor descriptor = realizedFont.FontDescriptor._descriptor;

            string text = null;
            if (font.Unicode)
            {
                StringBuilder sb = new StringBuilder();
                bool isSymbolFont = descriptor.FontFace.cmap.symbol;
                for (int idx = 0; idx < s.Length; idx++)
                {
                    char ch = s[idx];
                    if (isSymbolFont)
                    {
                        // Remap ch for symbol fonts.
                        ch = (char)(ch | (descriptor.FontFace.os2.usFirstCharIndex & 0xFF00));  // @@@ refactor
                    }
                    int glyphID = descriptor.CharCodeToGlyphIndex(ch);
                    sb.Append((char)glyphID);
                }
                s = sb.ToString();

                byte[] bytes = PdfEncoders.RawUnicodeEncoding.GetBytes(s);
                bytes = PdfEncoders.FormatStringLiteral(bytes, true, false, true, null);
                text = PdfEncoders.RawEncoding.GetString(bytes, 0, bytes.Length);
            }
            else
            {
                byte[] bytes = PdfEncoders.WinAnsiEncoding.GetBytes(s);
                text = PdfEncoders.ToStringLiteral(bytes, false, null);
            }

            // Map absolute position to PDF world space.
            XPoint pos = new XPoint(x, y);
            pos = WorldToView(pos);

            double verticalOffset = 0;
            if (boldSimulation)
            {
                // Adjust baseline in case of bold simulation???
                // No, because this would change the center of the glyphs.
                //verticalOffset = font.Size * Const.BoldEmphasis / 2;
            }

#if ITALIC_SIMULATION
            if (italicSimulation)
            {
                if (_gfxState.ItalicSimulationOn)
                {
                    AdjustTdOffset(ref pos, verticalOffset, true);
                    AppendFormatArgs("{0:" + format2 + "} {1:" + format2 + "} Td\n{2} Tj\n", pos.X, pos.Y, text);
                }
                else
                {
                    // Italic simulation is done by skewing characters 20° to the right.
                    XMatrix m = new XMatrix(1, 0, Const.ItalicSkewAngleSinus, 1, pos.X, pos.Y);
                    AppendFormatArgs("{0:" + format2 + "} {1:" + format2 + "} {2:" + format2 + "} {3:" + format2 + "} {4:" + format2 + "} {5:" + format2 + "} Tm\n{6} Tj\n",
                        m.M11, m.M12, m.M21, m.M22, m.OffsetX, m.OffsetY, text);
                    _gfxState.ItalicSimulationOn = true;
                    AdjustTdOffset(ref pos, verticalOffset, false);
                }
            }
            else
            {
                if (_gfxState.ItalicSimulationOn)
                {
                    XMatrix m = new XMatrix(1, 0, 0, 1, pos.X, pos.Y);
                    AppendFormatArgs("{0:" + format2 + "} {1:" + format2 + "} {2:" + format2 + "} {3:" + format2 + "} {4:" + format2 + "} {5:" + format2 + "} Tm\n{6} Tj\n",
                        m.M11, m.M12, m.M21, m.M22, m.OffsetX, m.OffsetY, text);
                    _gfxState.ItalicSimulationOn = false;
                    AdjustTdOffset(ref pos, verticalOffset, false);
                }
                else
                {
                    AdjustTdOffset(ref pos, verticalOffset, false);
                    AppendFormatArgs("{0:" + format2 + "} {1:" + format2 + "} Td {2} Tj\n", pos.X, pos.Y, text);
                }
            }
#else
                AdjustTextMatrix(ref pos);
                AppendFormat2("{0:" + format2 + "} {1:" + format2 + "} Td {2} Tj\n", pos.X, pos.Y, text);
#endif
            if (underline)
            {
                double underlinePosition = lineSpace * realizedFont.FontDescriptor._descriptor.UnderlinePosition / font.CellSpace;
                double underlineThickness = lineSpace * realizedFont.FontDescriptor._descriptor.UnderlineThickness / font.CellSpace;
                //DrawRectangle(null, brush, x, y - underlinePosition, width, underlineThickness);
                double underlineRectY = Gfx.PageDirection == XPageDirection.Downwards
                    ? y - underlinePosition
                    : y + underlinePosition - underlineThickness;
                DrawRectangle(null, brush, x, underlineRectY, width, underlineThickness);
            }

            if (strikeout)
            {
                double strikeoutPosition = lineSpace * realizedFont.FontDescriptor._descriptor.StrikeoutPosition / font.CellSpace;
                double strikeoutSize = lineSpace * realizedFont.FontDescriptor._descriptor.StrikeoutSize / font.CellSpace;
                //DrawRectangle(null, brush, x, y - strikeoutPosition - strikeoutSize, width, strikeoutSize);
                double strikeoutRectY = Gfx.PageDirection == XPageDirection.Downwards
                    ? y - strikeoutPosition
                    : y + strikeoutPosition - strikeoutSize;
                DrawRectangle(null, brush, x, strikeoutRectY, width, strikeoutSize);
            }
        }
    // ----- DrawString ---------------------------------------------------------------------------

    public void DrawString(string s, XFont font, XBrush brush, XRect rect, XStringFormat format)
    {
      Realize(font, brush, 0);

      double x = rect.X;
      double y = rect.Y;

      double lineSpace = font.GetHeight(this.gfx);
      //int cellSpace = font.cellSpace; // font.FontFamily.GetLineSpacing(font.Style);
      //int cellAscent = font.cellAscent; // font.FontFamily.GetCellAscent(font.Style);
      //int cellDescent = font.cellDescent; // font.FontFamily.GetCellDescent(font.Style);
      //double cyAscent = lineSpace * cellAscent / cellSpace;
      //double cyDescent = lineSpace * cellDescent / cellSpace;
      double cyAscent = lineSpace * font.cellAscent / font.cellSpace;
      double cyDescent = lineSpace * font.cellDescent / font.cellSpace;
      double width = this.gfx.MeasureString(s, font).Width;

      bool bold = (font.Style & XFontStyle.Bold) != 0;
      bool italic = (font.Style & XFontStyle.Italic) != 0;
      bool strikeout = (font.Style & XFontStyle.Strikeout) != 0;
      bool underline = (font.Style & XFontStyle.Underline) != 0;

      switch (format.Alignment)
      {
        case XStringAlignment.Near:
          // nothing to do
          break;

        case XStringAlignment.Center:
          x += (rect.Width - width) / 2;
          break;

        case XStringAlignment.Far:
          x += rect.Width - width;
          break;
      }
      if (Gfx.PageDirection == XPageDirection.Downwards)
      {
        switch (format.LineAlignment)
        {
          case XLineAlignment.Near:
            y += cyAscent;
            break;

          case XLineAlignment.Center:
            // TODO use CapHeight. PDFlib also uses 3/4 of ascent
            y += (cyAscent * 3 / 4) / 2 + rect.Height / 2;
            break;

          case XLineAlignment.Far:
            y += -cyDescent + rect.Height;
            break;

          case XLineAlignment.BaseLine:
            // nothing to do
            break;
        }
      }
      else
      {
        switch (format.LineAlignment)
        {
          case XLineAlignment.Near:
            y += cyDescent;
            break;

          case XLineAlignment.Center:
            // TODO use CapHeight. PDFlib also uses 3/4 of ascent
            y += -(cyAscent * 3 / 4) / 2 + rect.Height / 2;
            break;

          case XLineAlignment.Far:
            y += -cyAscent + rect.Height;
            break;

          case XLineAlignment.BaseLine:
            // nothing to do
            break;
        }
      }

      PdfFont realizedFont = this.gfxState.realizedFont;
      Debug.Assert(realizedFont != null);
      realizedFont.AddChars(s);

      OpenTypeDescriptor descriptor = realizedFont.FontDescriptor.descriptor;

      if (bold && !descriptor.IsBoldFace)
      {
        // TODO: emulate bold by thicker outline
      }

      if (italic && !descriptor.IsBoldFace)
      {
        // TODO: emulate italic by shearing transformation
      }

      if (font.Unicode)
      {
        string s2 = "";
        for (int idx = 0; idx < s.Length; idx++)
        {
          char ch = s[idx];
          int glyphID = 0;
          if (descriptor.fontData.cmap.symbol)
          {
            glyphID = (int)ch + (descriptor.fontData.os2.usFirstCharIndex & 0xFF00);
            glyphID = descriptor.CharCodeToGlyphIndex((char)glyphID);
          }
          else
            glyphID = descriptor.CharCodeToGlyphIndex(ch);
          s2 += (char)glyphID;
        }
        s = s2;

        byte[] bytes = PdfEncoders.RawUnicodeEncoding.GetBytes(s);
        bytes = PdfEncoders.FormatStringLiteral(bytes, true, false, true, null);
        string text = PdfEncoders.RawEncoding.GetString(bytes, 0, bytes.Length);
        XPoint pos = new XPoint(x, y);
        AdjustTextMatrix(ref pos);
        AppendFormat(
          "{0:0.####} {1:0.####} Td {2} Tj\n", pos.x, pos.y, text);
        //PdfEncoders.ToStringLiteral(s, PdfStringEncoding.RawEncoding, null));
      }
      else
      {
        byte[] bytes = PdfEncoders.WinAnsiEncoding.GetBytes(s);
        XPoint pos = new XPoint(x, y);
        AdjustTextMatrix(ref pos);
        AppendFormat(
          "{0:0.####} {1:0.####} Td {2} Tj\n", pos.x, pos.y,
          PdfEncoders.ToStringLiteral(bytes, false, null));
      }

      if (underline)
      {
        double underlinePosition = lineSpace * realizedFont.FontDescriptor.descriptor.UnderlinePosition / font.cellSpace;
        double underlineThickness = lineSpace * realizedFont.FontDescriptor.descriptor.UnderlineThickness / font.cellSpace;
        DrawRectangle(null, brush, x, y - underlinePosition, width, underlineThickness);
      }

      if (strikeout)
      {
        double strikeoutPosition = lineSpace * realizedFont.FontDescriptor.descriptor.StrikeoutPosition / font.cellSpace;
        double strikeoutSize = lineSpace * realizedFont.FontDescriptor.descriptor.StrikeoutSize / font.cellSpace;
        DrawRectangle(null, brush, x, y - strikeoutPosition - strikeoutSize, width, strikeoutSize);
      }
    }