wake-up-neo.com

Dynamische Anpassung der Schriftgröße an den Speicherplatz bei Verwendung von Graphics.DrawString

Hat jemand einen Tipp, während Sie die Schriftgröße dynamisch an einen bestimmten Bereich anpassen können? Zum Beispiel habe ich ein 800x110-Rechteck und möchte es mit der maximalen Schriftgröße füllen, die die gesamte Zeichenfolge unterstützen würde, die ich anzeigen möchte.

Bitmap bitmap = new Bitmap(800, 110);

using (Graphics graphics = Graphics.FromImage(bitmap))
using (Font font1 = new Font("Arial", 120, FontStyle.Regular, GraphicsUnit.Pixel))
{
    Rectangle rect1 = new Rectangle(0, 0, 800, 110);

    StringFormat stringFormat = new StringFormat();
    stringFormat.Alignment = StringAlignment.Center;
    stringFormat.LineAlignment = StringAlignment.Center;

    graphics.TextRenderingHint = TextRenderingHint.ClearTypeGridFit;
    graphics.DrawString("Billy Reallylonglastnameinstein", font1, Brushes.Red, rect1, stringFormat);
} 

bitmap.Save(Server.MapPath("~/Fonts/" + System.Guid.NewGuid() + ".png"));

Offensichtlich wird dieser ganze Name nicht in dem Bereich mit der großen Schriftgröße gerendert. Es muss einen einfachen Weg geben, dies zu tun?

16
farina

Sie sollten eine Skalentransformation für Font.Size durchführen. Die folgende Funktion ist ein Beispiel dafür, aber Sie können sie verbessern, um bessere Ergebnisse zu erzielen.

Hier ist die FindFont-Funktion, die einen Raum und einen Text mit der bevorzugten Größe erhält und Ihnen eine Schriftart gibt, in der Sie festlegen können, dass der gesamte Text in den Raum passt!

// This function checks the room size and your text and appropriate font
//  for your text to fit in room
// PreferedFont is the Font that you wish to apply
// Room is your space in which your text should be in.
// LongString is the string which it's bounds is more than room bounds.
private Font FindFont(
   System.Drawing.Graphics g,
   string longString,
   Size Room,
   Font PreferedFont
) {
   // you should perform some scale functions!!!
   SizeF RealSize = g.MeasureString(longString, PreferedFont);
   float HeightScaleRatio = Room.Height / RealSize.Height;
   float WidthScaleRatio = Room.Width / RealSize.Width;

   float ScaleRatio = (HeightScaleRatio < WidthScaleRatio)
      ? ScaleRatio = HeightScaleRatio
      : ScaleRatio = WidthScaleRatio;

   float ScaleFontSize = PreferedFont.Size * ScaleRatio;

   return new Font(PreferedFont.FontFamily, ScaleFontSize);
}

Für Ihre Frage können Sie es mit folgendem Code aufrufen:

Bitmap bitmap = new Bitmap(800, 110);

using (System.Drawing.Graphics graphics = System.Drawing.Graphics.FromImage(bitmap))
using (Font font1 = new Font("Arial", 120, FontStyle.Regular, GraphicsUnit.Pixel))
{
   Rectangle rect1 = new Rectangle(0, 0, 800, 110);

   StringFormat stringFormat = new StringFormat();
   stringFormat.Alignment = StringAlignment.Center;
   stringFormat.LineAlignment = StringAlignment.Center;
   graphics.TextRenderingHint = System.Drawing.Text.TextRenderingHint.ClearTypeGridFit;

   Font goodFont = FindFont(graphics, "Billy Reallylonglastnameinstein", rect1.Size, font1);

   graphics.DrawString(
      "Billy Reallylonglastnameinstein",
      goodFont,
      Brushes.Red,
      rect1,
      stringFormat
   );
}
22
saeed

Ich habe Saeeds großartige Funktion an meine Anforderungen angepasst. Kommentare erklären alles:

    // You hand this the text that you need to fit inside some
    // available room, and the font you'd like to use.
    // If the text fits nothing changes
    // If the text does not fit then it is reduced in size to
    // make it fit.
    // PreferedFont is the Font that you wish to apply
    // FontUnit is there because the default font unit is not
    // always the one you use, and it is info required in the
    // constructor for the new Font.
    public static void FindGoodFont(Graphics Graf, string sStringToFit,
                                    Size TextRoomAvail, 
                                    ref Font FontToUse,
                                    GraphicsUnit FontUnit)
    {
        // Find out what the current size of the string in this font is
        SizeF RealSize = Graf.MeasureString(sStringToFit, FontToUse);
        Debug.WriteLine("big string is {0}, orig size = {1},{2}",
                         sStringToFit, RealSize.Width, RealSize.Height);
        if ((RealSize.Width <= TextRoomAvail.Width) && (RealSize.Height <= TextRoomAvail.Height))
        {
            Debug.WriteLine("The space is big enough already");
            // The current font is fine...
            return;
        }

        // Either width or height is too big...
        // Usually either the height ratio or the width ratio
        // will be less than 1. Work them out...
        float HeightScaleRatio = TextRoomAvail.Height / RealSize.Height;
        float WidthScaleRatio = TextRoomAvail.Width / RealSize.Width;

        // We'll scale the font by the one which is furthest out of range...
        float ScaleRatio = (HeightScaleRatio < WidthScaleRatio) ? ScaleRatio = HeightScaleRatio : ScaleRatio = WidthScaleRatio;
        float ScaleFontSize = FontToUse.Size * ScaleRatio;

        Debug.WriteLine("Resizing with scales {0},{1} chose {2}",
                         HeightScaleRatio, WidthScaleRatio, ScaleRatio);

        Debug.WriteLine("Old font size was {0}, new={1} ",FontToUse.Size,ScaleFontSize);

        // Retain whatever the style was in the old font...
        FontStyle OldFontStyle = FontToUse.Style;

        // Get rid of the old non working font...
        FontToUse.Dispose();

        // Tell the caller to use this newer smaller font.
        FontToUse = new Font(FontToUse.FontFamily,
                                ScaleFontSize,
                                OldFontStyle,
                                FontUnit);
    }
3
Owen Ransen

Dies ist nur ein Update für die FindFont-Funktion von @ Saeed.

GraphicsUnit.Pixel muss zur FindFont-Funktionsrückkehrzeile hinzugefügt werden. Ohne GraphicsUnit.Pixel wirkt sich das System dpi auf die gezeichnete Zeichenfolge aus. Problem tritt auf, wenn die dpi von System und Bitmap nicht übereinstimmt. Sie können weitere Einzelheiten in dieser Windows DPI-Einstellung sehen, die sich auf Graphics.DrawString auswirkt. Da GraphicsUnit von PreferedFont bereits auf GraphicsUnit.Pixel eingestellt ist und die Rückgabeschriftart nicht mit GraphicsUnit.Pixel festgelegt ist. In diesem Fall verlässt der Text die Dimension Room, wenn die Bitmap-Auflösung größer als die Systemauflösung ist und die Schriftgröße kleiner als die erwartete Größe wird, wenn die Bitmap-Auflösung kleiner als die Systemauflösung ist. Hier ist die aktualisierte Funktion.

    private Font FindFont(  System.Drawing.Graphics g , string longString , Size Room , Font PreferedFont)
    {
        SizeF RealSize = g.MeasureString(longString, PreferedFont);
        float HeightScaleRatio = Room.Height / RealSize.Height;
        float WidthScaleRatio = Room.Width / RealSize.Width;
        float ScaleRatio = (HeightScaleRatio < WidthScaleRatio) ? ScaleRatio = HeightScaleRatio : ScaleRatio = WidthScaleRatio;
        float ScaleFontSize = PreferedFont.Size * ScaleRatio;
        return new Font(PreferedFont.FontFamily, ScaleFontSize,PreferedFont.Style,GraphicsUnit.Pixel);
    }
3
Rijul Sudhir

Ich möchte nicht gegen saaeds Lösung kämpfen, die wahrscheinlich auch ziemlich großartig ist. Aber ich habe eine andere auf msdn gefunden: Dynamic Graphic Text Resizing die für mich funktioniert hat.

public Font GetAdjustedFont(Graphics GraphicRef, string GraphicString, Font OriginalFont, int ContainerWidth, int MaxFontSize, int MinFontSize, bool SmallestOnFail)
{
   // We utilize MeasureString which we get via a control instance           
   for (int AdjustedSize = MaxFontSize; AdjustedSize >= MinFontSize; AdjustedSize--)
   {
      Font TestFont = new Font(OriginalFont.Name, AdjustedSize, OriginalFont.Style);

      // Test the string with the new size
      SizeF AdjustedSizeNew = GraphicRef.MeasureString(GraphicString, TestFont);

      if (ContainerWidth > Convert.ToInt32(AdjustedSizeNew.Width))
      {
       // Good font, return it
         return TestFont;
      }
   }

   // If you get here there was no fontsize that worked
   // return MinimumSize or Original?
   if (SmallestOnFail)
   {
      return new Font(OriginalFont.Name,MinFontSize,OriginalFont.Style);
   }
   else
   {
      return OriginalFont;
   }
}
2

Hier ist meine Lösung, die die Verpackung unterstützt.

public static Font GetAdjustedFont(Graphics graphic, string str, Font originalFont, Size containerSize)
    {
        // We utilize MeasureString which we get via a control instance           
        for (int adjustedSize = (int)originalFont.Size; adjustedSize >= 1; adjustedSize--)
        {
            var testFont = new Font(originalFont.Name, adjustedSize, originalFont.Style, GraphicsUnit.Pixel);

            // Test the string with the new size
            var adjustedSizeNew = graphic.MeasureString(str, testFont, containerSize.Width);

            if (containerSize.Height > Convert.ToInt32(adjustedSizeNew.Height))
            {
                // Good font, return it
                return testFont;
            }
        }

        return new Font(originalFont.Name, 1, originalFont.Style, GraphicsUnit.Pixel);
    }

Wie benutzt man:

var font = GetAdjustedFont(drawing, text, originalfont, wrapSize);
drawing.DrawString(text, font, textBrush, new Rectangle(0, 0, wrapSize.Width, wrapSize.Height));
0
Saykor