Esporta (0) Stampa
Espandi tutto

Metodo StringFormat.SetMeasurableCharacterRanges

Aggiornamento: novembre 2007

Specifica una matrice di strutture CharacterRange che rappresenta gli intervalli di caratteri misurati con una chiamata al metodo MeasureCharacterRanges.

Spazio dei nomi:  System.Drawing
Assembly:  System.Drawing (in System.Drawing.dll)

public void SetMeasurableCharacterRanges(
	CharacterRange[] ranges
)
public void SetMeasurableCharacterRanges(
	CharacterRange[] ranges
)
public function SetMeasurableCharacterRanges(
	ranges : CharacterRange[]
)

Parametri

ranges
Tipo: System.Drawing.CharacterRange[]

Matrice di strutture CharacterRange che specifica gli intervalli di caratteri misurati con una chiamata al metodo MeasureCharacterRanges.

EccezioneCondizione
OverflowException

Sono impostati più di 32 intervalli di caratteri.

L'impostazione di più di 32 intervalli di caratteri non è consentita e causa la generazione di System.OverflowException.

L'esempio che segue deve essere utilizzato con i Windows Form e richiede PaintEventArgse, un parametro del gestore eventi Paint. Nel codice vengono eseguite le seguenti azioni:

  • Impostazione degli intervalli di caratteri di StringFormat.

  • Misurazione degli intervalli di caratteri relativi alla stringa e al rettangolo di layout indicati.

  • Disegno della stringa e del rettangolo di layout.

  • Disegno delle aree. Ciascun oggetto Region specifica un'area occupata da un intervallo di caratteri. I valori delle aree vengono impostati quando gli intervalli di caratteri vengono misurati dal metodo MeasureCharacterRanges.

  • Ripetizione dei primi quattro passaggi con inclusione degli spazi finali nella misurazione di ciascun intervallo di caratteri.

  • Cancellazione dei flag di formato di StringFormat in modo che non siano inclusi spazi finali nella misurazione di ciascun intervallo di caratteri.

  • Ripetizione dei primi quattro passaggi, utilizzando, però, un rettangolo di layout diverso, solo per dimostrare che il rettangolo di layout incide sulle misurazioni degli intervalli di caratteri. Anche la dimensione del tipo di carattere incide sulla misurazione.

public void SetMeasCharRangesExample(PaintEventArgs e)
{
    Graphics     g = e.Graphics;
    SolidBrush   redBrush = new SolidBrush(Color.FromArgb(50, 255, 0, 0));

    // Layout rectangles, font, and string format used for displaying string.
    Rectangle    layoutRectA = new Rectangle(20, 20, 165, 80);
    Rectangle    layoutRectB = new Rectangle(20, 110, 165, 80);
    Rectangle    layoutRectC = new Rectangle(20, 200, 240, 80);
    Font         tnrFont = new Font("Times New Roman", 16);
    StringFormat strFormat = new StringFormat();

    // Ranges of character positions within a string.
    CharacterRange[] charRanges = { new CharacterRange(3, 5),
        new CharacterRange(15, 2), new CharacterRange(30, 15)};

    // Each region specifies the area occupied by the characters within a
    // range of positions. the values are obtained by using a method that
    // measures the character ranges.
    Region[]     charRegions = new Region[charRanges.Length];

    // String to be displayed.
    string  str =
        "The quick, brown fox easily jumps over the lazy dog.";

    // Set the char ranges for the string format.
    strFormat.SetMeasurableCharacterRanges(charRanges);

    // loop counter (unsigned 8-bit integer)
    byte  i;    

    // Measure the char ranges for a given string and layout rectangle. Each
    // area occupied by the characters in a range is stored as a region. Then
    // draw the string and layout rectangle, and paint the regions.
    charRegions = g.MeasureCharacterRanges(str, tnrFont,
        layoutRectA, strFormat);
   g.DrawString(str, tnrFont, Brushes.Blue, layoutRectA, strFormat);
    g.DrawRectangle(Pens.Black, layoutRectA);

    // Paint the regions.
    for (i = 0; i < charRegions.Length; i++)
        g.FillRegion(redBrush, charRegions[i]);   


    // Repeat the above steps, but include trailing spaces in the char
    // range measurement by setting the appropriate string format flag.
    strFormat.FormatFlags = StringFormatFlags.MeasureTrailingSpaces;
    charRegions = g.MeasureCharacterRanges(str, tnrFont,
        layoutRectB, strFormat);
    g.DrawString(str, tnrFont, Brushes.Blue, layoutRectB, strFormat);
    g.DrawRectangle(Pens.Black, layoutRectB);


    for (i = 0; i < charRegions.Length; i++)
        g.FillRegion(redBrush, charRegions[i]);   

    // Clear all the format flags.
    strFormat.FormatFlags = 0;                   

    // Repeat the steps, but use a different layout rectangle. the dimensions
    // of the layout rectangle and the size of the font both affect the
    // character range measurement.
    charRegions = g.MeasureCharacterRanges(str, tnrFont,
        layoutRectC, strFormat);
    g.DrawString(str, tnrFont, Brushes.Blue, layoutRectC, strFormat);
    g.DrawRectangle(Pens.Black, layoutRectC);

    // Paint the regions.
    for (i = 0; i < charRegions.Length; i++)
        g.FillRegion(redBrush, charRegions[i]);   

}


public void SetMeasCharRangesExample(PaintEventArgs e)
{
    Graphics g = e.get_Graphics();
    SolidBrush redBrush = new SolidBrush(Color.FromArgb(50, 255, 0, 0));

    // Layout rectangles, font, and string format 
    // used for displaying string.
    Rectangle layoutRectA = new Rectangle(20, 20, 165, 80);
    Rectangle layoutRectB = new Rectangle(20, 110, 165, 80);
    Rectangle layoutRectC = new Rectangle(20, 200, 240, 80);
    Font tnrFont = new Font("Times New Roman", 16);
    StringFormat strFormat = new StringFormat();

    // Ranges of character positions within a string.
    CharacterRange charRanges[] =  { new CharacterRange(3, 5), 
                                new CharacterRange(15, 2),
                                new CharacterRange(30, 15) };

    // Each region specifies the area occupied by the characters within a
    // range of positions. the values are obtained by using a method that
    // measures the character ranges.
    Region charRegions[] = new Region[charRanges.length];

    // String to be displayed.
    String str = "The quick, brown fox easily jumps over the lazy dog.";

    // Set the char ranges for the string format.
    strFormat.SetMeasurableCharacterRanges(charRanges);

    // loop counter (unsigned 8-bit integer)
    ubyte i;

    // Measure the char ranges for a given string and layout rectangle.Each
    // area occupied by the characters in a range is stored as a region. 
    // Then draw the string and layout rectangle, and paint the regions.
    charRegions = g.MeasureCharacterRanges(str, tnrFont, 
                RectangleF.op_Implicit(layoutRectA), strFormat);
    g.DrawString(str, tnrFont, Brushes.get_Blue(), 
        RectangleF.op_Implicit(layoutRectA), strFormat);
    g.DrawRectangle(Pens.get_Black(), layoutRectA);

    // Paint the regions.
    for (i = 0; i < charRegions.length; i++) {
        g.FillRegion(redBrush, charRegions[i]);
    }

    // Repeat the above steps, but include trailing spaces in the char
    // range measurement by setting the appropriate string format flag.
    strFormat.set_FormatFlags(StringFormatFlags.MeasureTrailingSpaces);
    charRegions = g.MeasureCharacterRanges(str, tnrFont, 
                RectangleF.op_Implicit(layoutRectB), strFormat);
    g.DrawString(str, tnrFont, Brushes.get_Blue(), 
        RectangleF.op_Implicit(layoutRectB), strFormat);
    g.DrawRectangle(Pens.get_Black(), layoutRectB);
    for (i = 0; i < charRegions.length; i++) {
        g.FillRegion(redBrush, charRegions[i]);
    }

    // Clear all the format flags.
    strFormat.set_FormatFlags((StringFormatFlags)0);

    // Repeat the steps, but use a different layout rectangle.
    //  the dimensions of the layout rectangle and the size of the font
    //  both affect the character range measurement.
    charRegions = g.MeasureCharacterRanges(str, tnrFont, 
                RectangleF.op_Implicit(layoutRectC), strFormat);
    g.DrawString(str, tnrFont, Brushes.get_Blue(), 
        RectangleF.op_Implicit(layoutRectC), strFormat);
    g.DrawRectangle(Pens.get_Black(), layoutRectC);

    // Paint the regions.
    for (i = 0; i < charRegions.length; i++) {
        g.FillRegion(redBrush, charRegions[i]);
    }
} //SetMeasCharRangesExample


Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition , Windows XP Starter Edition, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98

.NET Framework e .NET Compact Framework non supportano tutte le versioni di ciascuna piattaforma. Per un elenco delle versioni supportate, vedere Requisiti di sistema di .NET Framework.

.NET Framework

Supportato in: 3.5, 3.0, 2.0, 1.1, 1.0

Aggiunte alla community

AGGIUNGI
Mostra:
© 2014 Microsoft