public MeasureCharacterRanges ( string text, Font font, RectangleF layoutRect, StringFormat stringFormat ) : Region[] | ||
text | string | |
font | Font | |
layoutRect | RectangleF | |
stringFormat | StringFormat | |
return | Region[] |
public DisplayCharacterRanges(System.Drawing.Graphics gr, System.Drawing.Font font, StringFormat format, string text) { _rectF = new RectangleF[text.Length]; int c = 0; float xOffset = 0; for (int l = 0; l < text.Length; l += 32, c += 32) { string t = text.Substring(l, Math.Min(32, text.Length - l)); CharacterRange[] ranges = new CharacterRange[t.Length]; for (int i = 0; i < t.Length; i++) { ranges[i] = new CharacterRange(i, 1); } format.SetMeasurableCharacterRanges(ranges); SizeF size = gr.MeasureString(t, font); Region[] regions = gr.MeasureCharacterRanges(t, font, new RectangleF(0, 0, size.Width, size.Height), format); for (int i = 0; i < regions.Length; i++) { _rectF[c + i] = regions[i].GetBounds(gr); _rectF[c + i].X += xOffset; regions[i].Dispose(); } xOffset = _rectF[c + t.Length - 1].X + _rectF[c + t.Length - 1].Width; } }
private RectangleF MeasureString(System.Drawing.Graphics graphics, string text, System.Drawing.Font font) { bool isEmpty = false; if (string.IsNullOrEmpty(text)) { isEmpty = true; text = " "; } var format = CreateStringFormat(text); var rectangle = new RectangleF(0, 0, float.PositiveInfinity, float.PositiveInfinity); var regions = graphics.MeasureCharacterRanges(text, font, rectangle, format); Debug.Assert(regions.Length == 1); rectangle = regions[0].GetBounds(graphics); if (isEmpty) { rectangle.Width = 0; } else { rectangle.Width += 1.0f; } return(rectangle); }
internal java.awt.geom.Rectangle2D GetStringBounds(String aString, System.Drawing.Graphics g) { // TODO (KR) Could replace with System.Windows.Forms.TextRenderer#MeasureText (to skip creating Graphics) // // From .NET Framework Class Library documentation for Graphics#MeasureString: // // To obtain metrics suitable for adjacent strings in layout (for // example, when implementing formatted text), use the // MeasureCharacterRanges method or one of the MeasureString // methods that takes a StringFormat, and pass GenericTypographic. // Also, ensure the TextRenderingHint for the Graphics is // AntiAlias. // // TODO (KR) Consider implementing with one of the Graphics#MeasureString methods that takes a StringFormat. // TODO (KR) Consider implementing with Graphics#MeasureCharacterRanges(). if (aString.Length == 0) { SizeF size = g.MeasureString(aString, GetNetFont(), Int32.MaxValue, StringFormat.GenericTypographic); return(new java.awt.geom.Rectangle2D.Float(0, 0, size.Width, size.Height)); } else { StringFormat format = new StringFormat(StringFormatFlags.MeasureTrailingSpaces | StringFormatFlags.NoWrap); format.Trimming = StringTrimming.None; format.SetMeasurableCharacterRanges(new CharacterRange[] { new CharacterRange(0, aString.Length) }); Region[] regions = g.MeasureCharacterRanges(aString, GetNetFont(), new RectangleF(0, 0, int.MaxValue, int.MaxValue), format); SizeF size = regions[0].GetBounds(g).Size; regions[0].Dispose(); return(new java.awt.geom.Rectangle2D.Float(0, -getAscent(), size.Width, size.Height)); } }
private void drawFormattedText(string s, Font f, SolidBrush brush, RectangleF drawRect) { string s1, s2, s3; int i, j, len, r; CharacterRange[] ranges = new CharacterRange[5]; StringFormat stringFormat1 = new StringFormat(); r = 0; len = s.Length; i = s.IndexOf('*'); while (i != -1) { j = s.IndexOf('*', i + 1); CharacterRange range = new CharacterRange(i, j - i - 1); ranges[++r] = range; s1 = s.Substring(0, i); // text before bold s2 = s.Substring(i + 1, j - i - 1); // just the bold text s3 = s.Substring(j + 1); // text after the bold s = s1 + s2 + s3; i = s.IndexOf('*'); } stringFormat1.SetMeasurableCharacterRanges(ranges); Region[] charRegion = graphics.MeasureCharacterRanges(s, f, drawRect, stringFormat1); graphics.DrawString(s, f, brush, drawRect); int k; for (k = 0; k < charRegion.Length; k++) { graphics.FillRegion(new SolidBrush(Color.FromArgb(50, Color.Fuchsia)), charRegion[k]); } }
public static int GetDisplayLength(Graphics g, string s, Font font, TextDrawingMode textDrawingMode) { if (string.IsNullOrEmpty(s)) return 0; if (textDrawingMode == TextDrawingMode.GRAPHICS) { if (s.Contains("\t")) s = s.Replace("\t", " "); ranges[0].Length = s.Length; //CharacterRange[] ranges = new CharacterRange[] { new CharacterRange(0, s.Length) }; sf.SetMeasurableCharacterRanges(ranges); Region[] regions = g.MeasureCharacterRanges(s, font, layoutRect, sf); RectangleF rectF = regions[0].GetBounds(g); //return (int)rectF.Width;//プロポーショナルでなくても数ピクセルずれる return (int)((int)((rectF.Width - 1) / fontDisplaySize + 0.95f) * fontDisplaySize); } else if (textDrawingMode == TextDrawingMode.TEXTRENDERER) { Size size = TextRenderer.MeasureText(g, s, font, layoutSize, TextFormatFlags.NoPadding | TextFormatFlags.NoPrefix); //Size size = TextRenderer.MeasureText(g, s, StaticConfig.Font); return size.Width; } else// if (StaticConfig.TextDrawingMode == TextDrawingMode.WINAPI) { Size size = GDI.MeasureText(s, font); return size.Width; } //来るわけがない //else // throw new ExeEE("描画モード不明"); }
/// <summary> /// Updates the width of the word as it would be /// when drawn with the specified font in the specified graphics. /// </summary> public virtual void UpdateMeasures(Graphics graphics, Font font) { string word = _value; int rangePos = 0; int rangeLen = word.Length; if (IsWhitespace) { // Enclose the word in printable characters for // Graphics.MeasureText to work correctly. // Furthermore tabs are not measured, so replace // tabs with, say, 4 spaces word = "W" + word + "W"; word = word.Replace("\t", " "); rangePos = 1; rangeLen = word.Length - 2; } _sformat.SetMeasurableCharacterRanges(new CharacterRange[] { new CharacterRange(rangePos, rangeLen) }); Region[] r = graphics.MeasureCharacterRanges( word, font, _srect, _sformat); RectangleF bounds = r[0].GetBounds(graphics); r[0].Dispose(); _width = bounds.Width; }
private static RectangleF MeasureRectangle(System.Drawing.Graphics graphics, int fontSize, System.Drawing.Font font, string s) { var stringFormat = new StringFormat(StringFormatFlags.NoWrap); stringFormat.SetMeasurableCharacterRanges(new[] { new CharacterRange(0, 1) }); var ranges = graphics.MeasureCharacterRanges(s, font, new RectangleF(0, 0, 10 * fontSize, 10 * fontSize), stringFormat); var rect = ranges[0].GetBounds(graphics); return(rect); }
public static SizeF MeasureString(Graphics g, string str, Font font, Rectangle rect, StringFormat sf) { var sfTemp = sf.Clone() as StringFormat; var ranges = new CharacterRange[] { new CharacterRange(0, str.Length) }; sfTemp.SetMeasurableCharacterRanges(ranges); var regions = g.MeasureCharacterRanges(str, font, rect, sfTemp); if (regions != null && regions.Length > 0) return regions[0].GetBounds(g).Size; return new SizeF(); }
private static SizeF GetTextSize(string str, Graphics g, bool fTitle) { SizeF empty = SizeF.Empty; CharacterRange[] ranges = new CharacterRange[] { new CharacterRange(0, str.Length) }; sfMeasure.SetMeasurableCharacterRanges(ranges); Region[] regionArray = g.MeasureCharacterRanges(str, fTitle ? font : fontSubText, rctMeasure, sfMeasure); using(regionArray[0]) { empty = regionArray[0].GetBounds(g).Size; empty.Width += 6f; } return empty; }
/// <summary> /// Measures the Size of a Text. /// </summary> /// <param name="g">Graphics object used to draw the text</param> /// <param name="text">The text</param> /// <param name="font">Font used to draw the text</param> /// <returns></returns> public static SizeF measureText(Graphics g, string text, Font font) { if (text == null) return Size.Empty; StringFormat format = new StringFormat(); RectangleF rect = new RectangleF(0, 0, 1000, 1000); CharacterRange[] ranges = { new CharacterRange(0, text.Length) }; Region[] regions = new Region[1]; format.SetMeasurableCharacterRanges(ranges); regions = g.MeasureCharacterRanges(text, font, rect, format); rect = regions[0].GetBounds(g); return new SizeF(rect.Right + 1f, rect.Bottom + 1f); }
private static int StringWidth(Graphics graphics, string text, Font font) { System.Drawing.StringFormat format = new System.Drawing.StringFormat(); System.Drawing.RectangleF rect = new System.Drawing.RectangleF(0, 0, 1000, 1000); System.Drawing.CharacterRange[] ranges = { new System.Drawing.CharacterRange(0, text.Length) }; System.Drawing.Region[] regions = new System.Drawing.Region[1]; format.SetMeasurableCharacterRanges(ranges); regions = graphics.MeasureCharacterRanges(text, font, rect, format); rect = regions[0].GetBounds(graphics); return (int)(rect.Right + 1.0f); }
public static int MeasureCharWidth( Graphics graphics, char c, Font font) { if (c == ' ') c = '_'; char[] ch = new char[1]; ch[0] = c; string str = new string( ch ); StringFormat format = new StringFormat( StringFormat.GenericTypographic ); RectangleF rect = new RectangleF( 0, 0, 1000, 1000 ); CharacterRange[] ranges = { new CharacterRange( 0, str.Length ) }; Region[] regions = new Region[1]; format.SetMeasurableCharacterRanges( ranges ); regions = graphics.MeasureCharacterRanges( str, font, rect, format ); rect = regions[0].GetBounds( graphics ); return (int)(rect.Right + 1.0f); }
public static Size GetTextSize(Graphics graphics, string text, Font font, Size size) { if (text.Length == 0) { return Size.Empty; } StringFormat stringFormat = new StringFormat(); stringFormat.FormatFlags = StringFormatFlags.FitBlackBox; RectangleF layoutRect = new RectangleF(0f, 0f, size.Width, size.Height); CharacterRange[] ranges = new CharacterRange[] {new CharacterRange(0, text.Length)}; Region[] regionArray = new Region[1]; stringFormat.SetMeasurableCharacterRanges(ranges); Rectangle rectangle = Rectangle.Round(graphics.MeasureCharacterRanges(text, font, layoutRect, stringFormat)[0].GetBounds(graphics)); return new Size(rectangle.Width, rectangle.Height); }
public static RectangleF MeasureDisplayStringWidth(Graphics graphics, string text, Font font) { var zFormat = new StringFormat { Alignment = StringAlignment.Near, LineAlignment = StringAlignment.Near, }; var rect = new RectangleF(0, 0, 65536, 65536); CharacterRange[] ranges = { new CharacterRange(0, text.Length) }; var regions = new Region[1]; zFormat.SetMeasurableCharacterRanges(ranges); regions = graphics.MeasureCharacterRanges(text, font, rect, zFormat); rect = regions[0].GetBounds(graphics); return rect; }
public static Size GetTextSize(Graphics graphics, string text, Font font, Size size) { if(text.Length == 0) return Size.Empty; StringFormat format = new StringFormat(); format.FormatFlags = StringFormatFlags.FitBlackBox; //MeasureTrailingSpaces; RectangleF layoutRect = new System.Drawing.RectangleF(0, 0, size.Width, size.Height); CharacterRange[] chRange = {new CharacterRange(0, text.Length)}; Region[] regs = new Region[1]; format.SetMeasurableCharacterRanges(chRange); regs = graphics.MeasureCharacterRanges(text, font, layoutRect, format); Rectangle rect = Rectangle.Round(regs[0].GetBounds(graphics)); return new Size(rect.Width, rect.Height); }
/// <summary> /// Measures the actual width of the text /// http://www.codeproject.com/KB/GDI-plus/measurestring.aspx /// </summary> public static Int32 MeasureDisplayStringWidth(Graphics graphics, String text, Font font) { try { StringFormat format = new StringFormat(); RectangleF rect = new RectangleF(0, 0, 1000, 1000); CharacterRange[] ranges = { new CharacterRange(0, text.Length) }; Region[] regions = new Region[1]; format.SetMeasurableCharacterRanges(ranges); regions = graphics.MeasureCharacterRanges(text, font, rect, format); rect = regions[0].GetBounds(graphics); return (Int32)rect.Right; } catch (IndexOutOfRangeException) { return 0; } }
////////////////////////////////////////////////////////////////////////// public static SizeF MeasureDisplayStringWidth(Graphics graphics, string text, Font font) { if (text == "") return new SizeF(0, 0); System.Drawing.StringFormat format = new System.Drawing.StringFormat(); System.Drawing.RectangleF rect = new System.Drawing.RectangleF(0, 0, 1000, 1000); System.Drawing.CharacterRange[] ranges = { new System.Drawing.CharacterRange(0, text.Length) }; System.Drawing.Region[] regions = new System.Drawing.Region[1]; format.SetMeasurableCharacterRanges(ranges); regions = graphics.MeasureCharacterRanges(text, font, rect, format); rect = regions[0].GetBounds(graphics); return new SizeF(rect.Right + 1.0f, rect.Bottom); }
public static Size MeasureString(Graphics graphics, string text, Font font, RectangleF bounds, StringFormat format) { var size = Size.Empty; using (format = new StringFormat(format)) { if (bounds.IsEmpty) { bounds = new RectangleF(0, 0, float.MaxValue, float.MaxValue); // We need to clear RightToLeft and set StringAlignment.Near, otherwise we get an incorrect measurement. format.FormatFlags &= ~StringFormatFlags.DirectionRightToLeft; format.Alignment = StringAlignment.Near; format.LineAlignment = StringAlignment.Near; } try { // Measure text format.SetMeasurableCharacterRanges(new[] { new CharacterRange(0, text.Length) }); var regions = graphics.MeasureCharacterRanges(text, font, bounds, format); // Need to use Right and Bottom to account for leadingi var rect = regions[0].GetBounds(graphics); size = new Size((int)Math.Ceiling(rect.Right), (int)Math.Ceiling(rect.Bottom)); // Remain compatible with Graphics.MeasureString size.Height += 1; } catch (ExternalException ex) { // eat the exception when the text is too long. if (ex.ErrorCode != NativeMethods.E_FAIL) { throw; } size = Size.Empty; } } return size; }
//adapted from http://www.codeproject.com/KB/GDI-plus/measurestring.aspx public static SizeF MeasureDisplayStringWidth(System.Drawing.Graphics gCanvas, string sText, Font fntFont) { System.Drawing.StringFormat sfFormat = new System.Drawing.StringFormat(); System.Drawing.RectangleF rtRect = new System.Drawing.RectangleF(0, 0, 1000, 1000); System.Drawing.CharacterRange[] craRanges = { new System.Drawing.CharacterRange(0, sText.Length) }; System.Drawing.Region[] raRegions = new System.Drawing.Region[1]; sfFormat.SetMeasurableCharacterRanges(craRanges); raRegions = gCanvas.MeasureCharacterRanges(sText, fntFont, rtRect, sfFormat); rtRect = raRegions[0].GetBounds(gCanvas); SizeF sfFinal = new SizeF(); sfFinal.Width = (rtRect.Right + 1.0f); sfFinal.Height = (rtRect.Bottom); return(sfFinal); }
private Point GetCharSize(Graphics CurGraphics) { // DrawString doesn't actually print where you tell it to but instead consistently prints // with an offset. This is annoying when the other draw commands do not print with an offset // this method returns a point defining the offset so we can take it off the printstring command. CharacterRange[] characterRanges = {new CharacterRange(0, 1)}; RectangleF layoutRect = new RectangleF(0, 0, 100, 100); StringFormat stringFormat = new StringFormat(); stringFormat.SetMeasurableCharacterRanges(characterRanges); Region[] stringRegions = new Region[1]; stringRegions = CurGraphics.MeasureCharacterRanges( "A", this.Font, layoutRect, stringFormat); RectangleF measureRect1 = stringRegions[0].GetBounds(CurGraphics); return new Point((Int32) (measureRect1.Width + 0.5), (Int32) (measureRect1.Height + 0.5)); }
private static int getDrawLength(Graphics g, Font fnt, RectangleF rect, StringFormat sf, int maxLen) { CharacterRange[] ranges = new CharacterRange[] { new CharacterRange(0, 1) }; float num = 1f; float width = 0f; int num3 = 2; string text = StrFunc.CreateInstance().MakeCycleStr(maxLen, "X"); while ((num3 <= maxLen) && (width != num)) { num = width; ranges[0].Length = num3; sf.SetMeasurableCharacterRanges(ranges); width = g.MeasureCharacterRanges(text, fnt, rect, sf)[0].GetBounds(g).Width; num3++; } if (num3 == maxLen) { return maxLen; } return (num3 - 1); }
/// <summary> /// Calculates the exact size of a string. /// Code taken from http://www.codeproject.com/KB/GDI-plus/measurestring.aspx /// </summary> /// <param name="graphics">The graphics object used to calculate the string's size.</param> /// <param name="font">The font which will be used to draw the string.</param> /// <param name="text">The actual string which will be drawn.</param> /// <returns>Returns the untransformed size of the string when being drawn.</returns> static public SizeF MeasureDisplayStringWidth(Graphics graphics, string text, Font font) { // set something to generate the minimum size bool minimum= false; if(text ==string.Empty) { minimum= true; text= " "; } System.Drawing.StringFormat format = new System.Drawing.StringFormat(); System.Drawing.RectangleF rect = new System.Drawing.RectangleF(0, 0, 1000, 1000); System.Drawing.CharacterRange[] ranges = { new System.Drawing.CharacterRange(0, text.Length) }; System.Drawing.Region[] regions = new System.Drawing.Region[1]; format.SetMeasurableCharacterRanges(ranges); regions = graphics.MeasureCharacterRanges(text, font, rect, format); rect = regions[0].GetBounds(graphics); return minimum ? new SizeF(0.0f, rect.Height) : rect.Size; }
partial void MeasureCharacterRangeImp(string str, Font font, StringFormat format, CharacterRange range, ref RectangleF ret) { if (FixGdiPlusStringSize(ref str)) { if (range.First >= str.Length) { range.First = str.Length - 1; range.Length = 0; } else if (range.First + range.Length >= str.Length) { range.Length = str.Length - range.First; } } format.format.SetMeasurableCharacterRanges(new SD.CharacterRange[] { new SD.CharacterRange(range.First, range.Length) }); var regions = g.MeasureCharacterRanges(str, font.font, new SD.RectangleF(0, 0, 100500, 100000), format.format); var bounds = regions[0].GetBounds(g); regions[0].Dispose(); ret = bounds.ToRectangleF(); }
public SizeF MeasureString(string text) { if (UseCompatibleTextRendering) { if (measureGraphics == null) { measureGraphics = sd.Graphics.FromImage(new sd.Bitmap(1, 1)); } sd.CharacterRange[] ranges = { new sd.CharacterRange(0, text.Length) }; var stringFormat = GraphicsHandler.DefaultStringFormat; lock (stringFormat) { stringFormat.SetMeasurableCharacterRanges(ranges); var regions = measureGraphics.MeasureCharacterRanges(text, Control, sd.RectangleF.Empty, stringFormat); var rect = regions[0].GetBounds(measureGraphics); return(rect.Size.ToEto()); } } var size = swf.TextRenderer.MeasureText(text, Control, sd.Size.Empty, GraphicsHandler.DefaultTextFormat); return(size.ToEto()); }
Region [] Measure (Graphics gfx, RectangleF rect) { using (StringFormat format = StringFormat.GenericTypographic) { format.SetMeasurableCharacterRanges (ranges); using (Font font = new Font (FontFamily.GenericSerif, 11.0f)) { return gfx.MeasureCharacterRanges ("abc", font, rect, format); } } }
/// <summary> /// Draw the highlighted text using GDI+ /// </summary> /// <param name="g"></param> /// <param name="r"></param> /// <param name="txt"></param> protected virtual void DrawGdiPlusTextHighlighting(Graphics g, Rectangle r, string txt) { // Find the substrings we want to highlight List<CharacterRange> ranges = new List<CharacterRange>(this.Filter.FindAllMatchedRanges(txt)); if (ranges.Count == 0) return; using (StringFormat fmt = this.StringFormatForGdiPlus) { RectangleF rf = r; fmt.SetMeasurableCharacterRanges(ranges.ToArray()); Region[] stringRegions = g.MeasureCharacterRanges(txt, this.Font, rf, fmt); foreach (Region region in stringRegions) { RectangleF bounds = region.GetBounds(g); this.DrawSubstringFrame(g, bounds.X - 1, bounds.Y - 1, bounds.Width + 2, bounds.Height); } } }
private SizeF MeasureString(string s, StyleInfo si, Graphics g, out float descent) { Font drawFont=null; StringFormat drawFormat=null; SizeF ms = SizeF.Empty; descent = 0; if (s == null || s.Length == 0) return ms; try { // STYLE System.Drawing.FontStyle fs = 0; if (si.FontStyle == FontStyleEnum.Italic) fs |= System.Drawing.FontStyle.Italic; // WEIGHT switch (si.FontWeight) { case FontWeightEnum.Bold: case FontWeightEnum.Bolder: case FontWeightEnum.W500: case FontWeightEnum.W600: case FontWeightEnum.W700: case FontWeightEnum.W800: case FontWeightEnum.W900: fs |= System.Drawing.FontStyle.Bold; break; default: break; } try { FontFamily ff = si.GetFontFamily(); drawFont = new Font(ff, si.FontSize, fs); // following algorithm comes from the C# Font Metrics documentation float descentPixel = si.FontSize * ff.GetCellDescent(fs) / ff.GetEmHeight(fs); descent = RSize.PointsFromPixels(g, descentPixel); } catch { drawFont = new Font("Arial", si.FontSize, fs); // usually because font not found descent = 0; } drawFormat = new StringFormat(); drawFormat.Alignment = StringAlignment.Near; CharacterRange[] cr = {new CharacterRange(0, s.Length)}; drawFormat.SetMeasurableCharacterRanges(cr); Region[] rs = new Region[1]; rs = g.MeasureCharacterRanges(s, drawFont, new RectangleF(0,0,float.MaxValue,float.MaxValue), drawFormat); RectangleF mr = rs[0].GetBounds(g); ms.Height = RSize.PointsFromPixels(g, mr.Height); // convert to points from pixels ms.Width = RSize.PointsFromPixels(g, mr.Width); // convert to points from pixels return ms; } finally { if (drawFont != null) drawFont.Dispose(); if (drawFormat != null) drawFont.Dispose(); } }
/// <summary> /// Function to retrieve a character range for the specified character. /// </summary> /// <param name="character">The character to evaluate.</param> /// <param name="graphics">The graphics context to use.</param> /// <returns>The region for the character range.</returns> private RectangleF?GetCharacterRange(ref char character, System.Drawing.Graphics graphics) { Region[] characterRanges = null; Region[] defaultCharacterRanges = null; try { // Try to get the character size. characterRanges = graphics.MeasureCharacterRanges(character.ToString(CultureInfo.CurrentCulture), _fontData.Font, new RectangleF(0, 0, _fontInfo.TextureWidth, _fontInfo.TextureHeight), _fontData.StringFormat); defaultCharacterRanges = graphics.MeasureCharacterRanges(_fontInfo.DefaultCharacter.ToString(CultureInfo.CurrentCulture), _fontData.Font, new RectangleF(0, 0, _fontInfo.TextureWidth, _fontInfo.TextureHeight), _fontData.StringFormat); // If the character doesn't exist, then return an empty value. switch (characterRanges.Length) { case 0 when(defaultCharacterRanges.Length == 0): return(null); case 0 when(defaultCharacterRanges.Length > 0): character = _fontInfo.DefaultCharacter; characterRanges = defaultCharacterRanges; break; } // If we didn't get a size, but we have a default, then use that. RectangleF result = characterRanges[0].GetBounds(graphics); if ((result.Width >= 0.1f) || (result.Height >= 0.1f)) { return(result); } character = _fontInfo.DefaultCharacter; characterRanges = defaultCharacterRanges; result = characterRanges[0].GetBounds(graphics); characterRanges[0].Dispose(); characterRanges = null; return(((result.Width < 0.1f) || (result.Height < 0.1f)) ? null : (RectangleF?)result); } finally { if (characterRanges != null) { foreach (Region region in characterRanges) { region.Dispose(); } } if (defaultCharacterRanges != null) { foreach (Region region in defaultCharacterRanges) { region.Dispose(); } } } }
public Region[] Measure(Graphics g, Font f, string str, int x, int y, int xOffset, int yOffset, int cw, int index, int length) { if (this.m_Ranges == null) { this.m_Ranges = new CharacterRange[1]; } this.m_Ranges[0].First = index; this.m_Ranges[0].Length = length; this.m_StringFormat.SetMeasurableCharacterRanges(this.m_Ranges); this.m_TempRectF.X = x; this.m_TempRectF.Y = y; this.m_TempRectF.Width = cw; this.m_TempRectF.Height = this.m_LineHeight; return g.MeasureCharacterRanges(str, f, this.m_TempRectF, this.m_StringFormat); }
private SizeF MeasureString(string s, Graphics g, Font drawFont, StringFormat drawFormat) { if (s == null || s.Length == 0) return SizeF.Empty; CharacterRange[] cr = {new CharacterRange(0, s.Length)}; drawFormat.SetMeasurableCharacterRanges(cr); Region[] rs = new Region[1]; rs = g.MeasureCharacterRanges(s, drawFont, new RectangleF(0,0,float.MaxValue,float.MaxValue), drawFormat); RectangleF mr = rs[0].GetBounds(g); return new SizeF(mr.Width, mr.Height); }
internal static pTexture CreateText(string text, float size, Vector2 restrictBounds, Color color, ShadowType shadow, bool bold, bool italic, bool underline, TextAlignment alignment, bool forceAa, out Vector2 measured, out RectangleF[] characterRegions, Color background, Color border, int borderWidth, bool measureOnly, bool getCharacterRegions, FontFace fontFace, Vector4 cornerBounds, Vector2 padding, pTexture lastTexture = null, int startIndex = 0, int length = -1) { characterRegions = null; if (text == null) { measured = Vector2.Zero; return(null); } if (ConfigManager.dDisableTextRendering) { measured = new Vector2(text.Length * size, size); return(null); } #if DEBUG if (!text.Contains(@"NativeText")) { int limit_per_second = osu.GameModes.Play.Player.Playing ? 5 : 58; bool newSecond = GameBase.Time / 1000 != currentSecond; drawCount++; if (drawCount == limit_per_second) { Debug.Print(@"NativeText: High number of text refreshes per second."); } if (newSecond) { currentSecond = GameBase.Time / 1000; drawCount = 0; } } #endif //This lock ensures we are only using the shared GDI+ object (FromHwnd) in one place at a time. lock (createTextLock) { try { using (System.Drawing.Graphics graphics = System.Drawing.Graphics.FromHwnd(IntPtr.Zero)) using (StringFormat sf = new StringFormat()) { if (dpiRatio == 0) { dpiRatio = 96 / graphics.DpiX; } size *= dpiRatio; GameBase.PerformanceMonitor.ReportCount(CounterType.NativeText); graphics.TextRenderingHint = TextRenderingHint.AntiAlias; SizeF measuredSize; string face = GetFontFace(fontFace); if (face.StartsWith(@"Aller")) { //if we are using the default osu! font, allow specific language overrides based on simple detection. string fontFaceOverride = getLanguageSpeicificFont(text); if (fontFaceOverride != null) { face = fontFaceOverride; } } if (startIndex != 0 || length > 0) { text = text.Substring(startIndex, length); } else if (length == -1) { length = text.Length; } if (size < 20 && face.EndsWith(@" Light")) { face = face.Replace(@" Light", string.Empty); } FontStyle fs = FontStyle.Regular; if (bold) { if (face.EndsWith(@" Light")) { face = face.Replace(@" Light", string.Empty); } fs |= FontStyle.Bold; } if (italic) { fs |= FontStyle.Italic; } if (underline) { fs |= FontStyle.Underline; } switch (alignment) { case TextAlignment.Left: case TextAlignment.LeftFixed: sf.Alignment = StringAlignment.Near; break; case TextAlignment.Centre: sf.Alignment = StringAlignment.Center; break; case TextAlignment.Right: sf.Alignment = StringAlignment.Far; break; } if (!OsuMain.IsWine && face.StartsWith(@"Aller")) { for (char c = '0'; c <= '9'; c++) { text = text.Replace(c, (char)(c + (0xf83c - '0'))); } } Font f = GetFont(face, size * ScaleModifier, fs); if (ScaleModifier != 1) { restrictBounds *= ScaleModifier; } try { if (text.Length == 0) { text = " "; } measuredSize = restrictBounds != Vector2.Zero ? graphics.MeasureString(text, f, new SizeF(restrictBounds.X, restrictBounds.Y), sf) : graphics.MeasureString(text, f); } catch (InvalidOperationException) { measured = Vector2.Zero; return(null); } int width = (int)(measuredSize.Width + 1); int height = (int)(measuredSize.Height + 1); if (restrictBounds.Y != 0) { height = (int)restrictBounds.Y; } if (restrictBounds.X != 0 && (alignment != TextAlignment.Left || background.A > 0)) { width = (int)restrictBounds.X; } if (padding != Vector2.Zero && restrictBounds == Vector2.Zero) { width += (int)(padding.X * 2); height += (int)(padding.Y * 2); } measured = new Vector2(width, height); float offset = Math.Max(0.5f, Math.Min(1f, (size * ScaleModifier) / 14)); if (getCharacterRegions) { characterRegions = new RectangleF[text.Length]; // SetMeasurableCharacterRanges only accepts a maximum of 32 intervals to be queried, so we as the library user are // forced to split the string into 32 character long chunks and perform MeasureCharacterRanges on each. int numIntervals = (text.Length / 32) + 1; for (int i = 0; i < numIntervals; ++i) { int offsetIndex = i * 32; int end = Math.Min(text.Length - offsetIndex, 32); CharacterRange[] characterRanges = new CharacterRange[end]; for (int j = 0; j < end; ++j) { characterRanges[j] = new CharacterRange(j + offsetIndex, 1); } sf.SetMeasurableCharacterRanges(characterRanges); Region[] regions = graphics.MeasureCharacterRanges( text, f, new RectangleF( padding.X, padding.Y, restrictBounds.X == 0 ? Single.PositiveInfinity : restrictBounds.X, restrictBounds.Y == 0 ? Single.PositiveInfinity : restrictBounds.Y), sf); for (int j = 0; j < end; ++j) { Region region = regions[j] as Region; characterRegions[j + offsetIndex] = region.GetBounds(graphics); } } } if (measureOnly) { int startSpace = 0; int endSpace = 0; int i = 0; while (i < text.Length && text[i++] == ' ') { startSpace++; } int j = text.Length - 1; while (j >= i && text[j--] == ' ') { endSpace++; } if (startSpace == text.Length) { endSpace += startSpace; } measured = new Vector2(width + (endSpace * 5.145f * size / 12), height); return(null); } using (Bitmap b = new Bitmap(width, height, PixelFormat.Format32bppArgb)) using (System.Drawing.Graphics g = System.Drawing.Graphics.FromImage(b)) { //Quality settings g.TextRenderingHint = graphics.TextRenderingHint; g.SmoothingMode = SmoothingMode.HighQuality; g.InterpolationMode = InterpolationMode.HighQualityBicubic; if (background.A > 0) { if (cornerBounds != Vector4.Zero) { fillRoundedRectangle(g, new Rectangle(0, 0, width, height), new SolidBrush(OsuMathHelper.CConvert(background)), cornerBounds); if (borderWidth > 0) { drawRoundedRectangle(g, new Rectangle(0, 0, width - (int)Math.Ceiling(borderWidth / 2f), height - (int)Math.Ceiling(borderWidth / 2f)), new Pen(OsuMathHelper.CConvert(border), borderWidth), cornerBounds); } } else { g.Clear(OsuMathHelper.CConvert(background)); if (borderWidth > 0) { g.DrawRectangle(new Pen(OsuMathHelper.CConvert(border), borderWidth), new Rectangle(borderWidth / 2, borderWidth / 2, width - borderWidth, height - borderWidth)); } } } else { g.Clear(System.Drawing.Color.FromArgb(1, color.R, color.G, color.B)); } using (Brush brush = new SolidBrush(OsuMathHelper.CConvert(color))) { if (restrictBounds != Vector2.Zero) { restrictBounds.X -= padding.X * 2; restrictBounds.Y -= padding.Y * 2; switch (shadow) { case ShadowType.Normal: g.DrawString(text, f, shadowBrush, new RectangleF(padding.X - offset, offset + padding.Y, restrictBounds.X, restrictBounds.Y), sf); g.DrawString(text, f, shadowBrush, new RectangleF(padding.X + offset, offset + padding.Y, restrictBounds.X, restrictBounds.Y), sf); break; case ShadowType.Border: Brush borderBrush = greyBrush; if (background.A == 0 && borderWidth == 1 && border.A > 0) { borderBrush = new SolidBrush(OsuMathHelper.CConvert(border)); } g.DrawString(text, f, borderBrush, new RectangleF(padding.X + offset, padding.Y + offset, restrictBounds.X, restrictBounds.Y), sf); g.DrawString(text, f, borderBrush, new RectangleF(padding.X + offset, padding.Y - offset, restrictBounds.X, restrictBounds.Y), sf); g.DrawString(text, f, borderBrush, new RectangleF(padding.X - offset, padding.Y + offset, restrictBounds.X, restrictBounds.Y), sf); g.DrawString(text, f, borderBrush, new RectangleF(padding.X - offset, padding.Y - offset, restrictBounds.X, restrictBounds.Y), sf); break; } g.DrawString(text, f, brush, new RectangleF(padding.X, padding.Y, restrictBounds.X, restrictBounds.Y), sf); } else { switch (shadow) { case ShadowType.Normal: g.DrawString(text, f, shadowBrush, padding.X - offset, padding.Y + offset); g.DrawString(text, f, shadowBrush, padding.X + offset, padding.Y + offset); break; case ShadowType.Border: Brush borderBrush = greyBrush; if (background.A == 0 && borderWidth == 1 && border.A > 0) { borderBrush = new SolidBrush(OsuMathHelper.CConvert(border)); } g.DrawString(text, f, borderBrush, padding.X + offset, padding.Y + offset); g.DrawString(text, f, borderBrush, padding.X - offset, padding.Y + offset); g.DrawString(text, f, borderBrush, padding.X + offset, padding.Y - offset); g.DrawString(text, f, borderBrush, padding.X - offset, padding.Y - offset); break; } g.DrawString(text, f, brush, padding.X, padding.Y); } } //if (lastTexture == null || lastTexture.isDisposed) { lastTexture = pTexture.FromBitmap(b); lastTexture.Disposable = true; } /*else * { * lastTexture.Width = b.Width; * lastTexture.Height = b.Height; * lastTexture.SetData(b); * }*/ return(lastTexture); } } } catch (Exception e) { measured = Vector2.Zero; return(null); } } }
/// <summary> /// Get the smallest encompassing Region for the supplied string, Font and Graphics context. /// </summary> /// <param name="g">Graphics context object to measure string on.</param> /// <param name="str">String to measure.</param> /// <param name="fnt">Font to use for string.</param> /// <returns>Smallest Region encompassing the supplied string.</returns> public static Region GetGraphicalStringRegion(Graphics g, string str, Font fnt) { StringFormat format = new StringFormat(); RectangleF rect = new RectangleF(0, 0, 1000, 1000); CharacterRange[] ranges = {new CharacterRange(0, str.Length)}; Region[] regions = new Region[1]; format.SetMeasurableCharacterRanges(ranges); regions = g.MeasureCharacterRanges(str, fnt, rect, format); return regions[0]; }
/// <summary> /// Get the smallest encompassing Region of the supplied string using the supplied Font, Rectangle and StringFormat on the supplied Graphics context. /// </summary> /// <param name="g">Graphics context object to measure string on.</param> /// <param name="str">String to measure.</param> /// <param name="fnt">Font to use for string.</param> /// <param name="rct">Rectangle to measure string in.</param> /// <param name="strfmt">StringFormat to use when measuring the string.</param> /// <returns>Smallest Region encompassing the Text of the Control supplied using the StringFormat supplied.</returns> public static Region GetStringFormattedStringRegion(Graphics g, string str, Font fnt, Rectangle rct, StringFormat strfmt) { RectangleF rctF = new RectangleF(rct.X, rct.Y, rct.Width, rct.Height); CharacterRange[] ranges = {new CharacterRange(0, str.Length)}; Region[] regions = new Region[1]; strfmt.SetMeasurableCharacterRanges(ranges); regions = g.MeasureCharacterRanges(str, fnt, rctF, strfmt); return regions[0]; }
// "http://stackoverflow.com/questions/2116216#2116475" private static double GetTextWidth(Graphics g, Font f, string text) { StringFormat format = new StringFormat(StringFormat.GenericDefault); RectangleF rect = new RectangleF(0, 0, 1000, 1000); CharacterRange[] ranges = { new CharacterRange(0, text.Length) }; format.SetMeasurableCharacterRanges(ranges); format.FormatFlags = StringFormatFlags.MeasureTrailingSpaces; Region[] regions = g.MeasureCharacterRanges(text, f, rect, format); rect = regions[0].GetBounds(g); return rect.Right; }
static private int MeasureDisplayStringWidthExact(Graphics graphics, string text, Font font) { var ranges = new[] { new CharacterRange(0, text.Length) }; var format = new StringFormat(); format.SetMeasurableCharacterRanges(ranges); var rect = new RectangleF(0, 0, 1000, 1000); var regions = graphics.MeasureCharacterRanges(text, font, rect, format); rect = regions[0].GetBounds(graphics); return (int)(rect.Right + 1.0f); }
public float[] GetCharacterXPositions( Graphics g, string str ) { // Setup the StringFormat with proper CharacterRange references. StringFormat testFormat = new StringFormat(); CharacterRange[] ranges = new CharacterRange[ str.Length ]; for ( int i=0; i < str.Length; i++ ) ranges[i] = new CharacterRange( i, 1 ); testFormat.SetMeasurableCharacterRanges( ranges ); // Measure into Regions Region[] regions = g.MeasureCharacterRanges( str, _font, new Rectangle( 0, 0, 1000, 1000 ), testFormat ); // Convert Regions to Rects, then X coords. float[] xCoords = regions.Select( region => region.GetBounds( g ).X ).ToArray(); return xCoords; }
/// <summary> /// Measures the location of words within a string; limited by .Net 1.1 to 32 words /// MEASUREMAX is a constant that defines that limit /// </summary> /// <param name="s"></param> /// <param name="g"></param> /// <param name="drawFont"></param> /// <param name="drawFormat"></param> /// <param name="cra"></param> /// <returns></returns> private WordStartFinish[] MeasureString32(string s, Graphics g, Font drawFont, StringFormat drawFormat, CharacterRange[] cra) { if (s == null || s.Length == 0) return null; drawFormat.SetMeasurableCharacterRanges(cra); Region[] rs = new Region[cra.Length]; rs = g.MeasureCharacterRanges(s, drawFont, new RectangleF(0, 0, float.MaxValue, float.MaxValue), drawFormat); WordStartFinish[] sz = new WordStartFinish[cra.Length]; int isz = 0; foreach (Region r in rs) { RectangleF mr = r.GetBounds(g); sz[isz].start = RSize.PointsFromPixels(g, mr.Left); sz[isz].end = RSize.PointsFromPixels(g, mr.Right); isz++; } return sz; }
public int MeasureDisplayStringWidth(Graphics graphics, string text, Font font) { text = text.ToUpper(); System.Drawing.StringFormat format = new StringFormat(StringFormat.GenericTypographic); System.Drawing.RectangleF rect = new System.Drawing.RectangleF(0, 0, 1000, 1000); System.Drawing.CharacterRange[] ranges = { new System.Drawing.CharacterRange(0, text.Length) }; System.Drawing.Region[] regions = new System.Drawing.Region[1]; format.SetMeasurableCharacterRanges(ranges); regions = graphics.MeasureCharacterRanges(text, font, rect, format); rect = regions[0].GetBounds(graphics); return (int)(rect.Right + 1.0f); }
private void HighlightString(Graphics g, PageText dtext, RectangleF r, Font f, StringFormat sf) { if (_HighlightText == null || _HighlightText.Length == 0) return; // nothing to highlight bool bhighlightItem = dtext == _HighlightItem || (_HighlightItem != null && dtext.HtmlParent == _HighlightItem); if (!(_HighlightAll || bhighlightItem)) return; // not highlighting all and not on current highlight item string hlt = _HighlightCaseSensitive ? _HighlightText : _HighlightText.ToLower(); string text = _HighlightCaseSensitive ? dtext.Text : dtext.Text.ToLower(); if (text.IndexOf(hlt) < 0) return; // string not in text StringFormat sf2 = null; try { // Create a CharacterRange array with the highlight location and length // Handle multiple occurences of text List<CharacterRange> rangel = new List<CharacterRange>(); int loc = text.IndexOf(hlt); int hlen = hlt.Length; int len = text.Length; while (loc >= 0) { rangel.Add(new CharacterRange(loc, hlen)); if (loc + hlen < len) // out of range of text loc = text.IndexOf(hlt, loc + hlen); else loc = -1; } if (rangel.Count <= 0) // we should have gotten one; but return; CharacterRange[] ranges = rangel.ToArray(); // Construct a new StringFormat object. sf2 = sf.Clone() as StringFormat; // Set the ranges on the StringFormat object. sf2.SetMeasurableCharacterRanges(ranges); // Get the Regions to highlight by calling the // MeasureCharacterRanges method. if (r.Width <= 0 || r.Height <= 0) { SizeF ts = g.MeasureString(dtext.Text, f); r.Height = ts.Height; r.Width = ts.Width; } Region[] charRegion = g.MeasureCharacterRanges(dtext.Text, f, r, sf2); // Fill in the region using a semi-transparent color to highlight foreach (Region rg in charRegion) { Color hl = bhighlightItem ? _HighlightItemColor : _HighlightAllColor; g.FillRegion(new SolidBrush(Color.FromArgb(50, hl)), rg); } } catch { } // if highlighting fails we don't care; need to continue finally { if (sf2 != null) sf2.Dispose(); } }
public Region[] MeasureStringLine(Graphics g, string text, CharacterRange[] measureRanges, Font font, Rectangle textRect, StringAlignment align = StringAlignment.Near, StringAlignment lineAlign = StringAlignment.Center) { // Expand text rect, because DrawString stops too soon textRect.Width += DrawStringWidthAdd; textRect.Height = Math.Max(textRect.Height, font.Height); // Assume manual ellipsis textRect.Width -= 5; StringFormat nameLabelFormat = StringFormat.GenericDefault; nameLabelFormat.Alignment = align; nameLabelFormat.LineAlignment = lineAlign; nameLabelFormat.Trimming = StringTrimming.Character; nameLabelFormat.FormatFlags |= StringFormatFlags.NoWrap | StringFormatFlags.MeasureTrailingSpaces; nameLabelFormat.SetMeasurableCharacterRanges(measureRanges); return g.MeasureCharacterRanges(text, font, textRect, nameLabelFormat); }