public void ComputeTransLastHitGeometry() { switch (scMgr.GraphicsType) { case GraphicsType.GDIPLUS: if (hitGraphicsPath == null) { return; } transLastHitGraphicsPath = (GraphicsPath)hitGraphicsPath.Clone(); transLastHitGraphicsPath.Transform(globalMatrix); break; case GraphicsType.D2D: if (hitPathGeometry == null) { return; } SharpDX.Direct2D1.Factory d2dFactory = D2DGraphics.d2dFactory; RawMatrix3x2 m32 = GDIDataD2DUtils.TransMatrixToRawMatrix3x2(globalMatrix); transLastHitPathGeometry = new TransformedGeometry(d2dFactory, hitPathGeometry, m32); break; } }
public override GraphicsPath GetPath() { GraphicsPath gpLocal = (GraphicsPath)r_model.Clone(); Matrix mat = new Matrix(); mat.Translate(base.Pos.X, base.Pos.Y); mat.Rotate(_fRot); gpLocal.Transform(mat); if (Pos.X > (base.clientSize.Width - size)) { GraphicsPath gpWrap = (GraphicsPath)r_model.Clone(); Matrix mat2 = new Matrix(); mat2.Translate((Pos.X - base.clientSize.Width), Pos.Y); mat2.Rotate(_fRot, MatrixOrder.Prepend); gpWrap.Transform(mat2); gpLocal.AddPath(gpWrap, true); } else if (Pos.X < size) { GraphicsPath gpWrap = (GraphicsPath)r_model.Clone(); Matrix mat2 = new Matrix(); mat2.Translate(Pos.X + base.clientSize.Width, Pos.Y); mat2.Rotate(_fRot, MatrixOrder.Prepend); gpWrap.Transform(mat2); gpLocal.AddPath(gpWrap, true); } if (Pos.Y > (base.clientSize.Height - size)) { GraphicsPath gpWrap = (GraphicsPath)r_model.Clone(); Matrix mat2 = new Matrix(); mat2.Translate(Pos.X, Pos.Y - base.clientSize.Height); mat2.Rotate(_fRot, MatrixOrder.Prepend); gpWrap.Transform(mat2); gpLocal.AddPath(gpWrap, true); } else if (Pos.Y < size) { GraphicsPath gpWrap = (GraphicsPath)r_model.Clone(); //Do translation or movement Matrix mat2 = new Matrix(); mat2.Translate(Pos.X, Pos.Y + base.clientSize.Height); mat2.Rotate(_fRot, MatrixOrder.Prepend); gpWrap.Transform(mat2); gpLocal.AddPath(gpWrap, true); } return(gpLocal); }
/// <summary> /// Gets the path of the laser and translatesd it /// </summary> /// <returns>Translated graphics path</returns> public override GraphicsPath GetPath() { GraphicsPath laser = (GraphicsPath)_model.Clone(); Matrix matrice = new Matrix(); matrice.Translate(_pos.X, _pos.Y); //Scale/4 to be the right size compared to ship and rest matrice.Scale(_scale / 4, _scale / 4); matrice.Rotate(_rot); laser.Transform(matrice); return(laser); }
public GraphicsPath GetPath() { GraphicsPath gpClone = (GraphicsPath)_playerModel.Clone(); Matrix cloneMatrix = new Matrix(); cloneMatrix.Translate(_pos.X, _pos.Y); cloneMatrix.Rotate(_currentRot); cloneMatrix.Scale(20, 20); gpClone.Transform(cloneMatrix); return(gpClone); }
private PathGradientBrush GetSpecialCapBrush(GaugeGraphics g, GraphicsPath path, PointF pointOrigin, float angle, Color fillColor, GradientType fillGradientType, Color fillGradientEndColor, GaugeHatchStyle fillHatchStyle) { using (GraphicsPath graphicsPath = (GraphicsPath)path.Clone()) { graphicsPath.Flatten(null, 0.3f); graphicsPath.Reset(); RectangleF bounds = path.GetBounds(); bounds.Inflate(-20f, -20f); PointF[] points = new PointF[4] { new PointF(bounds.Left, bounds.Top), new PointF(bounds.Right, bounds.Top), new PointF(bounds.Right, bounds.Bottom), new PointF(bounds.Left, bounds.Bottom) }; graphicsPath.AddLines(points); PathGradientBrush pathGradientBrush = new PathGradientBrush(graphicsPath); pathGradientBrush.SurroundColors = new Color[4] { Color.Red, Color.Green, Color.Blue, Color.Green }; pathGradientBrush.CenterColor = Color.Transparent; pathGradientBrush.CenterPoint = new PointF(bounds.Left, bounds.Top); pathGradientBrush.RotateTransform(angle, MatrixOrder.Append); pathGradientBrush.TranslateTransform(pointOrigin.X, pointOrigin.Y, MatrixOrder.Append); return(pathGradientBrush); } }
/// <summary> /// Draws text. /// </summary> /// <param name="target"></param> /// <param name="x"></param> /// <param name="y"></param> /// <param name="text"></param> /// <param name="color"></param> /// <param name="size"></param> /// <param name="haloColor"></param> /// <param name="haloRadius"></param> /// <param name="fontName"></param> protected override void DrawText(Target2DWrapper <Graphics> target, double x, double y, string text, int color, double size, int?haloColor, int?haloRadius, string fontName) { float sizeInPixels = this.ToPixels(size); Color textColor = Color.FromArgb(color); Font font = new Font(FontFamily.GenericSansSerif, sizeInPixels); SolidBrush brush = new SolidBrush(textColor); double[] transformed = this.Tranform(x, y); float transformedX = (float)transformed[0]; float transformedY = (float)transformed[1]; Brush haloBrush = null; GraphicsPath characterPath = new GraphicsPath(); characterPath.AddString(text, font.FontFamily, (int)font.Style, font.Size, new PointF(transformedX, transformedY), StringFormat.GenericTypographic); if (haloColor.HasValue && haloRadius.HasValue && haloRadius.Value > 0) { haloBrush = new SolidBrush(Color.FromArgb(haloColor.Value)); GraphicsPath haloPath = characterPath.Clone() as GraphicsPath; using (haloPath) { haloPath.Widen(new Pen(haloBrush, haloRadius.Value * 2)); // Draw the character target.Target.FillPath(haloBrush, haloPath); } } // Draw the character target.Target.FillPath(brush, characterPath); }
public GraphicsPath TransformPath(GraphicsPath path) { var p = (GraphicsPath)path.Clone(); p.Flatten(_Transform, 0.1f); return(p); }
// Draw some text along a GraphicsPath. private void DrawTextOnPath(Graphics gr, Brush brush, Font font, string txt, GraphicsPath path, ContentAlignment alignment, GraphicsPath resultPath = null) { if (resultPath != null) { resultPath.Reset(); } // Make a copy so we don't mess up the original. path = (GraphicsPath)path.Clone(); // Flatten the path into segments. path.Flatten(new Matrix(), 0.005f); var points = path.PathPoints; gr.Transform.TransformPoints(points); // Draw characters. int start_ch = 0; PointF start_point = points[0]; for (int i = 1; i < points.Length; i++) { PointF end_point = points[i]; DrawTextOnSegment(gr, brush, font, txt, ref start_ch, ref start_point, end_point, alignment, resultPath); if (start_ch >= txt.Length) { break; } } }
/// <summary> /// Renders the selection. /// </summary> /// <param name="selectPath">The selection path.</param> /// <param name="deSelect">If set to <c>true</c> clear the selection.</param> private void RenderSelection(GraphicsPath selectPath, bool deSelect) { if (selectPath != null && selectPath.PointCount > 2) { path = (GraphicsPath)selectPath.Clone(); selectionRegion = new Region(selectPath); if (normalizedPath != null) { normalizedPath.Dispose(); normalizedPath = null; } } else if (deSelect) { if (path != null) { path.Dispose(); path = null; } if (normalizedPath != null) { normalizedPath.Dispose(); normalizedPath = null; } if (selectionRegion != null) { selectionRegion.Dispose(); selectionRegion = null; } } Invalidate(); }
protected override void OnPaint(PaintEventArgs e) { e.Graphics.Clear(BackColor); if (_maxPeakPath == null || _resizing) { base.OnPaint(e); return; } var halfHeight = ClientSize.Height / 2.0f; using (var maxPath = (GraphicsPath)_maxPeakPath.Clone()) { using (var matrix = new Matrix()) { matrix.Translate(0.0f, halfHeight); matrix.Scale(ClientSize.Width, halfHeight); maxPath.Transform(matrix); e.Graphics.FillPath(_outerBrush, maxPath); if (!_innerWaveVisible) { return; } using (var avgPath = (GraphicsPath)_avgPeakPath.Clone()) { matrix.Scale(1.0f, 0.5f); avgPath.Transform(matrix); e.Graphics.FillPath(_innerBrush, avgPath); } } } }
/// <summary> /// Path returns as a queue starting with hull, window, and boost to make sure they draw in the correct dequeue order /// </summary> /// <returns></returns> public override Queue <Tuple <GraphicsPath, Brush> > GetPath() { //Fade color if faded Color hullColor = Fade > 0 && (m_AnimationTimer.ElapsedMilliseconds & 1 << c_FadeFlashBit) > 0 ? Color.FromArgb(c_FadeAlpha, m_Color.R, m_Color.G, m_Color.B) : m_Color; Queue <Tuple <GraphicsPath, Brush> > queue = new Queue <Tuple <GraphicsPath, Brush> >(); //Get clones for all pieces GraphicsPath tempHull = (GraphicsPath)m_Hull.Clone(); GraphicsPath tempWin = (GraphicsPath)m_Window.Clone(); GraphicsPath tempBoost = (GraphicsPath)m_Booster.Clone(); //Do rest of ship Matrix mainMatrix = new Matrix(); mainMatrix.Scale(c_ShipScale, c_ShipScale); mainMatrix.Rotate(m_fRotation, MatrixOrder.Append); mainMatrix.Translate(m_pLocation.X, m_pLocation.Y, MatrixOrder.Append); tempHull.Transform(mainMatrix); tempWin.Transform(mainMatrix); queue.Enqueue(new Tuple <GraphicsPath, Brush>(tempHull, new SolidBrush(hullColor))); queue.Enqueue(new Tuple <GraphicsPath, Brush>(tempWin, new SolidBrush(Color.LightBlue))); //Do booster size scaling if (m_LinearSpeed > 0) { Matrix boosterMatrix = new Matrix(); boosterMatrix.Scale(1, m_LinearSpeed / c_MaxLinearSpeed); tempBoost.Transform(boosterMatrix); tempBoost.Transform(mainMatrix); queue.Enqueue(new Tuple <GraphicsPath, Brush>(tempBoost, new SolidBrush(Color.Goldenrod))); } return(queue); }
protected override void CreateHandles() { if (Container == null) { return; } SetHandles(new Handles()); //Get the default graphics path and scale it IRender render = RenderFromContainer(); GraphicsPath defaultPath = (GraphicsPath)Component.Instance.DefaultHandlePath.Clone(); Matrix matrix = new Matrix(); matrix.Scale(render.ZoomFactor, render.ZoomFactor); defaultPath.Transform(matrix); RectangleF pathRectangle = defaultPath.GetBounds(); RectangleF halfRectangle = new RectangleF(0, 0, pathRectangle.Width / 2, pathRectangle.Height / 2); //Loop through each point and add an offset handle GraphicsPath path; foreach (PointF point in Points) { path = (GraphicsPath)defaultPath.Clone(); matrix.Reset(); matrix.Translate(point.X - Rectangle.X - halfRectangle.Width, point.Y - Rectangle.Y - halfRectangle.Height); path.Transform(matrix); Handles.Add(new Handle(path, HandleType.Origin)); } Handles[0].CanDock = true; Handles[Handles.Count - 1].CanDock = true; }
/// <summary> /// Creates a path in form of rounded rectangle. This path is used as shape of the button. /// </summary> /// <returns>Created path</returns> private GraphicsPath CreateBorderPath() { using (GraphicsPath borderPath = new GraphicsPath()) { const int Radius = 3; const int HorizontalPad = 1; const int VerticalPad = 1; int width = Width - VerticalPad * 2; int height = Height - HorizontalPad * 2; borderPath.AddLine(HorizontalPad + Radius, VerticalPad, HorizontalPad + width - Radius * 2, VerticalPad); borderPath.AddArc(HorizontalPad + width - Radius * 2, VerticalPad, Radius * 2, Radius * 2, 270, 90); borderPath.AddLine(HorizontalPad + width, VerticalPad + Radius, HorizontalPad + width, VerticalPad + height - Radius * 2); borderPath.AddArc(HorizontalPad + width - Radius * 2, VerticalPad + height - Radius * 2, Radius * 2, Radius * 2, 0, 90); borderPath.AddLine(HorizontalPad + width - Radius * 2, VerticalPad + height, HorizontalPad + Radius, VerticalPad + height); borderPath.AddArc(HorizontalPad, VerticalPad + height - Radius * 2, Radius * 2, Radius * 2, 90, 90); borderPath.AddLine(HorizontalPad, VerticalPad + height - Radius * 2, HorizontalPad, VerticalPad + Radius); borderPath.AddArc(HorizontalPad, VerticalPad, Radius * 2, Radius * 2, 180, 90); borderPath.CloseFigure(); return((GraphicsPath)borderPath.Clone()); } }
/// <summary>Draws the grip in the graphics context.</summary> /// <param name="g">Graphics context.</param> /// <param name="pageScale">Current zoom factor that can be used to calculate pen width etc. for displaying the handle. Attention: this factor must not be used to transform the path of the handle.</param> public void Show(Graphics g, double pageScale) { var shape = (GraphicsPath)_rotationGripShape.Clone(); shape.Transform(_spanningHalfYRhombus); g.FillPath(Brushes.Blue, shape); }
public static RectangleF GetBounds(GraphicsPath path, Matrix matrix) { GraphicsPath path1 = (GraphicsPath)path.Clone(); path1.Flatten(matrix, 0.5f); return(path1.GetBounds()); }
public static Image ApplyRegionPathToImage(Image backgroundImage, GraphicsPath regionFillPath, SurfaceOptions options) { if (backgroundImage != null && regionFillPath != null) { Image img; Rectangle regionArea = Rectangle.Round(regionFillPath.GetBounds()); Rectangle screenRectangle = CaptureHelpers.GetScreenBounds0Based(); Rectangle newRegionArea = Rectangle.Intersect(regionArea, screenRectangle); using (GraphicsPath gp = (GraphicsPath)regionFillPath.Clone()) { using (Matrix matrix = new Matrix()) { gp.CloseFigure(); matrix.Translate(-Math.Max(0, regionArea.X), -Math.Max(0, regionArea.Y)); gp.Transform(matrix); } img = ImageHelpers.CropImage(backgroundImage, newRegionArea, gp); } return(img); } return(null); }
public GeometryGraphicsPath Clone() { GeometryGraphicsPath path = new GeometryGraphicsPath((GraphicsPath)gdiPath.Clone()); path.tooComplex = this.tooComplex; return(path); }
public override void draw(Graphics g) { int x = getX(); int y = getY(); int direction = getDirection(); Matrix trans = new Matrix(); Matrix transOrig = new Matrix(); Matrix rot = new Matrix(); GraphicsPath path = (GraphicsPath)sPath.Clone(); Color c = Color.Black; Pen p = new Pen(c); path.AddString(health.ToString(), FontFamily.GenericMonospace, 0, 10, new PointF(0, 12), StringFormat.GenericDefault); trans.Translate(x, y); transOrig.Translate(-5, -5); rot.Rotate(direction * 45); path.Transform(transOrig); path.Transform(rot); path.Transform(trans); g.DrawPath(p, path); this.bounds = path.GetBounds(); }
///// <summary> ///// Updates the background drawing ///// </summary> //protected virtual void UpdateBackground() //{ // if (Width == 0 || Height == 0) // { // return; // } // m_Background = new Bitmap(Width, Height); // Graphics g = Graphics.FromImage(m_Background); // g.FillRectangle(new SolidBrush(BackColor), 0, 0, Width, Height); // if (GridSize.X > 0 && GridSize.Y > 0) // { // for (int i = m_GridSize.X; i < Width; i += m_GridSize.X) // { // for (int j = m_GridSize.X; j < Height; j += m_GridSize.Y) // { // (m_Background as Bitmap).SetPixel(i, j, m_GridColor); // } // } // } // g.DrawLine(new Pen(m_GridColor), 0, m_Offset.Y, Width, m_Offset.Y); // g.DrawLine(new Pen(m_GridColor), m_Offset.X, 0, m_Offset.X, Height); //} /// <summary> /// Updates the symbol drawing /// </summary> protected virtual void UpdateDrawing() { if (Width == 0 || Height == 0) { return; } m_Drawing = new Bitmap(Width, Height); Graphics g = Graphics.FromImage(m_Drawing); g.FillRectangle(new SolidBrush(Color.Transparent), 0, 0, Width, Height); if (m_Element != null) { m_Element.Paint(g); } else { if (m_Path != null) { GraphicsPath path = (GraphicsPath)m_Path.Clone(); Matrix translation = ComputeTranslationMatrix(); path.Transform(translation); g.DrawPath(Pens.Black, path); } } }
public static Image GetRegionImage(Image surfaceImage, GraphicsPath regionFillPath, GraphicsPath regionDrawPath, SurfaceOptions options) { if (regionFillPath != null) { Image img; Rectangle regionArea = Rectangle.Round(regionFillPath.GetBounds()); Rectangle screenRectangle = CaptureHelpers.GetScreenBounds0Based(); Rectangle newRegionArea = Rectangle.Intersect(regionArea, screenRectangle); using (GraphicsPath gp = (GraphicsPath)regionFillPath.Clone()) { MoveGraphicsPath(gp, -Math.Max(0, regionArea.X), -Math.Max(0, regionArea.Y)); img = ImageHelpers.CropImage(surfaceImage, newRegionArea, gp); if (options.DrawBorder) { GraphicsPath gpOutline = regionDrawPath ?? regionFillPath; using (GraphicsPath gp2 = (GraphicsPath)gpOutline.Clone()) { MoveGraphicsPath(gp2, -Math.Max(0, regionArea.X), -Math.Max(0, regionArea.Y)); img = ImageHelpers.DrawOutline(img, gp2); } } } return(img); } return(null); }
public override GraphicsPath GetPath() { //Matrix for containing the tranforms Matrix MatTrans = new Matrix(); //translate first MatTrans.Translate(location.X, location.Y); //then rotate MatTrans.Rotate(_fRotation); //creating a working path GraphicsPath temp = (GraphicsPath)_Model.Clone(); //adding the string that shows the score temp.AddString(_score, FontFamily.GenericSansSerif, (int)FontStyle.Regular, 20, new PointF(0, 0), StringFormat.GenericTypographic); //adding a visual life counter for each life the player has for (int i = 0; i < _lives; i++) { int x = (i * 20); temp.AddPolygon(new PointF[] { new PointF(10 + x, 25), new PointF(0 + x, 50), new PointF(10 + x, 47), new PointF(20 + x, 50) }); //_Model.AddPath(temp, false); } //applying transforms temp.Transform(MatTrans); //creating a region for distance checking Region reg = new Region(temp); return(temp); }
public PdnGraphicsPath Clone() { PdnGraphicsPath path = new PdnGraphicsPath((GraphicsPath)gdiPath.Clone()); path.tooComplex = this.tooComplex; return(path); }
// </snippet15> // Snippet for: M:System.Drawing.Drawing2D.GraphicsPath.Clone // <snippet16> private void CloneExample(PaintEventArgs e) { // Set several markers in a path. GraphicsPath myPath = new GraphicsPath(); myPath.AddEllipse(0, 0, 100, 200); myPath.AddLine(new Point(100, 100), new Point(200, 100)); Rectangle rect = new Rectangle(200, 0, 100, 200); myPath.AddRectangle(rect); myPath.AddLine(new Point(250, 200), new Point(250, 300)); // Draw the path to the screen. Pen myPen = new Pen(Color.Black, 2); e.Graphics.DrawPath(myPen, myPath); // Clone a copy of myPath. GraphicsPath myPath2 = (GraphicsPath)myPath.Clone(); // Draw the path to the screen. Pen myPen2 = new Pen(Color.Red, 4); e.Graphics.DrawPath(myPen2, myPath2); }
void DrawOutlineText(Graphics g, String text, Font font, Rectangle r, Brush b, Color line) { // set atialiasing g.SmoothingMode = SmoothingMode.HighQuality; // make thick pen for outlining Pen pen = new Pen(line, 3); // round line joins of the pen pen.LineJoin = LineJoin.Round; // create graphics path GraphicsPath textPath = new GraphicsPath(); // convert string to path textPath.AddString(text, font.FontFamily, (int)font.Style, font.Size, r, StringFormat.GenericTypographic); // clone path to make outlining path GraphicsPath outlinePath = (GraphicsPath)textPath.Clone(); // outline the path outlinePath.Widen(pen); Brush br = new SolidBrush(line); // fill outline path with some color g.FillPath(br, outlinePath); // fill original text path with some color g.FillPath(b, textPath); }
void DrawElemBound(AutoElem ae, Graphics g, Color ForeColor, string Text) { if (ae == null || !ae.Available()) { return; } Rect BudRc = ae.Current.BoundingRectangle; if (BudRc == Rect.Empty) { return; } var ClientRc = this.RectangleToClient(BudRc.ToRectangle()); var ForeBrush = new SolidBrush(ForeColor); var ForePen = new Pen(ForeBrush, 3); var BackBrush = new SolidBrush(ForeColor.RevColor()); var BackPen = new Pen(BackBrush, 5); g.DrawRectangle(BackPen, ClientRc); g.DrawRectangle(ForePen, ClientRc); if (Text != "" && Text != null) { GraphicsPath gp = new GraphicsPath(); gp.AddString(Text, this.Font.FontFamily, (int)Font.Style, Font.Size, new Point(ClientRc.Left, ClientRc.Top), StringFormat.GenericDefault); var ogp = (GraphicsPath)gp.Clone(); gp.Widen(BackPen); g.FillPath(BackBrush, gp); g.FillPath(ForeBrush, ogp); } }
protected override void DoPage(Graphics grfx, Color clr, int cx, int cy) { grfx.ScaleTransform(cx / 300f, cy / 200f); for (int i = 0; i < 6; i++) { GraphicsPath pathClone = (GraphicsPath)path.Clone(); Matrix matrix = new Matrix(); Pen penThin = new Pen(clr, 1); Pen penThick = new Pen(clr, 5); Pen penWiden = new Pen(clr, 7.5f); Brush brush = new SolidBrush(clr); matrix.Translate((i % 3) * 100, (i / 3) * 100); if (i < 3) { pathClone.Transform(matrix); } else { pathClone.Widen(penWiden, matrix); } switch (i % 3) { case 0: grfx.DrawPath(penThin, pathClone); break; case 1: grfx.DrawPath(penThick, pathClone); break; case 2: grfx.FillPath(brush, pathClone); break; } } }
/// <summary> /// This is a helper function for the update arrows function it draws the arrow at a correct location /// using combination of translation /// </summary> /// <param name="size"></param> /// <returns></returns> private GraphicsPath GenerateTransforms(int size) { //creates a ship //create a points of array PointF[] points = new PointF[4]; //create a graphics path GraphicsPath gp = new GraphicsPath(); //add points to the array of points points[0] = new PointF(0, 0); points[1] = new PointF(-10, 20); points[2] = new PointF(0, 10); points[3] = new PointF(10, 20); //create a path gp.StartFigure(); gp.AddLines(points); gp.CloseFigure(); //apply transformation according to the suplied x argument on the same row Matrix transforms = new Matrix(); transforms.Translate(size, 40); GraphicsPath obj = (GraphicsPath)gp.Clone(); obj.Transform(transforms); //returns the new path with the ship drawn return(obj); }
public override object Clone() { return(new DrawablePath { Path = Path?.Clone() as GraphicsPath, Brush = Brush?.Clone() as Brush, Pen = Pen?.Clone() as Pen }); }
public void Rotate(double angle) { gp = (GraphicsPath)gpBase.Clone(); Matrix mTransform = new Matrix(); mTransform.RotateAt((float)angle, new PointF(midX, midY)); gp.Transform(mTransform); }
public HatchLoop Clone() { return (new HatchLoop( Boundary.Clone() as GraphicsPath, LayerName, TypeName)); }