winforms - subrayado - Formateo de texto en la etiqueta WinForm
negrita css (12)
Eso no es posible con una etiqueta WinForms tal como es. La etiqueta debe tener exactamente una fuente, con exactamente un tamaño y una cara. Tienes unas cuantas opciones:
- Usa etiquetas separadas
- Cree una nueva clase derivada de control que haga su propio dibujo a través de GDI + y utilícelo en lugar de Label; esta es probablemente su mejor opción, ya que le da control total sobre cómo ordenar al control que formatee su texto
- Use un control de etiquetas de terceros que le permita insertar fragmentos de HTML (hay un montón - compruebe CodeProject); esta sería la implementación de alguien más de # 2.
¿Es posible formatear cierto texto en una etiqueta WinForm en lugar de dividir el texto en varias etiquetas? Por favor, ignore las etiquetas HTML dentro del texto de la etiqueta; solo se usa para expresar mi punto.
Por ejemplo:
Dim myLabel As New Label
myLabel.Text = "This is <b>bold</b> text. This is <i>italicized</i> text."
Que produciría el texto en la etiqueta como:
Esto es texto en negrita Esto es texto en cursiva
No realmente, pero podría falsificarlo con un RichTextBox de solo lectura sin bordes. RichTextBox es compatible con el formato de texto enriquecido (rtf).
También me interesaría saber si es posible.
Cuando no pudimos encontrar una solución, recurrimos al control SuperLabel de Component Ones, que permite el marcado HTML en una etiqueta.
- Crea el texto como un archivo RTF en wordpad
- Crear control de texto enriquecido sin bordes y editable = falso
- Agregue el archivo RTF al proyecto como un recurso
En Form1_load do
myRtfControl.Rtf = Resource1.MyRtfControlText
Hay un excelente artículo de 2009 sobre Code Project llamado " Un renderizador HTML profesional que usarás " que implementa algo similar a lo que el póster original quiere.
Lo uso con éxito en varios proyectos de nosotros.
Al darme cuenta de que esta es una vieja pregunta, mi respuesta es más para aquellos, como yo, que aún pueden estar buscando soluciones y tropezar con esta pregunta.
Además de lo que ya se mencionó, LabelControl de DevExpress es una etiqueta que admite este comportamiento: demo aquí . Por desgracia, es parte de una biblioteca paga.
Si está buscando soluciones gratuitas, creo que HTML Renderer es la mejor opción.
Solución muy simple:
- Agregue 2 etiquetas en el formulario, LabelA y LabelB
- Vaya a las propiedades de LabelA y acoplarlo a la izquierda.
- Ir a propiedades de LabelB y acoplarlo a la izquierda también.
- Configure la fuente en negrita para LabelA.
Ahora la etiqueta B cambiará dependiendo de la longitud del texto de LabelA.
Eso es todo.
Un FlowLayoutPanel funciona bien para su problema. Si agrega etiquetas al panel de flujo y formatea las propiedades de margen y fuente de cada etiqueta, entonces puede tener diferentes estilos de fuente. Una solución bastante rápida y fácil para trabajar.
Sí. Puede implementar, usando HTML Render. Para ver, haga clic en el enlace: https://htmlrenderer.codeplex.com/ Espero que esto sea útil.
AutoRichLabel
Estaba resolviendo este problema creando un UserControl que contiene un TransparentRichTextBox que es de solo lectura. TransparentRichTextBox es un RichTextBox que permite ser transparente:
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;
}
}
}
El UserControl final actúa como contenedor de TransparentRichTextBox . Desafortunadamente, tuve que limitarlo a AutoSize en mi propio camino, porque el AutoSize de RichTextBox se rompió.
AutoRichLabel.designer.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 HST.SCADA.OPCServer.Config.Controls.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 sintaxis del formato de texto enriquecido es bastante simple:
Párrafo:
{/pard This is a paragraph!/par}
Texto en negrita / cursiva / subrayado:
/b bold text/b0
/i italic text/i0
/ul underline text/ul0
Color alternativo usando la tabla de colores:
{/colortbl ;/red0/green77/blue187;}
{/pard The word /cf1 fish/cf0 is blue./par
Pero tenga en cuenta: siempre ajuste cada texto en un párrafo. Además, se pueden apilar diferentes etiquetas (es decir, /pard/b/i Bold and Italic/i0/b0/par ) y se ignora el carácter de espacio detrás de una etiqueta. Entonces, si necesita un espacio detrás de él, inserte dos espacios (es decir, /pard The word /bBOLD/0 is bold./par ). Para escapar de / o { o } , use una / . Para obtener más información, hay una especificación completa del formato de texto enriquecido en línea .
Usando esta sintaxis bastante simple puedes producir algo como lo que puedes ver en la primera imagen. El contenido de texto enriquecido que se adjuntó a la propiedad RtfContent de mi AutoRichLabel en la primera imagen fue:
{/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 desea habilitar el ajuste de palabras, establezca el ancho máximo en el tamaño deseado. Sin embargo, esto arreglará el ancho hasta el ancho máximo, incluso cuando el texto sea más corto.
¡Que te diviertas!
Otra solución, tarde para la fiesta: si no quiere usar un control de terceros, y solo está buscando llamar la atención sobre parte del texto en su etiqueta, y está de acuerdo con los subrayados, puede usar un LinkLabel .
Tenga en cuenta que muchos consideran que esto es un " delito de usabilidad ", pero si no está diseñando algo para el consumo del usuario final, puede ser algo que esté dispuesto a tener en su conciencia.
El truco consiste en agregar enlaces deshabilitados a las partes de su texto que desea subrayar, y luego establecer globalmente los colores del enlace para que coincida con el resto de la etiqueta. Puede establecer casi todas las propiedades necesarias en tiempo de diseño aparte de la pieza Links.Add() , pero aquí están en el código:
linkLabel1.Text = "You are accessing a government system, and all activity " +
"will be logged. If you do not wish to continue, log out now.";
linkLabel1.AutoSize = false;
linkLabel1.Size = new Size(365, 50);
linkLabel1.TextAlign = ContentAlignment.MiddleCenter;
linkLabel1.Links.Clear();
linkLabel1.Links.Add(20, 17).Enabled = false; // "government system"
linkLabel1.Links.Add(105, 11).Enabled = false; // "log out now"
linkLabel1.LinkColor = linkLabel1.ForeColor;
linkLabel1.DisabledLinkColor = linkLabel1.ForeColor;
Resultado:
Solución trabajada para mí, utilizando RichEditBox personalizado. Con las propiedades correctas se verá como una simple etiqueta con soporte en negrita.
1) Primero, agregue su clase RichTextLabel personalizada con caret deshabilitado:
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) Dividir la oración en palabras con la bandera IsSelected, que determina si esa palabra debe ser negrita o no:
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) Agregue la función para convertir su texto a rtf válido (con soporte 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();
}
¡Funciona como un encanto para mí! Soluciones compiladas desde:
¿Cómo convertir una cadena a RTF en C #?