/// <summary> /// Gets the rotated alignments given the specified angle. /// </summary> /// <param name="angle">The angle.</param> /// <param name="defaultHorizontalAlignment">The default horizontal alignment.</param> /// <param name="defaultVerticalAlignment">The default vertical alignment.</param> /// <param name="ha">The rotated horizontal alignment.</param> /// <param name="va">The rotated vertical alignment.</param> private static void GetRotatedAlignments(double angle, HorizontalTextAlign defaultHorizontalAlignment, VerticalTextAlign defaultVerticalAlignment, out HorizontalTextAlign ha, out VerticalTextAlign va) { ha = defaultHorizontalAlignment; va = defaultVerticalAlignment; Debug.Assert(angle <= 180 && angle >= -180, "Axis angle should be in the interval [-180,180] degrees."); if (angle > -45 && angle < 45) { return; } if (angle > 135 || angle < -135) { ha = (HorizontalTextAlign)(-(int)defaultHorizontalAlignment); va = (VerticalTextAlign)(-(int)defaultVerticalAlignment); return; } if (angle > 45) { ha = (HorizontalTextAlign)((int)defaultVerticalAlignment); va = (VerticalTextAlign)(-(int)defaultHorizontalAlignment); return; } if (angle < -45) { ha = (HorizontalTextAlign)(-(int)defaultVerticalAlignment); va = (VerticalTextAlign)((int)defaultHorizontalAlignment); return; } }
public void SetTextAlign(HorizontalTextAlign align) { var textAlign = ""; switch (align) { case HorizontalTextAlign.Center: textAlign = "center"; break; case HorizontalTextAlign.Left: textAlign = "left"; break; case HorizontalTextAlign.Right: textAlign = "right"; break; default: throw new Exception("Invalid HorizontalTextAlign"); } _jsRuntime.InvokeVoid( _p5InvokeFunction, "textAlign", textAlign ); }
public override void RenderIcon(int icon, int x, int y, Color color, HorizontalTextAlign hAlign = HorizontalTextAlign.Center, VerticalTextAlign vAlign = VerticalTextAlign.Center) { var fnt = FontEngine.IconFont; if (fnt != null) { x += transX; y += transY; var pos = new Microsoft.Xna.Framework.Vector2(x, y); var col = color.GetColor(); string txt = "" + (char)icon; var ft = fnt.GetFont(); var size = ft.MeasureString(txt); if (hAlign == HorizontalTextAlign.Center) { pos.X -= size.Width / 2; } else if (hAlign == HorizontalTextAlign.Left) { } else if (hAlign == HorizontalTextAlign.Right) { pos.X -= size.Width; } if (vAlign == VerticalTextAlign.Center) { pos.Y -= size.Height / 2; } else if (vAlign == VerticalTextAlign.Bottom) { pos.Y -= size.Height; } batch.DrawString(fnt.GetFont(), txt, pos, col); } }
/// <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, HorizontalTextAlign horizontalAlignment, VerticalTextAlign verticalAlignment) { double left, right, top, bottom; switch (horizontalAlignment) { case HorizontalTextAlign.Center: left = -size.Width * 0.5; right = -left; break; case HorizontalTextAlign.Right: left = -size.Width; right = 0; break; default: left = 0; right = size.Width; break; } switch (verticalAlignment) { case VerticalTextAlign.Middle: top = -size.Height * 0.5; bottom = -top; break; case VerticalTextAlign.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> /// Called when this instance starts /// </summary> void Start() { mOldText = Text; mOldScale = Scale; mOldLineSpacingScale = LineSpacingScale; mOldVerticalAlign = VerticalAlign; mOldHorizontalAlign = HorizontalAlign; mOldTextColor = TextColor; }
/// <summary> /// Draws the text. /// </summary> /// <param name="p"> /// The p. /// </param> /// <param name="text"> /// The text. /// </param> /// <param name="fill"> /// The fill color. /// </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 rotatation angle. /// </param> /// <param name="halign"> /// The horizontal alignment. /// </param> /// <param name="valign"> /// The vertical alignment. /// </param> /// <param name="maxSize"> /// The maximum size of the text. /// </param> public abstract void DrawText( ScreenPoint p, string text, OxyColor fill, string fontFamily, double fontSize, double fontWeight, double rotate, HorizontalTextAlign halign, VerticalTextAlign valign, OxySize?maxSize);
public void SetTextAlign(HorizontalTextAlign horizontalAlign, VerticalTextAlign verticalAlign) { var horizontalTextAlign = ""; switch (horizontalAlign) { case HorizontalTextAlign.Center: horizontalTextAlign = "center"; break; case HorizontalTextAlign.Left: horizontalTextAlign = "left"; break; case HorizontalTextAlign.Right: horizontalTextAlign = "right"; break; default: throw new Exception("Invalid HorizontalTextAlign"); } var verticalTextAlign = ""; switch (verticalAlign) { case VerticalTextAlign.Baseline: verticalTextAlign = "alphabetic"; break; case VerticalTextAlign.Bottom: verticalTextAlign = "bottom"; break; case VerticalTextAlign.Center: verticalTextAlign = "center"; break; case VerticalTextAlign.Top: verticalTextAlign = "top"; break; default: throw new Exception("Invalid VerticalTextAlign"); } _jsRuntime.InvokeVoid( _p5InvokeFunction, "textAlign", horizontalTextAlign, verticalTextAlign ); }
/// <summary> /// Draws text containing sub- and superscript. /// </summary> /// <param name="rc">The render context.</param> /// <param name="pt">The point.</param> /// <param name="text">The text.</param> /// <param name="textColor">Color of the text.</param> /// <param name="fontFamily">The font family.</param> /// <param name="fontSize">The font size.</param> /// <param name="fontWeight">The font weight.</param> /// <param name="angle">The angle.</param> /// <param name="ha">The horizontal alignment.</param> /// <param name="va">The vertical alignment.</param> /// <param name="maxsize">The maximum size of the text.</param> /// <example> /// Subscript: H_{2}O /// Superscript: E=mc^{2} /// Both: A^{2}_{i,j} /// </example> public static void DrawMathText( this IRenderContext rc, ScreenPoint pt, string text, OxyColor textColor, string fontFamily, double fontSize, double fontWeight, double angle, HorizontalTextAlign ha, VerticalTextAlign va, OxySize?maxsize = null) { DrawMathText(rc, pt, text, textColor, fontFamily, fontSize, fontWeight, angle, ha, va, maxsize, false); }
public override void RenderIcon(int icon, int x, int y, Color color, HorizontalTextAlign hAlign = HorizontalTextAlign.Center, VerticalTextAlign vAlign = VerticalTextAlign.Center) { var fnt = FontEngine.IconFont; if (fnt != null) { x += transX; y += transY; SDL.SDL_Color col = new SDL.SDL_Color(); col.a = color.Alpha; col.r = color.R; col.g = color.G; col.b = color.B; IntPtr txt = SDL_ttf.TTF_RenderGlyph_Blended(fnt.GetFont(), (ushort)icon, col); IntPtr txt2 = SDL.SDL_CreateTextureFromSurface(game.ren, txt); SDL.SDL_QueryTexture(txt2, out uint format, out int access, out int w, out int h); int tx = x; int ty = y; switch (hAlign) { case HorizontalTextAlign.Center: tx -= w / 2; break; case HorizontalTextAlign.Right: tx -= w; break; } switch (vAlign) { case VerticalTextAlign.Center: ty -= h / 2; break; case VerticalTextAlign.Bottom: ty -= h; break; } SDL.SDL_Rect rect = new SDL.SDL_Rect(); rect.x = tx; rect.y = ty; rect.w = w; rect.h = h; SDL.SDL_RenderCopy(game.ren, txt2, IntPtr.Zero, ref rect); SDL.SDL_DestroyTexture(txt2); SDL.SDL_FreeSurface(txt); } }
public GuiButton(Rectangle area, string text, VerticalTextAlign verticalAlign = VerticalTextAlign.Center, HorizontalTextAlign horizontalAlign = HorizontalTextAlign.Center) { if (buttonFont == null) { buttonFont = ContentHelper.GetFont("KenneySpace"); } this.area = area; this.text = text; this.verticalAlign = verticalAlign; this.horizontalAlign = horizontalAlign; AssignDrawPositions(); InputHelper.ButtonPressed += OnButtonPressed; InputHelper.MouseMoved += OnMouseMoved; }
/// <summary> /// Draws the clipped text. /// </summary> /// <param name="rc">The rendering context.</param> /// <param name="clippingRectangle">The clipping rectangle.</param> /// <param name="p">The position.</param> /// <param name="text">The text.</param> /// <param name="fill">The fill color.</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 rotation angle.</param> /// <param name="horizontalAlignment">The horizontal align.</param> /// <param name="verticalAlignment">The vertical align.</param> /// <param name="maxSize">Size of the max.</param> public static void DrawClippedText( this IRenderContext rc, OxyRect clippingRectangle, ScreenPoint p, string text, OxyColor fill, string fontFamily = null, double fontSize = 10, double fontWeight = 500, double rotate = 0, HorizontalTextAlign horizontalAlignment = HorizontalTextAlign.Left, VerticalTextAlign verticalAlignment = VerticalTextAlign.Top, OxySize?maxSize = null) { if (clippingRectangle.Contains(p.X, p.Y)) { rc.DrawText(p, text, fill, fontFamily, fontSize, fontWeight, rotate, horizontalAlignment, verticalAlignment, maxSize); } }
/// <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 halign.</param> /// <param name="valign">The valign.</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, HorizontalTextAlign halign, VerticalTextAlign valign, OxySize?maxSize) { if (string.IsNullOrEmpty(text)) { return; } var lines = Regex.Split(text, "\r\n"); if (valign == VerticalTextAlign.Bottom) { for (var i = lines.Length - 1; i >= 0; i--) { var line = lines[i]; var size = this.MeasureText(line, fontFamily, fontSize, fontWeight); this.w.WriteText(p, line, c, fontFamily, fontSize, fontWeight, rotate, halign, valign); p.X += Math.Sin(rotate / 180.0 * Math.PI) * size.Height; p.Y -= Math.Cos(rotate / 180.0 * Math.PI) * size.Height; } } else { foreach (var line in lines) { var size = this.MeasureText(line, fontFamily, fontSize, fontWeight); this.w.WriteText(p, line, c, fontFamily, fontSize, fontWeight, rotate, halign, valign); p.X -= Math.Sin(rotate / 180.0 * Math.PI) * size.Height; p.Y += Math.Cos(rotate / 180.0 * Math.PI) * size.Height; } } }
/// <summary> /// Gets the axis title position, rotation and alignment. /// </summary> /// <param name="axis"> /// The axis. /// </param> /// <param name="titlePosition"> /// The title position. /// </param> /// <param name="angle"> /// The angle. /// </param> /// <param name="halign"> /// The horizontal alignment. /// </param> /// <param name="valign"> /// The vertical alignment. /// </param> /// <returns> /// The <see cref="ScreenPoint"/>. /// </returns> protected virtual ScreenPoint GetAxisTitlePositionAndAlignment( Axis axis, double titlePosition, ref double angle, ref HorizontalTextAlign halign, ref VerticalTextAlign valign) { double middle = axis.IsHorizontal() ? Lerp(axis.ScreenMin.X, axis.ScreenMax.X, axis.TitlePosition) : Lerp(axis.ScreenMax.Y, axis.ScreenMin.Y, axis.TitlePosition); if (axis.PositionAtZeroCrossing) { var perpendicularAxis = axis.IsHorizontal() ? this.Plot.DefaultYAxis : this.Plot.DefaultXAxis; middle = perpendicularAxis.Transform(perpendicularAxis.ActualMaximum); } switch (axis.Position) { case AxisPosition.Left: return(new ScreenPoint(titlePosition, middle)); case AxisPosition.Right: valign = VerticalTextAlign.Bottom; return(new ScreenPoint(titlePosition, middle)); case AxisPosition.Top: halign = HorizontalTextAlign.Center; valign = VerticalTextAlign.Top; angle = 0; return(new ScreenPoint(middle, titlePosition)); case AxisPosition.Bottom: halign = HorizontalTextAlign.Center; valign = VerticalTextAlign.Bottom; angle = 0; return(new ScreenPoint(middle, titlePosition)); default: throw new ArgumentOutOfRangeException("axis"); } }
public override void RenderIcon(int icon, int x, int y, Color color, HorizontalTextAlign hAlign = HorizontalTextAlign.Center, VerticalTextAlign vAlign = VerticalTextAlign.Center) { var fnt = FontEngine.IconFont; if (fnt != null) { x += transX; y += transY; string txt = new string(new char[] { (char)icon }); float fx = x; float fy = y; var ft = fnt.GetFont(); var size = gfx.MeasureString(txt, ft); if (hAlign == HorizontalTextAlign.Center) { fx -= size.Width / 2; } else if (hAlign == HorizontalTextAlign.Left) { } else if (hAlign == HorizontalTextAlign.Right) { fx -= size.Width; } if (vAlign == VerticalTextAlign.Center) { fy -= size.Height / 2; } else if (vAlign == VerticalTextAlign.Top) { } else if (vAlign == VerticalTextAlign.Bottom) { fy -= size.Height; } using (var brush = new System.Drawing.SolidBrush(color.GetColor())) { gfx.DrawString(txt, fnt.GetFont(), brush, fx, fy); } } }
void Update() { // Runtime on devices if (Font == null) { return; } var parentFont = (BitmapFont)Font.GetComponent(typeof(BitmapFont)); if (parentFont == null) { return; } if (mOldText != Text || Scale != mOldScale || HorizontalAlign != mOldHorizontalAlign || VerticalAlign != mOldVerticalAlign || LineSpacingScale != mOldLineSpacingScale || mWasCreatedRetina != parentFont.UseRetinaFont) { mOldText = Text; mOldScale = Scale; mOldLineSpacingScale = LineSpacingScale; mOldVerticalAlign = VerticalAlign; mOldHorizontalAlign = HorizontalAlign; RecreateText(Text); } if (TextColor.r != mOldTextColor.r || TextColor.g != mOldTextColor.g || TextColor.b != mOldTextColor.b || TextColor.a != mOldTextColor.a) { mOldTextColor.r = TextColor.r; mOldTextColor.g = TextColor.g; mOldTextColor.b = TextColor.b; mOldTextColor.a = TextColor.a; SetColor(TextColor); } }
/// <summary> /// Draws the clipped text. /// </summary> /// <param name="rc">The rendering context.</param> /// <param name="clippingRectangle">The clipping rectangle.</param> /// <param name="p">The position.</param> /// <param name="text">The text.</param> /// <param name="fill">The fill color.</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 rotation angle.</param> /// <param name="horizontalAlignment">The horizontal align.</param> /// <param name="verticalAlignment">The vertical align.</param> /// <param name="maxSize">Size of the max.</param> public static void DrawClippedText( this IRenderContext rc, OxyRect clippingRectangle, ScreenPoint p, string text, OxyColor fill, string fontFamily = null, double fontSize = 10, double fontWeight = 500, double rotate = 0, HorizontalTextAlign horizontalAlignment = HorizontalTextAlign.Left, VerticalTextAlign verticalAlignment = VerticalTextAlign.Top, OxySize? maxSize = null) { if (clippingRectangle.Contains(p.X, p.Y)) { rc.DrawText(p, text, fill, fontFamily, fontSize, fontWeight, rotate, horizontalAlignment, verticalAlignment, maxSize); } }
public void DrawText(Point p, string text, Color fill, string fontFamily, double fontSize, double fontWeight, double rotate, HorizontalTextAlign halign, VerticalTextAlign valign) { var tb = new TextBlock { Text = text, Foreground = new SolidColorBrush(fill.ToColor()) }; if (fontFamily != null) { tb.FontFamily = new FontFamily(fontFamily); } if (fontSize > 0) { tb.FontSize = fontSize; } if (fontWeight > 0) { tb.FontWeight = System.Windows.FontWeight.FromOpenTypeWeight((int)fontWeight); } tb.Measure(new System.Windows.Size(1000, 1000)); double dx = 0; if (halign == HorizontalTextAlign.Center) { dx = -tb.DesiredSize.Width / 2; } if (halign == HorizontalTextAlign.Right) { dx = -tb.DesiredSize.Width; } double dy = 0; if (valign == VerticalTextAlign.Middle) { dy = -tb.DesiredSize.Height / 2; } if (valign == VerticalTextAlign.Bottom) { dy = -tb.DesiredSize.Height; } var transform = new TransformGroup(); transform.Children.Add(new TranslateTransform(dx, dy)); if (rotate != 0) { transform.Children.Add(new RotateTransform(rotate)); } transform.Children.Add(new TranslateTransform(p.X, p.Y)); tb.RenderTransform = transform; tb.SetValue(RenderOptions.ClearTypeHintProperty, ClearTypeHint.Enabled); canvas.Children.Add(tb); }
/// <summary> /// Gets the axis title position, rotation and alignment. /// </summary> /// <param name="axis"> /// The axis. /// </param> /// <param name="titlePosition"> /// The title position. /// </param> /// <param name="angle"> /// The angle. /// </param> /// <param name="halign"> /// The horizontal alignment. /// </param> /// <param name="valign"> /// The vertical alignment. /// </param> /// <returns> /// The <see cref="ScreenPoint"/>. /// </returns> protected virtual ScreenPoint GetAxisTitlePositionAndAlignment( Axis axis, double titlePosition, ref double angle, ref HorizontalTextAlign halign, ref VerticalTextAlign valign) { double middle = axis.IsHorizontal() ? Lerp(axis.ScreenMin.X, axis.ScreenMax.X, axis.TitlePosition) : Lerp(axis.ScreenMax.Y, axis.ScreenMin.Y, axis.TitlePosition); if (axis.PositionAtZeroCrossing) { var perpendicularAxis = axis.IsHorizontal() ? this.Plot.DefaultYAxis : this.Plot.DefaultXAxis; middle = perpendicularAxis.Transform(perpendicularAxis.ActualMaximum); } switch (axis.Position) { case AxisPosition.Left: return new ScreenPoint(titlePosition, middle); case AxisPosition.Right: valign = VerticalTextAlign.Bottom; return new ScreenPoint(titlePosition, middle); case AxisPosition.Top: halign = HorizontalTextAlign.Center; valign = VerticalTextAlign.Top; angle = 0; return new ScreenPoint(middle, titlePosition); case AxisPosition.Bottom: halign = HorizontalTextAlign.Center; valign = VerticalTextAlign.Bottom; angle = 0; return new ScreenPoint(middle, titlePosition); default: throw new ArgumentOutOfRangeException("axis"); } }
/// <summary> /// Draws the text. /// </summary> /// <param name="p"> /// The p. /// </param> /// <param name="text"> /// The text. /// </param> /// <param name="fill"> /// The fill color. /// </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 rotatation angle. /// </param> /// <param name="halign"> /// The horizontal alignment. /// </param> /// <param name="valign"> /// The vertical alignment. /// </param> /// <param name="maxSize"> /// The maximum size of the text. /// </param> public abstract void DrawText( ScreenPoint p, string text, OxyColor fill, string fontFamily, double fontSize, double fontWeight, double rotate, HorizontalTextAlign halign, VerticalTextAlign valign, OxySize? maxSize);
// // Constructors // public GuiButton(Point position, string text, VerticalTextAlign verticalAlign = VerticalTextAlign.Center, HorizontalTextAlign horizontalAlign = HorizontalTextAlign.Center) : this(new Rectangle(position, new Point(DefaultWidth, DefaultHeight)), text, verticalAlign, horizontalAlign) { }
public abstract void RenderText(Font font, string text, int x, int y, Color color, Color bg, HorizontalTextAlign hAlign = HorizontalTextAlign.Center, VerticalTextAlign vAlign = VerticalTextAlign.Center);
/// <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, HorizontalTextAlign horizontalAlignment, VerticalTextAlign verticalAlignment) { double left, right, top, bottom; switch (horizontalAlignment) { case HorizontalTextAlign.Center: left = -size.Width * 0.5; right = -left; break; case HorizontalTextAlign.Right: left = -size.Width; right = 0; break; default: left = 0; right = size.Width; break; } switch (verticalAlignment) { case VerticalTextAlign.Middle: top = -size.Height * 0.5; bottom = -top; break; case VerticalTextAlign.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; }
public override void DrawText(ScreenPoint p, string text, OxyColor fill, string fontFamily, double fontSize, double fontWeight, double rotate, HorizontalTextAlign halign, VerticalTextAlign valign, OxySize?maxSize) { //This method needs work not 100% around vertical alignment. if (string.IsNullOrEmpty(text)) { return; } fontFamily = GetDefaultFont(fontFamily); if (fontWeight >= 700) { //fs = FontStyle.Bold; } //var textSize = MeasureText(text, fontFamily, fontSize, fontWeight); if (maxSize != null) { // if (size.Width > maxSize.Value.Width) // { // size.Width = (float)maxSize.Value.Width; // } // // if (size.Height > maxSize.Value.Height) // { // size.Height = (float)maxSize.Value.Height; // } } gctx.SaveState(); gctx.SelectFont(fontFamily, (float)fontSize, CGTextEncoding.MacRoman); ToColor(fill).SetFill(); gctx.SetTextDrawingMode(CGTextDrawingMode.Fill); var tfont = UIFont.FromName(fontFamily, (float)fontSize); NSString nsstr = new NSString(text); SizeF sz = nsstr.StringSize(tfont); float y = (float)(p.Y); float x = (float)(p.X); switch (halign) { case HorizontalTextAlign.Left: x = (float)(p.X); break; case HorizontalTextAlign.Right: x = (float)(p.X - sz.Width); break; case HorizontalTextAlign.Center: x = (float)(p.X - (sz.Width / 2)); break; } switch (valign) { case VerticalTextAlign.Bottom: y -= (float)fontSize; break; case VerticalTextAlign.Top: // y += (float)fontSize; break; case VerticalTextAlign.Middle: y -= (float)(fontSize / 2); break; } RectangleF rect = new RectangleF(x, y, sz.Width, sz.Height); nsstr.DrawString(rect, tfont); gctx.RestoreState(); //Console.WriteLine("X:{0:###} Y:{1:###} HA:{2}:{3:###} VA:{4}:{5:###} TW:{6:###} - {7}", p.X, p.Y, halign, x, valign, y, textSize.Width, text); }
public abstract void RenderIcon(int icon, int x, int y, Color color, HorizontalTextAlign hAlign = HorizontalTextAlign.Center, VerticalTextAlign vAlign = VerticalTextAlign.Center);
public override void RenderText(Font font, string text, int x, int y, Color color, Color bg, HorizontalTextAlign hAlign = HorizontalTextAlign.Center, VerticalTextAlign vAlign = VerticalTextAlign.Center) { if (font == null) { return; } x += transX; y += transY; var c = color.GetColor(); var fnt = font.GetFont(); var size = fnt.MeasureString(text); var pos = new Microsoft.Xna.Framework.Vector2(x, y); if (hAlign == HorizontalTextAlign.Center) { pos.X -= size.Width / 2; } else if (hAlign == HorizontalTextAlign.Left) { } else if (hAlign == HorizontalTextAlign.Right) { pos.X -= size.Width; } if (vAlign == VerticalTextAlign.Center) { pos.Y -= size.Height / 2; } else if (vAlign == VerticalTextAlign.Bottom) { pos.Y -= size.Height; } batch.DrawString(fnt, text, pos, c); }
/// <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 halign.</param> /// <param name="valign">The valign.</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, HorizontalTextAlign halign, VerticalTextAlign valign, OxySize? maxSize) { if (string.IsNullOrEmpty(text)) { return; } var lines = Regex.Split(text, "\r\n"); if (valign == VerticalTextAlign.Bottom) { for (var i = lines.Length - 1; i >= 0; i--) { var line = lines[i]; var size = this.MeasureText(line, fontFamily, fontSize, fontWeight); this.w.WriteText(p, line, c, fontFamily, fontSize, fontWeight, rotate, halign, valign); p.X += Math.Sin(rotate / 180.0 * Math.PI) * size.Height; p.Y -= Math.Cos(rotate / 180.0 * Math.PI) * size.Height; } } else { foreach (var line in lines) { var size = this.MeasureText(line, fontFamily, fontSize, fontWeight); this.w.WriteText(p, line, c, fontFamily, fontSize, fontWeight, rotate, halign, valign); p.X -= Math.Sin(rotate / 180.0 * Math.PI) * size.Height; p.Y += Math.Cos(rotate / 180.0 * Math.PI) * size.Height; } } }
/// <summary> /// Gets the alignments given the specified rotation angle. /// </summary> /// <param name="angle"> /// The angle. /// </param> /// <param name="defaultHorizontalAlignment"> /// The default horizontal alignment. /// </param> /// <param name="defaultVerticalAlignment"> /// The default vertical alignment. /// </param> /// <param name="ha"> /// The rotated horizontal alignment. /// </param> /// <param name="va"> /// The rotated vertical alignment. /// </param> protected virtual void GetRotatedAlignments( double angle, HorizontalTextAlign defaultHorizontalAlignment, VerticalTextAlign defaultVerticalAlignment, out HorizontalTextAlign ha, out VerticalTextAlign va) { ha = defaultHorizontalAlignment; va = defaultVerticalAlignment; Debug.Assert(angle <= 180 && angle >= -180, "Axis angle should be in the interval [-180,180] degrees."); if (angle > -45 && angle < 45) { return; } if (angle > 135 || angle < -135) { ha = (HorizontalTextAlign)(-(int)defaultHorizontalAlignment); va = (VerticalTextAlign)(-(int)defaultVerticalAlignment); return; } if (angle > 45) { ha = (HorizontalTextAlign)((int)defaultVerticalAlignment); va = (VerticalTextAlign)(-(int)defaultHorizontalAlignment); return; } if (angle < -45) { ha = (HorizontalTextAlign)(-(int)defaultVerticalAlignment); va = (VerticalTextAlign)((int)defaultHorizontalAlignment); } }
public override void RenderText(Font font, string text, int x, int y, Color color, Color bg, HorizontalTextAlign hAlign = HorizontalTextAlign.Center, VerticalTextAlign vAlign = VerticalTextAlign.Center) { if (font == null) { return; } x += transX; y += transY; SDL.SDL_Color col = new SDL.SDL_Color(); col.a = color.Alpha; col.r = color.R; col.g = color.G; col.b = color.B; SDL.SDL_Color bgcol = new SDL.SDL_Color(); bgcol.a = bg.Alpha; bgcol.r = bg.R; bgcol.g = bg.G; bgcol.b = bg.B; IntPtr txt = SDL_ttf.TTF_RenderText_Shaded(font.GetFont(), text, col, bgcol); IntPtr txt2 = SDL.SDL_CreateTextureFromSurface(game.ren, txt); SDL.SDL_QueryTexture(txt2, out uint format, out int access, out int w, out int h); int tx = x; int ty = y; switch (hAlign) { case HorizontalTextAlign.Center: tx -= w / 2; break; case HorizontalTextAlign.Right: tx -= w; break; } switch (vAlign) { case VerticalTextAlign.Center: ty -= h / 2; break; case VerticalTextAlign.Bottom: ty -= h; break; } SDL.SDL_Rect rect = new SDL.SDL_Rect(); rect.x = tx; rect.y = ty; rect.w = w; rect.h = h; SDL.SDL_SetRenderDrawBlendMode(game.ren, SDL.SDL_BlendMode.SDL_BLENDMODE_BLEND); SDL.SDL_RenderCopy(game.ren, txt2, IntPtr.Zero, ref rect); SDL.SDL_DestroyTexture(txt2); SDL.SDL_FreeSurface(txt); }
/// <summary> /// Writes text. /// </summary> /// <param name="position"> /// The position. /// </param> /// <param name="text"> /// The text. /// </param> /// <param name="fill"> /// The text color. /// </param> /// <param name="fontFamily"> /// The font family. /// </param> /// <param name="fontSize"> /// The font size. /// </param> /// <param name="fontWeight"> /// The font weight. /// </param> /// <param name="rotate"> /// The rotation angle. /// </param> /// <param name="halign"> /// The horizontal alignment. /// </param> /// <param name="valign"> /// The vertical alignment. /// </param> public void WriteText( ScreenPoint position, string text, OxyColor fill, string fontFamily = null, double fontSize = 10, double fontWeight = FontWeights.Normal, double rotate = 0, HorizontalTextAlign halign = HorizontalTextAlign.Left, VerticalTextAlign valign = VerticalTextAlign.Top) { // http://www.w3.org/TR/SVG/text.html this.WriteStartElement("text"); // WriteAttributeString("x", position.X); // WriteAttributeString("y", position.Y); string baselineAlignment = "hanging"; if (valign == VerticalTextAlign.Middle) { baselineAlignment = "middle"; } if (valign == VerticalTextAlign.Bottom) { baselineAlignment = "baseline"; } this.WriteAttributeString("dominant-baseline", baselineAlignment); string textAnchor = "start"; if (halign == HorizontalTextAlign.Center) { textAnchor = "middle"; } if (halign == HorizontalTextAlign.Right) { textAnchor = "end"; } this.WriteAttributeString("text-anchor", textAnchor); string fmt = "translate({0:" + this.NumberFormat + "},{1:" + this.NumberFormat + "})"; string transform = string.Format(CultureInfo.InvariantCulture, fmt, position.X, position.Y); if (Math.Abs(rotate) > 0) { transform += string.Format(CultureInfo.InvariantCulture, " rotate({0})", rotate); } this.WriteAttributeString("transform", transform); if (fontFamily != null) { this.WriteAttributeString("font-family", fontFamily); } if (fontSize > 0) { this.WriteAttributeString("font-size", fontSize); } if (fontWeight > 0) { this.WriteAttributeString("font-weight", fontWeight); } this.WriteAttributeString("fill", this.ColorToString(fill)); // WriteAttributeString("style", style); this.WriteString(text); this.WriteEndElement(); }
public void RenderLegends() { double maxWidth = 0; double maxHeight = 0; double totalHeight = 0; // Measure foreach (var s in plot.Series) { if (String.IsNullOrEmpty(s.Title)) { continue; } var oxySize = rc.MeasureText(s.Title, plot.LegendFont, plot.LegendFontSize); if (oxySize.Width > maxWidth) { maxWidth = oxySize.Width; } if (oxySize.Height > maxHeight) { maxHeight = oxySize.Height; } totalHeight += oxySize.Height; } double lineLength = plot.LegendSymbolLength; // Arrange double x0 = double.NaN, x1 = double.NaN, y0 = double.NaN; // padding padding // lineLength // y0 -----o---- seriesName // x0 x1 double sign = 1; if (plot.IsLegendOutsidePlotArea) { sign = -1; } // Horizontal alignment HorizontalTextAlign ha = HorizontalTextAlign.Left; switch (plot.LegendPosition) { case LegendPosition.TopRight: case LegendPosition.BottomRight: x0 = plot.Bounds.Right - LEGEND_PADDING * sign; x1 = x0 - lineLength * sign - LEGEND_PADDING * sign; ha = sign == 1 ? HorizontalTextAlign.Right : HorizontalTextAlign.Left; break; case LegendPosition.TopLeft: case LegendPosition.BottomLeft: x0 = plot.Bounds.Left + LEGEND_PADDING * sign; x1 = x0 + lineLength * sign + LEGEND_PADDING * sign; ha = sign == 1 ? HorizontalTextAlign.Left : HorizontalTextAlign.Right; break; } // Vertical alignment VerticalTextAlign va = VerticalTextAlign.Middle; switch (plot.LegendPosition) { case LegendPosition.TopRight: case LegendPosition.TopLeft: y0 = plot.Bounds.Top + LEGEND_PADDING + maxHeight / 2; break; case LegendPosition.BottomRight: case LegendPosition.BottomLeft: y0 = plot.Bounds.Bottom - maxHeight + LEGEND_PADDING; break; } foreach (var s in plot.Series) { if (String.IsNullOrEmpty(s.Title)) { continue; } rc.DrawText(new ScreenPoint(x1, y0), s.Title, plot.TextColor, plot.LegendFont, plot.LegendFontSize, 500, 0, ha, va); OxyRect rect = new OxyRect(x0 - lineLength, y0 - maxHeight / 2, lineLength, maxHeight); if (ha == HorizontalTextAlign.Left) { rect = new OxyRect(x0, y0 - maxHeight / 2, lineLength, maxHeight); } s.RenderLegend(rc, rect); if (plot.LegendPosition == LegendPosition.TopLeft || plot.LegendPosition == LegendPosition.TopRight) { y0 += maxHeight; } else { y0 -= maxHeight; } } }
private void RenderHorizontalAxis(Axis axis, Axis perpendicularAxis) { double y = Plot.Bounds.Bottom; switch (axis.Position) { case AxisPosition.Top: y = Plot.Bounds.Top; break; case AxisPosition.Bottom: y = Plot.Bounds.Bottom; break; } if (axis.PositionAtZeroCrossing) { y = perpendicularAxis.TransformX(0); } double y0, y1; if (axis.ShowMinorTicks) { GetVerticalTickPositions(axis, axis.TickStyle, axis.MinorTickSize, out y0, out y1); foreach (double xValue in minorTickValues) { if (xValue < axis.ActualMinimum || xValue > axis.ActualMaximum) { continue; } if (majorTickValues.Contains(xValue)) { continue; } double x = axis.TransformX(xValue); if (minorPen != null) { RenderLine(x, Plot.Bounds.Top, x, Plot.Bounds.Bottom, minorPen); } RenderLine(x, y + y0, x, y + y1, minorTickPen); } } GetVerticalTickPositions(axis, axis.TickStyle, axis.MajorTickSize, out y0, out y1); double maxh = 0; bool istop = axis.Position == AxisPosition.Top; foreach (double xValue in majorTickValues) { if (xValue < axis.ActualMinimum || xValue > axis.ActualMaximum) { continue; } double x = axis.TransformX(xValue); if (majorPen != null) { RenderLine(x, Plot.Bounds.Top, x, Plot.Bounds.Bottom, majorPen); } RenderLine(x, y + y0, x, y + y1, majorTickPen); if (xValue == 0 && axis.PositionAtZeroCrossing) { continue; } var pt = new ScreenPoint(x, istop ? y + y1 - TICK_DIST : y + y1 + TICK_DIST); string text = axis.FormatValue(xValue); double h = rc.MeasureText(text, axis.FontFamily, axis.FontSize, axis.FontWeight).Height; rc.DrawText(pt, text, Plot.TextColor, axis.FontFamily, axis.FontSize, axis.FontWeight, axis.Angle, HorizontalTextAlign.Center, istop ? VerticalTextAlign.Bottom : VerticalTextAlign.Top); maxh = Math.Max(maxh, h); } if (axis.PositionAtZeroCrossing) { double x = axis.TransformX(0); RenderLine(x, Plot.Bounds.Top, x, Plot.Bounds.Bottom, zeroPen); } if (axis.ExtraGridlines != null) { foreach (double x in axis.ExtraGridlines) { if (!IsWithin(x, axis.ActualMinimum, axis.ActualMaximum)) { continue; } double sx = axis.TransformX(x); RenderLine(sx, Plot.Bounds.Top, sx, Plot.Bounds.Bottom, extraPen); } } // The horizontal axis line RenderLine(Plot.Bounds.Left, y, Plot.Bounds.Right, y, majorPen); // The horizontal axis legend (centered horizontally) double legendX = axis.TransformX((axis.ActualMinimum + axis.ActualMaximum) / 2); HorizontalTextAlign halign = HorizontalTextAlign.Center; VerticalTextAlign valign = VerticalTextAlign.Bottom; if (axis.PositionAtZeroCrossing) { legendX = perpendicularAxis.TransformX(perpendicularAxis.ActualMaximum); } double legendY = rc.Height - AXIS_LEGEND_DIST; if (istop) { legendY = AXIS_LEGEND_DIST; valign = VerticalTextAlign.Top; } rc.DrawText(new ScreenPoint(legendX, legendY), axis.Title, Plot.TextColor, axis.FontFamily, axis.FontSize, axis.FontWeight, 0, halign, valign); }
/// <summary> /// Draws or measures text containing sub- and superscript. /// </summary> /// <param name="rc">The render context.</param> /// <param name="pt">The point.</param> /// <param name="text">The text.</param> /// <param name="textColor">Color of the text.</param> /// <param name="fontFamily">The font family.</param> /// <param name="fontSize">The font size.</param> /// <param name="fontWeight">The font weight.</param> /// <param name="angle">The angle.</param> /// <param name="ha">The horizontal alignment.</param> /// <param name="va">The vertical alignment.</param> /// <param name="maxsize">The maximum size of the text.</param> /// <param name="measure">Measure the size of the text if set to <c>true</c>.</param> /// <returns>The size of the text.</returns> /// <example> /// Subscript: H_{2}O /// Superscript: E=mc^{2} /// Both: A^{2}_{i,j} /// </example> public static OxySize DrawMathText( this IRenderContext rc, ScreenPoint pt, string text, OxyColor textColor, string fontFamily, double fontSize, double fontWeight, double angle, HorizontalTextAlign ha, VerticalTextAlign va, OxySize?maxsize, bool measure) { if (string.IsNullOrEmpty(text)) { return(OxySize.Empty); } if (angle.Equals(0) && (text.Contains("^{") || text.Contains("_{"))) { double x = pt.X; double y = pt.Y; // Measure var size = InternalDrawMathText(rc, x, y, text, textColor, fontFamily, fontSize, fontWeight, true); switch (ha) { case HorizontalTextAlign.Right: x -= size.Width; break; case HorizontalTextAlign.Center: x -= size.Width * 0.5; break; } switch (va) { case VerticalTextAlign.Bottom: y -= size.Height; break; case VerticalTextAlign.Middle: y -= size.Height * 0.5; break; } InternalDrawMathText(rc, x, y, text, textColor, fontFamily, fontSize, fontWeight, false); return(measure ? size : OxySize.Empty); } rc.DrawText(pt, text, textColor, fontFamily, fontSize, fontWeight, angle, ha, va, maxsize); if (measure) { return(rc.MeasureText(text, fontFamily, fontSize, fontWeight)); } return(OxySize.Empty); }
private void RenderVerticalAxis(Axis axis, Axis perpendicularAxis) { double x = Plot.Bounds.Left; switch (axis.Position) { case AxisPosition.Left: x = Plot.Bounds.Left; break; case AxisPosition.Right: x = Plot.Bounds.Right; break; } if (axis.PositionAtZeroCrossing) { x = perpendicularAxis.TransformX(0); } double x0, x1; if (axis.ShowMinorTicks) { GetHorizontalTickPositions(axis, axis.TickStyle, axis.MinorTickSize, out x0, out x1); foreach (double yValue in minorTickValues) { if (yValue < axis.ActualMinimum || yValue > axis.ActualMaximum) { continue; } if (majorTickValues.Contains(yValue)) { continue; } double y = axis.TransformX(yValue); if (minorPen != null) { RenderLine(Plot.Bounds.Left, y, Plot.Bounds.Right, y, minorPen); } RenderLine(x + x0, y, x + x1, y, minorTickPen); } } GetHorizontalTickPositions(axis, axis.TickStyle, axis.MajorTickSize, out x0, out x1); double maxw = 0; bool isleft = axis.Position == AxisPosition.Left; foreach (double yValue in majorTickValues) { if (yValue < axis.ActualMinimum || yValue > axis.ActualMaximum) { continue; } double y = axis.TransformX(yValue); if (majorPen != null) { RenderLine(Plot.Bounds.Left, y, Plot.Bounds.Right, y, majorPen); } RenderLine(x + x0, y, x + x1, y, majorTickPen); if (yValue == 0 && axis.PositionAtZeroCrossing) { continue; } var pt = new ScreenPoint(isleft ? x + x1 - TICK_DIST : x + x1 + TICK_DIST, y); string text = axis.FormatValue(yValue); double w = rc.MeasureText(text, axis.FontFamily, axis.FontSize, axis.FontWeight).Height; rc.DrawText(pt, text, Plot.TextColor, axis.FontFamily, axis.FontSize, axis.FontWeight, axis.Angle, isleft ? HorizontalTextAlign.Right : HorizontalTextAlign.Left, VerticalTextAlign.Middle); maxw = Math.Max(maxw, w); } if (axis.PositionAtZeroCrossing) { double y = axis.TransformX(0); RenderLine(Plot.Bounds.Left, y, Plot.Bounds.Right, y, zeroPen); } if (axis.ExtraGridlines != null) { foreach (double y in axis.ExtraGridlines) { if (!IsWithin(y, axis.ActualMinimum, axis.ActualMaximum)) { continue; } double sy = axis.TransformX(y); RenderLine(Plot.Bounds.Left, sy, Plot.Bounds.Right, sy, extraPen); } } RenderLine(x, Plot.Bounds.Top, x, Plot.Bounds.Bottom, majorPen); double ymid = axis.TransformX((axis.ActualMinimum + axis.ActualMaximum) / 2); HorizontalTextAlign halign = HorizontalTextAlign.Center; VerticalTextAlign valign = VerticalTextAlign.Top; if (axis.PositionAtZeroCrossing) { ymid = perpendicularAxis.TransformX(perpendicularAxis.ActualMaximum); // valign = axis.IsReversed ? VerticalTextAlign.Top : VerticalTextAlign.Bottom; } if (isleft) { x = AXIS_LEGEND_DIST; } else { x = rc.Width - AXIS_LEGEND_DIST; valign = VerticalTextAlign.Bottom; } rc.DrawText(new ScreenPoint(x, ymid), axis.Title, Plot.TextColor, axis.FontFamily, axis.FontSize, axis.FontWeight, -90, halign, valign); }
public GuiButton(Point position, Point size, string text, VerticalTextAlign verticalAlign = VerticalTextAlign.Center, HorizontalTextAlign horizontalAlign = HorizontalTextAlign.Center) : this(new Rectangle(position, new Point(size.X, size.Y)), text, verticalAlign, horizontalAlign) { }
public override void RenderText(Font font, string text, int x, int y, Color color, Color bg, HorizontalTextAlign hAlign = HorizontalTextAlign.Center, VerticalTextAlign vAlign = VerticalTextAlign.Center) { if (font == null) { return; } x += transX; y += transY; var fnt = font.GetFont(); float fx = x; float fy = y; var size = gfx.MeasureString(text, fnt); if (hAlign == HorizontalTextAlign.Center) { fx -= size.Width / 2; } else if (hAlign == HorizontalTextAlign.Left) { } else if (hAlign == HorizontalTextAlign.Right) { fx -= size.Width; } if (vAlign == VerticalTextAlign.Center) { fy -= size.Height / 2; } else if (vAlign == VerticalTextAlign.Top) { } else if (vAlign == VerticalTextAlign.Bottom) { fy -= size.Height; } using (var brush = new System.Drawing.SolidBrush(color.GetColor())) { gfx.DrawString(text, fnt, brush, fx, fy); } }
/// <summary> /// The draw text. /// </summary> /// <param name="p"> /// The p. /// </param> /// <param name="text"> /// The text. /// </param> /// <param name="fill"> /// The fill. /// </param> /// <param name="fontFamily"> /// The font family. /// </param> /// <param name="fontSize"> /// The font size. /// </param> /// <param name="fontWeight"> /// The font weight. /// </param> /// <param name="rotate"> /// The rotate. /// </param> /// <param name="halign"> /// The halign. /// </param> /// <param name="valign"> /// The valign. /// </param> /// <param name="maxSize"> /// The maximum size of the text. /// </param> public override void DrawText( ScreenPoint p, string text, OxyColor fill, string fontFamily, double fontSize, double fontWeight, double rotate, HorizontalTextAlign halign, VerticalTextAlign valign, OxySize? maxSize) { FontStyle fs = FontStyle.Regular; if (fontWeight >= 700) { fs = FontStyle.Bold; } var font = new Font(fontFamily, (float)fontSize * FontsizeFactor, fs); var sf = new StringFormat { Alignment = StringAlignment.Near }; SizeF size = this.g.MeasureString(text, font); if (maxSize != null) { if (size.Width > maxSize.Value.Width) { size.Width = (float)maxSize.Value.Width; } if (size.Height > maxSize.Value.Height) { size.Height = (float)maxSize.Value.Height; } } float dx = 0; if (halign == HorizontalTextAlign.Center) { dx = -size.Width / 2; // sf.Alignment = StringAlignment.Center; } if (halign == HorizontalTextAlign.Right) { dx = -size.Width; // sf.Alignment = StringAlignment.Far; } float dy = 0; sf.LineAlignment = StringAlignment.Near; if (valign == VerticalTextAlign.Middle) { // sf.LineAlignment = StringAlignment.Center; dy = -size.Height / 2; } if (valign == VerticalTextAlign.Bottom) { // sf.LineAlignment = StringAlignment.Far; dy = -size.Height; } this.g.TranslateTransform((float)p.X, (float)p.Y); if (Math.Abs(rotate) > double.Epsilon) { this.g.RotateTransform((float)rotate); } this.g.TranslateTransform(dx, dy); var layoutRectangle = new RectangleF(0, 0, size.Width, size.Height); this.g.DrawString(text, font, this.ToBrush(fill), layoutRectangle, sf); this.g.ResetTransform(); }
/// <summary> /// The draw text. /// </summary> /// <param name="p"> /// The p. /// </param> /// <param name="text"> /// The text. /// </param> /// <param name="fill"> /// The fill. /// </param> /// <param name="fontFamily"> /// The font family. /// </param> /// <param name="fontSize"> /// The font size. /// </param> /// <param name="fontWeight"> /// The font weight. /// </param> /// <param name="rotate"> /// The rotate. /// </param> /// <param name="halign"> /// The halign. /// </param> /// <param name="valign"> /// The valign. /// </param> /// <param name="maxSize"> /// The maximum size of the text. /// </param> public override void DrawText( ScreenPoint p, string text, OxyColor fill, string fontFamily, double fontSize, double fontWeight, double rotate, HorizontalTextAlign halign, VerticalTextAlign valign, OxySize?maxSize) { FontStyle fs = FontStyle.Regular; if (fontWeight >= 700) { fs = FontStyle.Bold; } var font = new Font(fontFamily, (float)fontSize * FontsizeFactor, fs); var sf = new StringFormat { Alignment = StringAlignment.Near }; SizeF size = this.g.MeasureString(text, font); if (maxSize != null) { if (size.Width > maxSize.Value.Width) { size.Width = (float)maxSize.Value.Width; } if (size.Height > maxSize.Value.Height) { size.Height = (float)maxSize.Value.Height; } } float dx = 0; if (halign == HorizontalTextAlign.Center) { dx = -size.Width / 2; // sf.Alignment = StringAlignment.Center; } if (halign == HorizontalTextAlign.Right) { dx = -size.Width; // sf.Alignment = StringAlignment.Far; } float dy = 0; sf.LineAlignment = StringAlignment.Near; if (valign == VerticalTextAlign.Middle) { // sf.LineAlignment = StringAlignment.Center; dy = -size.Height / 2; } if (valign == VerticalTextAlign.Bottom) { // sf.LineAlignment = StringAlignment.Far; dy = -size.Height; } this.g.TranslateTransform((float)p.X, (float)p.Y); if (Math.Abs(rotate) > double.Epsilon) { this.g.RotateTransform((float)rotate); } this.g.TranslateTransform(dx, dy); var layoutRectangle = new RectangleF(0, 0, size.Width, size.Height); this.g.DrawString(text, font, this.ToBrush(fill), layoutRectangle, sf); this.g.ResetTransform(); }
public override void DrawText (ScreenPoint p, string text, OxyColor fill, string fontFamily, double fontSize, double fontWeight, double rotate, HorizontalTextAlign halign, VerticalTextAlign valign, OxySize? maxSize) { //This method needs work not 100% around vertical alignment. if(string.IsNullOrEmpty(text)) { return; } fontFamily = GetDefaultFont(fontFamily); if (fontWeight >= 700) { //fs = FontStyle.Bold; } //var textSize = MeasureText(text, fontFamily, fontSize, fontWeight); if (maxSize != null) { // if (size.Width > maxSize.Value.Width) // { // size.Width = (float)maxSize.Value.Width; // } // // if (size.Height > maxSize.Value.Height) // { // size.Height = (float)maxSize.Value.Height; // } } gctx.SaveState(); gctx.SelectFont(fontFamily, (float)fontSize, CGTextEncoding.MacRoman); ToColor(fill).SetFill(); gctx.SetTextDrawingMode(CGTextDrawingMode.Fill); var tfont = UIFont.FromName (fontFamily,(float)fontSize); NSString nsstr = new NSString(text); SizeF sz = nsstr.StringSize(tfont); float y = (float)(p.Y); float x = (float)(p.X); switch(halign) { case HorizontalTextAlign.Left: x = (float)(p.X); break; case HorizontalTextAlign.Right: x = (float)(p.X - sz.Width); break; case HorizontalTextAlign.Center: x = (float)(p.X - (sz.Width / 2)); break; } switch(valign) { case VerticalTextAlign.Bottom: y -= (float)fontSize; break; case VerticalTextAlign.Top: // y += (float)fontSize; break; case VerticalTextAlign.Middle: y -= (float)(fontSize / 2); break; } RectangleF rect = new RectangleF(x,y,sz.Width,sz.Height); nsstr.DrawString( rect, tfont); gctx.RestoreState(); //Console.WriteLine("X:{0:###} Y:{1:###} HA:{2}:{3:###} VA:{4}:{5:###} TW:{6:###} - {7}", p.X, p.Y, halign, x, valign, y, textSize.Width, text); }
public void DrawText(Point p, string text, Color fill, string fontFamily, double fontSize, double fontWeight, double rotate, HorizontalTextAlign halign, VerticalTextAlign valign) { var tb = new TextBlock { Text = text, Foreground = new SolidColorBrush(fill.ToColor()) }; if (fontFamily != null) tb.FontFamily = new FontFamily(fontFamily); if (fontSize > 0) tb.FontSize = fontSize; if (fontWeight > 0) tb.FontWeight = System.Windows.FontWeight.FromOpenTypeWeight((int)fontWeight); tb.Measure(new System.Windows.Size(1000, 1000)); double dx = 0; if (halign == HorizontalTextAlign.Center) dx = -tb.DesiredSize.Width / 2; if (halign == HorizontalTextAlign.Right) dx = -tb.DesiredSize.Width; double dy = 0; if (valign == VerticalTextAlign.Middle) dy = -tb.DesiredSize.Height / 2; if (valign == VerticalTextAlign.Bottom) dy = -tb.DesiredSize.Height; var transform = new TransformGroup(); transform.Children.Add(new TranslateTransform(dx, dy)); if (rotate != 0) transform.Children.Add(new RotateTransform(rotate)); transform.Children.Add(new TranslateTransform(p.X, p.Y)); tb.RenderTransform = transform; tb.SetValue(RenderOptions.ClearTypeHintProperty, ClearTypeHint.Enabled); canvas.Children.Add(tb); }