/// <summary>
    /// Demonstrates the use of XLinearGradientBrush.
    /// </summary>
    public override void RenderPage(XGraphics gfx)
    {
      base.RenderPage(gfx);

      XRect rect;
      XLinearGradientBrush brush;
      Graphics grfx = gfx.Internals.Graphics;

      XLinearGradientBrush brush2 = 
        new XLinearGradientBrush(
        new XPoint(100, 100), 
        new XPoint(300, 300), 
        XColors.DarkRed, XColors.Yellow);

      //gfx.FillRectangle(brush, 0, 0, 600, 600);
      //gfx.TranslateTransform(35, 200);
      //gfx.RotateTransform(17);

      rect = new XRect(20, 50, 100, 200);
      brush = new XLinearGradientBrush(rect, 
        XColors.DarkRed, XColors.Yellow, XLinearGradientMode.Horizontal);
      gfx.DrawRectangle(XPens.Red, brush, rect);

      rect = new XRect(140, 50, 100, 200);
      brush = new XLinearGradientBrush(rect, 
        XColors.DarkRed, XColors.Yellow, XLinearGradientMode.Vertical);
        gfx.DrawRectangle(XPens.Red, brush, rect);

      rect = new XRect(260, 50, 100, 200);
      brush = new XLinearGradientBrush(rect, 
        XColors.DarkRed, XColors.Yellow, XLinearGradientMode.ForwardDiagonal);
        gfx.DrawRectangle(XPens.Red, brush, rect);

      rect = new XRect(380, 50, 100, 200);
      brush = new XLinearGradientBrush(rect, 
        XColors.DarkRed, XColors.Yellow, XLinearGradientMode.BackwardDiagonal);
        gfx.DrawRectangle(XPens.Red, brush, rect);


      gfx.TranslateTransform(80, 250);
      gfx.ScaleTransform(1.1);
      gfx.RotateTransform(20);

      rect = new XRect(20, 50, 100, 200);
      brush = new XLinearGradientBrush(rect, 
        XColors.Orange, XColors.DarkBlue, XLinearGradientMode.Horizontal);
      gfx.DrawRectangle(XPens.Red, brush, rect);

      rect = new XRect(140, 50, 100, 200);
      brush = new XLinearGradientBrush(rect, 
        XColors.Orange, XColors.DarkBlue, XLinearGradientMode.Vertical);
      gfx.DrawRectangle(XPens.Red, brush, rect);

      rect = new XRect(260, 50, 100, 200);
      brush = new XLinearGradientBrush(rect, 
        XColors.Orange, XColors.DarkBlue, XLinearGradientMode.ForwardDiagonal);
      gfx.DrawRectangle(XPens.Red, brush, rect);

      rect = new XRect(380, 50, 100, 200);
      brush = new XLinearGradientBrush(rect, 
        XColors.Orange, XColors.DarkBlue, XLinearGradientMode.BackwardDiagonal);
      gfx.DrawRectangle(XPens.Red, brush, rect);
    }
Ejemplo n.º 2
1
    /// <summary>
    /// Setups the shading pattern from the specified brush.
    /// </summary>
    public void SetupFromBrush(XLinearGradientBrush brush, XMatrix matrix)
    {
      if (brush == null)
        throw new ArgumentNullException("brush");

      PdfShading shading = new PdfShading(this.document);
      shading.SetupFromBrush(brush);
      Elements[Keys.Shading] = shading;
      Elements[Keys.Matrix] = new PdfLiteral("[" + PdfEncoders.ToString(matrix) + "]");
    }
Ejemplo n.º 3
0
        /// <summary>
        /// Setups the shading pattern from the specified brush.
        /// </summary>
        internal void SetupFromBrush(XLinearGradientBrush brush, XMatrix matrix, XGraphicsPdfRenderer renderer)
        {
            if (brush == null)
                throw new ArgumentNullException("brush");

            PdfShading shading = new PdfShading(_document);
            shading.SetupFromBrush(brush, renderer);
            Elements[Keys.Shading] = shading;
            //Elements[Keys.Matrix] = new PdfLiteral("[" + PdfEncoders.ToString(matrix) + "]");
            Elements.SetMatrix(Keys.Matrix, matrix);
        }
Ejemplo n.º 4
0
    static void Main()
    {
      const string watermark = "PDFsharp";
      const int emSize = 150;

      // Get a fresh copy of the sample PDF file
      const string filename = "Portable Document Format.pdf";
      File.Copy(Path.Combine("../../../../../PDFs/", filename),
        Path.Combine(Directory.GetCurrentDirectory(), filename), true);

      // Create the font for drawing the watermark
      XFont font = new XFont("Times New Roman", emSize, XFontStyle.BoldItalic);

      // Open an existing document for editing and loop through its pages
      PdfDocument document = PdfReader.Open(filename);

      // Set version to PDF 1.4 (Acrobat 5) because we use transparency.
      if (document.Version < 14)
        document.Version = 14;

      for (int idx = 0; idx < document.Pages.Count; idx++)
      {
        //if (idx == 1) break;
        PdfPage page = document.Pages[idx];

        switch (idx % 3)
        {
          case 0:
            {
              // Variation 1: Draw watermark as text string

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

#if true_
            // Fill background with linear gradient color
            XRect rect = page.MediaBox.ToXRect();
            XLinearGradientBrush gbrush = new XLinearGradientBrush(rect,
              XColors.LightSalmon, XColors.WhiteSmoke, XLinearGradientMode.Vertical);
            gfx.DrawRectangle(gbrush, rect);
#endif

              // 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(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);
            }
            break;

          case 1:
            {
              // Variation 2: Draw watermark as outlined graphical path

              // 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(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 graphical path
              XGraphicsPath path = new XGraphicsPath();

              // Add the text to the path
              path.AddString(watermark, font.FontFamily, XFontStyle.BoldItalic, 150,
                new XPoint((page.Width - size.Width) / 2, (page.Height - size.Height) / 2),
                XStringFormats.Default);

              // Create a dimmed red pen
              XPen pen = new XPen(XColor.FromArgb(128, 255, 0, 0), 2);

              // Stroke the outline of the path
              gfx.DrawPath(pen, path);
            }
            break;

          case 2:
            {
              // Variation 3: Draw watermark as transparent graphical path above text

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

              // 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 graphical path
              XGraphicsPath path = new XGraphicsPath();

              // Add the text to the path
              path.AddString(watermark, font.FontFamily, XFontStyle.BoldItalic, 150,
                new XPoint((page.Width - size.Width) / 2, (page.Height - size.Height) / 2),
                XStringFormats.Default);

              // Create a dimmed red pen and brush
              XPen pen = new XPen(XColor.FromArgb(50, 75, 0, 130), 3);
              XBrush brush = new XSolidBrush(XColor.FromArgb(50, 106, 90, 205));

              // Stroke the outline of the path
              gfx.DrawPath(pen, brush, path);
            }
            break;
        }
      }
      // Save the document...
      document.Save(filename);
      // ...and start a viewer
      Process.Start(filename);
    }
Ejemplo n.º 5
0
 public XBrush Gradient(Rect rect, Color color1, Color color2)
 {
     var brush = new XLinearGradientBrush(rect.ToRectangleF(), color1, color2, XLinearGradientMode.ForwardDiagonal);
     //m_items.Add(brush);
     return brush;
 }
Ejemplo n.º 6
0
    /// <summary>
    /// Renders the content of the page.
    /// </summary>
    public void Render(XGraphics gfx)
    {
      XRect rect;
      XPen pen;
      double x = 50, y = 100;
      XFont fontH1 = new XFont("Times", 18, XFontStyle.Bold);
      XFont font = new XFont("Times", 12);
      XFont fontItalic = new XFont("Times", 12, XFontStyle.BoldItalic);
      double ls = font.GetHeight(gfx);

      // Draw some text
      gfx.DrawString("Create PDF on the fly with PDFsharp",
          fontH1, XBrushes.Black, x, x);
      gfx.DrawString("With PDFsharp you can use the same code to draw graphic, " +
          "text and images on different targets.", font, XBrushes.Black, x, y);
      y += ls;
      gfx.DrawString("The object used for drawing is the XGraphics object.", 
          font, XBrushes.Black, x, y);
      y += 2 * ls;

      // Draw an arc
      pen = new XPen(XColors.Red, 4);
      pen.DashStyle = XDashStyle.Dash;
      gfx.DrawArc(pen, x + 20, y, 100, 60, 150, 120);

      // Draw a star
      XGraphicsState gs = gfx.Save();
      gfx.TranslateTransform(x + 140, y + 30);
      for (int idx = 0; idx < 360; idx += 10)
      {
        gfx.RotateTransform(10);
        gfx.DrawLine(XPens.DarkGreen, 0, 0, 30, 0);
      }
      gfx.Restore(gs);

      // Draw a rounded rectangle
      rect = new XRect(x + 230, y, 100, 60);
      pen = new XPen(XColors.DarkBlue, 2.5);
      XColor color1 = XColor.FromKnownColor(KnownColor.DarkBlue);
      XColor color2 = XColors.Red;
      XLinearGradientBrush lbrush = new XLinearGradientBrush(rect, color1, color2, 
        XLinearGradientMode.Vertical);
      gfx.DrawRoundedRectangle(pen, lbrush, rect, new XSize(10, 10));
      
      // Draw a pie
      pen = new XPen(XColors.DarkOrange, 1.5);
      pen.DashStyle = XDashStyle.Dot;
      gfx.DrawPie(pen, XBrushes.Blue, x + 360, y, 100, 60, -130, 135);
      
      // Draw some more text
      y += 60 + 2 * ls;
      gfx.DrawString("With XGraphics you can draw on a PDF page as well as " +
          "on any System.Drawing.Graphics object.", font, XBrushes.Black, x, y);
      y += ls * 1.1;
      gfx.DrawString("Use the same code to", font, XBrushes.Black, x, y);
      x += 10;
      y += ls * 1.1;
      gfx.DrawString("• draw on a newly created PDF page", font, XBrushes.Black, x, y);
      y += ls;
      gfx.DrawString("• draw above or beneath of the content of an existing PDF page", 
          font, XBrushes.Black, x, y);
      y += ls;
      gfx.DrawString("• draw in a window", font, XBrushes.Black, x, y);
      y += ls;
      gfx.DrawString("• draw on a printer", font, XBrushes.Black, x, y);
      y += ls;
      gfx.DrawString("• draw in a bitmap image", font, XBrushes.Black, x, y);
      x -= 10;
      y += ls * 1.1;
      gfx.DrawString("You can also import an existing PDF page and use it like " +
          "an image, e.g. draw it on another PDF page.", font, XBrushes.Black, x, y);
      y += ls * 1.1 * 2;
      gfx.DrawString("Imported PDF pages are neither drawn nor printed; create a " + 
          "PDF file to see or print them!", fontItalic, XBrushes.Firebrick, x, y);
      y += ls * 1.1;
      gfx.DrawString("Below this text is a PDF form that will be visible when " + 
          "viewed or printed with a PDF viewer.", fontItalic, XBrushes.Firebrick, x, y);
      y += ls * 1.1;
      XGraphicsState state = gfx.Save();
      XRect rcImage = new XRect(100, y, 100, 100 * Math.Sqrt(2));
      gfx.DrawRectangle(XBrushes.Snow, rcImage);
      gfx.DrawImage(XPdfForm.FromFile("../../../../../PDFs/SomeLayout.pdf"), rcImage);
      gfx.Restore(state);
    }
    void RealizeLinearGradientBrush(LinearGradientBrush brush, XForm xform)
    {
      XMatrix matrix = this.currentTransform;
      PdfShadingPattern pattern = new PdfShadingPattern(this.writer.Owner);
      pattern.Elements[PdfShadingPattern.Keys.PatternType] = new PdfInteger(2); // shading pattern

      // Setup shading
      PdfShading shading = new PdfShading(this.writer.Owner);
      PdfColorMode colorMode = PdfColorMode.Rgb; //this.document.Options.ColorMode;

      PdfDictionary function = BuildShadingFunction(brush.GradientStops, colorMode);
      function.Elements.SetString("/@", "This is the shading function of a LinearGradientBrush");
      shading.Elements[PdfShading.Keys.Function] = function;

      shading.Elements[PdfShading.Keys.ShadingType] = new PdfInteger(2); // Axial shading
      //if (colorMode != PdfColorMode.Cmyk)
      shading.Elements[PdfShading.Keys.ColorSpace] = new PdfName("/DeviceRGB");
      //else
      //shading.Elements[Keys.ColorSpace] = new PdfName("/DeviceCMYK");

      //double x1 = 0, y1 = 0, x2 = 0, y2 = 0;
      double x1 = brush.StartPoint.X;
      double y1 = brush.StartPoint.Y;
      double x2 = brush.EndPoint.X;
      double y2 = brush.EndPoint.Y;

      shading.Elements[PdfShading.Keys.Coords] = new PdfLiteral("[{0:0.###} {1:0.###} {2:0.###} {3:0.###}]", x1, y1, x2, y2);

      // old: Elements[Keys.Background] = new PdfRawItem("[0 1 1]");
      // old: Elements[Keys.Domain] = 
      shading.Elements[PdfShading.Keys.Extend] = new PdfLiteral("[true true]");

      // Setup pattern
      pattern.Elements[PdfShadingPattern.Keys.Shading] = shading;
      pattern.Elements[PdfShadingPattern.Keys.Matrix] = PdfLiteral.FromMatrix(matrix); // new PdfLiteral("[" + PdfEncoders.ToString(matrix) + "]");

      string name = this.writer.Resources.AddPattern(pattern);
      this.writer.WriteLiteral("/Pattern cs\n", name);
      this.writer.WriteLiteral("{0} scn\n", name);

      double alpha = brush.Opacity * brush.GradientStops.GetAverageAlpha();
      if (alpha < 1 && this.writer.renderMode == RenderMode.Default)
      {
#if true
        PdfExtGState extGState = this.writer.Owner.ExtGStateTable.GetExtGStateNonStroke(alpha);
        string gs = this.writer.Resources.AddExtGState(extGState);
        this.writer.WriteLiteral("{0} gs\n", gs);
#else
#if true
        if (xform == null)
        {
          PdfExtGState extGState = this.writer.Owner.ExtGStateTable.GetExtGStateNonStroke(alpha);
          string gs = this.writer.Resources.AddExtGState(extGState);
          this.writer.WriteGraphicState(extGState);
        }
        else
        {
          //PdfFormXObject pdfForm = this.writer.Owner.FormTable.GetForm(form);
          PdfFormXObject pdfForm = xform.pdfForm;
          pdfForm.Elements.SetString("/@", "This is the Form XObject of the soft mask");

          string formName = this.writer.Resources.AddForm(pdfForm);

          PdfTransparencyGroupAttributes tgAttributes = new PdfTransparencyGroupAttributes(this.writer.Owner);
          //this.writer.Owner.Internals.AddObject(tgAttributes);
          tgAttributes.Elements.SetName(PdfTransparencyGroupAttributes.Keys.CS, "/DeviceRGB");

          // Set reference to transparency group attributes
          pdfForm.Elements.SetObject(PdfFormXObject.Keys.Group, tgAttributes);
          pdfForm.Elements[PdfFormXObject.Keys.Matrix] = new PdfLiteral("[1.001 0 0 1.001 0.001 0.001]");


          PdfSoftMask softmask = new PdfSoftMask(this.writer.Owner);
          this.writer.Owner.Internals.AddObject(softmask);
          softmask.Elements.SetString("/@", "This is the soft mask");
          softmask.Elements.SetName(PdfSoftMask.Keys.S, "/Luminosity");
          softmask.Elements.SetReference(PdfSoftMask.Keys.G, pdfForm);
          //pdfForm.Elements.SetName(PdfFormXObject.Keys.Type, "Group");
          //pdfForm.Elements.SetName(PdfFormXObject.Keys.ss.Ss.Type, "Group");

          PdfExtGState extGState = new PdfExtGState(this.writer.Owner);
          this.writer.Owner.Internals.AddObject(extGState);
          extGState.Elements.SetReference(PdfExtGState.Keys.SMask, softmask);
          this.writer.WriteGraphicState(extGState);
        }

#else
        XForm form = new XForm(this.writer.Owner, 220, 140);
        XGraphics formGfx = XGraphics.FromForm(form);

        // draw something
        //XSolidBrush xbrush = new XSolidBrush(XColor.FromArgb(128, 128, 128));
        XLinearGradientBrush xbrush = new XLinearGradientBrush(new XPoint(0, 0), new XPoint(220,0), XColors.White, XColors.Black);
        formGfx.DrawRectangle(xbrush, -10000, -10000, 20000, 20000);
        //formGfx.DrawString("Text, Graphics, Images, and Forms", new XFont("Verdana", 10, XFontStyle.Regular), XBrushes.Navy, 3, 0, XStringFormat.TopLeft);
        formGfx.Dispose();

        // Close form
        form.Finish();
        PdfFormXObject pdfForm = this.writer.Owner.FormTable.GetForm(form);
        string formName = this.writer.Resources.AddForm(pdfForm);

        //double x = 20, y = 20;
        //double cx = 1;
        //double cy = 1;

        //this.writer.AppendFormat("q {2:0.###} 0 0 -{3:0.###} {0:0.###} {4:0.###} cm 100 Tz {5} Do Q\n",
        //  x, y, cx, cy, y + 0, formName);

        //this.writer.AppendFormat("q {2:0.###} 0 0 -{3:0.###} {0:0.###} {4:0.###} cm 100 Tz {5} Do Q\n",
        //  x, y, cx, cy, y + 220/1.5, formName);

        PdfTransparencyGroupAttributes tgAttributes = new PdfTransparencyGroupAttributes(this.writer.Owner);
        this.writer.Owner.Internals.AddObject(tgAttributes);

        tgAttributes.Elements.SetName(PdfTransparencyGroupAttributes.Keys.CS, "/DeviceRGB");


        // Set reference to transparency group attributes
        pdfForm.Elements.SetReference(PdfFormXObject.Keys.Group, tgAttributes);


        PdfSoftMask softmask = new PdfSoftMask(this.writer.Owner);
        this.writer.Owner.Internals.AddObject(softmask);
        softmask.Elements.SetName(PdfSoftMask.Keys.S, "/Luminosity");
        softmask.Elements.SetReference(PdfSoftMask.Keys.G, pdfForm);
        //pdfForm.Elements.SetName(PdfFormXObject.Keys.Type, "Group");
        //pdfForm.Elements.SetName(PdfFormXObject.Keys.ss.Ss.Type, "Group");

        PdfExtGState extGState = new PdfExtGState(this.writer.Owner);
        this.writer.Owner.Internals.AddObject(extGState);
        extGState.Elements.SetReference(PdfExtGState.Keys.SMask, softmask);
        this.writer.WriteGraphicState(extGState);
#endif
#endif
      }
    }
Ejemplo n.º 8
0
    /// <summary>
    /// Setups the shading from the specified brush.
    /// </summary>
    public void SetupFromBrush(XLinearGradientBrush brush)
    {
      if (brush == null)
        throw new ArgumentNullException("brush");

      PdfColorMode colorMode = this.document.Options.ColorMode;
      XColor color1 = ColorSpaceHelper.EnsureColorMode(colorMode, brush.color1);
      XColor color2 = ColorSpaceHelper.EnsureColorMode(colorMode, brush.color2);

      PdfDictionary function = new PdfDictionary();

      Elements[Keys.ShadingType] = new PdfInteger(2);
      if (colorMode != PdfColorMode.Cmyk)
        Elements[Keys.ColorSpace] = new PdfName("/DeviceRGB");
      else
        Elements[Keys.ColorSpace] = new PdfName("/DeviceCMYK");

      double x1 = 0, y1 = 0, x2 = 0, y2 = 0;
      if (brush.useRect)
      {
        switch (brush.linearGradientMode)
        {
          case XLinearGradientMode.Horizontal:
            x1 = brush.rect.x;
            y1 = brush.rect.y;
            x2 = brush.rect.x + brush.rect.width;
            y2 = brush.rect.y;
            break;

          case XLinearGradientMode.Vertical:
            x1 = brush.rect.x;
            y1 = brush.rect.y;
            x2 = brush.rect.x;
            y2 = brush.rect.y + brush.rect.height;
            break;

          case XLinearGradientMode.ForwardDiagonal:
            x1 = brush.rect.x;
            y1 = brush.rect.y;
            x2 = brush.rect.x + brush.rect.width;
            y2 = brush.rect.y + brush.rect.height;
            break;

          case XLinearGradientMode.BackwardDiagonal:
            x1 = brush.rect.x + brush.rect.width;
            y1 = brush.rect.y;
            x2 = brush.rect.x;
            y2 = brush.rect.y + brush.rect.height;
            break;
        }
      }
      else
      {
        x1 = brush.point1.x;
        y1 = brush.point1.y;
        x2 = brush.point2.x;
        y2 = brush.point2.y;
      }
      Elements[Keys.Coords] = new PdfLiteral("[{0:0.###} {1:0.###} {2:0.###} {3:0.###}]", x1, y1, x2, y2);

      //Elements[Keys.Background] = new PdfRawItem("[0 1 1]");
      //Elements[Keys.Domain] = 
      Elements[Keys.Function] = function;
      //Elements[Keys.Extend] = new PdfRawItem("[true true]");

      string clr1 = "[" + PdfEncoders.ToString(color1, colorMode) + "]";
      string clr2 = "[" + PdfEncoders.ToString(color2, colorMode) + "]";

      function.Elements["/FunctionType"] = new PdfInteger(2);
      function.Elements["/C0"] = new PdfLiteral(clr1);
      function.Elements["/C1"] = new PdfLiteral(clr2);
      function.Elements["/Domain"] = new PdfLiteral("[0 1]");
      function.Elements["/N"] = new PdfInteger(1);
    }
Ejemplo n.º 9
0
    /// <summary>
    /// Draws all charts inside the ChartFrame.
    /// </summary>
    public void Draw(XGraphics gfx)
    {
      // Draw frame of ChartFrame. First shadow frame.
      int dx = 5;
      int dy = 5;
      gfx.DrawRoundedRectangle(XBrushes.Gainsboro,
                               this.location.X + dx, this.location.Y + dy,
                               this.size.Width, this.size.Height, 20, 20);

      XRect chartRect = new XRect(this.location.X, this.location.Y, this.size.Width, this.size.Height);
      XLinearGradientBrush brush = new XLinearGradientBrush(chartRect, XColor.FromArgb(0xFFD0DEEF), XColors.White,
                                                            XLinearGradientMode.Vertical);
      XPen penBorder = new XPen(XColors.SteelBlue, 2.5);
      gfx.DrawRoundedRectangle(penBorder, brush,
                               this.location.X, this.location.Y, this.size.Width, this.size.Height,
                               15, 15);

      XGraphicsState state = gfx.Save();
      gfx.TranslateTransform(this.location.X, this.location.Y);

      // Calculate rectangle for all charts. Y-Position will be moved for each chart.
      int charts = this.chartList.Count;
      uint dxChart = 20;
      uint dyChart = 20;
      uint dyBetweenCharts = 30;
      XRect rect = new XRect(dxChart, dyChart,
        this.size.Width - 2 * dxChart,
        (this.size.Height - (charts - 1) * dyBetweenCharts - 2 * dyChart) / charts);

      // draw each chart in list
      foreach (Chart chart in this.chartList)
      {
        RendererParameters parms = new RendererParameters(gfx, rect);
        parms.DrawingItem = chart;

        ChartRenderer renderer = GetChartRenderer(chart, parms);
        renderer.Init();
        renderer.Format();
        renderer.Draw();

        rect.Y += rect.Height + dyBetweenCharts;
      }
      gfx.Restore(state);

//      // Calculate rectangle for all charts. Y-Position will be moved for each chart.
//      int charts = this.chartList.Count;
//      uint dxChart = 0;
//      uint dyChart = 0;
//      uint dyBetweenCharts = 0;
//      XRect rect = new XRect(dxChart, dyChart,
//        this.size.Width - 2 * dxChart,
//        (this.size.Height - (charts - 1) * dyBetweenCharts - 2 * dyChart) / charts);
//
//      // draw each chart in list
//      foreach (Chart chart in this.chartList)
//      {
//        RendererParameters parms = new RendererParameters(gfx, rect);
//        parms.DrawingItem = chart;
//
//        ChartRenderer renderer = GetChartRenderer(chart, parms);
//        renderer.Init();
//        renderer.Format();
//        renderer.Draw();
//
//        rect.Y += rect.Height + dyBetweenCharts;
//      }
    }
Ejemplo n.º 10
0
        /// <summary>
        /// Setups the shading from the specified brush.
        /// </summary>
        internal void SetupFromBrush(XLinearGradientBrush brush, XGraphicsPdfRenderer renderer)
        {
            if (brush == null)
                throw new ArgumentNullException("brush");

            PdfColorMode colorMode = _document.Options.ColorMode;
            XColor color1 = ColorSpaceHelper.EnsureColorMode(colorMode, brush._color1);
            XColor color2 = ColorSpaceHelper.EnsureColorMode(colorMode, brush._color2);

            PdfDictionary function = new PdfDictionary();

            Elements[Keys.ShadingType] = new PdfInteger(2);
            if (colorMode != PdfColorMode.Cmyk)
                Elements[Keys.ColorSpace] = new PdfName("/DeviceRGB");
            else
                Elements[Keys.ColorSpace] = new PdfName("/DeviceCMYK");

            double x1 = 0, y1 = 0, x2 = 0, y2 = 0;
            if (brush._useRect)
            {
                XPoint pt1 = renderer.WorldToView(brush._rect.TopLeft);
                XPoint pt2 = renderer.WorldToView(brush._rect.BottomRight);

                switch (brush._linearGradientMode)
                {
                    case XLinearGradientMode.Horizontal:
                        x1 = pt1.X;
                        y1 = pt1.Y;
                        x2 = pt2.X;
                        y2 = pt1.Y;
                        break;

                    case XLinearGradientMode.Vertical:
                        x1 = pt1.X;
                        y1 = pt1.Y;
                        x2 = pt1.X;
                        y2 = pt2.Y;
                        break;

                    case XLinearGradientMode.ForwardDiagonal:
                        x1 = pt1.X;
                        y1 = pt1.Y;
                        x2 = pt2.X;
                        y2 = pt2.Y;
                        break;

                    case XLinearGradientMode.BackwardDiagonal:
                        x1 = pt2.X;
                        y1 = pt1.Y;
                        x2 = pt1.X;
                        y2 = pt2.Y;
                        break;
                }
            }
            else
            {
                XPoint pt1 = renderer.WorldToView(brush._point1);
                XPoint pt2 = renderer.WorldToView(brush._point2);

                x1 = pt1.X;
                y1 = pt1.Y;
                x2 = pt2.X;
                y2 = pt2.Y;
            }

            const string format = Config.SignificantFigures3;
            Elements[Keys.Coords] = new PdfLiteral("[{0:" + format + "} {1:" + format + "} {2:" + format + "} {3:" + format + "}]", x1, y1, x2, y2);

            //Elements[Keys.Background] = new PdfRawItem("[0 1 1]");
            //Elements[Keys.Domain] = 
            Elements[Keys.Function] = function;
            //Elements[Keys.Extend] = new PdfRawItem("[true true]");

            string clr1 = "[" + PdfEncoders.ToString(color1, colorMode) + "]";
            string clr2 = "[" + PdfEncoders.ToString(color2, colorMode) + "]";

            function.Elements["/FunctionType"] = new PdfInteger(2);
            function.Elements["/C0"] = new PdfLiteral(clr1);
            function.Elements["/C1"] = new PdfLiteral(clr2);
            function.Elements["/Domain"] = new PdfLiteral("[0 1]");
            function.Elements["/N"] = new PdfInteger(1);
        }
Ejemplo n.º 11
0
    /// <summary>
    /// Converts a GDI-Brush to a PDF-XBrush.
    /// </summary>
    /// <remarks>
    /// Only Solid- and LinearGradientBrushes are supported. 
    /// </remarks>
    /// <param name="brush">The GDI-Brush to convert.</param>
    /// <returns>The converted PDF-XBrush.</returns>
    private static XBrush BrushToXBrush(Brush brush)
    {
      XBrush xbrush;
      SolidBrush solidBrush;
      LinearGradientBrush lgBrush;
      if((solidBrush = brush as SolidBrush) != null)
      {
        xbrush = new XSolidBrush(solidBrush.Color);
      }
      else if((lgBrush = brush as LinearGradientBrush) != null)
      {
        //There is no way to extract the angle of the gradient out of the GDI-brush.
        //It only has a transformation matrix. To create a new gradient for pdfsharp,
        //we use this matrix as follows:
        //Create a "line" (start and end point) through the rectangle at the half of
        //the heigth. The two points are p1 and p2. Transform these points with the
        //matrix. The transformed points are located on the border of the rectangle.
        PointF p1 = new PointF(lgBrush.Rectangle.Left, lgBrush.Rectangle.Top + lgBrush.Rectangle.Height/2.0f);
        PointF p2 = new PointF(lgBrush.Rectangle.Right, lgBrush.Rectangle.Top + lgBrush.Rectangle.Height/2.0f);
        PointF[] points = new[] {p1, p2};
        lgBrush.Transform.TransformPoints(points);
        p1 = points[0];
        p2 = points[1];

        //The direction is ok now. But the line might be to short. That is the case if
        //the line is neither horizontal, nor vertical, nor diagonal. To fill the whole
        //rectangle with the gradient, the start and end point of the line must be located
        //outside the rectangle. To determine this gap we have to use some trigonometry.
        //This will happily never the case in NClass. So we don't have to do this here.

        xbrush = new XLinearGradientBrush(p1, p2, lgBrush.LinearColors[0], lgBrush.LinearColors[1]);
      }
      else
      {
        throw new NotImplementedException("Brush type not supported by PDFsharp.");
      }
      return xbrush;
    }
Ejemplo n.º 12
-1
        public static void BeginBox(XGraphics gfx, int number, string title,
            double borderWidth, double borderHeight,
            XColor shadowColor, XColor backColor, XColor backColor2,
            XPen borderPen)
        {
            const int dEllipse = 15;
            XRect rect = new XRect(0, 20, 300, 200);
            if (number % 2 == 0)
                rect.X = 300 - 5;
            rect.Y = 40 + ((number - 1) / 2) * (200 - 5);
            rect.Inflate(-10, -10);
            XRect rect2 = rect;
            rect2.Offset(borderWidth, borderHeight);
            gfx.DrawRoundedRectangle(new XSolidBrush(shadowColor), rect2, new XSize(dEllipse + 8, dEllipse + 8));
            XLinearGradientBrush brush = new XLinearGradientBrush(rect, backColor, backColor2, XLinearGradientMode.Vertical);
            gfx.DrawRoundedRectangle(borderPen, brush, rect, new XSize(dEllipse, dEllipse));
            rect.Inflate(-5, -5);

            XFont font = new XFont("Verdana", 12, XFontStyle.Regular);
            gfx.DrawString(title, font, XBrushes.Navy, rect, XStringFormats.TopCenter);

            rect.Inflate(-10, -5);
            rect.Y += 20;
            rect.Height -= 20;

            state = gfx.Save();
            gfx.TranslateTransform(rect.X, rect.Y);
        }