protected override void OnPaintBackground(PaintEventArgs e) { base.OnPaintBackground(e); Graphics g = e.Graphics; // 如果设置了渐变色 if (this.FirstColor != Color.Empty && this.SecondColor != Color.Empty) { if (RoundBorderRadius > 0) { // 填充圆角矩形 using (LinearGradientBrush brush = new LinearGradientBrush( new Point(this.Width / 2, 0), new Point(this.Width / 2, this.Height), this.FirstColor, this.SecondColor )) { g.FillRoundedRectangle(brush, 0, 0, this.Width, this.Height, RoundBorderRadius); } } else { // 填充直角矩形 GradientFill.Fill(g, this.ClientRectangle, this.FirstColor, this.SecondColor, this.GradientDirection); } } if (this.BorderColor != Color.Empty) { if (RoundBorderRadius > 0) { // 画圆角边框 using (Pen borderPen = new Pen(this.BorderColor, BorderWidth)) { g.DrawRoundedRectangle(borderPen, 0, 0, this.Width - 1, this.Height - 1, this.RoundBorderRadius); } } else { // 画直角边框 using (Pen borderPen = new Pen(this.BorderColor, BorderWidth)) { g.DrawRectangle(borderPen, 0, 0, this.Width - 1, this.Height - 1); } } } else { if (BottomBorderColor != Color.Empty) { using (Pen borderPen = new Pen(this.BottomBorderColor, BorderWidth)) { g.DrawLine(borderPen, 0, this.Height - 1, this.Width, this.Height - 1); } } } }
/// <summary> /// 创建渐变填充的圆角矩形位图 /// </summary> /// <param name="rc"></param> /// <param name="startColorValue"></param> /// <param name="endColorValue"></param> /// <param name="borderColor"></param> /// <param name="size"></param> /// <param name="direction"></param> /// <returns></returns> private Bitmap GetGradiendRoundedRectangle(Rectangle rc, Color startColorValue, Color endColorValue, Color borderColor, Size size, FillDirection direction) { Bitmap outputImage = new Bitmap(rc.Width, rc.Height); // Create temporary graphics Graphics gx = Graphics.FromImage(outputImage); GradientFill.Fill( gx, rc, startColorValue, endColorValue, direction); Rectangle roundedRect = rc; roundedRect.Width--; roundedRect.Height--; Bitmap borderImage = ImposeRoundedRectangle(roundedRect, borderColor, size); ImageAttributes attrib = new ImageAttributes(); attrib.SetColorKey(Color.Green, Color.Green); gx.DrawImage(borderImage, rc, 0, 0, borderImage.Width, borderImage.Height, GraphicsUnit.Pixel, attrib); // Clean up attrib.Dispose(); gx.Dispose(); return(outputImage); }
public static float[] GetGradientLine(GradientFill gf) { float[] result = new float[4]; System.Drawing.PointF[] pts = GradientFill.GradientVexRect.SysPointFs(); using (Draw2D.Matrix m = gf.Transform.SysMatrix()) { m.TransformPoints(pts); } if (gf.GradientType == GradientType.Linear) { result[0] = pts[0].X; result[1] = pts[0].Y; result[2] = pts[1].X; result[3] = pts[1].Y; } else // radial is center to rightCenter edge { result[0] = pts[0].X + (pts[1].X - pts[0].X) / 2; result[1] = pts[0].Y + (pts[2].Y - pts[0].Y) / 2; result[2] = pts[1].X; result[3] = pts[1].Y + (pts[2].Y - pts[0].Y) / 2; } return(result); }
static Color32[] RasterizeGradient(GradientFill gradient, int width, int height) { Color32[] pixels = new Color32[width * height]; if (gradient.Type == GradientFillType.Linear) { int pixIndex = 0; for (int x = 0; x < width; x++) { pixels[pixIndex++] = SampleGradient(gradient.Stops, x / (float)(width - 1)); } for (int y = 1; y < height; y++) { Array.Copy(pixels, 0, pixels, pixIndex, width); pixIndex += width; } } else if (gradient.Type == GradientFillType.Radial) { int pixIndex = 0; for (int y = 0; y < height; y++) { float v = y / ((float)height - 1); for (int x = 0; x < width; x++) { float u = x / ((float)width - 1); pixels[pixIndex++] = SampleGradient(gradient.Stops, RadialAddress(new Vector2(u, 1.0f - v), gradient.RadialFocus)); } } } return(pixels); }
internal GradientFillContent(LottieDrawable lottieDrawable, BaseLayer layer, GradientFill fill) { _layer = layer; Name = fill.Name; _lottieDrawable = lottieDrawable; _type = fill.GradientType; _path.FillType = fill.FillType; _cacheSteps = (int)(lottieDrawable.Composition.Duration / CacheStepsMs); _colorAnimation = fill.GradientColor.CreateAnimation(); _colorAnimation.ValueChanged += OnValueChanged; layer.AddAnimation(_colorAnimation); _opacityAnimation = fill.Opacity.CreateAnimation(); _opacityAnimation.ValueChanged += OnValueChanged; layer.AddAnimation(_opacityAnimation); _startPointAnimation = fill.StartPoint.CreateAnimation(); _startPointAnimation.ValueChanged += OnValueChanged; layer.AddAnimation(_startPointAnimation); _endPointAnimation = fill.EndPoint.CreateAnimation(); _endPointAnimation.ValueChanged += OnValueChanged; layer.AddAnimation(_endPointAnimation); }
private static void AddGradient(SpreadsheetDocument spreadSheet, string dummyColorCode, string firstColorCode, string secondColorCode) { var wbPart = spreadSheet.GetPartsOfType <WorkbookPart>().FirstOrDefault(); var wbStylePart = wbPart?.GetPartsOfType <WorkbookStylesPart>().FirstOrDefault(); var stylesheet = wbStylePart?.Stylesheet; var oldFill = stylesheet?.Fills.FirstOrDefault(f => f.OuterXml.Contains(dummyColorCode)); // find the fill that uses your unique color if (oldFill == null) { return; } var gradientFill = new GradientFill { Degree = 0 }; gradientFill.Append(new GradientStop { Position = 0D, Color = new Color { Rgb = firstColorCode } }); gradientFill.Append(new GradientStop { Position = 1D, Color = new Color { Rgb = secondColorCode } }); oldFill.ReplaceChild(gradientFill, oldFill.FirstChild); // inside the fill replace the patternFill with your gradientFill }
private ColorBlend GetColorBlend(GradientFill fill) { List <float> positions = new List <float>(); List <Ms.Color> colors = new List <Ms.Color>(); int numGradients = fill.Fills.Count; for (int i = 0; i < numGradients; i++) { positions.Add(fill.Stops[i]); colors.Add(GetColor(fill.Fills[i])); } // GDI color blends must start at 0.0 and end at 1.0 or they will crash if ((float)positions[0] != 0.0F) { positions.Insert(0, 0.0F); colors.Insert(0, colors[0]); } if ((float)positions[positions.Count - 1] != 1.0F) { positions.Add(1.0F); colors.Add(colors[colors.Count - 1]); } ColorBlend cb = new ColorBlend(positions.Count); cb.Colors = colors.ToArray(); cb.Positions = positions.ToArray(); return(cb); }
public static void Run() { // ExStart:ModifyShapeGradientFillData // The path to the documents directory. string dataDir = RunExamples.GetDataDir_ShapeGradientFillData(); // Load the Visio diagram Diagram diagram = new Diagram(dataDir + "ShapewithGradientFill.vsdx"); // get page by name Aspose.Diagram.Page page = diagram.Pages.GetPage("Page-1"); // get shape by ID Aspose.Diagram.Shape shape = page.Shapes.GetShape(1); // get the gradient fill properties GradientFill gradientfill = shape.Fill.GradientFill; // get the gradient stops GradientStopCollection stops = gradientfill.GradientStops; // get the gradient stop by index GradientStop stop = stops[0]; // set gradient stop properties stop.Color.Ufe.F = ""; stop.Position.Value = 0.5; gradientfill.GradientDir.Value = (int)GradientFillDir.RectangleFromBottomRight; gradientfill.GradientAngle.Value = 0.7853981633974501; // save the Visio drawing diagram.Save(dataDir + "ShapewithGradientFill_out.vsdx", SaveFileFormat.VSDX); // ExEnd:ModifyShapeGradientFillData }
public void SetRunProperties(RunProperties runProperties, DocumentFormat.OpenXml.Presentation.Shape shape, ref LinkedList <string> effectShapes) { if (runProperties != null) { EffectList effects = runProperties.GetFirstChild <EffectList>(); GradientFill gradient = runProperties.GetFirstChild <GradientFill>(); if ((shape.TextBody.BodyProperties != null && shape.TextBody.BodyProperties.FromWordArt != null && shape.TextBody.BodyProperties.FromWordArt) || (effects != null && effects.HasChildren) || (gradient != null && gradient.HasChildren)) { UInt32Value id = shape.NonVisualShapeProperties.NonVisualDrawingProperties.Id; effectShapes.AddLast(slide.slideIndex + "_" + id.Value); } //get the text color. var solidFill = runProperties.GetFirstChild <SolidFill>(); if (solidFill != null) { this.ReadSolidFillColors(solidFill); } if (runProperties.FontSize != null) { FontSize = runProperties.FontSize / Globals.FontPoint; } if (runProperties.Bold != null) { Bold = runProperties.Bold; } if (runProperties.Italic != null) { Italic = runProperties.Italic; } if (runProperties.Underline != null) { Underline = runProperties.Underline.Value.ToString(); } if (runProperties.Spacing != null) { Spacing = runProperties.Spacing.Value; } var latinFonts = runProperties.GetFirstChild <LatinFont>(); var coplexScriptFonts = runProperties.Descendants <ComplexScriptFont>(); if (latinFonts != null) { this.ReadFontFamilyFromTheme(latinFonts); } else if (coplexScriptFonts.GetEnumerator().Current != null) { FontFamily = coplexScriptFonts.GetEnumerator().Current.Typeface; } } }
public GradientColor(Color color1, Color color2, GradientFill gradient) { this.color1 = color1; this.color2 = color2; this.fill = gradient; this.rect = new Rectangle(0, 0, 100, 100); this.align = TabAlignment.Top; }
private void DrawSeparator(PaintEventArgs e, Point point, int widthHeight, Orientation orientation) { for (int i = 0; i < 2; i++) { Color colorL = (i == 0 ? Strings.ToColor(Separator1L) : Strings.ToColor(Separator2L)); Color colorD = (i == 0 ? Strings.ToColor(Separator1D) : Strings.ToColor(Separator2D)); switch (orientation) { case Orientation.Horizontal: { Rectangle rect = new Rectangle(point.X, point.Y + i, widthHeight / 3, 1); if (e.ClipRectangle.IntersectsWith(rect)) { GradientFill.Fill(e.Graphics, rect, colorL, colorD, GradientFill.FillDirection.LeftToRight); } rect.Offset(rect.Width, 0); if (e.ClipRectangle.IntersectsWith(rect)) { e.Graphics.FillRectangle(new SolidBrush(colorD), rect); } rect.Offset(rect.Width, 0); if (e.ClipRectangle.IntersectsWith(rect)) { GradientFill.Fill(e.Graphics, rect, colorD, colorL, GradientFill.FillDirection.LeftToRight); } } break; case Orientation.Vertical: { Rectangle rect = new Rectangle(point.X + i, point.Y, 1, widthHeight / 3); if (e.ClipRectangle.IntersectsWith(rect)) { GradientFill.Fill(e.Graphics, rect, colorL, colorD, GradientFill.FillDirection.TopToBottom); } rect.Offset(0, rect.Height); if (e.ClipRectangle.IntersectsWith(rect)) { e.Graphics.FillRectangle(new SolidBrush(colorD), rect); } rect.Offset(0, rect.Height); if (e.ClipRectangle.IntersectsWith(rect)) { GradientFill.Fill(e.Graphics, rect, colorD, colorL, GradientFill.FillDirection.TopToBottom); } } break; default: break; } } }
static Color32[] RasterizeGradientStripe(GradientFill gradient, int width) { Color32[] pixels = new Color32[width]; for (int x = 0; x < width; ++x) { float u = x / ((float)width - 1); pixels[x] = SampleGradient(gradient.Stops, u); } return(pixels); }
public void SetGradientFill() { #region radspreadsheet-features-formatting-cells_5 Workbook workbook = new Workbook(); Worksheet worksheet = workbook.Worksheets.Add(); worksheet.Rows[0].SetHeight(new RowHeight(50, true)); GradientFill greenGradientFill = new GradientFill(GradientType.Horizontal, Color.FromRgb(46, 204, 113), Color.FromRgb(0, 134, 56)); worksheet.Cells[0, 0, 0, 5].SetFill(greenGradientFill); #endregion }
public void SetGradientFill() { #region radspreadprocessing-working-with-cells-get-set-clear-properties_5 Workbook workbook = new Workbook(); Worksheet worksheet = workbook.Worksheets.Add(); worksheet.Rows[0].SetHeight(new RowHeight(50, true)); GradientFill greenGradientFill = new GradientFill(GradientType.Horizontal, Color.FromRgb(46, 204, 113), Color.FromRgb(0, 134, 56)); worksheet.Cells[0, 0, 0, 5].SetFill(greenGradientFill); #endregion }
void Start() { var tessOptions = new VectorUtils.TessellationOptions() { StepDistance = 100.0f, MaxCordDeviation = 0.5f, MaxTanAngleDeviation = 0.1f, SamplingStepSize = 0.01f }; // Prepare the fill var fill = new GradientFill() { Type = GradientFillType.Linear, Stops = new GradientStop[] { new GradientStop() { Color = Color.blue, StopPercentage = 0.0f }, new GradientStop() { Color = Color.red, StopPercentage = 1.0f }, } }; // Build the scene var cornerRad = new Vector2(10, 10); var rect = VectorUtils.BuildRectangleContour(new Rect(0, 0, 100, 100), cornerRad, cornerRad, cornerRad, cornerRad); var scene = new Scene() { Root = new SceneNode() { Shapes = new List <Shape> { new Shape() { Contours = new BezierContour[] { rect }, Fill = fill } } } }; // Dynamically import the SVG data, and tessellate the resulting vector scene. var geoms = VectorUtils.TessellateScene(scene, tessOptions); // Build a sprite with the tessellated geometry. var sprite = VectorUtils.BuildSprite(geoms, 10.0f, VectorUtils.Alignment.Center, Vector2.zero, 16, true); GetComponent <SpriteRenderer>().sprite = sprite; }
static void ChangeCellGradientFill(IWorkbook workbook) { workbook.BeginUpdate(); try { Worksheet worksheet = workbook.Worksheets[0]; worksheet.Range["C3:F8"].Merge(); worksheet.Range["C3:F8"].Value = "Test"; worksheet.Range["C3:F8"].Alignment.Horizontal = SpreadsheetHorizontalAlignment.Center; worksheet.Range["C3:F8"].Alignment.Vertical = SpreadsheetVerticalAlignment.Center; worksheet.Range["C13:F18"].Merge(); worksheet.Range["C13:F18"].Value = "Test"; worksheet.Range["C13:F18"].Alignment.Horizontal = SpreadsheetHorizontalAlignment.Center; worksheet.Range["C13:F18"].Alignment.Vertical = SpreadsheetVerticalAlignment.Center; #region #GradientLinear // Specify a linear gradient fill for a cell. Fill fillA1 = worksheet.Cells["A1"].Fill; fillA1.FillType = FillType.Gradient; fillA1.Gradient.Type = GradientFillType.Linear; // Set the tilt for the gradient line in degrees. // 90 degree angle defines a color transition from the top to the bottom. fillA1.Gradient.Degree = 90; // Specify two gradient colors. // The position of a color stop should be either 0 (start) or 1 (end). fillA1.Gradient.Stops.Add(0, Color.Yellow); fillA1.Gradient.Stops.Add(1, Color.SkyBlue); // Specify a linear gradient fill for a range. worksheet.Range["C3:F8"].Fill.FillType = FillType.Gradient; GradientFill rangeGradient1 = worksheet.Range["C3:F8"].Fill.Gradient; rangeGradient1.Type = GradientFillType.Linear; // Set the tilt for the gradient line in degrees. // 45 degree angle defines a color transition from top left to bottom right. rangeGradient1.Degree = 45; // Specify two gradient colors. // The position of a color stop should be either 0 (start) or 1 (end). GradientStopCollection rangeStops1 = rangeGradient1.Stops; rangeStops1.Add(0, Color.BlanchedAlmond); rangeStops1.Add(1, Color.Blue); #endregion #GradientLinear } finally { workbook.EndUpdate(); } }
private string GetGradientLineString(GradientFill gf) { string result = ""; float[] pts = GetGradientLine(gf); string comma = ""; for (int i = 0; i < pts.Length; i++) { result += comma + pts[i].ToString("0.##"); comma = ","; } return(result); }
/// <summary> /// 绘制渐变填充的半透明圆角矩形 /// </summary> /// <param name="gx">Destination graphics</param> /// <param name="rc">Destination rectangle</param> /// <param name="startColorValue">Starting color for gradient</param> /// <param name="endColorValue">End color for gradient</param> /// <param name="borderColor">The color of the border</param> /// <param name="size">The size of the rounded corners</param> /// <param name="transparency">Transparency constant</param> public void DrawGradientRoundedRectangleAlpha(Graphics gx, Rectangle rc, Color startColorValue, Color endColorValue, Color borderColor, Size size, byte transparency, FillDirection direction) { // Prepare image for gradient Bitmap gradientImage = new Bitmap(rc.Width, rc.Height); // Create temporary graphics Graphics gxGradient = Graphics.FromImage(gradientImage); // This is our rectangle Rectangle roundedRect = new Rectangle(0, 0, rc.Width, rc.Height); // Fill in gradient GradientFill.Fill( gxGradient, roundedRect, startColorValue, endColorValue, direction); // Prepare the copy of the screen graphics Bitmap tempBitmap = new Bitmap(rc.Width, rc.Height); Graphics tempGx = Graphics.FromImage(tempBitmap); // Copy from the screen's graphics to the temp graphics CopyGraphics(gx, tempGx, rc.Width, rc.Height, rc.X, rc.Y); // Draw the gradient image with transparency on the temp graphics tempGx.DrawAlpha(gradientImage, transparency, rc.X, rc.Y); // Cut out the transparent image gxGradient.DrawImage(tempBitmap, new Rectangle(0, 0, rc.Width, rc.Height), rc, GraphicsUnit.Pixel); // Prepare for imposing roundedRect.Width--; roundedRect.Height--; // Impose the rounded rectangle with transparent color Bitmap borderImage = ImposeRoundedRectangle(roundedRect, borderColor, size); // Draw the transparent rounded rectangle ImageAttributes attrib = new ImageAttributes(); attrib.SetColorKey(Color.Green, Color.Green); gxGradient.DrawImage(borderImage, new Rectangle(0, 0, rc.Width, rc.Height), 0, 0, borderImage.Width, borderImage.Height, GraphicsUnit.Pixel, attrib); // OK... now are ready to draw the final image on the original graphics gx.DrawImageTransparent(gradientImage, rc); // Clean up attrib.Dispose(); tempGx.Dispose(); tempBitmap.Dispose(); gradientImage.Dispose(); gxGradient.Dispose(); }
internal override void DrawHeaderBackGround(HeaderStrip control, PaintEventArgs eventArgs) { Size controlSize = control.Size; if (control.Tabs.Count > 0) { controlSize.Height -= HeaderSelectedTabStrip * ScaleFactor.Height; } Rectangle rect = new Rectangle(eventArgs.ClipRectangle.X, 0, eventArgs.ClipRectangle.Width, controlSize.Height); Color start = Strings.ToColor(HeaderStartColor); Color end = Strings.ToColor(HeaderEndColor); GradientFill.Fill(eventArgs.Graphics, rect, start, end, GradientFill.FillDirection.TopToBottom); eventArgs.Graphics.DrawLine(new Pen(Strings.ToColor(BorderLineColor)), rect.X, rect.Height - 1, rect.Width, rect.Height - 1); }
protected override void OnPaintBackground(PaintEventArgs e) { base.OnPaintBackground(e); Graphics g = e.Graphics; if (this.FirstColor != Color.Empty && this.SecondColor != Color.Empty) { GradientFill.Fill(g, this.ClientRectangle, this.FirstColor, this.SecondColor, this.GradientDirection); } if (this.BorderColor != Color.Empty) { using (Pen borderPen = new Pen(this.BorderColor)) { g.DrawRectangle(borderPen, 0, 0, this.Width - 1, this.Height - 1); } } }
protected override void OnPaintBackground(PaintEventArgs e) { if (this.Focused && !this.ReadOnly) { e.Graphics.Clear(this.m_textBox.BackColor); } else if (this.VisualStyle == Resco.Controls.NumericUpDown.VisualStyle.VistaStyle) { GradientFill.DrawVistaGradient(e.Graphics, this.BackColor, new Rectangle(0, 0, base.Width, base.Height), FillDirection.Vertical); } else if (this.VisualStyle == Resco.Controls.NumericUpDown.VisualStyle.Gradients) { GradientFill.Fill(e.Graphics, base.ClientRectangle, base.ClientRectangle, this.m_gradientColors); } else { base.OnPaintBackground(e); } }
void kListControl1_DrawItem(object sender, Tenor.Mobile.UI.DrawItemEventArgs e) { Graphics g = e.Graphics; StringFormat format = new StringFormat(); format.Alignment = StringAlignment.Near; format.LineAlignment = StringAlignment.Near; SolidBrush textBrush; if (e.Item.Selected) { SolidBrush backBrush; backBrush = new SolidBrush(SystemColors.Highlight); textBrush = new SolidBrush(SystemColors.HighlightText); g.FillRectangle(backBrush, e.Bounds); } else { //backBrush = new SolidBrush(SystemColors.Window); textBrush = new SolidBrush(SystemColors.ControlText); } FF ff = (FF)e.Item.Value; Rectangle iconRect = new Rectangle(e.Bounds.X + 1, e.Bounds.Y + 1, ff.icon.Width, ff.icon.Height); RoundedRectangle.Fill(g, new Pen(SystemColors.ControlDark), new SolidBrush(SystemColors.ControlDark), iconRect, new Size(8, 8)); g.DrawIcon(ff.icon, iconRect.X, iconRect.Y); Rectangle r = e.Bounds; r.X += 32; g.DrawString(" " + ff.file.Name, kListControl1.Font, textBrush, r, format); r.Y += 14; g.DrawString(" " + ff.file.CreationTime.ToString(), kListControl1.Font, textBrush, r, format); Rectangle rect = new Rectangle(e.Bounds.X, e.Bounds.Bottom - 2, Convert.ToInt32(e.Bounds.Width / 2), 2); GradientFill.Fill(g, rect, SystemColors.Window, SystemColors.Control, GradientFill.FillDirection.LeftToRight); rect.Offset(rect.Width, 0); GradientFill.Fill(g, rect, SystemColors.Control, SystemColors.Window, GradientFill.FillDirection.LeftToRight); }
protected override void OnPaintBackground(PaintEventArgs e) { Color aColor = base.Capture ? ((this.PressedBackColor == Color.Transparent) ? this.ForeColor : this.PressedBackColor) : this.BackColor; if (this.m_visualStyle == Resco.Controls.NumericUpDown.VisualStyle.VistaStyle) { GradientFill.DrawVistaGradient(e.Graphics, aColor, base.ClientRectangle, FillDirection.Vertical); } else if (this.m_visualStyle == Resco.Controls.NumericUpDown.VisualStyle.Gradients) { GradientFill.Fill(e.Graphics, base.ClientRectangle, base.ClientRectangle, base.Capture ? this.m_gradientColorsPressed : this.m_gradientColors); } else if (this.m_visualStyle == Resco.Controls.NumericUpDown.VisualStyle.Images) { Image image = null; if (base.Capture) { image = ((e.Graphics.DpiX == 192f) && (this.m_imageVgaPressed != null)) ? this.m_imageVgaPressed : (image = this.m_imagePressed); } if (image == null) { image = ((e.Graphics.DpiX == 192f) && (this.m_imageVgaDefault != null)) ? this.m_imageVgaDefault : this.m_imageDefault; } if (image != null) { e.Graphics.DrawImage(image, base.ClientRectangle, new Rectangle(0, 0, image.Width, image.Height), GraphicsUnit.Pixel); } else { e.Graphics.Clear(aColor); } } else { e.Graphics.Clear(aColor); } }
internal override void DrawListItemBackground(Graphics g, Rectangle bounds, int index, bool selected) { if (selected) { Color gradT = Strings.ToColor(SelectedBackColorGradient); Color selectedColor = SelectedBackColor; Rectangle gradBounds = new Rectangle(bounds.X, bounds.Y, bounds.Width, 5 * ScaleFactor.Height); GradientFill.Fill(g, gradBounds, gradT, selectedColor, GradientFill.FillDirection.TopToBottom); gradBounds = new Rectangle(bounds.X, bounds.Y + gradBounds.Height, bounds.Width, bounds.Height - gradBounds.Height); SolidBrush brush = new SolidBrush(selectedColor); g.FillRectangle(brush, gradBounds); brush.Dispose(); } else { Color color; if (index % 2 == 0) { color = AlternateBackColor; } else { color = ControlBackColor; } SolidBrush brush = new SolidBrush(color); g.FillRectangle(brush, bounds); brush.Dispose(); Pen pen = new Pen(Strings.ToColor(ListSeparatorColor)); g.DrawLine(pen, bounds.X, bounds.Bottom, bounds.Right, bounds.Bottom); pen.Dispose(); } }
/// <summary> /// Form a DocumentFormat.OpenXml.Spreadsheet.GradientFill class from SLGradientFill. /// </summary> /// <returns>A DocumentFormat.OpenXml.Spreadsheet.GradientFill with the properties of this SLGradientFill.</returns> public GradientFill ToGradientFill() { GradientFill gf = new GradientFill(); for (int i = 0; i < this.listGradientStops.Count; ++i) { gf.Append(listGradientStops[i]); } if (HasType) gf.Type = this.Type; if (this.Degree != null) gf.Degree = this.Degree.Value; if (this.Left != null) gf.Left = this.Left.Value; if (this.Right != null) gf.Right = this.Right.Value; if (this.Top != null) gf.Top = this.Top.Value; if (this.Bottom != null) gf.Bottom = this.Bottom.Value; return gf; }
public override void WriteGradientColor(GradientFill gf) { //this.WriteString("#" + gf.Color.ARGB.ToString("X8")); }
/// <summary> /// Form SLGradientFill from DocumentFormat.OpenXml.Spreadsheet.GradientFill class. /// </summary> /// <param name="gradientFill">The source DocumentFormat.OpenXml.Spreadsheet.GradientFill class.</param> public void FromGradientFill(GradientFill gradientFill) { this.SetAllNull(); using (OpenXmlReader oxr = OpenXmlReader.Create(gradientFill)) { while (oxr.Read()) { if (oxr.ElementType == typeof(GradientStop)) { listGradientStops.Add((GradientStop)oxr.LoadCurrentElement().CloneNode(true)); } } } if (gradientFill.Type != null) { this.Type = gradientFill.Type.Value; } if (gradientFill.Degree != null) { this.Degree = gradientFill.Degree.Value; } if (gradientFill.Left != null) { this.Left = gradientFill.Left.Value; } if (gradientFill.Right != null) { this.Right = gradientFill.Right.Value; } if (gradientFill.Top != null) { this.Top = gradientFill.Top.Value; } if (gradientFill.Bottom != null) { this.Bottom = gradientFill.Bottom.Value; } }
private void FillPaths(FillStyle fill, List <GraphicsPath> paths) { Brush b = null; foreach (GraphicsPath path in paths) { path.Transform(translateMatrix); switch (fill.FillType) { case FillType.Solid: SolidFill sf = (SolidFill)fill; b = new SolidBrush(GetColor(sf.Color)); break; case FillType.Linear: GradientFill lf = (GradientFill)fill; RectangleF rect = Vex.GradientFill.GradientVexRect.SysRectangleF(); LinearGradientBrush lgb = new LinearGradientBrush( rect, Ms.Color.White, Ms.Color.White, 1.0F ); lgb.InterpolationColors = GetColorBlend(lf); lgb.Transform = GetMatrix(lf.Transform); lgb.WrapMode = WrapMode.TileFlipX; ExtendGradientBrush(lgb, path); b = lgb; break; case FillType.Radial: GradientFill rf = (GradientFill)fill; ColorBlend cb = GetColorBlend(rf); SolidBrush bkgCol = new SolidBrush(cb.Colors[0]); g.FillPath(bkgCol, path); bkgCol.Dispose(); // radial fill part GraphicsPath gp = new GraphicsPath(); gp.AddEllipse(Vex.GradientFill.GradientVexRect.SysRectangleF()); PathGradientBrush pgb = new PathGradientBrush(gp); pgb.InterpolationColors = GetColorBlend(rf); pgb.Transform = GetMatrix(rf.Transform); b = pgb; break; case FillType.Image: ImageFill imgFill = (ImageFill)fill; Bitmap bmp = new Bitmap(imgFill.ImagePath); b = new TextureBrush(bmp); break; default: b = new SolidBrush(Ms.Color.Red); break; } g.FillPath(b, path); } if (b != null) { b.Dispose(); } }
public static int GetFillIndex(SpreadsheetDocument document, GradientFill gradientFill) { return GetFillIndex(document, gradientFill.GetXElement()); }
public abstract void WriteGradientColor(GradientFill gf);
protected override void RenderPath(FillStyle fs, StrokeStyle ss, List <IShapeData> sh, bool silverlight) { // <Path Fill="#FFFF0000" // StrokeThickness="0.00491913" StrokeLineJoin="Round" Stroke="#FF014393" // Data="M 196.667,4L 388.667,100L 388.667,292L 196.667,388L 4.66669,292L 4.66669,100L 196.667,4 Z "/> if (sh.Count == 0) { return; } xw.WriteStartElement("Path"); bool isGradient = false; bool isTiledBitmap = false; if (fs != null) { if (fs.FillType == FillType.Solid) { Color c = ((SolidFill)fs).Color; xw.WriteStartAttribute("Fill"); xw.WriteColor(c); xw.WriteEndAttribute(); // try to clean up faint edges if (ss == null && c != new Color(0xFF, 0xFF, 0xFF) && c.A != 0) { ss = new SolidStroke(0.3F, c); } } else if ( fs.FillType == FillType.Linear || fs.FillType == FillType.Radial || fs.FillType == FillType.Focal) { isGradient = true; } else if (fs.FillType == FillType.Image) { // Fill="{StaticResource vb_1}" ImageFill img = (ImageFill)fs; if (img.IsTiled || silverlight) { isTiledBitmap = true;// this causes bitmap to be written inline } else { string brushName = imageBrushes[img.ImagePath]; xw.WriteStartAttribute("Fill"); xw.WriteValue("{StaticResource " + brushName + "}"); xw.WriteEndAttribute(); } } } if (ss != null) { if (ss is SolidStroke) { // StrokeThickness="3" StrokeLineJoin="Round" Stroke="#FF014393" // StrokeStartLineCap="Round" // StrokeEndLineCap="Round" SolidStroke st = (SolidStroke)ss; xw.WriteStartAttribute("StrokeThickness"); xw.WriteFloat(st.LineWidth); xw.WriteEndAttribute(); xw.WriteStartAttribute("StrokeLineJoin"); xw.WriteString("Round"); xw.WriteEndAttribute(); xw.WriteStartAttribute("StrokeStartLineCap"); xw.WriteString("Round"); xw.WriteEndAttribute(); xw.WriteStartAttribute("StrokeEndLineCap"); xw.WriteString("Round"); xw.WriteEndAttribute(); xw.WriteStartAttribute("Stroke"); xw.WriteColor(st.Color); xw.WriteEndAttribute(); } } float minX = float.PositiveInfinity; float minY = float.PositiveInfinity; float maxX = float.NegativeInfinity; float maxY = float.NegativeInfinity; xw.WriteStartAttribute("Data"); xw.WriteMoveTo(sh[0].StartPoint); Point lastPoint = sh[0].StartPoint; for (int i = 0; i < sh.Count; i++) { IShapeData sd = sh[i]; if (lastPoint != sd.StartPoint) { xw.WriteMoveTo(sd.StartPoint); } switch (sd.SegmentType) { case SegmentType.Line: xw.WriteLineTo(sd.EndPoint); lastPoint = sd.EndPoint; break; case SegmentType.CubicBezier: CubicBezier cb = (CubicBezier)sd; xw.WriteCubicCurveTo(cb.Control0, cb.Control1, cb.Anchor1); lastPoint = cb.EndPoint; minX = Math.Min(minX, cb.Control0.X); maxX = Math.Max(maxX, cb.Control0.X); minY = Math.Min(minY, cb.Control0.Y); maxY = Math.Max(maxY, cb.Control0.Y); minX = Math.Min(minX, cb.Control1.X); maxX = Math.Max(maxX, cb.Control1.X); minY = Math.Min(minY, cb.Control1.Y); maxY = Math.Max(maxY, cb.Control1.Y); break; case SegmentType.QuadraticBezier: QuadBezier qb = (QuadBezier)sd; xw.WriteQuadraticCurveTo(qb.Control, qb.Anchor1); lastPoint = qb.EndPoint; minX = Math.Min(minX, qb.Control.X); maxX = Math.Max(maxX, qb.Control.X); minY = Math.Min(minY, qb.Control.Y); maxY = Math.Max(maxY, qb.Control.Y); break; } // need bounds for gradient :( if (isGradient) { minX = Math.Min(minX, sd.StartPoint.X); maxX = Math.Max(maxX, sd.StartPoint.X); minY = Math.Min(minY, sd.StartPoint.Y); maxY = Math.Max(maxY, sd.StartPoint.Y); minX = Math.Min(minX, sd.EndPoint.X); maxX = Math.Max(maxX, sd.EndPoint.X); minY = Math.Min(minY, sd.EndPoint.Y); maxY = Math.Max(maxY, sd.EndPoint.Y); } } xw.WriteEndAttribute(); if (isGradient) { GradientFill gf = (GradientFill)fs; // need a gradient def here if (fs.FillType == FillType.Linear) { //<Path.Fill> // <LinearGradientBrush StartPoint="0.14706,0.532137" EndPoint="1.14962,0.55353"> // <LinearGradientBrush.GradientStops> // <GradientStop Color="#FF4A4A4A" Offset="0"/> // <GradientStop Color="#FFB0B0B0" Offset="0.412067"/> // <GradientStop Color="#FFBBBBBB" Offset="0.638141"/> // <GradientStop Color="#FF545454" Offset="1"/> // </LinearGradientBrush.GradientStops> // </LinearGradientBrush> //</Path.Fill> xw.WriteStartElement("Path.Fill"); xw.WriteStartElement("LinearGradientBrush"); Matrix m = gf.Transform; Rectangle r = GradientFill.GradientVexRect; sysDraw2D.Matrix m2 = new sysDraw2D.Matrix(m.ScaleX, m.Rotate0, m.Rotate1, m.ScaleY, m.TranslateX, m.TranslateY); float midY = r.Point.Y + (r.Size.Height / 2); sysDraw.PointF pt0 = new sysDraw.PointF(r.Point.X, midY); sysDraw.PointF pt1 = new sysDraw.PointF(r.Point.X + r.Size.Width, midY); sysDraw.PointF[] pts = new sysDraw.PointF[] { pt0, pt1 }; m2.TransformPoints(pts); float ratX = 1 / (maxX - minX); float ratY = 1 / (maxY - minY); float d0x = (pts[0].X - minX) * ratX; float d0y = (pts[0].Y - minY) * ratY; float d1x = (pts[1].X - minX) * ratX; float d1y = (pts[1].Y - minY) * ratY; xw.WriteStartAttribute("StartPoint"); xw.WritePoint(new Point(d0x, d0y)); xw.WriteEndAttribute(); xw.WriteStartAttribute("EndPoint"); xw.WritePoint(new Point(d1x, d1y)); xw.WriteEndAttribute(); xw.WriteStartAttribute("SpreadMethod"); xw.WriteValue("Pad"); xw.WriteEndAttribute(); xw.WriteStartElement("LinearGradientBrush.GradientStops"); for (int i = 0; i < gf.Stops.Count; i++) { xw.WriteStartElement("GradientStop"); xw.WriteStartAttribute("Color"); xw.WriteColor(gf.Fills[i]); xw.WriteEndAttribute(); xw.WriteStartAttribute("Offset"); xw.WriteFloat(gf.Stops[i]); xw.WriteEndAttribute(); xw.WriteEndElement(); // GradientStop } xw.WriteEndElement(); // LinearGradientBrush.GradientStops xw.WriteEndElement(); // LinearGradientBrush xw.WriteEndElement(); // Path.Fill } else if (fs.FillType == FillType.Radial) { //<Ellipse.Fill> // <RadialGradientBrush RadiusX="0.622359" RadiusY="0.604589" Center="0.5,0.5" GradientOrigin="0.5,0.5"> // <RadialGradientBrush.RelativeTransform> // <TransformGroup/> // </RadialGradientBrush.RelativeTransform> // <GradientStop Color="#95000000" Offset="0.347222"/> // <GradientStop Color="#007877A7" Offset="0.773148"/> // </RadialGradientBrush> //</Ellipse.Fill> xw.WriteStartElement("Path.Fill"); xw.WriteStartElement("RadialGradientBrush"); Matrix m = gf.Transform; Rectangle r = GradientFill.GradientVexRect; sysDraw2D.Matrix m2 = new sysDraw2D.Matrix(m.ScaleX, m.Rotate0, m.Rotate1, m.ScaleY, m.TranslateX, m.TranslateY); float midX = r.Point.X + (r.Size.Width / 2); float midY = r.Point.Y + (r.Size.Height / 2); sysDraw.PointF pt0 = new sysDraw.PointF(midX, midY); // center sysDraw.PointF pt1 = new sysDraw.PointF(r.Point.X + r.Size.Width, midY); // radius vector sysDraw.PointF[] pts = new sysDraw.PointF[] { pt0, pt1 }; m2.TransformPoints(pts); float ratX = 1 / (maxX - minX); float ratY = 1 / (maxY - minY); float d0x = (pts[0].X - minX) * ratX; float d0y = (pts[0].Y - minY) * ratY; float d1x = (pts[1].X - pts[0].X); //float d1y = (pts[1].Y - pts[0].Y) * ratY; float rad = (float)Math.Sqrt(d1x * d1x); xw.WriteStartAttribute("RadiusX"); xw.WriteFloat(rad * ratX); xw.WriteEndAttribute(); xw.WriteStartAttribute("RadiusY"); xw.WriteFloat(rad * ratY); xw.WriteEndAttribute(); xw.WriteStartAttribute("Center"); xw.WritePoint(new Point(d0x, d0y)); xw.WriteEndAttribute(); xw.WriteStartAttribute("GradientOrigin"); xw.WritePoint(new Point(d0x, d0y)); xw.WriteEndAttribute(); xw.WriteStartAttribute("SpreadMethod"); xw.WriteValue("Pad"); xw.WriteEndAttribute(); //xw.WriteStartElement("RadialGradientBrush.GradientStops"); for (int i = 0; i < gf.Stops.Count; i++) { xw.WriteStartElement("GradientStop"); xw.WriteStartAttribute("Color"); xw.WriteColor(gf.Fills[i]); xw.WriteEndAttribute(); xw.WriteStartAttribute("Offset"); xw.WriteFloat(1 - gf.Stops[i]); // xaml fill is reversed from gdi xw.WriteEndAttribute(); xw.WriteEndElement(); // GradientStop } //xw.WriteEndElement(); // LinearGradientBrush.GradientStops xw.WriteEndElement(); // LinearGradientBrush xw.WriteEndElement(); // Path.Fill } } else if (isTiledBitmap) { //<Path.Fill> // <ImageBrush ImageSource="Resources\bmp_1.jpg" TileMode="Tile" RelativeTransform=".2,0,0,.2,0,0"/> //</Path.Fill> ImageFill img = (ImageFill)fs; xw.WriteStartElement("Path.Fill"); xw.WriteStartElement("ImageBrush"); xw.WriteStartAttribute("ImageSource"); xw.WriteValue(img.ImagePath); xw.WriteEndAttribute(); if (!silverlight) { xw.WriteStartAttribute("TileMode"); xw.WriteValue("Tile"); xw.WriteEndAttribute(); } //xw.WriteStartAttribute("ViewportUnits"); //xw.WriteValue("Absolute"); //xw.WriteEndAttribute(); Matrix pMatrix = ApplyMatrixToShape(sh, img.Matrix, images[img.ImagePath].StrokeBounds); //Matrix pMatrix = ApplyMatrixToImage(img.Matrix, images[img.ImagePath].Bounds); xw.WriteStartAttribute("RelativeTransform"); xw.WriteMatrix(pMatrix); //xw.WriteMatrix(img.Matrix); xw.WriteEndAttribute(); xw.WriteEndElement(); // Path.Fill xw.WriteEndElement(); // ImageBrush } xw.WriteEndElement(); // Path }
internal void FromHash(string Hash) { GradientFill gf = new GradientFill(); string[] saElementAttribute = Hash.Split(new string[] { SLConstants.XmlGradientFillElementAttributeSeparator }, StringSplitOptions.None); if (saElementAttribute.Length >= 2) { gf.InnerXml = saElementAttribute[0]; string[] sa = saElementAttribute[1].Split(new string[] { SLConstants.XmlGradientFillAttributeSeparator }, StringSplitOptions.None); if (sa.Length >= 6) { if (!sa[0].Equals("null")) gf.Type = (GradientValues)Enum.Parse(typeof(GradientValues), sa[0]); if (!sa[1].Equals("null")) gf.Degree = double.Parse(sa[1]); if (!sa[2].Equals("null")) gf.Left = double.Parse(sa[2]); if (!sa[3].Equals("null")) gf.Right = double.Parse(sa[3]); if (!sa[4].Equals("null")) gf.Top = double.Parse(sa[4]); if (!sa[5].Equals("null")) gf.Bottom = double.Parse(sa[5]); } } this.FromGradientFill(gf); }
private static void ConsolidatePaths(Symbol symbol, DVexWriter writer) { List <FillStyle> fills = new List <FillStyle>(); List <StrokeStyle> strokes = new List <StrokeStyle>(); fills.Add(new SolidFill(Color.Transparent)); strokes.Add(new SolidStroke(0.0F, Color.Transparent)); ArrayList allPaths = new ArrayList(); ArrayList allSrs = new ArrayList(); // Find all used colors/strokes, and the F0,F1,S info for each seg foreach (Shape sh in symbol.Shapes) { foreach (IShapeData s in sh.ShapeData) { int fill = 0; int stroke = 0; if (!fills.Contains(shape.Fills[s.FillIndex])) { fill = fills.Add(shape.Fills[s.FillIndex]); } else { fill = fills.IndexOf(shape.Fills[s.FillIndex]); } if (!strokes.Contains(shape.Strokes[s.StrokeIndex])) { stroke = strokes.Add(shape.Strokes[s.StrokeIndex]); } else { stroke = strokes.IndexOf(shape.Strokes[s.StrokeIndex]); } // break path into shape records foreach (IPathPrimitive ipp in s.Path) { if (ipp is IShapeData) { IShapeData ip = (IShapeData)ipp; if (allPaths.Contains(ip)) { // this must be a fill1 if it is a dup int index = allPaths.IndexOf(ip); Shrec sr = (Shrec)allSrs[index]; Shrec newShrec = new Shrec(0, 0); newShrec.F0 = (sr.F0 == 0) ? fill : sr.F0; newShrec.F1 = (sr.F1 == 0) ? fill : sr.F1; newShrec.S = (sr.S == 0) ? stroke : sr.S; allSrs[index] = newShrec; } else { allSrs.Add(new Shrec(fill, stroke)); allPaths.Add(ip); } } } } // end groups } // end shapes // ok, now write out colors // sort fills by rgb, argb, and gradients ArrayList orderedFills = new ArrayList(); ArrayList rgbas = new ArrayList(); ArrayList gfs = new ArrayList(); foreach (Fill sf in fills) { if (sf is SolidFill) { if (((SolidFill)sf).Color.A == 255 || (SolidFill)sf == fills[0]) // 'no fill' { orderedFills.Add(sf); } else { rgbas.Add(sf); } } else if (sf is GradientFill) { gfs.Add(sf); } else { // bitmap fills orderedFills.Add(new SolidFill(Color.Gray)); }; } SolidFill[] wrgbs = new SolidFill[orderedFills.Count]; wrgbs[0] = new SolidFill(Color.FromArgb(255, 0, 0, 0)); int fRgb = 1; foreach (Fill f in orderedFills) { if (f != fills[0]) { wrgbs[fRgb++] = (SolidFill)f; } } int fRgba = 0; SolidFill[] wrgbas = new SolidFill[rgbas.Count]; foreach (Fill f in rgbas) { orderedFills.Add(f); wrgbas[fRgba++] = (SolidFill)f; } int fGr = 0; GradientFill[] wgfs = new GradientFill[gfs.Count]; foreach (Fill f in gfs) { orderedFills.Add(f); wgfs[fGr++] = (GradientFill)(f); } writer.WriteNbitColorDefs(wrgbs); writer.WriteNbitColorDefs(wrgbas); writer.WriteNbitGradientDefs(wgfs); //writer.WriteRgbColorDefs(wrgbs); //writer.WriteRgbaColorDefs(wrgbas); //writer.WriteGradientColorDefs(wgfs); // ok, colors written, now strokes // write out all the stroke defs second // get counts int wrgbCount = 0; int wrgbaCount = 0; foreach (Stroke st in strokes) { if (st.Color.A == 255 || st == strokes[0]) { wrgbCount++; } else { wrgbaCount++; } } // create stroke arrays Stroke[] wsrgbs = new Stroke[wrgbCount]; Stroke[] wsrgbas = new Stroke[wrgbaCount]; int sRgb = 0; int sRgba = 0; foreach (Stroke st in strokes) { if (st.Color.A == 255 || st == strokes[0]) { wsrgbs[sRgb++] = st; } else { wsrgbas[sRgba++] = st; } } // now write the stroke data writer.WriteNbitStrokeDefs(wsrgbs); writer.WriteNbitStrokeDefs(wsrgbas); //writer.WriteRgbStrokeDefs(wsrgbs); //writer.WriteRgbaStrokeDefs(wsrgbas); // and now paths // valid pathsegs must have the same F0, F1, and S ArrayList tempPaths = new ArrayList(); ArrayList tempSrsAl = new ArrayList(); PathCollection pc = new PathCollection(); Shrec curShrec = Shrec.Empty; for (int i = 0; i < allSrs.Count; i++) //Shrec sr in srsAl) { Shrec sr = (Shrec)allSrs[i]; if (sr.Equals(curShrec) || curShrec.Equals(Shrec.Empty)) { //add to path pc.Add((IShapeData)allPaths[i]); } else { // write to hash tempPaths.Add(pc); tempSrsAl.Add(curShrec); pc = new PathCollection(); pc.Add((IShapeData)allPaths[i]); } curShrec = sr; } if (!tempSrsAl.Contains(curShrec)) { tempPaths.Add(pc); tempSrsAl.Add(curShrec); } // split non contig paths ArrayList paths = new ArrayList(); ArrayList srsAl = new ArrayList(); foreach (PathCollection pcoll in tempPaths) { //pcoll.ReorderPath(); PathCollection[] pcolls = pcoll.SplitPath(); foreach (PathCollection splitP in pcolls) { paths.Add(splitP); srsAl.Add(tempSrsAl[tempPaths.IndexOf(pcoll)]); //writer.WritePath(splitP.PointSegments); } } IShapeData[][] ips = new IShapeData[paths.Count][]; for (int i = 0; i < paths.Count; i++) { ips[i] = ((PathCollection)paths[i]).PointSegments; } writer.WritePaths(ips); // convert to array Shrec[] srs = new Shrec[srsAl.Count]; for (int i = 0; i < srsAl.Count; i++) { srs[i] = (Shrec)srsAl[i]; } // and finally, uses - must be sorted by fill color // use order Fill1 (no strokes), fill0[stroke], stroke only's // for each fill index{..}, then dangling strokes ArrayList shapeRecords = new ArrayList(); // start at 1 to avoid empty fills foreach (Fill f in orderedFills) { int curFill = fills.IndexOf(f); if (curFill != 0) { // all F1's of this color first ArrayList Fs = new ArrayList(); for (int i = 0; i < srs.Length; i++) { if (srs[i].F0 == curFill) { // add use for F0 ShapeRecord curSr = new ShapeRecord(); curSr.Fill = orderedFills.IndexOf(f); curSr.Stroke = srs[i].S; curSr.Path = i; Fs.Add(curSr); } if (srs[i].F1 == curFill) { // add use for F1 ShapeRecord curSr = new ShapeRecord(); curSr.Fill = orderedFills.IndexOf(f); curSr.Stroke = 0; curSr.Path = i; Fs.Add(curSr); } } //now sort the F1s from tip to tail if (Fs.Count > 0) { ArrayList finalFs = new ArrayList(); finalFs.Add(Fs[0]); PointF end = ((PathCollection)paths[((ShapeRecord)Fs[0]).Path]).LastPoint; Fs.RemoveAt(0); while (Fs.Count > 0) { bool found = false; foreach (ShapeRecord sr in Fs) { PathCollection srp = (PathCollection)paths[sr.Path]; if (srp.FirstPoint == end) { end = srp.LastPoint; finalFs.Add(sr); Fs.Remove(sr); found = true; break; } } if (found == false) { finalFs.Add(Fs[0]); end = ((PathCollection)paths[ ((ShapeRecord)Fs[0]).Path]).LastPoint; Fs.RemoveAt(0); } } // and write them foreach (ShapeRecord sr in finalFs) { shapeRecords.Add(sr); } } } } for (int i = 0; i < srs.Length; i++) { if (srs[i].F0 == 0 && srs[i].F1 == 0) { // must be stroke ShapeRecord curSr = new ShapeRecord(); curSr.Fill = 0; curSr.Stroke = srs[i].S; curSr.Path = i; shapeRecords.Add(curSr); } } // convert to array ShapeRecord[] srecs = new ShapeRecord[shapeRecords.Count]; for (int i = 0; i < shapeRecords.Count; i++) { srecs[i] = (ShapeRecord)shapeRecords[i]; } writer.WriteUses(srecs); }
private void WriteGradientDefs(List <GradientFill> gradients) { WriteTag(VexDrawTag.GradientFillList); WriteBits(0, 5); // note: no nBits here, just padding WriteBits(gradients.Count, 11); for (int index = 0; index < gradients.Count; index++) { GradientFill gf = gradients[index]; // first type - all non radial will be solid // use 8 bits for future expansion and to keep semi aligned int type = (gf.FillType == FillType.Radial) ? 1 : 0; WriteBits(type, 3); float[] tltr = DrawObject.GetGradientLine(gf); int[] values = new int[4]; for (int i = 0; i < tltr.Length; i++) { values[i] = (int)(tltr[i] * DrawObject.twips); } WriteFourNBitValues(values); // new argb colors List <Color> colors = new List <Color>(gf.Fills); List <float> positions = new List <float>(gf.Stops); if (gf.FillType == FillType.Radial) { gf.ReverseStops(colors, positions); } // stops and ratios [[col,rat],[col,rat]...] int stopCount = colors.Count; if (stopCount > 8) { stopCount = 8; Console.WriteLine("*Flash only supports 8 colors max in gradients"); } uint[] wCols = new uint[stopCount]; for (int i = 0; i < stopCount; i++) { wCols[i] = colors[i].AFlipRGB; } uint colBits = MinBits(wCols); WriteNBitsCount(colBits); int[] ratios = new int[positions.Count]; for (int i = 0; i < stopCount; i++) { ratios[i] = (int)(positions[i] * 255); } uint ratioBits = MinBits(ratios); WriteNBitsCount(ratioBits); WriteBits(stopCount, 11); for (int i = 0; i < stopCount; i++) { WriteBits(wCols[i], colBits); WriteBits(ratios[i], ratioBits); } } FlushTag(); }