/// <summary> /// /// </summary> /// <param name="graphics"></param> /// <param name="pen"></param> /// <param name="bounds"></param> /// <param name="cornerRadius"></param> public static void DrawImage(this Graphics graphics, Image image, RectangleF bound, float rot) { if (graphics == null) { throw new ArgumentNullException("graphics"); } // store state var transform = graphics.Transform; // reset graphics.ResetTransform(); //move rotation point to center of image graphics.TranslateTransform(bound.X + bound.Width / 2, bound.Y + bound.Height / 2); //rotate graphics.RotateTransform((float)(rot * 180 / Math.PI)); //move image back graphics.TranslateTransform(-bound.X - bound.Width / 2, -bound.Y - bound.Height / 2); //draw passed in image onto graphics object graphics.MultiplyTransform(transform); // draw image graphics.DrawImage(image, bound); // restore state graphics.Transform = transform; }
protected override void DrawDisabled(Graphics g, ArrowDirection direction) { g.DrawEllipse(_disabledPen, _circleRect); if (direction == ArrowDirection.Right) g.MultiplyTransform(new Matrix(-1, 0, 0, 1, 23, 0)); g.DrawPath(_disabledArrowPen, _arrowPath); }
static void RenderTo(this DrawingGroup drawing, d.Graphics graphics, double opacity) { var gc = graphics.BeginContainer(); Utility.SetGraphicsQuality(graphics); if (drawing.Transform != null && !drawing.Transform.Value.IsIdentity) { graphics.MultiplyTransform(drawing.Transform.Value.ToGdiPlus(), d2.MatrixOrder.Prepend); } if (drawing.ClipGeometry != null) { graphics.Clip = new d.Region(drawing.ClipGeometry.ToGdiPlus()); } if (!Utility.IsZero(drawing.Opacity - 1) && drawing.Children.Count > 1) { var intersects = false; var c = drawing.Children.Count; var b = new Rect[c]; for (var i = 0; i < c; ++i) { b[i] = drawing.Children[i].Bounds; } for (var i = 0; i < c; ++i) { for (var j = 0; j < c; ++j) { if (i != j && Rect.Intersect(b[i], b[j]) != Rect.Empty) { intersects = true; break; } } if (intersects) { break; } } if (intersects) { Utility.Warning("DrawingGroup.Opacity creates translucency between overlapping children"); } } foreach (Drawing d in drawing.Children) { d.RenderTo(graphics, opacity * drawing.Opacity); } graphics.EndContainer(gc); if (drawing.OpacityMask != null) { Utility.Warning("DrawingGroup OpacityMask ignored."); } if (drawing.BitmapEffect != null) { Utility.Warning("DrawingGroup BitmapEffect ignored."); } if (drawing.GuidelineSet != null) { Utility.Warning("DrawingGroup GuidelineSet ignored."); } }
/// <summary> /// /// </summary> /// <param name="grfx"></param> public override void Draw(System.Drawing.Graphics grfx) { Matrix worldXform; if (this.container != null) { worldXform = this.container.GetLabelTransform(this.matrix); } else { worldXform = this.matrix; } RectangleF bounds = this.GetTextBox(); Matrix prevXform = grfx.Transform; grfx.Transform = worldXform; grfx.MultiplyTransform(Global.ViewMatrix, MatrixOrder.Append); Brush backgroundBrush = this.BackgroundStyle.CreateBrush(); grfx.FillRectangle(backgroundBrush, bounds.Left, bounds.Top, bounds.Width, bounds.Height); backgroundBrush.Dispose(); Font font = this.FontStyle.CreateFont(); Brush fillBrush = new SolidBrush(Color.Black); StringFormat fmt = GetStringFormat(); grfx.DrawString(this.Text, font, fillBrush, bounds, fmt); font.Dispose(); fillBrush.Dispose(); if (this.BorderStyle.ShowBorder) { Pen pen = this.BorderStyle.CreatePen(); grfx.DrawRectangle(pen, bounds.Left, bounds.Top, bounds.Width, bounds.Height); pen.Dispose(); } grfx.Transform = prevXform; }
/// <summary> /// Renders the image onto a System.Drawing.Graphics object. /// </summary> /// <param name="grfx">Graphics context to render onto</param> public virtual void Draw(System.Drawing.Graphics grfx) { Matrix prevXform = grfx.Transform; grfx.Transform = Global.MatrixStack.Peek(); grfx.MultiplyTransform(Global.ViewMatrix, MatrixOrder.Append); Pen pen = this.lineStyle.CreatePen(); System.Drawing.Image img = this.Image; if (img != null) { grfx.DrawImage(img, this.bounds); } else { grfx.DrawRectangle(pen, this.bounds.Left, this.bounds.Top, this.bounds.Width, this.bounds.Height); } pen.Dispose(); grfx.Transform = prevXform; }
/// <summary> /// Метод рисования графического примитива /// </summary> /// <param name="g"></param> /// <returns></returns> public override void Draw(System.Drawing.Graphics g) { GraphicsContainer containerState = null; try { /*создать графический контейнер, в нем можно делать с графиксом что угодно*/ containerState = g.BeginContainer(); using (Matrix transform = g.Transform) { /* * чтобы нарисовать примитив в нужном масштабе и положении * нужно умножить матрицу преобразования графикса на матрицу ей обратную * т.е на единичной матрице графикса рисуем примитив */ transform.Invert(); g.MultiplyTransform(transform); if (g.VisibleClipBounds.IntersectsWith(_boundRect) == true) { /* * если видимый прямоугольник графикса пересекается * с ограничивающим прямоугольноком примитива * рисуем его */ g.DrawEllipse(_pen, _circleRect); g.DrawRectangle(_pen, _boundRect); g.DrawLine(_pen, _circlePoint, _centerPoint); } } } finally { if (containerState != null) { /*закрыть графический контейнер*/ g.EndContainer(containerState); } } }
protected virtual void PlotLabels(Graphics g, float labelspacing) { if (!OKToRender()) return; int ypos = Height - ProtectedBottomPadding; //y2Pxl(0.0); float ylabelspacing = GetTickSpacingEstimate(MinY, MaxY); SizeF size = g.MeasureString("0", LabelFont); while (size.Height > (ConvertYToPixel(0) - ConvertYToPixel(ylabelspacing))) { ylabelspacing = ylabelspacing*2; } if (labelspacing == 0 || ylabelspacing == 0) return; double xval = FindMin(MinX, labelspacing); float yval = FindMin(MinY, ylabelspacing); double oldxval = xval; float oldyval = yval; // draw the x grid labels xval = oldxval; StringFormat format = new StringFormat { Alignment = StringAlignment.Center, LineAlignment = StringAlignment.Center }; using (Brush labelBrush = new SolidBrush(LabelColor)) { using (Brush titleBrush = new SolidBrush(TitleColor)) { using (Brush axesLabelBrush = new SolidBrush(AxesLabelColor)) { int xpos; string cstr; SizeF strsize; if (_showTickLabels) { float tMax = MaxX; while (xval <= tMax) { double displayXVal = xval + XAxisOffset; xpos = (int) ConvertXToPixel(xval); if (displayXVal == (int) displayXVal) cstr = string.Format("{0}", (int) displayXVal); else { if (labelspacing < 0.06 || xval < .01) cstr = string.Format("{0:F3}", displayXVal); else if (labelspacing < 0.6 || xval < .1) cstr = string.Format("{0:F2}", displayXVal); else cstr = string.Format("{0:F1}", displayXVal); } if (cstr.EndsWith("000000000")) cstr = cstr.Substring(0, cstr.Length - 9) + "G"; if (cstr.EndsWith("000000")) cstr = cstr.Substring(0, cstr.Length - 6) + "M"; if (cstr.EndsWith("000")) cstr = cstr.Substring(0, cstr.Length - 3) + "K"; strsize = g.MeasureString(cstr, LabelFont); if (!_hideXLabels) { g.DrawString(cstr, LabelFont, labelBrush, new Rectangle(xpos - (int) strsize.Width/2 - 2, Height - ProtectedBottomPadding + 1, (int) strsize.Width + 4, (int) strsize.Height), format); } xval = xval + labelspacing; } } else if (XAxisLabels.Count > 0 && _hideXLabels == false) { int minimumXPos = int.MinValue; float sin = (float) Math.Sin(Math.PI*Math.Abs(_xAxisLabelRotation)/180); foreach (AxisLabel label in XAxisLabels) { xpos = (int) ConvertXToPixel(label.Position); int ytry = Height - ProtectedBottomPadding + 1; strsize = g.MeasureString(label.Value, LabelFont); Matrix saveCoordFrame1 = g.Transform.Clone(); int xtry; int xkeepout; if (_xAxisLabelRotation != 0) { xtry = xpos - 2 - (int) strsize.Width; ytry = Height - ProtectedBottomPadding - 1; xkeepout = (int) (strsize.Height/sin) + 1; Matrix m1 = new Matrix(); m1.RotateAt(_xAxisLabelRotation, new PointF(xpos, Height - ProtectedBottomPadding)); g.MultiplyTransform(m1); if (xpos > minimumXPos) { g.DrawString(label.Value, LabelFont, labelBrush, new Rectangle(xtry, ytry, (int) (strsize.Width + 1), (int) (strsize.Height + 1)), format); minimumXPos = xpos + xkeepout; } } else { xkeepout = (int) (strsize.Width/2 + 2); xtry = xpos - (int) strsize.Width/2 - 2; if (xtry > minimumXPos) { g.DrawString(label.Value, LabelFont, labelBrush, new Rectangle(xtry, Height - ProtectedBottomPadding + 1, (int) strsize.Width + 4, (int) strsize.Height), format); minimumXPos = xpos + xkeepout; } } g.Transform = saveCoordFrame1; } } // the x axis label; if (!_hideXLabels) { g.DrawString(XLabel, AxesLabelFont, axesLabelBrush, new Rectangle(ProtectedLeftPadding, Height - ProtectedBottomPadding + 2, Width - ProtectedLeftPadding - ProtectedRightPadding, ProtectedBottomPadding), format); } // draw the title g.DrawString(Title, TitleFont, titleBrush, new Rectangle(ProtectedLeftPadding, 0, Width - ProtectedLeftPadding - ProtectedRightPadding, ProtectedTopPadding), format); // draw the y grid labels format.Alignment = StringAlignment.Far; float maxwidth = 0; ypos = (int) ConvertYToPixel(MaxY) - 10; cstr = _yUnits; strsize = g.MeasureString(cstr, LabelFont); format.Alignment = StringAlignment.Far; g.DrawString(cstr, LabelFont, labelBrush, new Rectangle(0, ypos - (int) strsize.Height/2 - 1, ProtectedLeftPadding - 2, (int) strsize.Height + 2), format); format.Alignment = StringAlignment.Near; g.DrawString(cstr, LabelFont, labelBrush, new Rectangle(Width - ProtectedRightPadding + 2, ypos - (int) strsize.Height/2 - 1, ProtectedRightPadding - 2, (int) strsize.Height + 2), format); yval = oldyval; while (yval < MaxY) { ypos = (int) ConvertYToPixel(yval); if (yval == (int) yval) cstr = string.Format("{0}", (int) yval); else { if (ylabelspacing < 0.06) cstr = string.Format("{0:F3}", yval); else if (ylabelspacing < .6) cstr = string.Format("{0:F2}", yval); else cstr = string.Format("{0:F1}", yval); } if (cstr.EndsWith("000000")) cstr = cstr.Substring(0, cstr.Length - 6) + "M"; if (cstr.EndsWith("000")) cstr = cstr.Substring(0, cstr.Length - 3) + "K"; strsize = g.MeasureString(cstr, LabelFont); if (strsize.Width > maxwidth) maxwidth = strsize.Width; //Y scale format.Alignment = StringAlignment.Far; int top = ypos - (int) strsize.Height/2 - 1; if (top < 0) top = 0; g.DrawString(cstr, LabelFont, labelBrush, new Rectangle(0, top, ProtectedLeftPadding - 2, (int) strsize.Height + 2), format); format.Alignment = StringAlignment.Near; if (_drawRightYAxisLabels) g.DrawString(cstr, LabelFont, labelBrush, new Rectangle(Width - ProtectedRightPadding + 2, top, ProtectedRightPadding - 2, (int) strsize.Height + 2), format); yval += ylabelspacing; } // the y axis label; format.Alignment = StringAlignment.Center; format.LineAlignment = StringAlignment.Center; Matrix saveCoordFrame = g.Transform.Clone(); Matrix m = new Matrix(); m.Rotate(-90F); g.MultiplyTransform(m); g.TranslateTransform( (ProtectedLeftPadding - 20 - maxwidth)*saveCoordFrame.Elements[0], (Height - ProtectedBottomPadding)*saveCoordFrame.Elements[3], MatrixOrder.Append); g.DrawString(YLabel, AxesLabelFont, axesLabelBrush, new Rectangle(0, 0, Height - ProtectedBottomPadding - ProtectedTopPadding, 20), format); g.Transform = saveCoordFrame; } } } }
protected override void DrawPressed(Graphics g, ArrowDirection direction) { g.FillEllipse(_pressedBrush, new RectangleF(_circleRect.X - 0.5f, _circleRect.Y - 0.5f, _circleRect.Width + 1, _circleRect.Height + 1)); if (direction == ArrowDirection.Right) g.MultiplyTransform(new Matrix(-1, 0, 0, 1, 23, 0)); g.DrawPath(_hoverArrowPen, _arrowPath); }
/// <summary> /// Draws the temporary line(s) from the first point to the mouse. /// </summary> /// <param name="g"></param> public override void AfterPaint(Graphics g) { if (_currentPoint >= 1) { if (null != _grac.ActiveLayer) { g.MultiplyTransform(_cachedActiveLayerTransformationGdi); // g.TranslateTransform((float)_grac.ActiveLayer.Position.X, (float)_grac.ActiveLayer.Position.Y); // g.RotateTransform((float)-_grac.ActiveLayer.Rotation); var currLayerCoord = _cachedActiveLayerTransformation.InverseTransformPoint(_positionCurrentMouseInRootLayerCoordinates); DrawRectangleFromLTRB(g, _Points[0].LayerCoordinates, currLayerCoord); } else { DrawRectangleFromLTRB(g, _Points[0].RootLayerCoordinates, _positionCurrentMouseInRootLayerCoordinates); } } }
protected override void DrawDisabled(Graphics g, ArrowDirection direction) { g.FillPath(_disabledUpperBackgroundBrush, _upperBackgroundPath); g.FillPath(_disabledLowerBackgroundBrush, _lowerBackgroundPath); g.FillPath(_disabledUpperBrush, _upperBackgroundPath); g.FillPath(_disabledLowerBrush, _lowerBackgroundPath); if (direction == ArrowDirection.Right) g.MultiplyTransform(new Matrix(-1, 0, 0, 1, 24f, 0)); g.DrawPath(_disabledArrowPen, _arrowPath); }
public virtual void Paint(Graphics g) { GraphicsState savedgstate = g.Save(); //g.TranslateTransform(m_LayerPosition.X,m_LayerPosition.Y); //g.RotateTransform(m_LayerAngle); g.MultiplyTransform(_cachedForwardMatrix); RectangleF layerBounds = new RectangleF(_cachedLayerPosition, _cachedLayerSize); _gridPlanes.Paint(g, this); _axisStyles.Paint(g, this); if (ClipDataToFrame==LayerDataClipping.StrictToCS) { g.Clip = CoordinateSystem.GetRegion(); } foreach (IGPlotItem pi in _plotItems) { pi.Paint(g, this); } if (ClipDataToFrame==LayerDataClipping.StrictToCS) { g.ResetClip(); } _graphObjects.DrawObjects(g, 1, this); _legends.DrawObjects(g, 1, this); g.Restore(savedgstate); }
private static PointF DrawLineArrowInternal(Graphics gfx, Pen pen, Brush brush, float x, float y, float angle, ArrowStyle style) { PointF pt; var rt = new Matrix(); rt.RotateAt(angle, new PointF(x, y)); double rx = style.RadiusX; double ry = style.RadiusY; double sx = 2.0 * rx; double sy = 2.0 * ry; switch (style.ArrowType) { default: case ArrowType.None: { pt = new PointF(x, y); } break; case ArrowType.Rectangle: { var pts = new PointF[] { new PointF(x - (float)sx, y) }; rt.TransformPoints(pts); pt = pts[0]; var rect = new Rect2(x - sx, y - ry, sx, sy); var gs = gfx.Save(); gfx.MultiplyTransform(rt); DrawRectangleInternal(gfx, brush, pen, style.IsStroked, style.IsFilled, ref rect); gfx.Restore(gs); } break; case ArrowType.Ellipse: { var pts = new PointF[] { new PointF(x - (float)sx, y) }; rt.TransformPoints(pts); pt = pts[0]; var gs = gfx.Save(); gfx.MultiplyTransform(rt); var rect = new Rect2(x - sx, y - ry, sx, sy); DrawEllipseInternal(gfx, brush, pen, style.IsStroked, style.IsFilled, ref rect); gfx.Restore(gs); } break; case ArrowType.Arrow: { var pts = new PointF[] { new PointF(x, y), new PointF(x - (float)sx, y + (float)sy), new PointF(x, y), new PointF(x - (float)sx, y - (float)sy), new PointF(x, y) }; rt.TransformPoints(pts); pt = pts[0]; var p11 = pts[1]; var p21 = pts[2]; var p12 = pts[3]; var p22 = pts[4]; DrawLineInternal(gfx, pen, style.IsStroked, ref p11, ref p21); DrawLineInternal(gfx, pen, style.IsStroked, ref p12, ref p22); } break; } return pt; }
private void drawInputImage(Graphics g, int width, int height) { using (var brush = new SolidBrush(Color.Black)) { if (inputBGImage != null) g.DrawImage(inputBGImage, 0, 0); g.Transform = currentM; g.MultiplyTransform(transM, MatrixOrder.Append); g.InterpolationMode = InterpolationMode.High; g.DrawString(inputWord, inputStringFontDialog.Font, brush, 0, 0); g.ResetTransform(); } }
public void SetupGraphics(Graphics g, string detail) { scale = (double)(this.Height - 2 * padding_top) / Table.Height; g.SmoothingMode = SmoothingMode.AntiAlias; g.TranslateTransform((this.Width / 2) - (int)((scale * Table.Width) / 2), this.Height - padding_top); g.DrawString(detail, this.Font, Brushes.Black, 0, 10); g.MultiplyTransform(flip_vertically); }
private void DrawListsToGraphics(ref Graphics g) { if (mGfxBuff == null) return; mCurPen.Width = -1; { g.PixelOffsetMode = System.Drawing.Drawing2D.PixelOffsetMode.HighQuality; g.PageUnit = GraphicsUnit.Inch; g.ResetTransform(); g.MultiplyTransform(mMtxWCS); //Draw the axis indicator and axis lines foreach (clsDisplayList p in mWcsDisplayLists) { if (p.Rapid) { mWCSPen.DashStyle = System.Drawing.Drawing2D.DashStyle.Custom; mWCSPen.DashPattern = mAxisDashStyle; } else { mWCSPen.DashStyle = System.Drawing.Drawing2D.DashStyle.Solid; } mWCSPen.Color = p.Color; g.DrawLines(mWCSPen, p.Points); } g.ResetTransform(); //Now draw the toolpath mRapidDashStyle[0] = 0.05f / mScaleToReal; mRapidDashStyle[1] = 0.05f / mScaleToReal; g.MultiplyTransform(mMtxDraw); foreach (clsDisplayList p in mDisplayLists) { if (!p.InView) { continue; } if (p.Rapid) { mCurPen.DashStyle = System.Drawing.Drawing2D.DashStyle.Custom; mCurPen.DashPattern = mRapidDashStyle; } else { mCurPen.DashStyle = System.Drawing.Drawing2D.DashStyle.Solid; } mCurPen.Color = p.Color; LineFixUp(ref p.Points); g.DrawLines(mCurPen, p.Points); } } }
public void shear(float x, float y) { System.Drawing.Drawing2D.Matrix mx = new System.Drawing.Drawing2D.Matrix(); mx.Shear(x, y); dg.MultiplyTransform(mx); }
/// <summary> /// Fulfill the IAlteration contract. Applies the matrix alteration /// to the Graphics object of the sprite. /// Bug: /// </summary> /// <param name="p_g"> /// A <see cref="Graphics"/> on which the sprite is being drawn /// </param> /// <param name="p_point"> /// A <see cref="Point"/> indicating where the sprite will be drawn /// </param> /// <param name="p_bitmap"> /// A <see cref="Bitmap"/> of the sprite /// </param> public void ApplyAlteration(Graphics p_g, Point p_point, ref Bitmap p_bitmap) { //p_g.Transform = matrix; p_g.MultiplyTransform(matrix); }
/// <summary> /// This switches the graphics context from printable area coordinates to layer coordinates. /// </summary> /// <param name="g">The graphics state to change.</param> public void GraphToLayerCoordinates(Graphics g) { g.MultiplyTransform(_cachedForwardMatrix); }
private GraphicsPath _enclosingPath = new GraphicsPath(); // with Winding also overlapping rectangles are selected public override void Paint(Graphics g, XYPlotLayer layer, CSAxisInformation styleInfo, AxisLineStyle axisstyle, bool useMinorTicks) { _cachedStyleID = styleInfo.Identifier; CSLineID styleID = styleInfo.Identifier; Scale raxis = styleID.ParallelAxisNumber==0 ? layer.XAxis : layer.YAxis; _enclosingPath.Reset(); _enclosingPath.FillMode = FillMode.Winding; // with Winding also overlapping rectangles are selected GraphicsPath helperPath = new GraphicsPath(); Matrix math = new Matrix(); Logical3D r0 = _cachedStyleID.Begin; Logical3D r1 = _cachedStyleID.End; SizeF layerSize = layer.Size; PointF outVector; Logical3D outer; float outerDistance = null==axisstyle? 0 : axisstyle.GetOuterDistance(styleInfo.PreferedLabelSide); float dist_x = outerDistance; // Distance from axis tick point to label float dist_y = outerDistance; // y distance from axis tick point to label // dist_x += this._font.SizeInPoints/3; // add some space to the horizontal direction in order to separate the chars a little from the ticks // next statement is necessary to have a consistent string length both // on 0 degree rotated text and rotated text // without this statement, the text is fitted to the pixel grid, which // leads to "steps" during scaling g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAlias; double[] relpositions; AltaxoVariant[] ticks; if(useMinorTicks) { relpositions = raxis.GetMinorTicksNormal(); ticks = raxis.GetMinorTicksAsVariant(); } else { relpositions = raxis.GetMajorTicksNormal(); ticks = raxis.GetMajorTicksAsVariant(); } IMeasuredLabelItem[] labels = _labelFormatting.GetMeasuredItems(g,_font,_stringFormat,ticks); float emSize = _font.SizeInPoints; for(int i=0;i<ticks.Length;i++) { double r = relpositions[i]; outer = layer.CoordinateSystem.GetLogicalDirection(styleID.ParallelAxisNumber, styleInfo.PreferedLabelSide); PointF tickorg = layer.CoordinateSystem.GetNormalizedDirection(r0, r1, r, outer, out outVector); PointF tickend = tickorg; tickend.X += outVector.X * outerDistance; tickend.Y += outVector.Y * outerDistance; SizeF msize = labels[i].Size; PointF morg = tickend; if (_automaticRotationShift) { double alpha = _rotation * Math.PI / 180 - Math.Atan2(outVector.Y, outVector.X); double shift = msize.Height * 0.5 * Math.Abs(Math.Sin(alpha)) + (msize.Width + _font.SizeInPoints / 2) * 0.5 * Math.Abs(Math.Cos(alpha)); morg.X += (float)(outVector.X * shift); morg.Y += (float)(outVector.Y * shift); } else { morg.X += (float)(outVector.X * _font.SizeInPoints/3); } RectangleF mrect = new RectangleF(morg,msize); if(_automaticRotationShift) AdjustRectangle(ref mrect, StringAlignment.Center, StringAlignment.Center); else AdjustRectangle(ref mrect, _horizontalAlignment, _verticalAlignment); math.Reset(); math.Translate((float)morg.X, (float)morg.Y); if (this._rotation != 0) { math.Rotate((float)-this._rotation); } math.Translate((float)(mrect.X - morg.X + emSize * _xOffset), (float)(mrect.Y - morg.Y + emSize * _yOffset)); System.Drawing.Drawing2D.GraphicsState gs = g.Save(); g.MultiplyTransform(math); if(this._backgroundStyle!=null) _backgroundStyle.Draw(g,new RectangleF(PointF.Empty,msize)); _brush.Rectangle = new RectangleF(PointF.Empty, msize); labels[i].Draw(g,_brush,new PointF(0,0)); g.Restore(gs); // Restore the graphics state helperPath.Reset(); helperPath.AddRectangle(new RectangleF(PointF.Empty, msize)); helperPath.Transform(math); _enclosingPath.AddPath(helperPath,true); } }
/// <summary> /// Transforms the graphics context is such a way, that the object can be drawn in local coordinates. /// </summary> /// <param name="g">Graphics context (should be saved beforehand).</param> protected override void TransformGraphics(Graphics g) { g.MultiplyTransform(_transformation); }
/// <summary> /// Paints the axis style labels. /// </summary> /// <param name="g">Graphics environment.</param> /// <param name="coordSyst">The coordinate system. Used to get the path along the axis.</param> /// <param name="scale">Scale.</param> /// <param name="tickSpacing">If not <c>null</c>, this parameter provides a custom tick spacing that is used instead of the default tick spacing of the scale.</param> /// <param name="styleInfo">Information about begin of axis, end of axis.</param> /// <param name="outerDistance">Distance between axis and labels.</param> /// <param name="useMinorTicks">If true, minor ticks are shown.</param> public virtual void Paint(Graphics g, G2DCoordinateSystem coordSyst, Scale scale, TickSpacing tickSpacing, CSAxisInformation styleInfo, double outerDistance, bool useMinorTicks) { _cachedAxisStyleInfo = styleInfo; CSLineID styleID = styleInfo.Identifier; Scale raxis = scale; TickSpacing ticking = tickSpacing; _enclosingPath.Reset(); _enclosingPath.FillMode = FillMode.Winding; // with Winding also overlapping rectangles are selected GraphicsPath helperPath = new GraphicsPath(); Matrix math = new Matrix(); Logical3D r0 = styleID.GetLogicalPoint(styleInfo.LogicalValueAxisOrg); Logical3D r1 = styleID.GetLogicalPoint(styleInfo.LogicalValueAxisEnd); PointD2D outVector; Logical3D outer; var dist_x = outerDistance; // Distance from axis tick point to label var dist_y = outerDistance; // y distance from axis tick point to label // dist_x += this._font.SizeInPoints/3; // add some space to the horizontal direction in order to separate the chars a little from the ticks // next statement is necessary to have a consistent string length both // on 0 degree rotated text and rotated text // without this statement, the text is fitted to the pixel grid, which // leads to "steps" during scaling g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAlias; double[] relpositions; AltaxoVariant[] ticks; if (useMinorTicks) { relpositions = ticking.GetMinorTicksNormal(raxis); ticks = ticking.GetMinorTicksAsVariant(); } else { relpositions = ticking.GetMajorTicksNormal(raxis); ticks = ticking.GetMajorTicksAsVariant(); } if (!_suppressedLabels.IsEmpty) { List<AltaxoVariant> filteredTicks = new List<AltaxoVariant>(); List<double> filteredRelPositions = new List<double>(); for (int i = 0; i < ticks.Length; i++) { if (_suppressedLabels.ByValues.Contains(ticks[i])) continue; if (_suppressedLabels.ByNumbers.Contains(i)) continue; if (_suppressedLabels.ByNumbers.Contains(i - ticks.Length)) continue; filteredTicks.Add(ticks[i]); filteredRelPositions.Add(relpositions[i]); } ticks = filteredTicks.ToArray(); relpositions = filteredRelPositions.ToArray(); } IMeasuredLabelItem[] labels = _labelFormatting.GetMeasuredItems(g, _font, _stringFormat, ticks); double emSize = _font.Size; CSAxisSide labelSide = null != _labelSide ? _labelSide.Value : styleInfo.PreferredLabelSide; for (int i = 0; i < ticks.Length; i++) { double r = relpositions[i]; if (!Altaxo.Calc.RMath.IsInIntervalCC(r, -1000, 1000)) continue; outer = coordSyst.GetLogicalDirection(styleID.ParallelAxisNumber, labelSide); PointD2D tickorg = coordSyst.GetNormalizedDirection(r0, r1, r, outer, out outVector); PointD2D tickend = tickorg + outVector * outerDistance; PointD2D msize = labels[i].Size; PointD2D morg = tickend; if (_automaticRotationShift) { double alpha = _rotation * Math.PI / 180 - Math.Atan2(outVector.Y, outVector.X); double shift = msize.Y * 0.5 * Math.Abs(Math.Sin(alpha)) + (msize.X + _font.Size / 2) * 0.5 * Math.Abs(Math.Cos(alpha)); morg = morg + outVector * shift; } else { morg = morg.WithXPlus(outVector.X * _font.Size / 3); } RectangleD2D mrect = new RectangleD2D(morg, msize); if (_automaticRotationShift) AdjustRectangle(ref mrect, StringAlignment.Center, StringAlignment.Center); else AdjustRectangle(ref mrect, _horizontalAlignment, _verticalAlignment); math.Reset(); math.Translate((float)morg.X, (float)morg.Y); if (this._rotation != 0) { math.Rotate((float)-this._rotation); } math.Translate((float)(mrect.X - morg.X + emSize * _xOffset), (float)(mrect.Y - morg.Y + emSize * _yOffset)); System.Drawing.Drawing2D.GraphicsState gs = g.Save(); g.MultiplyTransform(math); if (this._backgroundStyle != null) _backgroundStyle.Draw(g, new RectangleD2D(PointD2D.Empty, msize)); _brush.SetEnvironment(new RectangleD2D(PointD2D.Empty, msize), BrushX.GetEffectiveMaximumResolution(g, 1)); labels[i].Draw(g, _brush, new PointF(0, 0)); g.Restore(gs); // Restore the graphics state helperPath.Reset(); helperPath.AddRectangle(new RectangleF(PointF.Empty, (SizeF)msize)); helperPath.Transform(math); _enclosingPath.AddPath(helperPath, true); } }
protected override void DrawPressed(Graphics g, ArrowDirection direction) { g.FillPath(_pressedBackgrounBrush, _lowerBackgroundPath); g.FillPath(_pressedUpperBackgroundBrush, _upperBackgroundPath); g.FillEllipse(_pressedLowerBackgroundBrush, _backgroundRect); if (direction == ArrowDirection.Right) g.MultiplyTransform(new Matrix(-1, 0, 0, 1, 24f, 0)); g.DrawPath(_normalArrowPen, _arrowPath); }
/// <summary> /// Apply the flip /// </summary> /// <param name="p_g">Graphic object</param> /// <param name="p_point">Location where to draw object</param> /// <param name="p_bitmap">Reference to bitmap to draw on</param> public void ApplyAlteration(Graphics p_g, Point p_point, ref Bitmap p_bitmap) { p_g.TranslateTransform((float)(p_point.X), (float)(p_point.Y)); Matrix m = new Matrix(1,0,0,1,0,0); switch(flipType) { case Animation.Flip.FlipType.Horizontal: m = new Matrix(-1,0,0,1,0,0); break; case Animation.Flip.FlipType.Vertical: m = new Matrix(1,0,0,-1,0,0); break; case Animation.Flip.FlipType.Both: m = new Matrix(-1,0,0,-1,0,0); break; default: m = new Matrix(1,0,0,1,0,0); break; } // Rotate desired degrees p_g.MultiplyTransform(m); // Move the origin back to where it belongs while it is rotated p_g.TranslateTransform((float)(p_point.X) * -1, (float)(p_point.Y) * -1); }