public override void Render(IRenderContext rc) { base.Render(rc); var sY = StartPoint.Y * (AssociatedSeries.Inverted ? -1 : 1); var eY = EndPoint.Y * (AssociatedSeries.Inverted ? -1 : 1); var actualStart = new DataPoint(StartPoint.X, sY); var actualEnd = new DataPoint(EndPoint.X, eY); _screenEndPoint = Transform(actualEnd); _screenStartPoint = Transform(actualStart); var d = _screenEndPoint - _screenStartPoint; d.Normalize(); var n = new ScreenVector(d.Y, -d.X); const double minimumSegmentLength = 4; var dashArray = LineStyle.GetDashArray(); if (!(StrokeThickness > 0) || LineStyle == LineStyle.None) { return; } rc.DrawReducedLine( new[] { _screenStartPoint, _screenEndPoint }, minimumSegmentLength * minimumSegmentLength, GetSelectableColor(ActualColor), StrokeThickness, EdgeRenderingMode, dashArray, LineJoin); }
/// <summary> /// Transposes the ScreenVector if the series is transposed. Reverses the respective direction if X or Y axis are reversed. /// </summary> /// <param name="element">The <see cref="ITransposablePlotElement" />.</param> /// <param name="vector">The <see cref="ScreenVector" /> to orientate.</param> /// <returns>The oriented vector.</returns> public static ScreenVector Orientate(this ITransposablePlotElement element, ScreenVector vector) { vector = new ScreenVector( element.XAxis.IsReversed ? -vector.X : vector.X, element.YAxis.IsReversed ? -vector.Y : vector.Y); return(element.IsTransposed() ? new ScreenVector(-vector.Y, -vector.X) : vector); }
/// <summary> /// Gets the coordinates of the (rotated) background rectangle. /// </summary> /// <param name="position">The position.</param> /// <param name="size">The size.</param> /// <param name="padding">The padding.</param> /// <param name="rotation">The rotation.</param> /// <param name="horizontalAlignment">The horizontal alignment.</param> /// <param name="verticalAlignment">The vertical alignment.</param> /// <returns>The background rectangle coordinates.</returns> private static IList <ScreenPoint> GetTextBounds( ScreenPoint position, OxySize size, OxyThickness padding, double rotation, HorizontalAlignment horizontalAlignment, VerticalAlignment verticalAlignment) { double left, right, top, bottom; switch (horizontalAlignment) { case HorizontalAlignment.Center: left = -size.Width * 0.5; right = -left; break; case HorizontalAlignment.Right: left = -size.Width; right = 0; break; default: left = 0; right = size.Width; break; } switch (verticalAlignment) { case VerticalAlignment.Middle: top = -size.Height * 0.5; bottom = -top; break; case VerticalAlignment.Bottom: top = -size.Height; bottom = 0; break; default: top = 0; bottom = size.Height; break; } double cost = Math.Cos(rotation / 180 * Math.PI); double sint = Math.Sin(rotation / 180 * Math.PI); var u = new ScreenVector(cost, sint); var v = new ScreenVector(-sint, cost); var polygon = new ScreenPoint[4]; polygon[0] = position + (u * (left - padding.Left)) + (v * (top - padding.Top)); polygon[1] = position + (u * (right + padding.Right)) + (v * (top - padding.Top)); polygon[2] = position + (u * (right + padding.Right)) + (v * (bottom + padding.Bottom)); polygon[3] = position + (u * (left - padding.Left)) + (v * (bottom + padding.Bottom)); return(polygon); }
/// <summary> /// Calculates the starting distance. /// </summary> private void CalculateStartingDistance() { if (this.activeTouches.Count < 2) { this.startingDistance = default(ScreenVector); return; } var loc1 = this.activeTouches.ElementAt(0).LocationInView(this.View).ToScreenPoint(); var loc2 = this.activeTouches.ElementAt(1).LocationInView(this.View).ToScreenPoint(); this.startingDistance = loc1 - loc2; }
/// <summary> /// Called when a touch gesture is moving. /// </summary> /// <param name="touches">The touches.</param> /// <param name="evt">The event arguments.</param> public override void TouchesMoved(NSSet touches, UIEvent evt) { base.TouchesMoved(touches, evt); if (this.activeTouches.Any(touch => touch.Phase == UITouchPhase.Moved)) { // get current and previous location of the first touch point var t1 = this.activeTouches.First(); var l1 = t1.LocationInView(this.View).ToScreenPoint(); var pl1 = t1.Phase == UITouchPhase.Moved ? t1.PreviousLocationInView(this.View).ToScreenPoint() : l1; var l = l1; var t = l1 - pl1; var s = new ScreenVector(1, 1); if (this.activeTouches.Count > 1) { // get current and previous location of the second touch point var t2 = this.activeTouches.ElementAt(1); var l2 = t2.LocationInView(this.View).ToScreenPoint(); var pl2 = t2.Phase == UITouchPhase.Moved ? t2.PreviousLocationInView(this.View).ToScreenPoint() : l2; var d = l1 - l2; var pd = pl1 - pl2; if (!this.KeepAspectRatioWhenPinching) { if (!this.AllowPinchPastZero) { // Don't allow fingers crossing in a zoom-out gesture to turn it back into a zoom-in gesture d = this.PreventCross(d); } var scalex = this.CalculateScaleFactor(d.X, pd.X); var scaley = this.CalculateScaleFactor(d.Y, pd.Y); s = new ScreenVector(scalex, scaley); } else { var scale = pd.Length > 0 ? d.Length / pd.Length : 1; s = new ScreenVector(scale, scale); } } var e = new OxyTouchEventArgs { Position = l, DeltaTranslation = t, DeltaScale = s }; this.TouchEventArgs = e; this.State = UIGestureRecognizerState.Changed; } }
public override void Render(IRenderContext rc) { // transform to screen coordinates var p0 = this.Transform(this.StartPoint); var p1 = this.Transform(this.EndPoint); var direction = p1 - p0; var normal = new ScreenVector(direction.Y, -direction.X); // the end points of the arrow head, scaled by length of arrow var p2 = p1 - (direction * 0.2) + (normal * 0.1); var p3 = p1 - (direction * 0.2) - (normal * 0.1); // draw the line segments rc.DrawLineSegments(new[] { p0, p1, p1, p2, p1, p3 }, this.ActualColor, this.StrokeThickness); }
/// <summary> /// Applies the "prevent fingers crossing" to the specified vector. /// </summary> /// <param name="currentDistance">The current distance.</param> /// <returns>A vector where the "prevent fingers crossing" is applied.</returns> private ScreenVector PreventCross(ScreenVector currentDistance) { var x = currentDistance.X; var y = currentDistance.Y; if (DidDirectionChange(x, this.startingDistance.X)) { x = 0; } if (DidDirectionChange(y, this.startingDistance.Y)) { y = 0; } return(new ScreenVector(x, y)); }
/// <summary> /// Called when a touch gesture is moving. /// </summary> /// <param name="touches">The touches.</param> /// <param name="evt">The event arguments.</param> public override void TouchesMoved(NSSet touches, UIEvent evt) { // it seems to be easier to handle touch events here than using UIPanGesturRecognizer and UIPinchGestureRecognizer base.TouchesMoved(touches, evt); // convert the touch points to an array var ta = touches.ToArray <UITouch>(); if (ta.Length > 0) { // get current and previous location of the first touch point var t1 = ta[0]; var l1 = t1.LocationInView(this).ToScreenPoint(); var pl1 = t1.PreviousLocationInView(this).ToScreenPoint(); var l = l1; var t = l1 - pl1; var s = new ScreenVector(1, 1); if (ta.Length > 1) { // get current and previous location of the second touch point var t2 = ta[1]; var l2 = t2.LocationInView(this).ToScreenPoint(); var pl2 = t2.PreviousLocationInView(this).ToScreenPoint(); var d = l1 - l2; var pd = pl1 - pl2; if (!this.KeepAspectRatioWhenPinching) { var scalex = System.Math.Abs(pd.X) > 0 ? System.Math.Abs(d.X / pd.X) : 1; var scaley = System.Math.Abs(pd.Y) > 0 ? System.Math.Abs(d.Y / pd.Y) : 1; s = new ScreenVector(scalex, scaley); } else { var scale = pd.Length > 0 ? d.Length / pd.Length : 1; s = new ScreenVector(scale, scale); } } var e = new OxyTouchEventArgs { Position = l, DeltaTranslation = t, DeltaScale = s }; this.ActualController.HandleTouchDelta(this, e); } }
/// <summary> /// Draws the text. /// </summary> /// <param name="p">The p.</param> /// <param name="text">The text.</param> /// <param name="c">The c.</param> /// <param name="fontFamily">The font family.</param> /// <param name="fontSize">Size of the font.</param> /// <param name="fontWeight">The font weight.</param> /// <param name="rotate">The rotate.</param> /// <param name="halign">The horizontal alignment.</param> /// <param name="valign">The vertical alignment.</param> /// <param name="maxSize">Size of the max.</param> public override void DrawText(ScreenPoint p, string text, OxyColor c, string fontFamily, double fontSize, double fontWeight, double rotate, OxyPlot.HorizontalAlignment halign, OxyPlot.VerticalAlignment valign, OxySize?maxSize) { if (string.IsNullOrEmpty(text)) { return; } string[] array = Regex.Split(text, "\r\n"); if (valign == OxyPlot.VerticalAlignment.Bottom) { for (int i = array.Length - 1; i >= 0; i--) { string text2 = array[i]; OxySize oxySize = this.MeasureText(text2, fontFamily, fontSize, fontWeight); this.w.WriteText(p, text2, c, fontFamily, fontSize, fontWeight, rotate, halign, valign); p += new ScreenVector(Math.Sin(rotate / 180.0 * 3.1415926535897931) * oxySize.Height, Math.Cos(rotate / 180.0 * 3.1415926535897931) * oxySize.Height); } return; } string[] array2 = array; if (text.Contains(".")) { p += new ScreenVector(0.0, 8.0); } else { p += new ScreenVector(0.0, 14.0); } for (int j = 0; j < array2.Length; j++) { string text3 = array2[j]; OxySize oxySize2 = this.MeasureText(text3, fontFamily, fontSize, fontWeight); this.w.WriteText(p, text3, c, fontFamily, fontSize, fontWeight, rotate, halign, valign); p += new ScreenVector(-Math.Sin(rotate / 180.0 * 3.1415926535897931) * oxySize2.Height, Math.Cos(rotate / 180.0 * 3.1415926535897931) * oxySize2.Height); } }
/// <summary> /// Renders the annotation on the specified context. /// </summary> /// <param name="rc">The render context.</param> public override void Render(IRenderContext rc) { base.Render(rc); this.CalculateActualMinimumsMaximums(); this.screenPoints = this.GetScreenPoints(); var clippingRectangle = this.GetClippingRect(); const double MinimumSegmentLength = 4; var clippedPoints = new List <ScreenPoint>(); var dashArray = this.LineStyle.GetDashArray(); if (this.StrokeThickness > 0 && this.LineStyle != LineStyle.None) { rc.DrawClippedLine( clippingRectangle, this.screenPoints, MinimumSegmentLength * MinimumSegmentLength, this.GetSelectableColor(this.Color), this.StrokeThickness, dashArray, this.LineJoin, this.Aliased, null, clippedPoints.AddRange); } var margin = this.TextMargin; this.GetActualTextAlignment(out var ha, out var va); if (ha == HorizontalAlignment.Center) { margin = 0; } else { margin *= this.TextLinePosition < 0.5 ? 1 : -1; } if (GetPointAtRelativeDistance(clippedPoints, this.TextLinePosition, margin, out var position, out var angle)) { if (angle < -90) { angle += 180; } if (angle > 90) { angle -= 180; } switch (this.TextOrientation) { case AnnotationTextOrientation.Horizontal: angle = 0; break; case AnnotationTextOrientation.Vertical: angle = -90; break; } // Apply 'padding' to the position var angleInRadians = angle / 180 * Math.PI; var f = 1; if (ha == HorizontalAlignment.Right) { f = -1; } if (ha == HorizontalAlignment.Center) { f = 0; } position += new ScreenVector(f * this.TextPadding * Math.Cos(angleInRadians), f * this.TextPadding * Math.Sin(angleInRadians)); if (!string.IsNullOrEmpty(this.Text)) { var textPosition = this.GetActualTextPosition(() => position); if (this.TextPosition.IsDefined()) { angle = this.TextRotation; } if (this.ClipText) { var cs = new CohenSutherlandClipping(clippingRectangle); if (cs.IsInside(position)) { rc.DrawClippedText( clippingRectangle, textPosition, this.Text, this.ActualTextColor, this.ActualFont, this.ActualFontSize, this.ActualFontWeight, angle, this.TextHorizontalAlignment, this.TextVerticalAlignment); } } else { rc.DrawText( textPosition, this.Text, this.ActualTextColor, this.ActualFont, this.ActualFontSize, this.ActualFontWeight, angle, ha, va); } } } }
/// <summary> /// Renders the arrow annotation. /// </summary> /// <param name="rc">The render context.</param> /// <param name="model">The plot model.</param> public override void Render(IRenderContext rc, PlotModel model) { base.Render(rc, model); this.screenEndPoint = this.Transform(this.EndPoint); if (this.ArrowDirection.LengthSquared > 0) { this.screenStartPoint = this.screenEndPoint - this.ArrowDirection; } else { this.screenStartPoint = this.Transform(this.StartPoint); } var d = this.screenEndPoint - this.screenStartPoint; d.Normalize(); var n = new ScreenVector(d.Y, -d.X); var p1 = this.screenEndPoint - (d * this.HeadLength * this.StrokeThickness); var p2 = p1 + (n * this.HeadWidth * this.StrokeThickness); var p3 = p1 - (n * this.HeadWidth * this.StrokeThickness); var p4 = p1 + (d * this.Veeness * this.StrokeThickness); var clippingRectangle = this.GetClippingRect(); const double MinimumSegmentLength = 4; var dashArray = this.LineStyle.GetDashArray(); rc.DrawClippedLine( clippingRectangle, new[] { this.screenStartPoint, p4 }, MinimumSegmentLength * MinimumSegmentLength, this.GetSelectableColor(this.Color), this.StrokeThickness, dashArray, this.LineJoin, false); rc.DrawClippedPolygon( clippingRectangle, new[] { p3, this.screenEndPoint, p2, p4 }, MinimumSegmentLength * MinimumSegmentLength, this.GetSelectableColor(this.Color), OxyColors.Undefined); if (!string.IsNullOrEmpty(this.Text)) { var ha = this.TextHorizontalAlignment; var va = this.TextVerticalAlignment; if (!this.TextPosition.IsDefined()) { // automatic position => use automatic alignment ha = d.X < 0 ? HorizontalAlignment.Left : HorizontalAlignment.Right; va = d.Y < 0 ? VerticalAlignment.Top : VerticalAlignment.Bottom; } var textPoint = this.GetActualTextPosition(() => this.screenStartPoint); rc.DrawClippedText( clippingRectangle, textPoint, this.Text, this.ActualTextColor, this.ActualFont, this.ActualFontSize, this.ActualFontWeight, this.TextRotation, ha, va); } }
/// <summary> /// Gets the coordinates of the (rotated) background rectangle. /// </summary> /// <param name="position"> /// The position. /// </param> /// <param name="size"> /// The size. /// </param> /// <param name="padding"> /// The padding. /// </param> /// <param name="rotation"> /// The rotation. /// </param> /// <param name="horizontalAlignment"> /// The horizontal alignment. /// </param> /// <param name="verticalAlignment"> /// The vertical alignment. /// </param> /// <returns> /// The background rectangle coordinates. /// </returns> private static IList<ScreenPoint> GetTextBounds( ScreenPoint position, OxySize size, OxyThickness padding, double rotation, HorizontalAlignment horizontalAlignment, VerticalAlignment verticalAlignment) { double left, right, top, bottom; switch (horizontalAlignment) { case HorizontalAlignment.Center: left = -size.Width * 0.5; right = -left; break; case HorizontalAlignment.Right: left = -size.Width; right = 0; break; default: left = 0; right = size.Width; break; } switch (verticalAlignment) { case VerticalAlignment.Middle: top = -size.Height * 0.5; bottom = -top; break; case VerticalAlignment.Bottom: top = -size.Height; bottom = 0; break; default: top = 0; bottom = size.Height; break; } double cost = Math.Cos(rotation / 180 * Math.PI); double sint = Math.Sin(rotation / 180 * Math.PI); var u = new ScreenVector(cost, sint); var v = new ScreenVector(-sint, cost); var polygon = new ScreenPoint[4]; polygon[0] = position + (u * (left - padding.Left)) + (v * (top - padding.Top)); polygon[1] = position + (u * (right + padding.Right)) + (v * (top - padding.Top)); polygon[2] = position + (u * (right + padding.Right)) + (v * (bottom + padding.Bottom)); polygon[3] = position + (u * (left - padding.Left)) + (v * (bottom + padding.Bottom)); return polygon; }
/// <summary> /// Renders the arrow annotation. /// </summary> /// <param name="rc">The render context.</param> public override void Render(IRenderContext rc) { base.Render(rc); this.screenEndPoint = this.Transform(this.EndPoint); if (this.ArrowDirection.LengthSquared > 0) { this.screenStartPoint = this.screenEndPoint - this.ArrowDirection; } else { this.screenStartPoint = this.Transform(this.StartPoint); } var d = this.screenEndPoint - this.screenStartPoint; d.Normalize(); var n = new ScreenVector(d.Y, -d.X); var p1 = this.screenEndPoint - (d * this.HeadLength * this.StrokeThickness); var p2 = p1 + (n * this.HeadWidth * this.StrokeThickness); var p3 = p1 - (n * this.HeadWidth * this.StrokeThickness); var p4 = p1 + (d * this.Veeness * this.StrokeThickness); var clippingRectangle = this.GetClippingRect(); const double MinimumSegmentLength = 4; var dashArray = this.LineStyle.GetDashArray(); rc.DrawClippedLine( clippingRectangle, new[] { this.screenStartPoint, p4 }, MinimumSegmentLength * MinimumSegmentLength, this.GetSelectableColor(this.Color), this.StrokeThickness, dashArray, this.LineJoin, false); rc.DrawClippedPolygon( clippingRectangle, new[] { p3, this.screenEndPoint, p2, p4 }, MinimumSegmentLength * MinimumSegmentLength, this.GetSelectableColor(this.Color), OxyColors.Undefined); if (!string.IsNullOrEmpty(this.Text)) { var ha = this.TextHorizontalAlignment; var va = this.TextVerticalAlignment; if (!this.TextPosition.IsDefined()) { // automatic position => use automatic alignment ha = d.X < 0 ? HorizontalAlignment.Left : HorizontalAlignment.Right; va = d.Y < 0 ? VerticalAlignment.Top : VerticalAlignment.Bottom; } var textPoint = this.GetActualTextPosition(() => this.screenStartPoint); rc.DrawClippedText( clippingRectangle, textPoint, this.Text, this.ActualTextColor, this.ActualFont, this.ActualFontSize, this.ActualFontWeight, this.TextRotation, ha, va); } }
/// <summary> /// Renders the arrow annotation. /// </summary> /// <param name="rc"> /// The render context. /// </param> /// <param name="model"> /// The plot model. /// </param> public override void Render(IRenderContext rc, PlotModel model) { base.Render(rc, model); this.screenEndPoint = this.Transform(this.EndPoint); if (!this.ArrowDirection.x.IsZero() || !this.ArrowDirection.y.IsZero()) { this.screenStartPoint = this.screenEndPoint - this.ArrowDirection; } else { this.screenStartPoint = this.Transform(this.StartPoint); } var d = this.screenEndPoint - this.screenStartPoint; d.Normalize(); var n = new ScreenVector(d.Y, -d.X); var p1 = this.screenEndPoint - (d * this.HeadLength * this.StrokeThickness); var p2 = p1 + (n * this.HeadWidth * this.StrokeThickness); var p3 = p1 - (n * this.HeadWidth * this.StrokeThickness); var p4 = p1 + (d * this.Veeness * this.StrokeThickness); OxyRect clippingRect = this.GetClippingRect(); const double MinimumSegmentLength = 4; rc.DrawClippedLine( new[] { this.screenStartPoint, p4 }, clippingRect, MinimumSegmentLength * MinimumSegmentLength, this.GetSelectableColor(this.Color), this.StrokeThickness, this.LineStyle, this.LineJoin, false); rc.DrawClippedPolygon( new[] { p3, this.screenEndPoint, p2, p4 }, clippingRect, MinimumSegmentLength * MinimumSegmentLength, this.GetSelectableColor(this.Color), null); if (!string.IsNullOrEmpty(this.Text)) { var ha = d.X < 0 ? HorizontalAlignment.Left : HorizontalAlignment.Right; var va = d.Y < 0 ? VerticalAlignment.Top : VerticalAlignment.Bottom; var textPoint = this.screenStartPoint; rc.DrawClippedText( clippingRect, textPoint, this.Text, this.ActualTextColor, this.ActualFont, this.ActualFontSize, this.ActualFontWeight, 0, ha, va); } }
/// <summary> /// Renders the item label. /// </summary> /// <param name="rc">The render context</param> /// <param name="clippingRect">The clipping rectangle</param> /// <param name="item">The item.</param> /// <param name="baseValue">The bar item base value.</param> /// <param name="topValue">The bar item top value.</param> /// <param name="categoryValue">The bar item category value.</param> /// <param name="categoryEndValue">The bar item category end value.</param> protected void RenderLabel( IRenderContext rc, OxyRect clippingRect, BarItem item, double baseValue, double topValue, double categoryValue, double categoryEndValue) { var s = StringHelper.Format(this.ActualCulture, this.LabelFormatString, item, item.Value); HorizontalAlignment ha; ScreenPoint pt; var y = (categoryEndValue + categoryValue) / 2; var sign = Math.Sign(item.Value); var marginVector = new ScreenVector(this.LabelMargin, 0) * sign; switch (this.LabelPlacement) { case LabelPlacement.Inside: pt = this.Transform(topValue, y); marginVector = -marginVector; ha = (HorizontalAlignment)sign; break; case LabelPlacement.Outside: pt = this.Transform(topValue, y); ha = (HorizontalAlignment)(-sign); break; case LabelPlacement.Middle: pt = this.Transform((topValue + baseValue) / 2, y); marginVector = new ScreenVector(0, 0); ha = HorizontalAlignment.Center; break; case LabelPlacement.Base: pt = this.Transform(baseValue, y); ha = (HorizontalAlignment)(-sign); break; default: throw new ArgumentOutOfRangeException(); } var va = VerticalAlignment.Middle; this.Orientate(ref ha, ref va); pt += this.Orientate(marginVector); rc.DrawClippedText( clippingRect, pt, s, this.ActualTextColor, this.ActualFont, this.ActualFontSize, this.ActualFontWeight, 0, ha, va); }
public static void RenderBoxText(IRenderContext rc, eThemeMode themeMode, OxyRect clippingRect, string text, int textPadding, ScreenPoint sp, ScreenPoint offset, OxyColor color, BoxPosition position = BoxPosition.Left, string font = "Arial") { OxySize text_size = rc.MeasureText(text, font); ScreenPoint down_line_sp = new ScreenPoint(sp.X + offset.X, sp.Y + offset.Y); ScreenPoint text_sp = new ScreenPoint(sp.X + offset.X + TextPadding, sp.Y - text_size.Height - TextPadding + offset.Y); IList <ScreenPoint> line = new List <ScreenPoint>(); line.Add(sp); double box_width = text_size.Width + 2 * TextPadding; double box_height = text_size.Height + 2 * TextPadding; OxyRect rect; switch (position) { case BoxPosition.Left: rect = new OxyRect(down_line_sp.X, down_line_sp.Y - box_height, box_width, box_height); break; case BoxPosition.Middle: down_line_sp = new ScreenPoint(down_line_sp.X - offset.X, down_line_sp.Y); rect = new OxyRect(down_line_sp.X - box_width / 2, down_line_sp.Y - box_height, box_width, box_height); text_sp = new ScreenPoint(down_line_sp.X - text_size.Width / 2, text_sp.Y); break; case BoxPosition.Right: rect = new OxyRect(down_line_sp.X - box_width, down_line_sp.Y - box_height, box_width, box_height); text_sp = new ScreenPoint(down_line_sp.X - text_size.Width, text_sp.Y); break; default: rect = new OxyRect(0, 0, 0, 0); break; } //ajust if (!Pan.ContainsRect(clippingRect, rect)) { ScreenVector vector = Pan.AjustBound(rect, clippingRect); rect = Pan.PanRect(rect, vector); down_line_sp = Pan.PanPoint(down_line_sp, vector); text_sp = Pan.PanPoint(text_sp, vector); } line.Add(down_line_sp); rc.DrawLine(line, color); if (rect.Width > 0 && rect.Height > 0) { OxyColor back_color = Convertor.ConvertColorToOxyColor(Helper.DarkBackColor); OxyColor fore_color = Convertor.ConvertColorToOxyColor(Helper.LightBackColor); switch (themeMode) { case eThemeMode.Dark: back_color = Convertor.ConvertColorToOxyColor(Helper.DarkBackColor); fore_color = OxyColors.White; break; case eThemeMode.Light: back_color = Convertor.ConvertColorToOxyColor(Helper.LightBackColor); fore_color = OxyColors.Black; break; } rc.DrawRectangle(rect, back_color, fore_color); rc.DrawText(text_sp, text, fore_color, font); } }
/// <summary> /// Renders the annotation on the specified context. /// </summary> /// <param name="rc">The render context.</param> /// <param name="model">The model.</param> public override void Render(IRenderContext rc, PlotModel model) { base.Render(rc, model); this.CalculateActualMinimumsMaximums(); this.screenPoints = this.GetScreenPoints(); // clip to the area defined by the axes var clippingRectangle = OxyRect.Create( this.ClipByXAxis ? this.XAxis.ScreenMin.X : PlotModel.PlotArea.Left, this.ClipByYAxis ? this.YAxis.ScreenMin.Y : PlotModel.PlotArea.Top, this.ClipByXAxis ? this.XAxis.ScreenMax.X : PlotModel.PlotArea.Right, this.ClipByYAxis ? this.YAxis.ScreenMax.Y : PlotModel.PlotArea.Bottom); const double MinimumSegmentLength = 4; var clippedPoints = new List<ScreenPoint>(); var dashArray = this.LineStyle.GetDashArray(); rc.DrawClippedLine( clippingRectangle, this.screenPoints, MinimumSegmentLength * MinimumSegmentLength, this.GetSelectableColor(this.Color), this.StrokeThickness, dashArray, this.LineJoin, this.aliased, null, clippedPoints.AddRange); ScreenPoint position; double angle; double margin = this.TextMargin; if (this.TextHorizontalAlignment == HorizontalAlignment.Center) { margin = 0; } else { margin *= this.TextLinePosition < 0.5 ? 1 : -1; } if (GetPointAtRelativeDistance(clippedPoints, this.TextLinePosition, margin, out position, out angle)) { if (angle < -90) { angle += 180; } if (angle > 90) { angle -= 180; } switch (this.TextOrientation) { case AnnotationTextOrientation.Horizontal: angle = 0; break; case AnnotationTextOrientation.Vertical: angle = -90; break; } // Apply 'padding' to the position var angleInRadians = angle / 180 * Math.PI; var f = 1; if (this.TextHorizontalAlignment == HorizontalAlignment.Right) { f = -1; } if (this.TextHorizontalAlignment == HorizontalAlignment.Center) { f = 0; } position += new ScreenVector(f * this.TextPadding * Math.Cos(angleInRadians), f * this.TextPadding * Math.Sin(angleInRadians)); if (!string.IsNullOrEmpty(this.Text)) { var textPosition = this.GetActualTextPosition(() => position); if (this.TextPosition.IsDefined()) { angle = this.TextRotation; } if (this.ClipText) { var cs = new CohenSutherlandClipping(clippingRectangle); if (cs.IsInside(position)) { rc.DrawClippedText( clippingRectangle, textPosition, this.Text, this.ActualTextColor, this.ActualFont, this.ActualFontSize, this.ActualFontWeight, angle, this.TextHorizontalAlignment, this.TextVerticalAlignment); } } else { rc.DrawText( textPosition, this.Text, this.ActualTextColor, this.ActualFont, this.ActualFontSize, this.ActualFontWeight, angle, this.TextHorizontalAlignment, this.TextVerticalAlignment); } } } }
/// <summary> /// Transposes the ScreenVector if the series is transposed. Reverses the respective direction if X or Y axis are reversed. /// </summary> /// <param name="vector">The <see cref="ScreenVector" /> to orientate.</param> /// <returns>The oriented vector.</returns> protected ScreenVector Orientate(ScreenVector vector) { vector = new ScreenVector(this.XAxis.IsReversed ? -vector.X : vector.X, this.YAxis.IsReversed ? -vector.Y : vector.Y); return(this.IsTransposed() ? new ScreenVector(-vector.Y, -vector.X) : vector); }
/// <summary> /// Converts a ScreenVector to a Vector. /// </summary> /// <param name="c">The c.</param> /// <returns>A <see cref="Vector" /> instance.</returns> public static Vector ToVector(this ScreenVector c) { return(new Vector(c.X, c.Y)); }
public static ScreenPoint PanPoint(ScreenPoint source, ScreenVector vector) { return(new ScreenPoint(source.X + vector.X, source.Y + vector.Y)); }
/// <summary> /// Renders the arrow annotation. /// </summary> /// <param name="rc"> /// The render context. /// </param> /// <param name="model"> /// The plot model. /// </param> public override void Render(IRenderContext rc, PlotModel model) { base.Render(rc, model); this.screenEndPoint = this.Transform(this.EndPoint); if (!this.ArrowDirection.x.IsZero() || !this.ArrowDirection.y.IsZero()) { this.screenStartPoint = this.screenEndPoint - this.ArrowDirection; } else { this.screenStartPoint = this.Transform(this.StartPoint); } var d = this.screenEndPoint - this.screenStartPoint; d.Normalize(); var n = new ScreenVector(d.Y, -d.X); var p1 = this.screenEndPoint - (d * this.HeadLength * this.StrokeThickness); var p2 = p1 + (n * this.HeadWidth * this.StrokeThickness); var p3 = p1 - (n * this.HeadWidth * this.StrokeThickness); var p4 = p1 + (d * this.Veeness * this.StrokeThickness); OxyRect clippingRect = this.GetClippingRect(); const double MinimumSegmentLength = 4; rc.DrawClippedLine( new[] { this.screenStartPoint, p4 }, clippingRect, MinimumSegmentLength * MinimumSegmentLength, this.GetSelectableColor(this.Color), this.StrokeThickness, this.LineStyle, this.LineJoin, false); rc.DrawClippedPolygon( new[] { p3, this.screenEndPoint, p2, p4 }, clippingRect, MinimumSegmentLength * MinimumSegmentLength, this.GetSelectableColor(this.Color), null); var ha = d.X < 0 ? HorizontalTextAlign.Left : HorizontalTextAlign.Right; var va = d.Y < 0 ? VerticalTextAlign.Top : VerticalTextAlign.Bottom; var textPoint = this.screenStartPoint; rc.DrawClippedText( clippingRect, textPoint, this.Text, this.ActualTextColor, this.ActualFont, this.ActualFontSize, this.ActualFontWeight, 0, ha, va); }
/// <summary> /// Renders the annotation on the specified context. /// </summary> /// <param name="rc">The render context.</param> /// <param name="model">The model.</param> public override void Render(IRenderContext rc, PlotModel model) { base.Render(rc, model); this.CalculateActualMinimumsMaximums(); this.screenPoints = this.GetScreenPoints(); // clip to the area defined by the axes var clippingRectangle = OxyRect.Create( this.ClipByXAxis ? this.XAxis.ScreenMin.X : PlotModel.PlotArea.Left, this.ClipByYAxis ? this.YAxis.ScreenMin.Y : PlotModel.PlotArea.Top, this.ClipByXAxis ? this.XAxis.ScreenMax.X : PlotModel.PlotArea.Right, this.ClipByYAxis ? this.YAxis.ScreenMax.Y : PlotModel.PlotArea.Bottom); const double MinimumSegmentLength = 4; var clippedPoints = new List <ScreenPoint>(); var dashArray = this.LineStyle.GetDashArray(); rc.DrawClippedLine( clippingRectangle, this.screenPoints, MinimumSegmentLength * MinimumSegmentLength, this.GetSelectableColor(this.Color), this.StrokeThickness, dashArray, this.LineJoin, this.aliased, null, clippedPoints.AddRange); ScreenPoint position; double angle; double margin = this.TextMargin; if (this.TextHorizontalAlignment == HorizontalAlignment.Center) { margin = 0; } else { margin *= this.TextLinePosition < 0.5 ? 1 : -1; } if (GetPointAtRelativeDistance(clippedPoints, this.TextLinePosition, margin, out position, out angle)) { if (angle < -90) { angle += 180; } if (angle > 90) { angle -= 180; } switch (this.TextOrientation) { case AnnotationTextOrientation.Horizontal: angle = 0; break; case AnnotationTextOrientation.Vertical: angle = -90; break; } // Apply 'padding' to the position var angleInRadians = angle / 180 * Math.PI; var f = 1; if (this.TextHorizontalAlignment == HorizontalAlignment.Right) { f = -1; } if (this.TextHorizontalAlignment == HorizontalAlignment.Center) { f = 0; } position += new ScreenVector(f * this.TextPadding * Math.Cos(angleInRadians), f * this.TextPadding * Math.Sin(angleInRadians)); if (!string.IsNullOrEmpty(this.Text)) { var textPosition = this.GetActualTextPosition(() => position); if (this.TextPosition.IsDefined()) { angle = this.TextRotation; } if (this.ClipText) { var cs = new CohenSutherlandClipping(clippingRectangle); if (cs.IsInside(position)) { rc.DrawClippedText( clippingRectangle, textPosition, this.Text, this.ActualTextColor, this.ActualFont, this.ActualFontSize, this.ActualFontWeight, angle, this.TextHorizontalAlignment, this.TextVerticalAlignment); } } else { rc.DrawText( textPosition, this.Text, this.ActualTextColor, this.ActualFont, this.ActualFontSize, this.ActualFontWeight, angle, this.TextHorizontalAlignment, this.TextVerticalAlignment); } } } }
/// <summary> /// Renders the arrow annotation. /// </summary> /// <param name="rc">The render context.</param> public override void Render(IRenderContext rc) { base.Render(rc); this.screenEndPoint = this.Transform(this.EndPoint); if (this.ArrowDirection.LengthSquared > 0) { this.screenStartPoint = this.screenEndPoint - this.Orientate(this.ArrowDirection); } else { this.screenStartPoint = this.Transform(this.StartPoint); } var d = this.screenEndPoint - this.screenStartPoint; d.Normalize(); var n = new ScreenVector(d.Y, -d.X); var p1 = this.screenEndPoint - (d * this.HeadLength * this.StrokeThickness); var p2 = p1 + (n * this.HeadWidth * this.StrokeThickness); var p3 = p1 - (n * this.HeadWidth * this.StrokeThickness); var p4 = p1 + (d * this.Veeness * this.StrokeThickness); var clippingRectangle = this.GetClippingRect(); const double MinimumSegmentLength = 4; var dashArray = this.LineStyle.GetDashArray(); if (this.StrokeThickness > 0 && this.LineStyle != LineStyle.None) { rc.DrawClippedLine( clippingRectangle, new[] { this.screenStartPoint, p4 }, MinimumSegmentLength * MinimumSegmentLength, this.GetSelectableColor(this.Color), this.StrokeThickness, dashArray, this.LineJoin, false); rc.DrawClippedPolygon( clippingRectangle, new[] { p3, this.screenEndPoint, p2, p4 }, MinimumSegmentLength * MinimumSegmentLength, this.GetSelectableColor(this.Color), OxyColors.Undefined); } if (string.IsNullOrEmpty(this.Text)) { return; } HorizontalAlignment ha; VerticalAlignment va; if (this.TextPosition.IsDefined()) { this.GetActualTextAlignment(out ha, out va); } else { var angle = Math.Atan2(d.Y, d.X); var piOver8 = Math.PI / 8; if (angle < 3 * piOver8 && angle > -3 * piOver8) { ha = HorizontalAlignment.Right; } else if (angle > 5 * piOver8 || angle < -5 * piOver8) { ha = HorizontalAlignment.Left; } else { ha = HorizontalAlignment.Center; } if (angle > piOver8 && angle < 7 * piOver8) { va = VerticalAlignment.Bottom; } else if (angle < -piOver8 && angle > -7 * piOver8) { va = VerticalAlignment.Top; } else { va = VerticalAlignment.Middle; } } var textPoint = this.GetActualTextPosition(() => this.screenStartPoint); rc.DrawClippedText( clippingRectangle, textPoint, this.Text, this.ActualTextColor, this.ActualFont, this.ActualFontSize, this.ActualFontWeight, this.TextRotation, ha, va); }
public static OxyRect PanRect(OxyRect rect, ScreenVector vector) { return(new OxyRect(rect.Left + vector.X, rect.Top + vector.Y, rect.Width, rect.Height)); }
/// <summary> /// Draws the text. /// </summary> /// <param name="p">The p.</param> /// <param name="text">The text.</param> /// <param name="c">The c.</param> /// <param name="fontFamily">The font family.</param> /// <param name="fontSize">Size of the font.</param> /// <param name="fontWeight">The font weight.</param> /// <param name="rotate">The rotate.</param> /// <param name="halign">The horizontal alignment.</param> /// <param name="valign">The vertical alignment.</param> /// <param name="maxSize">Size of the max.</param> public override void DrawText( ScreenPoint p, string text, OxyColor c, string fontFamily, double fontSize, double fontWeight, double rotate, HorizontalAlignment halign, VerticalAlignment valign, OxySize?maxSize) { if (string.IsNullOrEmpty(text)) { return; } var lines = Regex.Split(text, "\r\n"); var textSize = this.MeasureText(text, fontFamily, fontSize, fontWeight); var lineHeight = textSize.Height / lines.Length; var lineOffset = new ScreenVector(-Math.Sin(rotate / 180.0 * Math.PI) * lineHeight, +Math.Cos(rotate / 180.0 * Math.PI) * lineHeight); if (this.UseVerticalTextAlignmentWorkaround) { // offset the position, and set the valign to neutral value of `Bottom` double offsetRatio = valign == VerticalAlignment.Bottom ? (1.0 - lines.Length) : valign == VerticalAlignment.Top ? 1.0 : (1.0 - (lines.Length / 2.0)); valign = VerticalAlignment.Bottom; p += lineOffset * offsetRatio; foreach (var line in lines) { var size = this.MeasureText(line, fontFamily, fontSize, fontWeight); this.WriteText(p, line, c, fontFamily, fontSize, fontWeight, rotate, halign, valign); p += lineOffset; } } else { if (valign == VerticalAlignment.Bottom) { for (var i = lines.Length - 1; i >= 0; i--) { var line = lines[i]; _ = this.MeasureText(line, fontFamily, fontSize, fontWeight); this.WriteText(p, line, c, fontFamily, fontSize, fontWeight, rotate, halign, valign); p -= lineOffset; } } else { foreach (var line in lines) { var size = this.MeasureText(line, fontFamily, fontSize, fontWeight); this.WriteText(p, line, c, fontFamily, fontSize, fontWeight, rotate, halign, valign); p += lineOffset; } } } }
private void Loop() { while (true) { // GC.Collect(); gfx.BeginScene(); gfx.ClearScene(); if (CheatData.panorama) { for (int i = 0; i < 100; i++) { MyBaseAdr = mem.Read <int>(CheatData.bClient + Offsets.New.dwLocalPlayer); mteam = mem.Read <int>(MyBaseAdr + Offsets.New.m_iTeamNum); mycoords = mem.Read <Vector3>(MyBaseAdr + Offsets.New.m_vecOrigin); eBaseAdr = mem.Read <int>(CheatData.bClient + Offsets.New.dwEntityList + (i * Offsets.New.Loop_offset)); eteam = mem.Read <int>(eBaseAdr + Offsets.New.m_iTeamNum); dormant = mem.Read <bool>(eBaseAdr + Offsets.New.m_bDormant); // glowind = mem.Read<int>(eBaseAdr + Offsets.m_iGlowIndex); hp = mem.Read <int>(eBaseAdr + Offsets.New.m_iHealth); coords = mem.Read <Vector3>(eBaseAdr + Offsets.New.m_vecOrigin); head = CalcEnemyHead(eBaseAdr, 8); Gres = mem.Read <int>(CheatData.bClient + Offsets.New.dwPlayerResource); rank = mem.Read <int>(Gres + Offsets.New.m_iCompetitiveRanking + i * 4); int radar = mem.Read <int>(CheatData.bClient + Offsets.New.dwRadarBase); name = mem.Read <char>(radar + (i * 50) + 0x204, 50); string n = string.Empty; for (int j = 0; j < 49; j++) { n += name[j]; } // // angles = mem.Read<Vector2>(eBaseAdr + Offsets.m_angEyeAngles); mt = mteam; et = eteam; if (MyBaseAdr == 0x0) { continue; } VMatrix = mem.Read <Matrix4x4>(CheatData.bClient + Offsets.New.dwViewMatrix); ScreenVector sv = WorldToScreen(coords.X, coords.Y, coords.Z); ScreenVector svh = WorldToScreen(head.X, head.Y, head.Z); if (dormant) { continue; } if (hp == 0) { continue; } if (!sv.Result) { continue; } int ex = (int)sv.X; int ey = (int)sv.Y; int sx = WHwindow.Width / 2; int sy = WHwindow.Height; float h = (svh.Y - sv.Y); float w = 18500 / (float)Vector3.Distance(mycoords, coords); float x = (int)(sv.X - w / 2); float y = (sv.Y); if ((eteam != mteam) && mteam != 1) { if (CheatData.lines_wh) { gfx.DrawLine(sx, sy, ex, ey, 2, new Direct2DColor(pen[0], pen[1], pen[2])); } if (CheatData.hp_wh) { gfx.DrawHorizontalBar(hp, x, y, 2, h, 1, new Direct2DColor(255, 0, 0), new Direct2DColor(0, 0, 0)); } if (CheatData.box) { double d = Vector3.Distance(mycoords, coords); if (d < 1f) { continue; } Drawbox(sv.X, sv.Y, (int)d); } if (CheatData.ranks) { gfx.DrawText(n, svh.X, svh.Y, new Direct2DFont(factory, "Arial", 12), new Direct2DColor(255, 0, 0)); gfx.DrawText(Ranks[rank], ex, ey, new Direct2DFont(factory, "Arial", 12), new Direct2DColor(255, 0, 0)); } } } } else { for (int i = 0; i < 100; i++) { MyBaseAdr = mem.Read <int>(CheatData.bClient + Offsets.Old.dwLocalPlayer); mteam = mem.Read <int>(MyBaseAdr + Offsets.Old.m_iTeamNum); mycoords = mem.Read <Vector3>(MyBaseAdr + Offsets.Old.m_vecOrigin); eBaseAdr = mem.Read <int>(CheatData.bClient + Offsets.Old.dwEntityList + (i * Offsets.New.Loop_offset)); eteam = mem.Read <int>(eBaseAdr + Offsets.Old.m_iTeamNum); dormant = mem.Read <bool>(eBaseAdr + Offsets.New.m_bDormant); // glowind = mem.Read<int>(eBaseAdr + Offsets.m_iGlowIndex); hp = mem.Read <int>(eBaseAdr + Offsets.Old.m_iHealth); coords = mem.Read <Vector3>(eBaseAdr + Offsets.Old.m_vecOrigin); head = CalcEnemyHead(eBaseAdr, 8); Gres = mem.Read <int>(CheatData.bClient + Offsets.Old.dwPlayerResource); rank = mem.Read <int>(Gres + Offsets.Old.m_iCompetitiveRanking + i * 4); int radar = mem.Read <int>(CheatData.bClient + Offsets.Old.dwRadarBase); name = mem.Read <char>(radar + (i * 50) + 0x204, 50); string n = string.Empty; for (int j = 0; j < 49; j++) { n += name[j]; } // // angles = mem.Read<Vector2>(eBaseAdr + Offsets.m_angEyeAngles); mt = mteam; et = eteam; if (MyBaseAdr == 0x0) { continue; } VMatrix = mem.Read <Matrix4x4>(CheatData.bClient + Offsets.Old.dwViewMatrix); ScreenVector sv = WorldToScreen(coords.X, coords.Y, coords.Z); ScreenVector svh = WorldToScreen(head.X, head.Y, head.Z); if (dormant) { continue; } if (hp == 0) { continue; } if (!sv.Result) { continue; } int ex = (int)sv.X; int ey = (int)sv.Y; int sx = WHwindow.Width / 2; int sy = WHwindow.Height; float h = (svh.Y - sv.Y); float w = 18500 / (float)Vector3.Distance(mycoords, coords); float x = (int)(sv.X - w / 2); float y = (sv.Y); if ((eteam != mteam) && mteam != 1) { if (CheatData.lines_wh) { gfx.DrawLine(sx, sy, ex, ey, 2, new Direct2DColor(pen[0], pen[1], pen[2])); } if (CheatData.hp_wh) { gfx.DrawHorizontalBar(hp, x, y, 2, h, 1, new Direct2DColor(255, 0, 0), new Direct2DColor(0, 0, 0)); } if (CheatData.box) { double d = Vector3.Distance(mycoords, coords); if (d < 1f) { continue; } Drawbox(sv.X, sv.Y, (int)d); } if (CheatData.ranks) { gfx.DrawText(n, svh.X, svh.Y, new Direct2DFont(factory, "Arial", 12), new Direct2DColor(255, 0, 0)); gfx.DrawText(Ranks[rank], ex, ey, new Direct2DFont(factory, "Arial", 12), new Direct2DColor(255, 0, 0)); } } } } gfx.EndScene(); //Thread.Sleep(5); } }