Le formatage du texte en WinForm Étiquette

Pas vraiment, mais on pouvait faire semblant avec une lecture seule RichTextBox sans frontières. RichTextBox prend en charge Rich Text Format (rtf).

Travaillé pour moi, la solution - l'aide personnalisée RichEditBox. Avec de bonnes propriétés, il sera regardé comme une simple étiquette avec l'appui audacieux.

1) tout d'Abord, ajouter votre personnalisé RichTextLabel classe handicapés curseur :

public class RichTextLabel : RichTextBox
{
    public RichTextLabel()
    {
        base.ReadOnly = true;
        base.BorderStyle = BorderStyle.None;
        base.TabStop = false;
        base.SetStyle(ControlStyles.Selectable, false);
        base.SetStyle(ControlStyles.UserMouse, true);
        base.SetStyle(ControlStyles.SupportsTransparentBackColor, true);

        base.MouseEnter += delegate(object sender, EventArgs e)
        {
            this.Cursor = Cursors.Default;
        };
    }

    protected override void WndProc(ref Message m)
    {
        if (m.Msg == 0x204) return; //WM_RBUTTONDOWN
        if (m.Msg == 0x205) return; //WM_RBUTTONUP
        base.WndProc(ref m);
    }
}

2) Split vous de la phrase de mots avec IsSelected drapeau, que de déterminer si ce mot doit être en gras ou non :

        private void AutocompleteItemControl_Load(object sender, EventArgs e)
    {
        RichTextLabel rtl = new RichTextLabel();
        rtl.Font = new Font("MS Reference Sans Serif", 15.57F);
        StringBuilder sb = new StringBuilder();
        sb.Append(@"{\rtf1\ansi ");
        foreach (var wordPart in wordParts)
        {
            if (wordPart.IsSelected)
            {
                sb.Append(@"\b ");
            }
            sb.Append(ConvertString2RTF(wordPart.WordPart));
            if (wordPart.IsSelected)
            {
                sb.Append(@"\b0 ");
            }
        }
        sb.Append(@"}");

        rtl.Rtf = sb.ToString();
        rtl.Width = this.Width;
        this.Controls.Add(rtl);
    }

3) Ajouter une fonction pour convertir des vous texte valide rtf (avec support de l'unicode!) :

   private string ConvertString2RTF(string input)
    {
        //first take care of special RTF chars
        StringBuilder backslashed = new StringBuilder(input);
        backslashed.Replace(@"\", @"\\");
        backslashed.Replace(@"{", @"\{");
        backslashed.Replace(@"}", @"\}");

        //then convert the string char by char
        StringBuilder sb = new StringBuilder();
        foreach (char character in backslashed.ToString())
        {
            if (character <= 0x7f)
                sb.Append(character);
            else
                sb.Append("\\u" + Convert.ToUInt32(character) + "?");
        }
        return sb.ToString();
    }

Fonctionne comme un charme pour moi!
Solutions compilé à partir de :

Comment convertir une chaîne de caractères au format RTF en C#?

Format texte dans la Zone de Texte enrichi

Comment masquer le curseur dans un RichTextBox?

AutoRichLabel

      

J'ai été la résolution de ce problème par la construction d'un UserControl qui contient un TransparentRichTextBox qui est en lecture seule. Le TransparentRichTextBox est un RichTextBox qui permet d'être transparent:

TransparentRichTextBox.cs:

public class TransparentRichTextBox : RichTextBox
{
    [DllImport("kernel32.dll", CharSet = CharSet.Auto)]
    static extern IntPtr LoadLibrary(string lpFileName);

    protected override CreateParams CreateParams
    {
        get
        {
            CreateParams prams = base.CreateParams;
            if (TransparentRichTextBox.LoadLibrary("msftedit.dll") != IntPtr.Zero)
            {
                prams.ExStyle |= 0x020; //transparent 
                prams.ClassName = "RICHEDIT50W";
            }
            return prams;
        }
    }
}

La finale UserControl agit comme un wrapper de la TransparentRichTextBox. Malheureusement, j'ai dû limiter à AutoSize sur mon propre chemin, parce que les AutoSize de la RichTextBox se sont rompus.

AutoRichLabel.le concepteur.cs:

partial class AutoRichLabel
{
///<summary> 
///Required designer variable.
///</summary>
private System.ComponentModel.IContainer components = null;
///<summary> 
///Clean up any resources being used.
///</summary>
///<param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
protected override void Dispose(bool disposing)
{
if (disposing && (components != null))
{
components.Dispose();
}
base.Dispose(disposing);
}
#region Component Designer generated code
///<summary> 
///Required method for Designer support - do not modify 
///the contents of this method with the code editor.
///</summary>
private void InitializeComponent()
{
this.rtb = new TransparentRichTextBox();
this.SuspendLayout();
//
//rtb
//
this.rtb.BorderStyle = System.Windows.Forms.BorderStyle.None;
this.rtb.Dock = System.Windows.Forms.DockStyle.Fill;
this.rtb.Location = new System.Drawing.Point(0, 0);
this.rtb.Margin = new System.Windows.Forms.Padding(0);
this.rtb.Name = "rtb";
this.rtb.ReadOnly = true;
this.rtb.ScrollBars = System.Windows.Forms.RichTextBoxScrollBars.None;
this.rtb.Size = new System.Drawing.Size(46, 30);
this.rtb.TabIndex = 0;
this.rtb.Text = "";
this.rtb.WordWrap = false;
this.rtb.ContentsResized += new System.Windows.Forms.ContentsResizedEventHandler(this.rtb_ContentsResized);
//
//AutoRichLabel
//
this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
this.AutoSizeMode = System.Windows.Forms.AutoSizeMode.GrowAndShrink;
this.BackColor = System.Drawing.Color.Transparent;
this.Controls.Add(this.rtb);
this.Name = "AutoRichLabel";
this.Size = new System.Drawing.Size(46, 30);
this.ResumeLayout(false);
}
#endregion
private TransparentRichTextBox rtb;
}

AutoRichLabel.cs:

///<summary>
///<para>An auto sized label with the ability to display text with formattings by using the Rich Text Format.</para>
///<para>­</para>
///<para>Short RTF syntax examples: </para>
///<para>­</para>
///<para>Paragraph: </para>
///<para>{\pard This is a paragraph!\par}</para>
///<para>­</para>
///<para>Bold /Italic /Underline: </para>
///<para>\b bold text\b0</para>
///<para>\i italic text\i0</para>
///<para>\ul underline text\ul0</para>
///<para>­</para>
///<para>Alternate color using color table: </para>
///<para>{\colortbl ;\red0\green77\blue187;}{\pard The word \cf1 fish\cf0  is blue.\par</para>
///<para>­</para>
///<para>Additional information: </para>
///<para>Always wrap every text in a paragraph. </para>
///<para>Different tags can be stacked (i.e. \pard\b\i Bold and Italic\i0\b0\par)</para>
///<para>The space behind a tag is ignored. So if you need a space behind it, insert two spaces (i.e. \pard The word \bBOLD\0  is bold.\par)</para>
///<para>Full specification: http://www.biblioscape.com/rtf15_spec.htm </para>
///</summary>
public partial class AutoRichLabel : UserControl
{
///<summary>
///The rich text content. 
///<para>­</para>
///<para>Short RTF syntax examples: </para>
///<para>­</para>
///<para>Paragraph: </para>
///<para>{\pard This is a paragraph!\par}</para>
///<para>­</para>
///<para>Bold /Italic /Underline: </para>
///<para>\b bold text\b0</para>
///<para>\i italic text\i0</para>
///<para>\ul underline text\ul0</para>
///<para>­</para>
///<para>Alternate color using color table: </para>
///<para>{\colortbl ;\red0\green77\blue187;}{\pard The word \cf1 fish\cf0  is blue.\par</para>
///<para>­</para>
///<para>Additional information: </para>
///<para>Always wrap every text in a paragraph. </para>
///<para>Different tags can be stacked (i.e. \pard\b\i Bold and Italic\i0\b0\par)</para>
///<para>The space behind a tag is ignored. So if you need a space behind it, insert two spaces (i.e. \pard The word \bBOLD\0  is bold.\par)</para>
///<para>Full specification: http://www.biblioscape.com/rtf15_spec.htm </para>
///</summary>
[Browsable(true)]
public string RtfContent
{
get
{
return this.rtb.Rtf;
}
set
{
this.rtb.WordWrap = false; //to prevent any display bugs, word wrap must be off while changing the rich text content. 
this.rtb.Rtf = value.StartsWith(@"{\rtf1") ? value : @"{\rtf1" + value + "}"; //Setting the rich text content will trigger the ContentsResized event. 
this.Fit(); //Override width and height. 
this.rtb.WordWrap = this.WordWrap; //Set the word wrap back. 
}
}
///<summary>
///Dynamic width of the control. 
///</summary>
[Browsable(false)]
public new int Width
{
get
{
return base.Width;
} 
}
///<summary>
///Dynamic height of the control. 
///</summary>
[Browsable(false)]
public new int Height
{
get
{
return base.Height;
}
}
///<summary>
///The measured width based on the content. 
///</summary>
public int DesiredWidth { get; private set; }
///<summary>
///The measured height based on the content. 
///</summary>
public int DesiredHeight { get; private set; }
///<summary>
///Determines the text will be word wrapped. This is true, when the maximum size has been set. 
///</summary>
public bool WordWrap { get; private set; }
///<summary>
///Constructor. 
///</summary>
public AutoRichLabel()
{
InitializeComponent();
}
///<summary>
///Overrides the width and height with the measured width and height
///</summary>
public void Fit()
{
base.Width = this.DesiredWidth;
base.Height = this.DesiredHeight;
}
///<summary>
///Will be called when the rich text content of the control changes. 
///</summary>
private void rtb_ContentsResized(object sender, ContentsResizedEventArgs e)
{
this.AutoSize = false; //Disable auto size, else it will break everything
this.WordWrap = this.MaximumSize.Width > 0; //Enable word wrap when the maximum width has been set. 
this.DesiredWidth = this.rtb.WordWrap ? this.MaximumSize.Width : e.NewRectangle.Width; //Measure width. 
this.DesiredHeight = this.MaximumSize.Height > 0 && this.MaximumSize.Height < e.NewRectangle.Height ? this.MaximumSize.Height : e.NewRectangle.Height; //Measure height. 
this.Fit(); //Override width and height. 
}
}

La syntaxe du format de texte enrichi est assez simple:

Paragraphe:

{\pard This is a paragraph!\par}

Gras /Italique /Souligné texte:

\b bold text\b0
\i italic text\i0
\ul underline text\ul0

Autre couleur à l'aide de la table des couleurs:

{\colortbl ;\red0\green77\blue187;}
{\pard The word \cf1 fish\cf0  is blue.\par

Mais s'il vous plaît note: Toujours enrouler chaque texte dans un paragraphe. Aussi, les différentes balises peuvent être empilés (c'est à dire \pard\b\i Bold and Italic\i0\b0\par) et le caractère d'espace derrière une balise est ignoré. Donc, si vous avez besoin d'un espace derrière elle, insérer deux espaces (c'est à dire \pard The word \bBOLD\0 is bold.\par). Pour échapper à \ ou { ou }, veuillez utiliser l'un des principaux \.
Pour plus d'informations il y a un spécification complète de l'rich text format en ligne.

À l'aide de cette syntaxe plutôt simple, vous pouvez produire quelque chose comme vous pouvez le voir dans la première image. Le contenu de texte enrichi, qui était attachée à la RtfContent propriété de mon AutoRichLabel dans la première image a été:

{\colortbl ;\red0\green77\blue187;}
{\pard\b BOLD\b0  \i ITALIC\i0  \ul UNDERLINE\ul0 \\\{\}\par}
{\pard\cf1\b BOLD\b0  \i ITALIC\i0  \ul UNDERLINE\ul0\cf0 \\\{\}\par}

Si vous souhaitez activer le renvoi automatique à la ligne, veuillez régler la largeur maximale à la taille désirée. Toutefois, cela permettra de fixer la largeur de la largeur maximale, même lorsque le texte est plus court.

Amusez-vous!

Solution très simple:

1. Ajouter 2 étiquettes sur la forme, LabelA et LabelB
2. Allez à propriétés pour LabelA et de l'ancrer à gauche.
3. Allez à propriétés pour LabelB et de l'ancrer à gauche ainsi.
4. Définir la Police de caractères gras pour LabelA .

Maintenant la LabelB va varier en fonction de la longueur de texte de LabelA.

C'est tout.

Cette réalisation est une vieille question, ma réponse est plus pour ceux qui, comme moi, qui reste peut-être à la recherche de ces solutions et de tomber sur cette question.

En dehors de ce qui a déjà été mentionné, DevExpress de LabelControl est un label qui prend en charge ce comportement - démo ici. Hélas, elle est partie à une bibliothèque.

Si vous êtes à la recherche de solutions libres, je crois Convertisseur HTML est la meilleure chose suivante.

Ouais.
Vous pouvez met en œuvre, à l'aide de Rendu HTML.
Pour vous voir, cliquez sur le lien: https://htmlrenderer.codeplex.com/
J'espère que cela est utile.