Struct Label

pub struct Label { /* private fields */ }

The Label widget displays a small amount of text.

As the name implies, most labels are used to label another widget such as a Button.

Shortcuts and Gestures

Label supports the following keyboard shortcuts, when the cursor is visible:

• Shift+F10 or Menu opens the context menu.
• Ctrl+A or Ctrl+/ selects all.
• Ctrl+Shift+A or Ctrl+\ unselects all.

Additionally, the following signals have default keybindings:

• activate-current-link
• copy-clipboard
• move-cursor

Actions

Label defines a set of built-in actions:

• clipboard.copy copies the text to the clipboard.
• clipboard.cut doesn’t do anything, since text in labels can’t be deleted.
• clipboard.paste doesn’t do anything, since text in labels can’t be edited.
• link.open opens the link, when activated on a link inside the label.
• link.copy copies the link to the clipboard, when activated on a link inside the label.
• menu.popup opens the context menu.
• selection.delete doesn’t do anything, since text in labels can’t be deleted.
• selection.select-all selects all of the text, if the label allows selection.

CSS nodes

label
├── [selection]
├── [link]
┊
╰── [link]

Label has a single CSS node with the name label. A wide variety of style classes may be applied to labels, such as .title, .subtitle, .dim-label, etc. In the ShortcutsWindow, labels are used with the .keycap style class.

If the label has a selection, it gets a subnode with name selection.

If the label has links, there is one subnode per link. These subnodes carry the link or visited state depending on whether they have been visited. In this case, label node also gets a .link style class.

GtkLabel as GtkBuildable

The GtkLabel implementation of the GtkBuildable interface supports a custom <attributes> element, which supports any number of <attribute> elements. The <attribute> element has attributes named “name“, “value“, “start“ and “end“ and allows you to specify Pango::Attribute values for this label.

An example of a UI definition fragment specifying Pango attributes:

<object class="GtkLabel">
  <attributes>
    <attribute name="weight" value="PANGO_WEIGHT_BOLD"/>
    <attribute name="background" value="red" start="5" end="10"/>
  </attributes>
</object>

The start and end attributes specify the range of characters to which the Pango attribute applies. If start and end are not specified, the attribute is applied to the whole text. Note that specifying ranges does not make much sense with translatable attributes. Use markup embedded in the translatable content instead.

Accessibility

Label uses the AccessibleRole::Label role.

Mnemonics

Labels may contain “mnemonics”. Mnemonics are underlined characters in the label, used for keyboard navigation. Mnemonics are created by providing a string with an underscore before the mnemonic character, such as "_File", to the functions with_mnemonic() or set_text_with_mnemonic().

Mnemonics automatically activate any activatable widget the label is inside, such as a Button; if the label is not inside the mnemonic’s target widget, you have to tell the label about the target using set_mnemonic_widget().

Here’s a simple example where the label is inside a button:

⚠️ The following code is in c ⚠️

// Pressing Alt+H will activate this button
GtkWidget *button = gtk_button_new ();
GtkWidget *label = gtk_label_new_with_mnemonic ("_Hello");
gtk_button_set_child (GTK_BUTTON (button), label);

There’s a convenience function to create buttons with a mnemonic label already inside:

⚠️ The following code is in c ⚠️

// Pressing Alt+H will activate this button
GtkWidget *button = gtk_button_new_with_mnemonic ("_Hello");

To create a mnemonic for a widget alongside the label, such as a Entry, you have to point the label at the entry with set_mnemonic_widget():

⚠️ The following code is in c ⚠️

// Pressing Alt+H will focus the entry
GtkWidget *entry = gtk_entry_new ();
GtkWidget *label = gtk_label_new_with_mnemonic ("_Hello");
gtk_label_set_mnemonic_widget (GTK_LABEL (label), entry);

Markup (styled text)

To make it easy to format text in a label (changing colors, fonts, etc.), label text can be provided in a simple markup format:

Here’s how to create a label with a small font: ⚠️ The following code is in c ⚠️

GtkWidget *label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label), "<small>Small text</small>");

(See the Pango manual for complete documentation] of available tags, parse_markup())

The markup passed to set_markup() must be valid; for example, literal <, > and & characters must be escaped as <, >, and &. If you pass text obtained from the user, file, or a network to set_markup(), you’ll want to escape it with markup_escape_text() or markup_printf_escaped().

Markup strings are just a convenient way to set the pango::AttrList on a label; set_attributes() may be a simpler way to set attributes in some cases. Be careful though; pango::AttrList tends to cause internationalization problems, unless you’re applying attributes to the entire string (i.e. unless you set the range of each attribute to [0, G_MAXINT)). The reason is that specifying the start_index and end_index for a Pango::Attribute requires knowledge of the exact string being displayed, so translations will cause problems.

Selectable labels

Labels can be made selectable with set_selectable(). Selectable labels allow the user to copy the label contents to the clipboard. Only labels that contain useful-to-copy information—such as error messages—should be made selectable.

Text layout

A label can contain any number of paragraphs, but will have performance problems if it contains more than a small number. Paragraphs are separated by newlines or other paragraph separators understood by Pango.

Labels can automatically wrap text if you call set_wrap().

set_justify() sets how the lines in a label align with one another. If you want to set how the label as a whole aligns in its available space, see the halign and valign properties.

The width-chars and max-width-chars properties can be used to control the size allocation of ellipsized or wrapped labels. For ellipsizing labels, if either is specified (and less than the actual text size), it is used as the minimum width, and the actual text size is used as the natural width of the label. For wrapping labels, width-chars is used as the minimum width, if specified, and max-width-chars is used as the natural width. Even if max-width-chars specified, wrapping labels will be rewrapped to use all of the available width.

Links

GTK supports markup for clickable hyperlinks in addition to regular Pango markup. The markup for links is borrowed from HTML, using the <a> with “href“, “title“ and “class“ attributes. GTK renders links similar to the way they appear in web browsers, with colored, underlined text. The “title“ attribute is displayed as a tooltip on the link. The “class“ attribute is used as style class on the CSS node for the link.

An example of inline links looks like this:

⚠️ The following code is in c ⚠️

const char *text =
"Go to the "
"<a href=\"https://www.gtk.org\" title=\"&lt;i&gt;Our&lt;/i&gt; website\">"
"GTK website</a> for more...";
GtkWidget *label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label), text);

It is possible to implement custom handling for links and their tooltips with the activate-link signal and the current_uri() function.

Properties

attributes

A list of style attributes to apply to the text of the label.

Readable | Writeable

ellipsize

The preferred place to ellipsize the string, if the label does not have enough room to display the entire string.

Note that setting this property to a value other than pango::EllipsizeMode::None has the side-effect that the label requests only enough space to display the ellipsis “…”. In particular, this means that ellipsizing labels do not work well in notebook tabs, unless the tab-expand child property is set to true. Other ways to set a label’s width are WidgetExt::set_size_request() and Label::set_width_chars().

Readable | Writeable

extra-menu

A menu model whose contents will be appended to the context menu.

Readable | Writeable

justify

The alignment of the lines in the text of the label, relative to each other.

This does not affect the alignment of the label within its allocation. See xalign for that.

Readable | Writeable

label

The contents of the label.

If the string contains Pango markup (see parse_markup()), you will have to set the use-markup property to true in order for the label to display the markup attributes. See also Label::set_markup() for a convenience function that sets both this property and the use-markup property at the same time.

If the string contains underlines acting as mnemonics, you will have to set the use-underline property to true in order for the label to display them.

Readable | Writeable

lines

The number of lines to which an ellipsized, wrapping label should be limited.

This property has no effect if the label is not wrapping or ellipsized. Set this property to -1 if you don’t want to limit the number of lines.

Readable | Writeable

max-width-chars

The desired maximum width of the label, in characters.

If this property is set to -1, the width will be calculated automatically.

See the section on text layout for details of how width-chars and max-width-chars determine the width of ellipsized and wrapped labels.

Readable | Writeable

mnemonic-keyval

The mnemonic accelerator key for the label.

Readable

mnemonic-widget

The widget to be activated when the labels mnemonic key is pressed.

Readable | Writeable

natural-wrap-mode

Select the line wrapping for the natural size request.

This only affects the natural size requested. For the actual wrapping used, see the wrap-mode property.

The default is NaturalWrapMode::Inherit, which inherits the behavior of the wrap-mode property.

Readable | Writeable

selectable

Whether the label text can be selected with the mouse.

Readable | Writeable

single-line-mode

Whether the label is in single line mode.

In single line mode, the height of the label does not depend on the actual text, it is always set to ascent + descent of the font. This can be an advantage in situations where resizing the label because of text changes would be distracting, e.g. in a statusbar.

Readable | Writeable

tabs

Custom tabs for this label.

Readable | Writeable

use-markup

true if the text of the label includes Pango markup.

See parse_markup().

Readable | Writeable

use-underline

true if the text of the label indicates a mnemonic with an _ before the mnemonic character.

Readable | Writeable

width-chars

The desired width of the label, in characters.

If this property is set to -1, the width will be calculated automatically.

See the section on text layout for details of how width-chars and max-width-chars determine the width of ellipsized and wrapped labels.

Readable | Writeable

wrap

true if the label text will wrap if it gets too wide.

Readable | Writeable

wrap-mode

Controls how the line wrapping is done.

This only affects the formatting if line wrapping is on (see the wrap property). The default is pango::WrapMode::Word, which means wrap on word boundaries.

For sizing behavior, also consider the natural-wrap-mode property.

Readable | Writeable

xalign

The horizontal alignment of the label text inside its size allocation.

Compare this to halign, which determines how the labels size allocation is positioned in the space available for the label.

Readable | Writeable

yalign

The vertical alignment of the label text inside its size allocation.

Compare this to valign, which determines how the labels size allocation is positioned in the space available for the label.

Readable | Writeable

Widget

can-focus

Whether the widget or any of its descendents can accept the input focus.

This property is meant to be set by widget implementations, typically in their instance init function.

Readable | Writeable

can-target

Whether the widget can receive pointer events.

Readable | Writeable

css-classes

A list of css classes applied to this widget.

Readable | Writeable

css-name

The name of this widget in the CSS tree.

This property is meant to be set by widget implementations, typically in their instance init function.

Readable | Writeable | Construct Only

cursor

The cursor used by @widget.

Readable | Writeable

focus-on-click

Whether the widget should grab focus when it is clicked with the mouse.

This property is only relevant for widgets that can take focus.

Readable | Writeable

focusable

Whether this widget itself will accept the input focus.

Readable | Writeable

halign

How to distribute horizontal space if widget gets extra space.

Readable | Writeable

has-default

Whether the widget is the default widget.

Readable

has-focus

Whether the widget has the input focus.

Readable

has-tooltip

Enables or disables the emission of the ::query-tooltip signal on @widget.

A value of true indicates that @widget can have a tooltip, in this case the widget will be queried using query-tooltip to determine whether it will provide a tooltip or not.

Readable | Writeable

height-request

Override for height request of the widget.

If this is -1, the natural request will be used.

Readable | Writeable

hexpand

Whether to expand horizontally.

Readable | Writeable

hexpand-set

Whether to use the hexpand property.

Readable | Writeable

layout-manager

The LayoutManager instance to use to compute the preferred size of the widget, and allocate its children.

This property is meant to be set by widget implementations, typically in their instance init function.

Readable | Writeable

margin-bottom

Margin on bottom side of widget.

This property adds margin outside of the widget’s normal size request, the margin will be added in addition to the size from WidgetExt::set_size_request() for example.

Readable | Writeable

margin-end

Margin on end of widget, horizontally.

This property supports left-to-right and right-to-left text directions.

This property adds margin outside of the widget’s normal size request, the margin will be added in addition to the size from WidgetExt::set_size_request() for example.

Readable | Writeable

margin-start

Margin on start of widget, horizontally.

This property supports left-to-right and right-to-left text directions.

This property adds margin outside of the widget’s normal size request, the margin will be added in addition to the size from WidgetExt::set_size_request() for example.

Readable | Writeable

margin-top

Margin on top side of widget.

This property adds margin outside of the widget’s normal size request, the margin will be added in addition to the size from WidgetExt::set_size_request() for example.

Readable | Writeable

name

The name of the widget.

Readable | Writeable

opacity

The requested opacity of the widget.

Readable | Writeable

overflow

How content outside the widget’s content area is treated.

This property is meant to be set by widget implementations, typically in their instance init function.

Readable | Writeable

parent

The parent widget of this widget.

Readable

receives-default

Whether the widget will receive the default action when it is focused.

Readable | Writeable

root

The Root widget of the widget tree containing this widget.

This will be None if the widget is not contained in a root widget.

Readable

scale-factor

The scale factor of the widget.

Readable

sensitive

Whether the widget responds to input.

Readable | Writeable

tooltip-markup

Sets the text of tooltip to be the given string, which is marked up with Pango markup.

Also see Tooltip::set_markup().

This is a convenience property which will take care of getting the tooltip shown if the given string is not None: has-tooltip will automatically be set to true and there will be taken care of query-tooltip in the default signal handler.

Note that if both tooltip-text and tooltip-markup are set, the last one wins.

Readable | Writeable

tooltip-text

Sets the text of tooltip to be the given string.

Also see Tooltip::set_text().

This is a convenience property which will take care of getting the tooltip shown if the given string is not None: has-tooltip will automatically be set to true and there will be taken care of query-tooltip in the default signal handler.

Note that if both tooltip-text and tooltip-markup are set, the last one wins.

Readable | Writeable

valign

How to distribute vertical space if widget gets extra space.

Readable | Writeable

vexpand

Whether to expand vertically.

Readable | Writeable

vexpand-set

Whether to use the vexpand property.

Readable | Writeable

visible

Whether the widget is visible.

Readable | Writeable

width-request

Override for width request of the widget.

If this is -1, the natural request will be used.

Readable | Writeable

Accessible

accessible-role

The accessible role of the given Accessible implementation.

The accessible role cannot be changed once set.

Readable | Writeable

Signals

activate-current-link

Gets emitted when the user activates a link in the label.

The ::activate-current-link is a keybinding signal.

Applications may also emit the signal with g_signal_emit_by_name() if they need to control activation of URIs programmatically.

The default bindings for this signal are all forms of the Enter key.

Action

activate-link

Gets emitted to activate a URI.

Applications may connect to it to override the default behaviour, which is to call FileLauncher::launch().

copy-clipboard

Gets emitted to copy the selection to the clipboard.

The ::copy-clipboard signal is a keybinding signal.

The default binding for this signal is Ctrl+c.

Action

move-cursor

Gets emitted when the user initiates a cursor movement.

The ::move-cursor signal is a keybinding signal. If the cursor is not visible in @entry, this signal causes the viewport to be moved instead.

Applications should not connect to it, but may emit it with g_signal_emit_by_name() if they need to control the cursor programmatically.

The default bindings for this signal come in two variants, the variant with the Shift modifier extends the selection, the variant without the Shift modifier does not. There are too many key combinations to list them all here.

• ←, →, ↑, ↓ move by individual characters/lines
• Ctrl+←, etc. move by words/paragraphs
• Home and End move to the ends of the buffer

Action

Widget

destroy

Signals that all holders of a reference to the widget should release the reference that they hold.

May result in finalization of the widget if all references are released.

This signal is not suitable for saving widget state.

direction-changed

Emitted when the text direction of a widget changes.

hide

Emitted when @widget is hidden.

keynav-failed

Emitted if keyboard navigation fails.

See WidgetExt::keynav_failed() for details.

map

Emitted when @widget is going to be mapped.

A widget is mapped when the widget is visible (which is controlled with visible) and all its parents up to the toplevel widget are also visible.

The ::map signal can be used to determine whether a widget will be drawn, for instance it can resume an animation that was stopped during the emission of unmap.

mnemonic-activate

Emitted when a widget is activated via a mnemonic.

The default handler for this signal activates @widget if @group_cycling is false, or just makes @widget grab focus if @group_cycling is true.

move-focus

Emitted when the focus is moved.

The ::move-focus signal is a keybinding signal.

The default bindings for this signal are Tab to move forward, and Shift+Tab to move backward.

Action

query-tooltip

Emitted when the widget’s tooltip is about to be shown.

This happens when the has-tooltip property is true and the hover timeout has expired with the cursor hovering “above” @widget; or emitted when @widget got focus in keyboard mode.

Using the given coordinates, the signal handler should determine whether a tooltip should be shown for @widget. If this is the case true should be returned, false otherwise. Note that if @keyboard_mode is true, the values of @x and @y are undefined and should not be used.

The signal handler is free to manipulate @tooltip with the therefore destined function calls.

realize

Emitted when @widget is associated with a gdk::Surface.

This means that WidgetExt::realize() has been called or the widget has been mapped (that is, it is going to be drawn).

show

Emitted when @widget is shown.

state-flags-changed

Emitted when the widget state changes.

See WidgetExt::state_flags().

unmap

Emitted when @widget is going to be unmapped.

A widget is unmapped when either it or any of its parents up to the toplevel widget have been set as hidden.

As ::unmap indicates that a widget will not be shown any longer, it can be used to, for example, stop an animation on the widget.

unrealize

Emitted when the gdk::Surface associated with @widget is destroyed.

This means that WidgetExt::unrealize() has been called or the widget has been unmapped (that is, it is going to be hidden).

Implements

WidgetExt, [trait@glib::ObjectExt], AccessibleExt, BuildableExt, ConstraintTargetExt, AccessibleTextExt, WidgetExtManual, AccessibleExtManual

GLib type: GObject with reference counted clone semantics.

Implementations

impl Label

pub fn new(str: Option<&str>) -> Label

Creates a new label with the given text inside it.

You can pass None to get an empty label widget.

str

The text of the label

Returns

the new Label

pub fn with_mnemonic(str: &str) -> Label

Creates a new Label, containing the text in @str.

If characters in @str are preceded by an underscore, they are underlined. If you need a literal underscore character in a label, use ‘__’ (two underscores). The first underlined character represents a keyboard accelerator called a mnemonic. The mnemonic key can be used to activate another widget, chosen automatically, or explicitly using set_mnemonic_widget().

If set_mnemonic_widget() is not called, then the first activatable ancestor of the Label will be chosen as the mnemonic widget. For instance, if the label is inside a button or menu item, the button or menu item will automatically become the mnemonic widget and be activated by the mnemonic.

str

The text of the label, with an underscore in front of the mnemonic character

Returns

the new Label

pub fn builder() -> LabelBuilder

Creates a new builder-pattern struct instance to construct Label objects.

This method returns an instance of LabelBuilder which can be used to create Label objects.

pub fn attributes(&self) -> Option<AttrList>

Gets the label’s attribute list.

This is the pango::AttrList that was set on the label using set_attributes(), if any. This function does not reflect attributes that come from the label’s markup (see set_markup()). If you want to get the effective attributes for the label, use pango_layout_get_attributes (gtk_label_get_layout (self)).

Returns

the attribute list

pub fn current_uri(&self) -> Option<GString>

Returns the URI for the currently active link in the label.

The active link is the one under the mouse pointer or, in a selectable label, the link in which the text cursor is currently positioned.

This function is intended for use in a activate-link handler or for use in a query-tooltip handler.

Returns

the currently active URI

pub fn ellipsize(&self) -> EllipsizeMode

Returns the ellipsizing position of the label.

See set_ellipsize().

Returns

pango::EllipsizeMode

pub fn extra_menu(&self) -> Option<MenuModel>

Gets the extra menu model of @label.

See set_extra_menu().

Returns

the menu model

pub fn justify(&self) -> Justification

Returns the justification of the label.

See set_justify().

Returns

Justification

pub fn label(&self) -> GString

Fetches the text from a label.

The returned text includes any embedded underlines indicating mnemonics and Pango markup. (See text()).

Returns

the text of the label widget. This string is owned by the widget and must not be modified or freed.

pub fn layout(&self) -> Layout

Gets the pango::Layout used to display the label.

The layout is useful to e.g. convert text positions to pixel positions, in combination with layout_offsets(). The returned layout is owned by the @label so need not be freed by the caller. The @label is free to recreate its layout at any time, so it should be considered read-only.

Returns

the pango::Layout for this label

pub fn layout_offsets(&self) -> (i32, i32)

Obtains the coordinates where the label will draw its pango::Layout.

The coordinates are useful to convert mouse events into coordinates inside the pango::Layout, e.g. to take some action if some part of the label is clicked. Remember when using the pango::Layout functions you need to convert to and from pixels using PANGO_PIXELS() or Pango::SCALE.

Returns

x

location to store X offset of layout

y

location to store Y offset of layout

pub fn lines(&self) -> i32

Gets the number of lines to which an ellipsized, wrapping label should be limited.

See set_lines().

Returns

The number of lines

pub fn max_width_chars(&self) -> i32

Retrieves the desired maximum width of @label, in characters.

See set_width_chars().

Returns

the maximum width of the label in characters.

pub fn mnemonic_widget(&self) -> Option<Widget>

Retrieves the target of the mnemonic (keyboard shortcut) of this label.

See set_mnemonic_widget().

Returns

the target of the label’s mnemonic, or None if none has been set and the default algorithm will be used.

pub fn natural_wrap_mode(&self) -> NaturalWrapMode

Available on crate feature v4_6 only.

Returns line wrap mode used by the label.

See set_natural_wrap_mode().

Returns

the natural line wrap mode

pub fn is_selectable(&self) -> bool

Returns whether the label is selectable.

Returns

true if the user can copy text from the label

pub fn selection_bounds(&self) -> Option<(i32, i32)>

Gets the selected range of characters in the label.

Returns

true if selection is non-empty

start

return location for start of selection, as a character offset

end

return location for end of selection, as a character offset

pub fn is_single_line_mode(&self) -> bool

Returns whether the label is in single line mode.

Returns

true when the label is in single line mode.

pub fn tabs(&self) -> Option<TabArray>

Available on crate feature v4_8 only.

Gets the tabs for @self.

The returned array will be None if “standard” (8-space) tabs are used. Free the return value with Pango::TabArray::free().

Returns

copy of default tab array, or None if standard tabs are used; must be freed with Pango::TabArray::free().

pub fn text(&self) -> GString

Fetches the text from a label.

The returned text is as it appears on screen. This does not include any embedded underlines indicating mnemonics or Pango markup. (See label())

Returns

the text in the label widget. This is the internal string used by the label, and must not be modified.

pub fn uses_markup(&self) -> bool

Returns whether the label’s text is interpreted as Pango markup.

See set_use_markup().

Returns

true if the label’s text will be parsed for markup.

pub fn uses_underline(&self) -> bool

Returns whether an embedded underlines in the label indicate mnemonics.

See set_use_underline().

Returns

true whether an embedded underline in the label indicates the mnemonic accelerator keys.

pub fn width_chars(&self) -> i32

Retrieves the desired width of @label, in characters.

See set_width_chars().

Returns

the width of the label in characters.

pub fn wraps(&self) -> bool

Returns whether lines in the label are automatically wrapped.

See set_wrap().

Returns

true if the lines of the label are automatically wrapped.

pub fn wrap_mode(&self) -> WrapMode

Returns line wrap mode used by the label.

See set_wrap_mode().

Returns

the line wrap mode

pub fn xalign(&self) -> f32

Gets the xalign of the label.

See the xalign property.

Returns

the xalign property

pub fn yalign(&self) -> f32

Gets the yalign of the label.

See the yalign property.

Returns

the yalign property

pub fn select_region(&self, start_offset: i32, end_offset: i32)

Selects a range of characters in the label, if the label is selectable.

See set_selectable(). If the label is not selectable, this function has no effect. If @start_offset or @end_offset are -1, then the end of the label will be substituted.

start_offset

start offset (in characters not bytes)

end_offset

end offset (in characters not bytes)

pub fn set_attributes(&self, attrs: Option<&AttrList>)

Apply attributes to the label text.

The attributes set with this function will be applied and merged with any other attributes previously effected by way of the use-underline or use-markup properties. While it is not recommended to mix markup strings with manually set attributes, if you must; know that the attributes will be applied to the label after the markup string is parsed.

attrs

a pango::AttrList

pub fn set_ellipsize(&self, mode: EllipsizeMode)

Sets the mode used to ellipsize the text.

The text will be ellipsized if there is not enough space to render the entire string.

mode

a pango::EllipsizeMode

pub fn set_extra_menu(&self, model: Option<&impl IsA<MenuModel>>)

Sets a menu model to add when constructing the context menu for @label.

model

a GMenuModel

pub fn set_justify(&self, jtype: Justification)

Sets the alignment of the lines in the text of the label relative to each other.

Justification::Left is the default value when the widget is first created with new(). If you instead want to set the alignment of the label as a whole, use WidgetExt::set_halign() instead. set_justify() has no effect on labels containing only a single line.

jtype

a Justification

pub fn set_label(&self, str: &str)

Sets the text of the label.

The label is interpreted as including embedded underlines and/or Pango markup depending on the values of the use-underline and use-markup properties.

str

the new text to set for the label

pub fn set_lines(&self, lines: i32)

Sets the number of lines to which an ellipsized, wrapping label should be limited.

This has no effect if the label is not wrapping or ellipsized. Set this to -1 if you don’t want to limit the number of lines.

lines

the desired number of lines, or -1

pub fn set_markup(&self, str: &str)

Sets the labels text and attributes from markup.

The string must be marked up with Pango markup (see parse_markup()).

If the @str is external data, you may need to escape it with g_markup_escape_text() or g_markup_printf_escaped():

⚠️ The following code is in c ⚠️

GtkWidget *self = gtk_label_new (NULL);
const char *str = "...";
const char *format = "<span style=\"italic\">\%s</span>";
char *markup;

markup = g_markup_printf_escaped (format, str);
gtk_label_set_markup (GTK_LABEL (self), markup);
g_free (markup);

This function will set the use-markup property to true as a side effect.

If you set the label contents using the label property you should also ensure that you set the use-markup property accordingly.

See also: set_text()

str

a markup string

pub fn set_markup_with_mnemonic(&self, str: &str)

Sets the labels text, attributes and mnemonic from markup.

Parses @str which is marked up with Pango markup (see parse_markup()), setting the label’s text and attribute list based on the parse results. If characters in @str are preceded by an underscore, they are underlined indicating that they represent a keyboard accelerator called a mnemonic.

The mnemonic key can be used to activate another widget, chosen automatically, or explicitly using set_mnemonic_widget().

str

a markup string

pub fn set_max_width_chars(&self, n_chars: i32)

Sets the desired maximum width in characters of @label to @n_chars.

n_chars

the new desired maximum width, in characters.

pub fn set_mnemonic_widget(&self, widget: Option<&impl IsA<Widget>>)

Associate the label with its mnemonic target.

If the label has been set so that it has a mnemonic key (using i.e. set_markup_with_mnemonic(), set_text_with_mnemonic(), with_mnemonic() or the use_underline property) the label can be associated with a widget that is the target of the mnemonic. When the label is inside a widget (like a Button or a Notebook tab) it is automatically associated with the correct widget, but sometimes (i.e. when the target is a Entry next to the label) you need to set it explicitly using this function.

The target widget will be accelerated by emitting the mnemonic-activate signal on it. The default handler for this signal will activate the widget if there are no mnemonic collisions and toggle focus between the colliding widgets otherwise.

widget

the target Widget, or None to unset

pub fn set_natural_wrap_mode(&self, wrap_mode: NaturalWrapMode)

Available on crate feature v4_6 only.

Select the line wrapping for the natural size request.

This only affects the natural size requested, for the actual wrapping used, see the wrap-mode property.

wrap_mode

the line wrapping mode

pub fn set_selectable(&self, setting: bool)

Makes text in the label selectable.

Selectable labels allow the user to select text from the label, for copy-and-paste.

setting

true to allow selecting text in the label

pub fn set_single_line_mode(&self, single_line_mode: bool)

Sets whether the label is in single line mode.

single_line_mode

true if the label should be in single line mode

pub fn set_tabs(&self, tabs: Option<&TabArray>)

Available on crate feature v4_8 only.

Sets the default tab stops for paragraphs in @self.

tabs

tabs as a pango::TabArray

pub fn set_text(&self, str: &str)

Sets the text within the Label widget.

It overwrites any text that was there before.

This function will clear any previously set mnemonic accelerators, and set the use-underline property to false as a side effect.

This function will set the use-markup property to false as a side effect.

See also: set_markup()

str

The text you want to set

pub fn set_text_with_mnemonic(&self, str: &str)

Sets the label’s text from the string @str.

If characters in @str are preceded by an underscore, they are underlined indicating that they represent a keyboard accelerator called a mnemonic. The mnemonic key can be used to activate another widget, chosen automatically, or explicitly using set_mnemonic_widget().

str

a string

pub fn set_use_markup(&self, setting: bool)

Sets whether the text of the label contains markup.

See set_markup().

setting

true if the label’s text should be parsed for markup.

pub fn set_use_underline(&self, setting: bool)

Sets whether underlines in the text indicate mnemonics.

setting

true if underlines in the text indicate mnemonics

pub fn set_width_chars(&self, n_chars: i32)

Sets the desired width in characters of @label to @n_chars.

n_chars

the new desired width, in characters.

pub fn set_wrap(&self, wrap: bool)

Toggles line wrapping within the Label widget.

true makes it break lines if text exceeds the widget’s size. false lets the text get cut off by the edge of the widget if it exceeds the widget size.

Note that setting line wrapping to true does not make the label wrap at its parent container’s width, because GTK widgets conceptually can’t make their requisition depend on the parent container’s size. For a label that wraps at a specific position, set the label’s width using WidgetExt::set_size_request().

wrap

the setting

pub fn set_wrap_mode(&self, wrap_mode: WrapMode)

Controls how line wrapping is done.

This only affects the label if line wrapping is on. (See set_wrap()) The default is pango::WrapMode::Word which means wrap on word boundaries.

For sizing behavior, also consider the natural-wrap-mode property.

wrap_mode

the line wrapping mode

pub fn set_xalign(&self, xalign: f32)

Sets the xalign of the label.

See the xalign property.

xalign

the new xalign value, between 0 and 1

pub fn set_yalign(&self, yalign: f32)

Sets the yalign of the label.

See the yalign property.

yalign

the new yalign value, between 0 and 1

pub fn connect_activate_current_link<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

Gets emitted when the user activates a link in the label.

The ::activate-current-link is a keybinding signal.

Applications may also emit the signal with g_signal_emit_by_name() if they need to control activation of URIs programmatically.

The default bindings for this signal are all forms of the Enter key.

pub fn emit_activate_current_link(&self)

pub fn connect_activate_link<F: Fn(&Self, &str) -> Propagation + 'static>( &self, f: F, ) -> SignalHandlerId

Gets emitted to activate a URI.

Applications may connect to it to override the default behaviour, which is to call FileLauncher::launch().

uri

the URI that is activated

Returns

true if the link has been activated

pub fn connect_copy_clipboard<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

Gets emitted to copy the selection to the clipboard.

The ::copy-clipboard signal is a keybinding signal.

The default binding for this signal is Ctrl+c.

pub fn emit_copy_clipboard(&self)

pub fn connect_move_cursor<F: Fn(&Self, MovementStep, i32, bool) + 'static>( &self, f: F, ) -> SignalHandlerId

Gets emitted when the user initiates a cursor movement.

The ::move-cursor signal is a keybinding signal. If the cursor is not visible in @entry, this signal causes the viewport to be moved instead.

Applications should not connect to it, but may emit it with g_signal_emit_by_name() if they need to control the cursor programmatically.

The default bindings for this signal come in two variants, the variant with the Shift modifier extends the selection, the variant without the Shift modifier does not. There are too many key combinations to list them all here.

• ←, →, ↑, ↓ move by individual characters/lines
• Ctrl+←, etc. move by words/paragraphs
• Home and End move to the ends of the buffer

step

the granularity of the move, as a MovementStep

count

the number of @step units to move

extend_selection

true if the move should extend the selection

pub fn emit_move_cursor( &self, step: MovementStep, count: i32, extend_selection: bool, )

pub fn connect_attributes_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_ellipsize_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_extra_menu_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_justify_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_label_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_lines_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_max_width_chars_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_mnemonic_keyval_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_mnemonic_widget_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_natural_wrap_mode_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

Available on crate feature v4_6 only.

pub fn connect_selectable_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_single_line_mode_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_tabs_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

Available on crate feature v4_8 only.

pub fn connect_use_markup_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_use_underline_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_width_chars_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_wrap_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_wrap_mode_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_xalign_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_yalign_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

impl Label

pub fn mnemonic_keyval(&self) -> Key

Return the mnemonic accelerator.

If the label has been set so that it has a mnemonic key this function returns the keyval used for the mnemonic accelerator. If there is no mnemonic set up it returns GDK_KEY_VoidSymbol.

Returns

GDK keyval usable for accelerators, or GDK_KEY_VoidSymbol

Trait Implementations

impl Clone for Label

fn clone(&self) -> Self

Makes a clone of this shared reference.

This increments the strong reference count of the object. Dropping the object will decrement it again.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Label

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Label

fn default() -> Self

Returns the “default value” for a type.

impl HasParamSpec for Label

type ParamSpec = ParamSpecObject

type SetValue = Label

Preferred value to be used as setter for the associated ParamSpec.

type BuilderFn = fn(_: &str) -> ParamSpecObjectBuilder<'_, Label>

fn param_spec_builder() -> Self::BuilderFn

impl Hash for Label

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Hashes the memory address of this object.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Label

fn cmp(&self, other: &Self) -> Ordering

Comparison for two GObjects.

Compares the memory addresses of the provided objects.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl ParentClassIs for Label

type Parent = Widget

impl<OT: ObjectType> PartialEq<OT> for Label

fn eq(&self, other: &OT) -> bool

Equality for two GObjects.

Two GObjects are equal if their memory addresses are equal.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<OT: ObjectType> PartialOrd<OT> for Label

fn partial_cmp(&self, other: &OT) -> Option<Ordering>

Partial comparison for two GObjects.

Compares the memory addresses of the provided objects.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StaticType for Label

fn static_type() -> Type

Returns the type identifier of Self.

impl Eq for Label

impl IsA<Accessible> for Label

impl IsA<AccessibleText> for Label

impl IsA<Buildable> for Label

impl IsA<ConstraintTarget> for Label

impl IsA<Widget> for Label