Länge der Zeichenfolge, die in einer bestimmten Breite passt

Question

Ich bin sicher, dass ich etwas offensichtlich fehlen, habe ich einen Bereich, in dem ich Text zeichnen möchte. Ich kenne seine (die Fläche) Höhe und Breite. Ich möchte wissen, wie viele Zeichen/Wörter in die Breite passen, vorzugsweise Zeichen. Zweite Frage, wenn die Zeile zu lang ist, möchte ich eine zweite Zeile zeichnen, also denke ich, dass ich auch die Höhe des Textes bekommen muss, einschließlich was immer es für die richtige vertikale Auffüllung hält?

Ich würde auch lieber die Umkehrung wissen, d. H. Wie viele Zeichen ich in einer bestimmten Breite passen kann.

Ich nehme an, die Tatsache, dass WPF nicht auf Pixel beschränkt ist, wird die Antwort beeinflussen?

Letztendlich plane ich, Text um unregelmäßig geformte Bilder zu verpacken, die in den Text eingebettet sind.

Alle Zeiger in die richtige Richtung wären toll.

Dank

Answer 1

Für WPF können Sie die FormattedText Klasse verwenden, um zu berechnen, wie viel Breite eine gegebene Textzeichenfolge verwenden wird - es hängt vom tatsächlichen Text ab.

Beispiel:

FormattedText formattedText = new FormattedText("Hello Stackoverflow", 
               System.Globalization.CultureInfo.GetCultureInfo("en-us"), 
               FlowDirection.LeftToRight, 
               new Typeface("Arial"), FontSize =14, Brushes.Black); 
double textWidth = formattedText.Width; 

Getting a sub-String für eine gegebene Breite (vereinfacht):

string text = GetSubStringForWidth("Hello Stackoverflow", 55); 
... 
public string GetSubStringForWidth(string text, double width) 
{ 
    if (width <= 0) 
     return ""; 

    int length = text.Length; 
    string testString; 

    while(true)//0 length string will always fit 
    { 
     testString = text.Substring(0, length); 
     FormattedText formattedText = new FormattedText(testString, 
                 CultureInfo.GetCultureInfo("en-us"), 
                 FlowDirection.LeftToRight, 
                 new Typeface("Arial"), 
                 FontSize = 14, 
                 Brushes.Black); 
     if(formattedText.Width <= width) 
      break; 
     else 
      length--; 
    } 
    return testString; 
} 

Answer 2

Dies ist nicht möglich, da Zeichen unterschiedliche Länge haben, zum Beispiel W ist viel breiter als i (es sei denn, Sie eine Schriftart wie Courier New verwenden).

Answer 3

@ BrokenGlass Antwort ist groß, aber abhängig von den Eigenschaften der Anwendung Möglicherweise erzielen Sie mit einer binären Suche eine bessere Leistung. Wenn die Mehrheit Ihrer Strings in die verfügbare Breite passt oder im Allgemeinen nur um ein oder zwei Zeichen gekürzt werden muss, ist eine lineare Suche am besten. Wenn Sie jedoch viele lange Strings haben, die stark abgeschnitten werden, funktioniert die folgende binäre Suche gut.

Beachten Sie, dass sowohl availableWidth als auch fontSize in geräteunabhängigen Einheiten (1/96stel Zoll) angegeben sind. Verwenden Sie auch den TextFormattingMode, der der Art entspricht, in der Sie Ihren Text zeichnen.

public static string TruncateTextToFitAvailableWidth(
    string text, 
    double availableWidth, 
    string fontName, 
    double fontSize) 
{ 
    if(availableWidth <= 0) 
     return string.Empty; 

    Typeface typeface = new Typeface(fontName); 

    int foundCharIndex = BinarySearch(
     text.Length, 
     availableWidth, 
     predicate: (idxValue1, value2) => 
     { 
      FormattedText ft = new FormattedText(
       text.Substring(0, idxValue1 + 1), 
       CultureInfo.CurrentCulture, 
       FlowDirection.LeftToRight, 
       typeface, 
       fontSize, 
       Brushes.Black, 
       numberSubstitution: null, 
       textFormattingMode: TextFormattingMode.Ideal); 

      return ft.WidthIncludingTrailingWhitespace.CompareTo(value2); 
     }); 

    int numChars = (foundCharIndex < 0) ? ~foundCharIndex : foundCharIndex + 1; 

    return text.Substring(0, numChars); 
} 

/** 
<summary> 
See <see cref="T:System.Array.BinarySearch"/>. This implementation is exactly the same, 
except that it is not bound to any specific type of collection. The behavior of the 
supplied predicate should match that of the T.Compare method (for example, 
<see cref="T:System.String.Compare"/>). 
</summary> 
*/  
public static int BinarySearch<T>(
    int    length, 
    T     value, 
    Func<int, T, int> predicate) // idxValue1, value2, compareResult 
{ 
    return BinarySearch(0, length, value, predicate); 
} 

public static int BinarySearch<T>(
    int    index, 
    int    length, 
    T     value, 
    Func<int, T, int> predicate) 
{ 
    int lo = index; 
    int hi = (index + length) - 1; 

    while(lo <= hi) 
    { 
     int mid = lo + ((hi - lo)/2); 

     int compareResult = predicate(mid, value); 

     if(compareResult == 0) 
      return mid; 
     else if(compareResult < 0) 
      lo = mid + 1; 
     else 
      hi = mid - 1; 
    } 

    return ~lo; 
}