/* GTK - The GIMP Toolkit * Copyright ( C ) 1995 - 1997 Peter Mattis , Spencer Kimball and Josh MacDonald * * This library is free software ; you can redistribute it and / or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation ; either * version 2 of the License , or ( at your option ) any later version . * * This library is distributed in the hope that it will be useful , * but WITHOUT ANY WARRANTY ; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the GNU * Lesser General Public License for more details . * * You should have received a copy of the GNU Lesser General Public * License along with this library . If not , see < http : //www.gnu.org/licenses/>.Free /* * Modified by the GTK + Team and others 1997 - 2000 . See the AUTHORS * file for a list of people on the GTK + Team . See the ChangeLog * files for a list of changes . These files are distributed with * GTK + at ftp : //ftp.gtk.org/pub/gtk/. #include "config.h" #include "gtklabelprivate.h" #include "gtkaccessibletextprivate.h" #include "gtkaccessiblehypertextprivate.h" #include "gtkbuildable.h" #include "gtkbuilderprivate.h" #include "gtkcsscolorvalueprivate.h" #include "gtkdragsourceprivate.h" #include "gtkdragicon.h" #include "gtkeventcontrollermotion.h" #include "gtkeventcontrollerfocus.h" #include "gtkfilelauncher.h" #include "gtkgesturedrag.h" #include "gtkgestureclick.h" #include "gtkgesturesingle.h" #include "gtkjoinedmenuprivate.h" #include "gtkmarshalers.h" #include "gtknative.h" #include "gtknotebook.h" #include "gtkpangoprivate.h" #include "gtkpopovermenu.h" #include "gtkprivate.h" #include "gtkrenderbackgroundprivate.h" #include "gtkrenderborderprivate.h" #include "gtkrenderlayoutprivate.h" #include "gtkshortcut.h" #include "gtkshortcutcontroller.h" #include "gtkshortcuttrigger.h" #include "gtksnapshot.h" #include "gtktextutilprivate.h" #include "gtktooltip.h" #include "gtktypebuiltins.h" #include "gtkurilauncher.h" #include "gtkwidgetprivate.h" #include <math.h>#include <stdlib.h>#include <string.h>#include <glib/gi18n-lib.h>/** * GtkLabel : * * Displays a small amount of text . * * Most labels are used to label another widget ( such as an [ class @ Entry ] ) . * * < picture > * < source srcset = " label - dark . png " media = " ( prefers - color - scheme : dark ) " > * < img alt = " An example GtkLabel " src = " label . png " > * < / picture > * * # # Shortcuts and Gestures * * ` GtkLabel ` supports the following keyboard shortcuts , when the cursor is * visible : * * - < kbd > Shift < / kbd > + < kbd > F10 < / kbd > or < kbd > Menu < / kbd > opens the context menu . * - < kbd > Ctrl < / kbd > + < kbd > A < / kbd > or < kbd > Ctrl < / kbd > + < kbd > & sol ; < / kbd > * selects all . * - < kbd > Ctrl < / kbd > + < kbd > Shift < / kbd > + < kbd > A < / kbd > or * < kbd > Ctrl < / kbd > + < kbd > & bsol ; < / kbd > unselects all . * * Additionally , the following signals have default keybindings : * * - [ signal @ Gtk . Label : : activate - current - link ] * - [ signal @ Gtk . Label : : copy - clipboard ] * - [ signal @ Gtk . Label : : move - cursor ] * * # # Actions * * ` GtkLabel ` 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 ] * ` ` ` * * ` GtkLabel ` 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 ` GtkShortcutsWindow ` , 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 [ struct @ Pango . Attribute ] * values for this label . * * An example of a UI definition fragment specifying Pango attributes : * * ` ` ` xml * < 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 * * ` GtkLabel ` uses the [ enum @ Gtk . 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 [ ctor @ Gtk . Label . new_with_mnemonic ] or * [ method @ Gtk . Label . set_text_with_mnemonic ] . * * Mnemonics automatically activate any activatable widget the label is * inside , such as a [ class @ Gtk . Button ] ; if the label is not inside the * mnemonic ’ s target widget , you have to tell the label about the target * using [ method @ Gtk . Label . set_mnemonic_widget ] . * * Here ’ s a simple example where the label is inside a button : * * ` ` ` 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 : * * ` ` ` 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 * [ class @ Gtk . Entry ] , you have to point the label at the entry with * [ method @ Gtk . Label . set_mnemonic_widget ] : * * ` ` ` 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 : * ` ` ` 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 , [ func @ Pango . parse_markup ] ) * * The markup passed to [ method @ Gtk . Label . set_markup ] must be valid XML ; for example , * literal ` < ` , ` > ` and ` & ` characters must be escaped as ` & lt ; ` , ` & gt ; ` , and ` &an>amp ; ` . * If you pass text obtained from the user , file , or a network to * [ method @ Gtk . Label . set_markup ] , you ’ ll want to escape it with * [ func @ GLib . markup_escape_text ] or [ func @ GLib . markup_printf_escaped ] . * * Markup strings are just a convenient way to set the [ struct @ Pango . AttrList ] * on a label ; [ method @ Gtk . Label . set_attributes ] may be a simpler way to set * attributes in some cases . Be careful though ; [ struct @ 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 [ struct @ Pango . Attribute ] requires knowledge of the exact * string being displayed , so translations will cause problems . * * # # Selectable labels * * Labels can be made selectable with [ method @ Gtk . Label . 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 [ method @ Gtk . Label . set_wrap ] . * * [ method @ Gtk . Label . 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 [ property @ Gtk . Widget : halign ] and * [ property @ Gtk . Widget : valign ] properties . * * The [ property @ Gtk . Label : width - chars ] and [ property @ Gtk . Label : 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 > ` tag * 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 : * * ` ` ` c * const char * text = * " Go to the " * " < a href = \ " https : //www.gtk.org\" title=\"<i>Our</i> 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 [ signal @ Gtk . Label : : activate - link ] signal and the * [ method @ Gtk . Label . get_current_uri ] function . typedef struct _GtkLabelClass GtkLabelClass;typedef struct _GtkLabelSelectionInfo GtkLabelSelectionInfo;struct _GtkLabelchar *label;char *text;float xalign;float yalign;1 ;2 ;1 ;1 ;3 ;1 ;3 ;3 ;1 ;1 ;1 ;int width_chars;int max_width_chars;int lines;struct _GtkLabelClassvoid (* move_cursor) (GtkLabel *self,int count,void (* copy_clipboard) (GtkLabel *self);const char *uri);/* Notes about the handling of links: * * Links share the GtkLabelSelectionInfo struct with selectable labels . * There are some new fields for links . The links field contains the list * of GtkLabelLink structs that describe the links which are embedded in * the label . The active_link field points to the link under the mouse * pointer . For keyboard navigation , the “ focus ” link is determined by * finding the link which contains the selection_anchor position . * The link_clicked field is used with button press and release events * to ensure that pressing inside a link and releasing outside of it * does not activate the link . * * Links are rendered with the GTK_STATE_FLAG_LINK / GTK_STATE_FLAG_VISITED * state flags . When the mouse pointer is over a link , the pointer is changed * to indicate the link . * * Labels with links accept keyboard focus , and it is possible to move * the focus between the embedded links using Tab / Shift - Tab . The focus * is indicated by a focus rectangle that is drawn around the link text . * Pressing Enter activates the focused link , and there is a suitable * context menu for links that can be opened with the Menu key . Pressing * Control - C copies the link URI to the clipboard . * * In selectable labels with links , link functionality is only available * when the selection is empty . typedef struct char *uri;char *title; /* the title attribute, used as tooltip */ /* get set when the link is activated; this flag * gets preserved over later set_markup ( ) calls int start; /* position of the link in the PangoLayout */ int end;struct _GtkLabelSelectionInfoint selection_anchor;int selection_end;int drag_start_x;int drag_start_y;1 ;1 ;1 ;1 ;enum {enum {static GParamSpec *label_props[NUM_PROPERTIES] = { NULL, };static guint signals[LAST_SIGNAL] = { 0 };static GQuark quark_mnemonics_visible_connected;static void gtk_label_set_markup_internal (GtkLabel *self,const char *str,static void gtk_label_recalculate (GtkLabel *self);static void gtk_label_do_popup (GtkLabel *self,double x,double y);static void gtk_label_ensure_select_info (GtkLabel *self);static void gtk_label_clear_select_info (GtkLabel *self);static void gtk_label_clear_provider_info (GtkLabel *self);static void gtk_label_clear_layout (GtkLabel *self);static void gtk_label_ensure_layout (GtkLabel *self);static void gtk_label_select_region_index (GtkLabel *self,int anchor_index,int end_index);static void gtk_label_update_active_link (GtkWidget *widget,double x,double y);static void gtk_label_setup_mnemonic (GtkLabel *self);/* For selectable labels: */ static void gtk_label_move_cursor (GtkLabel *self,int count,static void gtk_label_buildable_interface_init (GtkBuildableIface *iface);static GtkBuildableIface *buildable_parent_iface = NULL;static void gtk_label_accessible_init (GtkAccessibleInterface *iface);static void gtk_label_accessible_text_init (GtkAccessibleTextInterface *iface);static void gtk_label_accessible_hypertext_init (GtkAccessibleHypertextInterface *iface);static void int count)0 );"move-cursor" ,"(iib)" , step, count, FALSE );/* Selection-extending version */ "move-cursor" ,"(iib)" , step, count, TRUE );static void const GValue *value,switch (prop_id)case PROP_LABEL:break ;case PROP_ATTRIBUTES:break ;case PROP_USE_MARKUP:break ;case PROP_USE_UNDERLINE:break ;case PROP_JUSTIFY:break ;case PROP_WRAP:break ;case PROP_WRAP_MODE:break ;case PROP_NATURAL_WRAP_MODE:break ;case PROP_SELECTABLE:break ;case PROP_MNEMONIC_WIDGET:break ;case PROP_ELLIPSIZE:break ;case PROP_WIDTH_CHARS:break ;case PROP_SINGLE_LINE_MODE:break ;case PROP_MAX_WIDTH_CHARS:break ;case PROP_LINES:break ;case PROP_XALIGN:break ;case PROP_YALIGN:break ;case PROP_EXTRA_MENU:break ;case PROP_TABS:break ;default :break ;static void switch (prop_id)case PROP_LABEL:break ;case PROP_ATTRIBUTES:break ;case PROP_USE_MARKUP:break ;case PROP_USE_UNDERLINE:break ;case PROP_JUSTIFY:break ;case PROP_WRAP:break ;case PROP_WRAP_MODE:break ;case PROP_NATURAL_WRAP_MODE:break ;case PROP_SELECTABLE:break ;case PROP_MNEMONIC_KEYVAL:break ;case PROP_MNEMONIC_WIDGET:break ;case PROP_ELLIPSIZE:break ;case PROP_WIDTH_CHARS:break ;case PROP_SINGLE_LINE_MODE:break ;case PROP_MAX_WIDTH_CHARS:break ;case PROP_LINES:break ;case PROP_XALIGN:break ;case PROP_YALIGN:break ;case PROP_EXTRA_MENU:break ;case PROP_TABS:break ;default :break ;static void 1 ;1 ;"" );1 ;0 .5 ;0 .5 ;FALSE ;FALSE ;FALSE ;"" );FALSE ;static const GtkBuildableParser pango_parser =static gbooleanconst char *tagname,if (buildable_parent_iface->custom_tag_start (buildable, builder, child,return TRUE ;if (strcmp (tagname, "attributes" ) == 0 )"attributes" , "attributes" );1 );return TRUE ;return FALSE ;static void const char *tagname,if (strcmp (tagname, "attributes" ) == 0 )if (data->attrs)static void static void if (!self->select_info)return ;for (i = 0 ; i < self->select_info->n_links; i++)const GtkLabelLink *link = &self->select_info->links[i];if (link->visited)else if (link == self->select_info->active_link)if (self->select_info->link_clicked)else static void if (!self->select_info)return ;if (gtk_widget_is_sensitive (widget))if (self->select_info->active_link)"pointer" );else if (self->select_info->selectable)"text" );else else static void if (self->select_info)if (!gtk_widget_is_sensitive (widget))0 , 0 );if (self->select_info->selection_node)if (GTK_WIDGET_CLASS (gtk_label_parent_class)->state_flags_changed)static void if (self->layout == NULL)return ;if (self->select_info && self->select_info->links)for (i = 0 ; i < self->select_info->n_links; i++)const GtkLabelLink *link = &self->select_info->links[i];const GdkRGBA *link_color;if (link_attrs)for (l = attributes; l; l = l->next)65535 . + 0 .5 , 0 , 65535 ),65535 . + 0 .5 , 0 , 65535 ),65535 . + 0 .5 , 0 , 65535 ));if (link_color->alpha < 0 .999 )65535 . + 0 .5 , 0 , 65535 ));else if (!style_attrs)if (style_attrs)static void if (gtk_css_style_change_affects (change, GTK_CSS_AFFECTS_TEXT_ATTRS))change));else FALSE ;if (change == NULL || attrs_affected || (self->select_info && self->select_info->links))if (attrs_affected)static PangoDirectionfor (l = pango_layout_get_lines_readonly (self->layout); l; l = l->next)/* If self->select_info->selection_end is at the very end of * the line , we don ' t know if the cursor is on this line or * the next without looking ahead at the next line . ( End * of paragraph is different from line break . ) But it ' s * definitely in this paragraph , which is good enough * to figure out the resolved direction . if (pango_layout_line_get_start_index (line) + pango_layout_line_get_length (line) >= self->select_info->selection_end)return pango_layout_line_get_resolved_direction (line);return PANGO_DIRECTION_LTR;static int int pos)if (self->select_info)for (i = 0 ; i < self->select_info->n_links; i++)const GtkLabelLink *link = &self->select_info->links[i];if (link->start <= pos && pos < link->end)return i;return -1 ;static GtkLabelLink *int *out_index)int link_index;if (!info ||goto nope;if (link_index != -1 )if (out_index)return &info->links[link_index];if (out_index)1 ;return NULL;/** * gtk_label_get_measuring_layout : * @ self : the label * @ existing_layout : an existing layout already in use * @ width : the width to measure with , in Pango units , or - 1 for infinite * * Gets a layout that can be used for measuring sizes . * * The returned layout will be identical to the label ’ s layout except * for the layout ’ s width , which will be set to @ width . Do not modify * the returned layout . * * Returns : a Pango layout static PangoLayout *int width)if (existing_layout != NULL)if (existing_layout != self->layout)return existing_layout;if (pango_layout_get_width (self->layout) == width)return self->layout;/* We can use the label's own layout if we're not allocated a size yet, * because we don ' t need it to be properly setup at that point . * This way we can make use of caching upon the label ' s creation . if (gtk_widget_get_width (GTK_WIDGET (self)) <= 1 )return self->layout;/* oftentimes we want to measure a width that is far wider than the current width, * even though the layout would not change if we made it wider . In that case , we * can just return the current layout , because for measuring purposes , it will be * identical . if (!pango_layout_is_wrapped (self->layout) &&if (width == -1 )return g_object_ref (self->layout);if (rect.width <= width)return g_object_ref (self->layout);return copy;static int int char_width, digit_width;return MAX (char_width, digit_width);static void int *minimum,int *natural)int char_pixels;if (self->width_chars < 0 && self->max_width_chars < 0 )if (minimum)1 ;if (natural)1 ;return ;if (minimum)if (self->width_chars < 0 )1 ;else if (natural)if (self->max_width_chars < 0 )1 ;else static void int *minimum,int *natural,int *minimum_baseline,int *natural_baseline)int minimum_default, natural_default;1 if (orientation == GTK_ORIENTATION_HORIZONTAL)if (self->ellipsize)0 );/* yes, Pango ellipsizes even when that needs more space */ else if (minimum_default > *minimum)else static void int width,int *minimum_height,int *natural_height,int *minimum_baseline,int *natural_baseline)int natural_width, text_height, baseline;if (width < 0 )/* Minimum height is assuming infinite width */ 1 );/* Natural height is assuming natural width */ else /* minimum = natural for any given width */ static int int for_height,int min,int max)int mid, text_width, text_height;while (min < max)2 ;if (text_width > mid)else if (text_height > for_height)1 ;else return min * PANGO_SCALE;static void int height,int *minimum_width,int *natural_width)int minimum_default, natural_default;if (height < 0 )/* Minimum width is as many line breaks as possible */ 0 ));/* Natural width is natural width - or as wide as possible */ else int min, max;/* Can't use a measuring layout here, because we need to force /* binary search for the smallest width where the height doesn't 0 );1 );/* first, do natural width */ if (self->natural_wrap_mode == GTK_NATURAL_WRAP_NONE)else if (self->natural_wrap_mode == GTK_NATURAL_WRAP_WORD)/* then, do minimum width */ if (self->natural_wrap_mode == GTK_NATURAL_WRAP_INHERIT && self->ellipsize == PANGO_ELLIPSIZE_NONE)else idth);static void int for_size,int *minimum,int *natural,int *minimum_baseline,int *natural_baseline)if (for_size > 0 )if (!self->wrap)ne);else if (orientation == GTK_ORIENTATION_VERTICAL)line);else if (*minimum_baseline > 0 )if (*natural_baseline > 0 )void float *xp,float *yp)const int widget_width = gtk_widget_get_width (widget);const int widget_height = gtk_widget_get_height (widget);float xalign;int baseline;float x, y;if (_gtk_widget_get_direction (widget) != GTK_TEXT_DIR_LTR)1 .0 - xalign;if (baseline != -1 )int layout_baseline = pango_layout_get_baseline (self->layout) / PANGO_SCALE;/* yalign is 0 because we can't support yalign while baseline aligning */ else static void int width,int height,int baseline)if (self->layout)if (self->ellipsize || self->wrap)else 1 );if (self->popup_menu)#define GRAPHENE_RECT_FROM_RECT(_r) (GRAPHENE_RECT_INIT ((_r)->x, (_r)->y, (_r)->width, (_r)->height))static void float lx, ly;int width, height;if (!self->text || (*self->text == '\0' ))return ;if (!info)return ;if (info->selection_anchor != info->selection_end)int range[2 ];int i;0 ] = MIN (info->selection_anchor, info->selection_end);1 ] = MAX (info->selection_anchor, info->selection_end);0 , 0 , width, height);1 );for (i = 0 ; i < cairo_region_num_rectangles (range_clip); i++)else int range[2 ];int i;if (info->selectable &&if (active_link)0 ] = active_link->start;1 ] = active_link->end;0 , 0 , width, height);1 );for (i = 0 ; i < cairo_region_num_rectangles (range_clip); i++)if (focus_link && gtk_widget_has_visible_focus (widget))0 ] = focus_link->start;1 ] = focus_link->end;1 );static GtkSizeRequestModeif (self->wrap)return GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH;return GTK_SIZE_REQUEST_CONSTANT_SIZE;static void static void if (!self->select_info)return ;for (i = 0 ; i < self->select_info->n_links; i++)0 ;"link" );static void if (self->select_info && self->select_info->provider)static void if (self->select_info &&if (gdk_clipboard_get_content (clipboard) == self->select_info->provider)static gbooleanint range_start,int range_end,int *ellipsis_start,int *ellipsis_end)if (!self->ellipsize)return FALSE ;if (!pango_layout_is_ellipsized (self->layout))return FALSE ;FALSE ;do {if (run)if (item->offset <= range_start && range_end <= item->offset + item->length)if (item->analysis.flags & PANGO_ANALYSIS_FLAG_IS_ELLIPSIS)if (ellipsis_start)if (ellipsis_end)TRUE ;break ;else if (item->offset + item->length >= range_end)break ;while (pango_layout_iter_next_run (iter));return in_ellipsis;static gbooleanint range_start,int range_end)return range_is_in_ellipsis_full (self, range_start, range_end, NULL, NULL);static gbooleanif (self->select_info == NULL)return FALSE ;if (!GTK_WIDGET_CLASS (gtk_label_parent_class)->grab_focus (widget))return FALSE ;if (self->select_info->selectable)"gtk-label-select-on-focus" ,if (select_on_focus && !self->in_click &&0 , -1 );else if (self->select_info->links && !self->in_click &&for (i = 0 ; i < self->select_info->n_links; i++)const GtkLabelLink *link = &self->select_info->links[i];if (!range_is_in_ellipsis (self, link->start, link->end))break ;return TRUE ;static gbooleanint x,int y,int *index)int trailing = 0 ;const char *cluster;const char *cluster_end;float lx, ly;0 ;/* Translate x/y to layout position */ while (trailing)return inside;static gbooleanint x,int y,int index = -1 ;if (info && info->links)if (keyboard_tip)if (info->selection_anchor == info->selection_end)else if (!get_layout_index (self, x, y, &index))1 ;if (index != -1 )const int link_index = _gtk_label_get_link_at (self, index);if (link_index != -1 )const GtkLabelLink *link = &info->links[link_index];if (link->title)return TRUE ;return GTK_WIDGET_CLASS (gtk_label_parent_class)->query_tooltip (widget,static void if (link->accessible)static gbooleanFALSE ;if (focus_child)if (focus_in_child)return TRUE ;if (!gtk_widget_is_focus (widget))if (info)if (focus_link && direction == GTK_DIR_TAB_BACKWARD)int i;TRUE );for (i = info->n_links - 1 ; i >= 0 ; i--)if (!range_is_in_ellipsis (self, focus_link->start, focus_link->end))break ;return TRUE ;return FALSE ;if (!info)return FALSE ;if (info->selectable)int index;if (info->selection_anchor != info->selection_end)goto out;if (focus_link)FALSE );if (direction == GTK_DIR_TAB_FORWARD)for (i = 0 ; i < info->n_links; i++)if (link->start > index)TRUE );if (!range_is_in_ellipsis (self, link->start, link->end))return TRUE ;else if (direction == GTK_DIR_TAB_BACKWARD)int i;for (i = info->n_links - 1 ; i >= 0 ; i--)if (link->end < index)TRUE );if (!range_is_in_ellipsis (self, link->start, link->end))return TRUE ;goto out;else int focus_link_index;int new_index = -1 ;if (info->n_links == 0 )goto out;if (!focus_link)goto out;FALSE );switch (direction)case GTK_DIR_TAB_FORWARD:if (focus_link)1 ;else 0 ;if (new_index >= info->n_links)goto out;while (new_index < info->n_links)const GtkLabelLink *link = &info->links[new_index];if (!range_is_in_ellipsis (self, link->start, link->end))break ;break ;case GTK_DIR_TAB_BACKWARD:if (focus_link)1 ;else 1 ;if (new_index < 0 )goto out;while (new_index >= 0 )const GtkLabelLink *link = &info->links[new_index];if (!range_is_in_ellipsis (self, link->start, link->end))break ;break ;default :case GTK_DIR_UP:case GTK_DIR_DOWN:case GTK_DIR_LEFT:case GTK_DIR_RIGHT:goto out;if (new_index != -1 && new_index < info->n_links)TRUE );return TRUE ;return FALSE ;static void 0 , link->uri, &handled);/* signal handler might have invalidated the layout */ if (!self->layout)return ;if (handled && !link->visited &&TRUE ;static void const char *name,if (self->select_info)if (link)static void const char *name,if (self->select_info)if (link)static void const char *name,"copy-clipboard" );static gboolean0 , strlen (self->text));return gtk_label_get_selectable (self);static void const char *name,static void const char *name,static gbooleanif (self->mnemonic_widget)return gtk_widget_mnemonic_activate (self->mnemonic_widget, group_cycling);/* Not a label for something else, but is selectable, so set focus into * the label itself . if (gtk_label_get_selectable (self) && gtk_widget_get_focusable (widget))return gtk_label_grab_focus (widget);/* Try to find the widget to activate by traversing the * widget ' s ancestry . if (GTK_IS_NOTEBOOK (parent))return FALSE ;while (parent)if (gtk_widget_get_focusable (parent) ||return gtk_widget_mnemonic_activate (parent, group_cycling);/* barf if there was nothing to activate */ "Couldn't find a target for a mnemonic activation." );return FALSE ;static void const char *action_name,1 , -1 );static void /* The PangoContext is replaced when the display changes, so clear the layouts */ static void static void if (GTK_IS_FILE_LAUNCHER (source))else if (GTK_IS_URI_LAUNCHER (source))else if (!success)"Failed to launch handler: %s" , error->message);static gbooleanconst char *uri)const char *uri_scheme;if (!GTK_IS_WINDOW (toplevel))return FALSE ;if (g_strcmp0 (uri_scheme, "file" ) == 0 )else return TRUE ;static void if (link)else static void if (self->text && self->select_info)int start, end;int len;if (end > len)if (start > len)if (start != end)char *str = g_strndup (self->text + start, end - start);else if (link)static void static void class )class );class );class ->move_cursor = gtk_label_move_cursor;class ->copy_clipboard = gtk_label_copy_clipboard;class ->activate_link = gtk_label_activate_link;/** * GtkLabel : : move - cursor : * @ entry : the label which emitted the signal * @ step : the granularity of the move , as a ` GtkMovementStep ` * @ count : the number of @ step units to move * @ extend_selection : true if the move should extend the selection * * Gets emitted when the user initiates a cursor movement . * * The ` : : move - cursor ` signal is a [ keybinding signal ] ( class . SignalAction . html ) . * 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 * [ func @ GObject . 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 < kbd > Shift < / kbd > modifier extends the selection , * the variant without the < kbd > Shift < / kbd > modifier does not . * There are too many key combinations to list them all here . * * - < kbd > ← < / kbd > , < kbd > → < / kbd > , < kbd > ↑ < / kbd > , < kbd > ↓ < / kbd > * move by individual characters / lines * - < kbd > Ctrl < / kbd > + < kbd > ← < / kbd > , etc . move by words / paragraphs * - < kbd > Home < / kbd > and < kbd > End < / kbd > move to the ends of the buffer "move-cursor" ),3 ,/** * GtkLabel : : copy - clipboard : * @ self : the label which emitted the signal * * Gets emitted to copy the selection to the clipboard . * * The ` : : copy - clipboard ` signal is a [ keybinding signal ] ( class . SignalAction . html ) . * * The default binding for this signal is < kbd > Ctrl < / kbd > + < kbd > c < / kbd > . "copy-clipboard" ),0 );/** * GtkLabel : : activate - current - link : * @ self : the label which emitted the signal * * Gets emitted when the user activates a link in the label . * * The ` : : activate - current - link ` is a [ keybinding signal ] ( class . SignalAction . html ) . * * 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 < kbd > Enter < / kbd > key . "activate-current-link" ),0 );/** * GtkLabel : : activate - link : * @ self : the label which emitted the signal * @ uri : the URI that is activated * * Gets emitted to activate a URI . * * Applications may connect to it to override the default behaviour , * which is to call [ method @ Gtk . FileLauncher . launch ] . * * Returns : true if the link has been activated "activate-link" ),1 , G_TYPE_STRING);/** * GtkLabel : label : * * The contents of the label . * * If the string contains Pango markup ( see [ func @ Pango . parse_markup ] ) , * you will have to set the [ property @ Gtk . Label : use - markup ] property to * true in order for the label to display the markup attributes . See also * [ method @ Gtk . Label . set_markup ] for a convenience function that sets both * this property and the [ property @ Gtk . Label : use - markup ] property at the * same time . * * If the string contains underlines acting as mnemonics , you will have to * set the [ property @ Gtk . Label : use - underline ] property to true in order * for the label to display them . "label" , NULL, NULL,"" ,/** * GtkLabel : attributes : * * A list of style attributes to apply to the text of the label . "attributes" , NULL, NULL,/** * GtkLabel : use - markup : * * True if the text of the label includes Pango markup . * * See [ func @ Pango . parse_markup ] . "use-markup" , NULL, NULL,FALSE ,/** * GtkLabel : use - underline : * * True if the text of the label indicates a mnemonic with an ` _ ` * before the mnemonic character . "use-underline" , NULL, NULL,FALSE ,/** * GtkLabel : 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 [ property @ Gtk . Label : xalign ] for that . "justify" , NULL, NULL,/** * GtkLabel : xalign : * * The horizontal alignment of the label text inside its size allocation . * * Compare this to [ property @ Gtk . Widget : halign ] , which determines how the * labels size allocation is positioned in the space available for the label . "xalign" , NULL, NULL,0 .0 , 1 .0 ,0 .5 ,/** * GtkLabel : yalign : * * The vertical alignment of the label text inside its size allocation . * * Compare this to [ property @ Gtk . Widget : valign ] , which determines how the * labels size allocation is positioned in the space available for the label . "yalign" , NULL, NULL,0 .0 , 1 .0 ,0 .5 ,/** * GtkLabel : wrap : * * True if the label text will wrap if it gets too wide . "wrap" , NULL, NULL,FALSE ,/** * GtkLabel : wrap - mode : * * Controls how the line wrapping is done . * * This only affects the formatting if line wrapping is on ( see the * [ property @ Gtk . Label : wrap ] property ) . The default is [ enum @ Pango . WrapMode . word ] , * which means wrap on word boundaries . * * For sizing behavior , also consider the [ property @ Gtk . Label : natural - wrap - mode ] * property . "wrap-mode" , NULL, NULL,/** * GtkLabel : 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 [ property @ Gtk . Label : wrap - mode ] property . * * The default is [ enum @ Gtk . NaturalWrapMode . inherit ] , which inherits * the behavior of the [ property @ Gtk . Label : wrap - mode ] property . * * Since : 4 . 6 "natural-wrap-mode" , NULL, NULL,/** * GtkLabel : selectable : * * Whether the label text can be selected with the mouse . "selectable" , NULL, NULL,FALSE ,/** * GtkLabel : mnemonic - keyval : * * The mnemonic accelerator key for the label . "mnemonic-keyval" , NULL, NULL,0 , G_MAXUINT,/** * GtkLabel : mnemonic - widget : * * The widget to be activated when the labels mnemonic key is pressed . "mnemonic-widget" , NULL, NULL,/** * GtkLabel : 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 * [ enum . 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 [ property @ Gtk . NotebookPage : tab - expand ] child property is set to true . * * Other ways to set a label ' s width are [ method @ Gtk . Widget . set_size_request ] * and [ method @ Gtk . Label . set_width_chars ] . "ellipsize" , NULL, NULL,/** * GtkLabel : 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 ] ( class . Label . html # text - layout ) for details * of how [ property @ Gtk . Label : width - chars ] and [ property @ Gtk . Label : max - width - chars ] * determine the width of ellipsized and wrapped labels . "width-chars" , NULL, NULL,1 , G_MAXINT,1 ,/** * GtkLabel : 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 . "single-line-mode" , NULL, NULL,FALSE ,/** * GtkLabel : 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 ] ( class . Label . html # text - layout ) for details * of how [ property @ Gtk . Label : width - chars ] and [ property @ Gtk . Label : max - width - chars ] * determine the width of ellipsized and wrapped labels . "max-width-chars" , NULL, NULL,1 , G_MAXINT,1 ,/** * GtkLabel : lines : * * The number of lines to which an ellipsized , wrapping label * should display before it gets ellipsized . This both prevents the label * from ellipsizing before this many lines are displayed , and limits the * height request of the label to this many lines . * * : : : warning * Setting this property has unintuitive and unfortunate consequences * for the minimum _ width_ of the label . Specifically , if the height * of the label is such that it fits a smaller number of lines than * the value of this property , the label can not be ellipsized at all , * which means it must be wide enough to fit all the text fully . * * 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 . "lines" , NULL, NULL,1 , G_MAXINT,1 ,/** * GtkLabel : extra - menu : * * A menu model whose contents will be appended to the context menu . "extra-menu" , NULL, NULL,/** * GtkLabel : tabs : * * Custom tabs for this label . * * Since : 4 . 8 "tabs" , NULL, NULL,/** * GtkLabel | menu . popup : * * Opens the context menu . "menu.popup" , NULL, gtk_label_popup_menu);/* * Key bindings "menu.popup" ));/* Moving the insertion point */ 0 ,1 );0 ,1 );1 );1 );1 );1 );/* select all */ #ifdef __APPLE__#else #endif /* unselect all */ #ifdef __APPLE__"move-cursor" ,"(iib)" , GTK_MOVEMENT_PARAGRAPH_ENDS, 0 , FALSE );#else "move-cursor" ,"(iib)" , GTK_MOVEMENT_PARAGRAPH_ENDS, 0 , FALSE );"move-cursor" ,"(iib)" , GTK_MOVEMENT_PARAGRAPH_ENDS, 0 , FALSE );#endif 1 );1 );0 ,1 );0 ,1 );1 );1 );#ifdef __APPLE__1 );1 );1 );1 );1 );1 );#endif /* copy */ #ifdef __APPLE__"copy-clipboard" ,#else "copy-clipboard" ,#endif "activate-current-link" ,"label" ));"gtk-label-mnemonics-visible-connected" );/** * GtkLabel | clipboard . cut : * * Doesn ' t do anything , since text in labels can ' t be deleted . "clipboard.cut" , NULL,/** * GtkLabel | clipboard . copy : * * Copies the text to the clipboard . "clipboard.copy" , NULL,/** * GtkLabel | clipboard . paste : * * Doesn ' t do anything , since text in labels can ' t be edited . "clipboard.paste" , NULL,/** * GtkLabel | selection . delete : * * Doesn ' t do anything , since text in labels can ' t be deleted . "selection.delete" , NULL,/** * GtkLabel | selection . select - all : * * Selects all of the text , if the label allows selection . "selection.select-all" , NULL,/** * GtkLabel | link . open : * * Opens the link , when activated on a link inside the label . "link.open" , NULL,/** * GtkLabel | link . copy : * * Copies the link to the clipboard , when activated on a link * inside the label . "link.copy" , NULL,/** * gtk_label_new : * @ str : ( nullable ) : the text of the label * * Creates a new label with the given text inside it . * * You can pass ` NULL ` to get an empty label widget . * * Returns : the new label const char *str)if (str && *str)return GTK_WIDGET (self);/** * gtk_label_new_with_mnemonic : * @ str : ( nullable ) : the text of the label , with an underscore in front of the * mnemonic character * * Creates a new label with the given text inside it , and a mnemonic . * * 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 * [ method @ Gtk . Label . set_mnemonic_widget ] . * * If [ method @ Gtk . Label . 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 . * * Returns : the new label const char *str)if (str && *str)return GTK_WIDGET (self);static void if (GTK_IS_LABEL (widget))if (self->mnemonics_visible != visible)else for (child = gtk_widget_get_first_child (widget);if (GTK_IS_NATIVE (child))continue ;static void "mnemonics-visible" , &visible, NULL);static void if (self->mnemonic_keyval == GDK_KEY_VoidSymbol)if (self->mnemonic_controller)return ;if (self->mnemonic_controller == NULL)PTURE);er), GTK_SHORTCUT_SCOPE_MANAGED);oller), shortcut);else 0 ););/* Connect to notify::mnemonics-visible of the root */ if (!GTK_IS_WINDOW (native) && !GTK_IS_POPOVER (native))return ;/* always set up this widgets initial value */ "mnemonics-visible" , &mnemonics_visible, NULL);if (self->mnemonics_visible != mnemonics_visible)if (!connected)"notify::mnemonics-visible" ,1 ));static void /** * gtk_label_set_mnemonic_widget : * @ self : a label * @ widget : ( nullable ) : the target widget * * Associate the label with its mnemonic target . * * If the label has been set so that it has a mnemonic key ( using * i . e . [ method @ Gtk . Label . set_markup_with_mnemonic ] , * [ method @ Gtk . Label . set_text_with_mnemonic ] , * [ ctor @ Gtk . Label . new_with_mnemonic ] * or the [ property @ Gtk . Label : 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 [ class @ Gtk . Button ] or a * [ class @ Gtk . Notebook ] tab ) it is automatically associated with the * correct widget , but sometimes ( i . e . when the target is a [ class @ Gtk . Entry ] * next to the label ) you need to set it explicitly using this function . * * The target widget will be accelerated by emitting the * [ signal @ Gtk . Widget : : 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 . void if (self->mnemonic_widget == widget)return ;if (self->mnemonic_widget)if (self->mnemonic_widget)/** * gtk_label_get_mnemonic_widget : * @ self : a label * * Retrieves the mnemonic target of this label . * * See [ method @ Gtk . Label . set_mnemonic_widget ] . * * Returns : ( nullable ) ( transfer none ) : the target of the label ’ s mnemonic , * or ` NULL ` if none has been set and the default algorithm will be used . return self->mnemonic_widget;/** * gtk_label_get_mnemonic_keyval : * @ self : a label * * 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 ` return self->mnemonic_keyval;static void char *str)if (g_strcmp0 (self->text, str) == 0 )return ;if (gtk_accessible_role_get_naming (role) != GTK_ACCESSIBLE_NAME_PROHIBITED)1 );0 , 0 );static gbooleanconst char *str)if (g_strcmp0 (str, self->label) == 0 )return FALSE ;"" );return TRUE ;static gbooleanif (self->use_markup != val)return TRUE ;return FALSE ;static gbooleanif (self->use_underline != val)return TRUE ;return FALSE ;/* Calculates text, attrs and mnemonic_keyval from * label , use_underline and use_markup static void if (self->use_markup)else if (self->use_underline)char *text;1 );TRUE );else if (!self->use_underline)if (keyval != self->mnemonic_keyval)/** * gtk_label_set_text : * @ self : a label * @ str : the text to show in @ self * * Sets the text for the label . * * It overwrites any text that was there before and clears any * previously set mnemonic accelerators , and sets the * [ property @ Gtk . Label : use - underline ] and * [ property @ Gtk . Label : use - markup ] properties to false . * * Also see [ method @ Gtk . Label . set_markup ] . void const char *str)FALSE ) || changed;FALSE ) || changed;if (changed)/** * gtk_label_set_attributes : * @ self : a label * @ attrs : ( nullable ) : a list of style attributes * * 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 * [ property @ Gtk . Label : use - underline ] or [ property @ Gtk . Label : 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 . void if (!attrs && !self->attrs)return ;if (attrs)if (self->attrs)/** * gtk_label_get_attributes : * @ self : a label * * Gets the label ' s attribute list . * * This is the [ struct @ Pango . AttrList ] that was set on the label using * [ method @ Gtk . Label . set_attributes ] , if any . This function does not * reflect attributes that come from the label ' s markup ( see * [ method @ Gtk . Label . set_markup ] ) . If you want to get the effective * attributes for the label , use * ` pango_layout_get_attributes ( gtk_label_get_layout ( self ) ) ` . * * Returns : ( nullable ) ( transfer none ) : the attribute list return self->attrs;/** * gtk_label_set_label : * @ self : a label * @ str : the new text to set for the label * * Sets the text of the label . * * The label is interpreted as including embedded underlines and / or Pango * markup depending on the values of the [ property @ Gtk . Label : use - underline ] * and [ property @ Gtk . Label : use - markup ] properties . void const char *str)if (gtk_label_set_label_internal (self, str))/** * gtk_label_get_label : * @ self : a label * * Fetches the text from a label . * * The returned text includes any embedded underlines indicating * mnemonics and Pango markup . ( See [ method @ Gtk . Label . get_text ] ) . * * Returns : the text of the label widget const char *return self->label;typedef struct static char *const char *text,char *new_text;const char *p;char *q;FALSE ;1 );for (p = text; *p; p++)if (*p == '_' && !after_uline)TRUE ;continue ;if (after_uline && *p != '_' && *accel_key == 0 )FALSE ;if (after_uline)'_' ;'\0' ;return new_text;static void if (pdata->text_data->len > 0 )char *text;char *newtext;if (pdata->strip_ulines && strchr (pdata->text_data->str, '_' ))else if (text != pdata->text_data->str)0 );static void if (gtk_css_style_change_affects (change,static void if (gtk_css_style_change_affects (change, GTK_CSS_AFFECTS_REDRAW))static void static void const char *element_name,const char **attribute_names,const char **attribute_values,if (strcmp (element_name, "a" ) == 0 )const char *uri = NULL;const char *title = NULL;const char *class = NULL;FALSE ;int line_number;int char_number;int i;for (i = 0 ; attribute_names[i] != NULL; i++)const char *attr = attribute_names[i];if (strcmp (attr, "href" ) == 0 )else if (strcmp (attr, "title" ) == 0 )else if (strcmp (attr, "class" ) == 0 )class = attribute_values[i];else "Attribute '%s' is not allowed on the <a> tag " "on line %d char %d" ,return ;if (uri == NULL)"Attribute 'href' was missing on the <a> tag " "on line %d char %d" ,return ;FALSE ;if (self->select_info)for (i = 0 ; i < self->select_info->n_links; i++)const GtkLabelLink *l = &self->select_info->links[i];if (strcmp (uri, l->uri) == 0 )break ;if (!pdata->links)FALSE , TRUE , sizeof (GtkLabelLink));"link" ));if (class )class ));"style-changed" , G_CALLBACK (link_style_changed_cb), self);if (visited)else else int i;'<' );for (i = 0 ; attribute_names[i] != NULL; i++)const char *attr = attribute_names[i];const char *value = attribute_values[i];char *newvalue;1 );' ' );"=\" "); '\"' );'>' );static void const char *element_name,if (strcmp (element_name, "a" ) == 0 )1 );else "</" );'>' );static void const char *text,static const GMarkupParser markup_parser =static gbooleanchar c)return (c == ' ' || c == '\t' || c == '\n' || c == '\r' );static gbooleanconst char *str,char **new_str,const char *p, *end;0 ;"" );0 ;while (p != end && xml_isspace (*p))0 , &pdata, NULL);if (end - p >= 8 && strncmp (p, "<markup>" , 8 ) == 0 )if (!g_markup_parse_context_parse (context, str, length, error))goto failed;else if (!g_markup_parse_context_parse (context, "<markup>" , 8 , error))goto failed;if (!g_markup_parse_context_parse (context, str, length, error))goto failed;if (!g_markup_parse_context_parse (context, "</markup>" , 9 , error))goto failed;if (!g_markup_parse_context_end_parse (context, error))goto failed;TRUE );FALSE );if (pdata.links)FALSE );else if (accel_key)return TRUE ;TRUE );if (pdata.links)TRUE );return FALSE ;static void if (has_tooltip) {return ;for (i = 0 ; i < self->select_info->n_links; i++)const GtkLabelLink *link = &self->select_info->links[i];if (link->title)TRUE ;break ;static void const char *str,char *text = NULL;char *str_for_display = NULL;0 ;0 ;if (!parse_uri_markup (self, str,goto error_set;if (links)"link" );if (!pango_parse_markup (str_for_display, -1 ,'_' : 0 ,goto error_set;if (text)return ;"Failed to set text '%s' from markup due to error parsing markup: %s" ,/** * gtk_label_set_markup : * @ self : a label * @ str : the markup string * * Sets the labels text and attributes from markup . * * The string must be marked up with Pango markup * ( see [ func @ Pango . parse_markup ] ) . * * If @ str is external data , you may need to escape it * with [ func @ GLib . markup_escape_text ] or [ func @ GLib . markup_printf_escaped ] : * * ` ` ` 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 sets the [ property @ Gtk . Label : use - markup ] property * to true . * * Also see [ method @ Gtk . Label . set_text ] . void const char *str)TRUE ) || changed;FALSE ) || changed;if (changed)/** * gtk_label_set_markup_with_mnemonic : * @ self : a label * @ str : the markup string * * Sets the labels text , attributes and mnemonic from markup . * * Parses @ str which is marked up with Pango markup ( see [ func @ Pango . 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 [ method @ Gtk . Label . set_mnemonic_widget ] . void const char *str)TRUE ) || changed;TRUE ) || changed;if (changed)/** * gtk_label_get_text : * @ self : a label * * Gets the text of the label . * * The returned text is as it appears on screen . This does not include * any embedded underlines indicating mnemonics or Pango markup . ( See * [ method @ Gtk . Label . get_label ] ) * * Returns : the text in the label widget const char *return self->text;/** * gtk_label_set_justify : * @ self : a label * @ jtype : the new justification * * Sets the alignment of lines in the label relative to each other . * * This function has no effect on labels containing only a single line . * * [ enum @ Gtk . Justification . left ] is the default value when the widget * is first created with [ ctor @ Gtk . Label . new ] . * * If you instead want to set the alignment of the label as a whole , * use [ method @ Gtk . Widget . set_halign ] instead . void if ((GtkJustification) self->jtype != jtype)/* No real need to be this drastic, but easier than duplicating the code */ /** * gtk_label_get_justify : * @ self : a label * * Returns the justification of the label . * * See [ method @ Gtk . Label . set_justify ] . * * Returns : the justification value 0 );return self->jtype;/** * gtk_label_set_ellipsize : * @ self : a label * @ mode : the ellipsization mode * * Sets the mode used to ellipsize the text . * * The text will be ellipsized if there is not * enough space to render the entire string . void if ((PangoEllipsizeMode) self->ellipsize != mode)/* No real need to be this drastic, but easier than duplicating the code */ /** * gtk_label_get_ellipsize : * @ self : a label * * Returns the ellipsization mode of the label . * * See [ method @ Gtk . Label . set_ellipsize ] . * * Returns : the ellipsization mode return self->ellipsize;/** * gtk_label_set_width_chars : * @ self : a label * @ n_chars : the new desired width , in characters . * * Sets the desired width in characters of the label . void int n_chars)if (self->width_chars != n_chars)/** * gtk_label_get_width_chars : * @ self : a label * * Retrieves the desired width of the label in characters . * * See [ method @ Gtk . Label . set_width_chars ] . * * Returns : the desired width of the label , in characters int 1 );return self->width_chars;/** * gtk_label_set_max_width_chars : * @ self : a label * @ n_chars : the new maximum width , in characters . * * Sets the maximum width of the label in characters . void int n_chars)if (self->max_width_chars != n_chars)/** * gtk_label_get_max_width_chars : * @ self : a label * * Retrieves the maximum width of the label in characters . * * See [ method @ Gtk . Label . set_width_chars ] . * * Returns : the maximum width of the label , in characters int 1 );return self->max_width_chars;/** * gtk_label_set_wrap : * @ self : a label * @ wrap : whether to wrap lines * * Toggles line wrapping within the label . * * 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 widget ’ s width , because GTK widgets conceptually * can ’ t make their requisition depend on the parent widget ’ s size . * For a label that wraps at a specific position , set the label ’ s width * using [ method @ Gtk . Widget . set_size_request ] . void FALSE ;if (self->wrap != wrap)/** * gtk_label_get_wrap : * @ self : a label * * Returns whether lines in the label are automatically wrapped . * * See [ method @ Gtk . Label . set_wrap ] . * * Returns : true if the lines of the label are automatically wrapped FALSE );return self->wrap;/** * gtk_label_set_wrap_mode : * @ self : a label * @ wrap_mode : the line wrapping mode * * Controls how line wrapping is done . * * This only affects the label if line wrapping is on . ( See * [ method @ Gtk . Label . set_wrap ] ) * * The default is [ enum @ Pango . WrapMode . word ] , which means * wrap on word boundaries . * * For sizing behavior , also consider the * [ property @ Gtk . Label : natural - wrap - mode ] property . void if (self->wrap_mode != wrap_mode)/** * gtk_label_get_wrap_mode : * @ self : a label * * Returns line wrap mode used by the label . * * See [ method @ Gtk . Label . set_wrap_mode ] . * * Returns : the line wrap mode return self->wrap_mode;/** * gtk_label_set_natural_wrap_mode : * @ self : a label * @ wrap_mode : the line wrapping mode * * Selects the line wrapping for the natural size request . * * This only affects the natural size requested , for the actual wrapping used , * see the [ property @ Gtk . Label : wrap - mode ] property . * * Since : 4 . 6 void if (self->natural_wrap_mode != wrap_mode)/** * gtk_label_get_natural_wrap_mode : * @ self : a label * * Returns natural line wrap mode used by the label . * * See [ method @ Gtk . Label . set_natural_wrap_mode ] . * * Returns : the natural line wrap mode * * Since : 4 . 6 return self->natural_wrap_mode;static void static void if (self->layout)return ;switch (self->jtype)case GTK_JUSTIFY_LEFT:break ;case GTK_JUSTIFY_RIGHT:break ;case GTK_JUSTIFY_CENTER:break ;case GTK_JUSTIFY_FILL:TRUE );break ;default :if (self->lines > 0 )if (self->ellipsize || self->wrap)SCALE);/** * gtk_label_set_text_with_mnemonic : * @ self : a label * @ str : the text * * Sets the text for the label , with mnemonics . * * 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 [ method @ Gtk . Label . set_mnemonic_widget ] . void const char *str)FALSE ) || changed;TRUE ) || changed;if (changed)static int int start)int new_pos = g_utf8_pointer_to_offset (self->text, self->text + start);int length;1 );if (new_pos < length)const PangoLogAttr *log_attrs;int n_attrs;/* Find the next word end */ while (new_pos < n_attrs && !log_attrs[new_pos].is_word_end)return g_utf8_offset_to_pointer (self->text, new_pos) - self->text;static int int start)int new_pos = g_utf8_pointer_to_offset (self->text, self->text + start);if (new_pos > 0 )const PangoLogAttr *log_attrs;int n_attrs;1 ;/* Find the previous word beginning */ while (new_pos > 0 && !log_attrs[new_pos].is_word_start)return g_utf8_offset_to_pointer (self->text, new_pos) - self->text;static void int min, max;int start_index = gtk_label_move_backward_word (self, self->select_info->selection_end);int end_index = gtk_label_move_forward_word (self, self->select_info->selection_end);static void int n_press,double widget_x,double widget_y,if (info->active_link)if (gdk_event_triggers_context_menu (event))TRUE ;return ;else if (button == GDK_BUTTON_PRIMARY)TRUE ;if (!info->selectable)return ;if (!info->selectable)return ;FALSE ;FALSE ;if (gdk_event_triggers_context_menu (event))else if (button == GDK_BUTTON_PRIMARY)if (!gtk_widget_has_focus (widget))TRUE ;FALSE ;if (n_press == 3 )0 , strlen (self->text));else if (n_press == 2 )TRUE ;else return ;if (n_press >= 3 )static void int n_press,double x,double y,int index;if (info == NULL)return ;if (!gtk_gesture_handles_sequence (GTK_GESTURE (gesture), sequence))return ;if (n_press != 1 )return ;if (info->in_drag)FALSE ;else if (info->active_link &&FALSE ;static GdkPaintable *if ((self->select_info->selection_anchor !=int start, end;int len;if (end > len)if (start > len)return gtk_text_util_create_drag_icon (GTK_WIDGET (self), self->text + start, end - start);return NULL;static void double start_x,double start_y,int min, max, index;if (!info || !info->selectable)return ;if ((info->selection_anchor != info->selection_end) &&0 ))if (index > min && index < max)/* truncate selection, but keep it as big as possible */ if (index - min > max - index)else else /* extend (same as motion) */ /* ensure the anchor is opposite index */ if (index == min)int tmp = min;else if (min < max && min <= index && index <= max)if (!info->select_words)TRUE ;else /* start a replacement */ static void double offset_x,double offset_y,double x, y;int index;if (info == NULL || !info->selectable)return ;if (info->in_drag)if (gtk_drag_check_threshold_double (widget, info->drag_start_x, info->drag_start_y, x, y))0 , 0 );FALSE ;else if (index != info->selection_anchor)if (info->select_words)int min, max;int old_min, old_max;int anchor, end;if (min < old_min)else if (old_max < max)else if (anchor == old_min)if (anchor != min)else if (anchor != max)else static void if (self->select_info)else FALSE ;"clipboard.cut" , FALSE );"clipboard.copy" , has_selection);"clipboard.paste" , FALSE );"selection.select-all" ,"selection.delete" , FALSE );"link.open" , !has_selection && link);"link.copy" , !has_selection && link);static void double x,double y)int index;if (info == NULL)return ;if (info->links && !info->in_drag)FALSE ;if (info->selection_anchor == info->selection_end)if (get_layout_index (self, x, y, &index))const int link_index = _gtk_label_get_link_at (self, index);if (link_index != -1 )if (!range_is_in_ellipsis (self, link->start, link->end))TRUE ;if (found)if (info->active_link != link)FALSE ;else if (info->active_link != NULL)FALSE ;static void double x,double y,static void if (self->select_info)#define GTK_TYPE_LABEL_CONTENT (gtk_label_content_get_type ())#define GTK_LABEL_CONTENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_LABEL_CONTENT, GtkLabelContent))#define GTK_IS_LABEL_CONTENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_LABEL_CONTENT))#define GTK_LABEL_CONTENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_LABEL_CONTENT, GtkLabelContentClass))#define GTK_IS_LABEL_CONTENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_LABEL_CONTENT))#define GTK_LABEL_CONTENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_LABEL_CONTENT, GtkLabelContentClass))typedef struct _GtkLabelContent GtkLabelContent;typedef struct _GtkLabelContentClass GtkLabelContentClass;struct _GtkLabelContentstruct _GtkLabelContentClassvoid ) G_GNUC_CONST;static GdkContentFormats *if (content->label)return gdk_content_formats_new_for_gtype (G_TYPE_STRING);else return gdk_content_formats_new (NULL, 0 );static gbooleanif (G_VALUE_HOLDS (value, G_TYPE_STRING) &&if (self->select_info &&int start, end;int len;char *str;if (end > len)if (start > len)return TRUE ;return GDK_CONTENT_PROVIDER_CLASS (gtk_label_content_parent_class)->get_value (provider, value, error);static void if (self == NULL || self->select_info == NULL)return ;static void class )class );static void static void static void if (self->select_info == NULL)1 );TRUE );"drag-begin" ,"drag-update" ,e), TRUE );->drag_gesture));"pressed" ,"released" ,, 0 );re), TRUE );->click_gesture));"motion" ,"leave" ,"enter" ,"leave" ,->focus_controller));static void if (self->select_info == NULL)return ;if (!self->select_info->selectable && !self->select_info->links)nfo->drag_gesture));nfo->click_gesture)););;FALSE );static void if (self->select_info == NULL)return ;/** * gtk_label_set_selectable : * @ self : a label * @ setting : true to allow selecting text in the label * * Makes text in the label selectable . * * Selectable labels allow the user to select text from the label , * for copy - and - paste . void FALSE ;if (setting)TRUE ;TRUE ,1 );else if (old_setting)/* unselect, to give up the selection */ 0 , 0 );FALSE ;OPUP);if (setting != old_setting)/** * gtk_label_get_selectable : * @ self : a label * * Returns whether the label is selectable . * * Returns : true if the user can copy text from the label FALSE );return self->select_info && self->select_info->selectable;static void int anchor_index,int end_index)if (self->select_info && self->select_info->selectable)int s, e;/* Ensure that we treat an ellipsized region like a single * character with respect to selection . if (anchor_index < end_index)if (range_is_in_ellipsis_full (self, anchor_index, anchor_index + 1 , &s, &e))if (self->select_info->selection_anchor == s)else if (range_is_in_ellipsis_full (self, end_index - 1 , end_index, &s, &e))if (self->select_info->selection_end == e)else else if (end_index < anchor_index)if (range_is_in_ellipsis_full (self, end_index, end_index + 1 , &s, &e))if (self->select_info->selection_end == s)else if (range_is_in_ellipsis_full (self, anchor_index - 1 , anchor_index, &s, &e))if (self->select_info->selection_anchor == e)else else if (range_is_in_ellipsis_full (self, anchor_index, anchor_index, &s, &e))if (self->select_info->selection_anchor == s)else if (self->select_info->selection_anchor == e)else if (anchor_index - s < e - anchor_index)else if (self->select_info->selection_anchor == anchor_index &&return ;if (anchor_index != end_index)if (!self->select_info->selection_node)("selection" ));dget_node));"style-changed" ,else if (gdk_clipboard_get_content (clipboard) == self->select_info->provider)if (self->select_info->selection_node)/** * gtk_label_select_region : * @ self : a label * @ start_offset : start offset , in characters * @ end_offset : end offset , in characters * * Selects a range of characters in the label , if the label is selectable . * * See [ method @ Gtk . Label . 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 . void int start_offset,int end_offset)if (self->text && self->select_info)if (start_offset < 0 )1 );if (end_offset < 0 )1 );/** * gtk_label_get_selection_bounds : * @ self : a label * @ start : ( out ) ( optional ) : return location for start of selection * @ end : ( out ) ( optional ) : return location for end of selection * * Gets the selected range of characters in the label . * * The returned @ start and @ end positions are in characters . * * Returns : true if selection is non - empty int *start,int *end)FALSE );if (self->select_info == NULL)/* not a selectable label */ if (start)0 ;if (end)0 ;return FALSE ;else int start_index, end_index;int start_offset, end_offset;int len;if (end_index > len)if (start_index > len)if (start_offset > end_offset)int tmp = start_offset;if (start)if (end)return start_offset != end_offset;/** * gtk_label_get_layout : * @ self : a label * * 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 [ method @ Gtk . Label . get_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 : ( transfer none ) : the [ class @ Pango . Layout ] for this label return self->layout;/** * gtk_label_get_layout_offsets : * @ self : a label * @ x : ( out ) ( optional ) : location to store X offset of layout * @ y : ( out ) ( optional ) : location to store Y offset of layout * * Obtains the coordinates where the label will draw its Pango layout . * * The coordinates are useful to convert mouse events into coordinates * inside the [ class @ Pango . Layout ] , e . g . to take some action if some part * of the label is clicked . Remember when using the [ class @ Pango . Layout ] * functions you need to convert to and from pixels using ` PANGO_PIXELS ( ) ` * or [ const @ Pango . SCALE ] . void int *x,int *y)float local_x, local_y;if (x)int ) local_x;if (y)int ) local_y;/** * gtk_label_set_use_markup : * @ self : a label * @ setting : true if the label ’ s text should be parsed for markup . * * Sets whether the text of the label contains markup . * * See [ method @ Gtk . Label . set_markup ] . void if (gtk_label_set_use_markup_internal (self, !!setting))/** * gtk_label_get_use_markup : * @ self : a label * * Returns whether the label ’ s text is interpreted as Pango markup . * * See [ method @ Gtk . Label . set_use_markup ] . * * Returns : true if the label ’ s text will be parsed for markup FALSE );return self->use_markup;/** * gtk_label_set_use_underline : * @ self : a label * @ setting : true if underlines in the text indicate mnemonics * * Sets whether underlines in the text indicate mnemonics . void if (gtk_label_set_use_underline_internal (self, !!setting))/** * gtk_label_get_use_underline : * @ self : a label * * Returns whether underlines in the label indicate mnemonics . * * See [ method @ Gtk . Label . set_use_underline ] . * * Returns : true if underlines in the label indicate mnemonics FALSE );return self->use_underline;/** * gtk_label_set_single_line_mode : * @ self : a label * @ single_line_mode : true to enable single line mode * * Sets whether the label is in single line mode . void FALSE ;if (self->single_line_mode != single_line_mode)/** * gtk_label_get_single_line_mode : * @ self : a label * * Returns whether the label is in single line mode . * * Returns : true if the label is in single line mode FALSE );return self->single_line_mode;/* Compute the X position for an offset that corresponds to the more important * cursor position for that offset . We use this when trying to guess to which * end of the selection we should go to when the user hits the left or * right arrow key . static void int index,int *x,int *y)if (seat)else if (keyboard)else "gtk-split-cursor" , &split_cursor,if (split_cursor)else if (keymap_direction == cursor_direction)else static int int start,int count)int offset = g_utf8_pointer_to_offset (self->text, self->text + start);if (self->text)const PangoLogAttr *log_attrs;int n_attrs;int length;1 );while (count > 0 && offset < length)do while (offset < length && !log_attrs[offset].is_cursor_position);while (count < 0 && offset > 0 )do while (offset > 0 && !log_attrs[offset].is_cursor_position);return g_utf8_offset_to_pointer (self->text, offset) - self->text;static int int start,int count)int index;while (count != 0 )int new_index, new_trailing;"gtk-split-cursor" , &split_cursor,if (split_cursor)TRUE ;else if (seat)else if (keyboard)else if (count > 0 )0 , 1 , &new_index, &new_trailing);else 0 , -1 , &new_index, &new_trailing);if (new_index < 0 || new_index == G_MAXINT)break ;while (new_trailing--)return index;static void int count,int old_pos;int new_pos;if (self->select_info == NULL)return ;if (self->select_info->selection_end != self->select_info->selection_anchor &&/* If we have a current selection and aren't extending it, move to the * start / or end of the selection as appropriate switch (step)case GTK_MOVEMENT_VISUAL_POSITIONS:int end_x, end_y;int anchor_x, anchor_y;if (count < 0 )chor;else nchor;break ;case GTK_MOVEMENT_LOGICAL_POSITIONS:case GTK_MOVEMENT_WORDS:if (count < 0 )else break ;case GTK_MOVEMENT_DISPLAY_LINE_ENDS:case GTK_MOVEMENT_PARAGRAPH_ENDS:case GTK_MOVEMENT_BUFFER_ENDS:/* FIXME: Can do better here */ 0 ? 0 : strlen (self->text);break ;case GTK_MOVEMENT_DISPLAY_LINES:case GTK_MOVEMENT_PARAGRAPHS:case GTK_MOVEMENT_PAGES:case GTK_MOVEMENT_HORIZONTAL_PAGES:default :break ;else switch (step)case GTK_MOVEMENT_LOGICAL_POSITIONS:break ;case GTK_MOVEMENT_VISUAL_POSITIONS:if (new_pos == old_pos)if (!extend_selection)if (!gtk_widget_keynav_failed (GTK_WIDGET (self),0 ?if (root)0 ? GTK_DIR_RIGHT : GTK_DIR_LEFT);else break ;case GTK_MOVEMENT_WORDS:while (count > 0 )while (count < 0 )if (new_pos == old_pos)break ;case GTK_MOVEMENT_DISPLAY_LINE_ENDS:case GTK_MOVEMENT_PARAGRAPH_ENDS:case GTK_MOVEMENT_BUFFER_ENDS:/* FIXME: Can do better here */ 0 ? 0 : strlen (self->text);if (new_pos == old_pos)break ;case GTK_MOVEMENT_DISPLAY_LINES:case GTK_MOVEMENT_PARAGRAPHS:case GTK_MOVEMENT_PAGES:case GTK_MOVEMENT_HORIZONTAL_PAGES:default :break ;if (extend_selection)else static GMenuModel *"Cu_t" ), "clipboard.cut" );"_Copy" ), "clipboard.copy" );"_Paste" ), "clipboard.paste" );"_Delete" ), "selection.delete" );"Select _All" ), "selection.select-all" );"_Open Link" ), "link.open" );"hidden-when" , "s" , "action-disabled" );"Copy _Link Address" ), "link.copy" );"hidden-when" , "s" , "action-disabled" );if (self->extra_menu)return G_MENU_MODEL (joined);static void double x,double y)if (!self->select_info)return ;if (self->select_info->link_clicked)else if (!self->popup_menu)FALSE );"Context menu" ),1 );if (x != -1 && y != -1 )1 , 1 };else /** * gtk_label_get_current_uri : * @ self : a label * * Returns the URI for the 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 [ signal @ Gtk . Label : : activate - link ] * handler or for use in a [ signal @ Gtk . Widget : : query - tooltip ] handler . * * Returns : ( nullable ) : the active URI const char *const GtkLabelLink *link;if (!self->select_info)return NULL;if (!self->select_info->link_clicked && self->select_info->selectable)else if (link)return link->uri;return NULL;int if (self->select_info && self->select_info->selectable)return g_utf8_pointer_to_offset (self->text,return 0 ;int if (self->select_info && self->select_info->selectable)return g_utf8_pointer_to_offset (self->text,return 0 ;/** * gtk_label_set_lines : * @ self : a label * @ lines : the desired number of lines , or - 1 * * 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 . void int lines)if (self->lines != lines)/** * gtk_label_get_lines : * @ self : a label * * Gets the number of lines to which an ellipsized , wrapping * label should be limited . * * See [ method @ Gtk . Label . set_lines ] . * * Returns : the number of lines int 1 );return self->lines;/** * gtk_label_set_xalign : * @ self : a label * @ xalign : the new xalign value , between 0 and 1 * * Sets the ` xalign ` of the label . * * See the [ property @ Gtk . Label : xalign ] property . void float xalign)0 .0 , 1 .0 );if (self->xalign == xalign)return ;/** * gtk_label_get_xalign : * @ self : a label * * Gets the ` xalign ` of the label . * * See the [ property @ Gtk . Label : xalign ] property . * * Returns : the xalign value float 0 .5 );return self->xalign;/** * gtk_label_set_yalign : * @ self : a label * @ yalign : the new yalign value , between 0 and 1 * * Sets the ` yalign ` of the label . * * See the [ property @ Gtk . Label : yalign ] property . void float yalign)0 .0 , 1 .0 );if (self->yalign == yalign)return ;/** * gtk_label_get_yalign : * @ self : a label * * Gets the ` yalign ` of the label . * * See the [ property @ Gtk . Label : yalign ] property . * * Returns : the yalign value float 0 .5 );return self->yalign;/** * gtk_label_set_extra_menu : * @ self : a label * @ model : ( nullable ) : a menu model * * Sets a menu model to add to the context menu of the label . void if (g_set_object (&self->extra_menu, model))/** * gtk_label_get_extra_menu : * @ self : a label * * Gets the extra menu model of the label . * * See [ method @ Gtk . Label . set_extra_menu ] . * * Returns : ( transfer none ) ( nullable ) : the menu model return self->extra_menu;/** * gtk_label_set_tabs : * @ self : a label * @ tabs : ( nullable ) : tab stops * * Sets tab stops for the label . * * Since : 4 . 8 void if (self->tabs == tabs)return ;if (self->tabs)/** * gtk_label_get_tabs : * @ self : a label * * Gets the tab stops for the label . * * The returned array will be ` NULL ` if “ standard ” ( 8 - space ) tabs are used . * * Returns : ( nullable ) ( transfer full ) : copy of default tab array , * or ` NULL ` if standard tabs are used * * Since : 4 . 8 return self->tabs ? pango_tab_array_copy (self->tabs) : NULL;/* {{{ GtkAccessible implementation */ static void if (!link->accessible)x, link->uri, &range);if (index + 1 < self->select_info->n_links)1 ];1 );if (link->title)1 );TRUE );if (link == gtk_label_get_focus_link (self, NULL))TRUE );static GtkAccessible *if (label->select_info && label->select_info->links &&0 < label->select_info->n_links)0 ];0 );return GTK_ACCESSIBLE (g_object_ref (link->accessible));return NULL;static void ;/* }}} */ /* {{{ GtkAccessibleText implementation */ static GBytes *unsigned int start,unsigned int end)const char *text;int len;char *string;1 );0 , len);0 , len);if (end <= start)"" );1 ;else const char *p, *q;1 ;return g_bytes_new_take (string, size);static GBytes *unsigned int offset,unsigned int *start,unsigned int *end)char *string = gtk_pango_get_string_at (layout, offset, granularity, start, end);return g_bytes_new_take (string, strlen (string));static unsigned return _gtk_label_get_cursor_position (GTK_LABEL (self));static gbooleanint start, end;if (!gtk_label_get_selection_bounds (GTK_LABEL (self), &start, &end))return FALSE ;1 ;1 );0 ].start = start;0 ].length = end - start;return TRUE ;static void char ***attribute_names,char ***attribute_values)char **names, **values;static gbooleanunsigned int offset,char ***attribute_names,char ***attribute_values)unsigned int start, end;char **names, **values;for (unsigned i = 0 ; i < *n_ranges; i++)return TRUE ;static gbooleanunsigned int start,unsigned int end,const char *text;float lx, ly;int range[2 ];0 ] = g_utf8_pointer_to_offset (text, text + start);1 ] = g_utf8_pointer_to_offset (text, text + end);1 );return TRUE ;static gbooleanconst graphene_point_t *point,unsigned int *offset)int index;if (!get_layout_index (label, roundf (point->x), roundf (point->y), &index))return FALSE ;unsigned int ) g_utf8_pointer_to_offset (label->text, label->text + index);return TRUE ;static gbooleanunsigned int offset)int index;if (!gtk_label_get_selectable (label))return FALSE ;return TRUE ;static gbooleanint index1, index2;if (!gtk_label_get_selectable (label))return FALSE ;if (i != 0 )return FALSE ;return TRUE ;static void /* }}} */ /* {{{ GtkAccessibleHypertext implementation */ static unsigned int if (label->select_info && label->select_info->links)return label->select_info->n_links;return 0 ;static GtkAccessibleHyperlink *unsigned int index)if (label->select_info && label->select_info->links &&return GTK_ACCESSIBLE_HYPERLINK (link->accessible);return NULL;static unsigned int unsigned int offset)int pos;int link_index;if (link_index != -1 )return (unsigned int ) link_index;return G_MAXUINT;static void /* }}} */ /* vim:set foldmethod=marker: */
Messung V0.5 in Prozent C=98 H=96 G=96
¤ Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.0.300Bemerkung:
(vorverarbeitet am 2026-07-03)
¤ *Bot Zugriff
