Mnémoniques

Les labels peuvent contenir des mnémoniques. Les mnémoniques sont des caractères soulignés dans le label et utilisés pour la navigation clavier. Ils sont créés en fournissant une chaîne avec un underscore placé avant le carcatère du mnémonique, comme  "_Fichier", à la fonction gtk_label_new_with_mnemonic() ou gtk_label_set_text_with_mnemonic().

Les mnémoniques activent automatiquement tout widget activable et contenant le label, comme un  GtkButton; si le label n'est pas à l'intérieur du widget cible du mnémonique, vous devez signaler la cible en utilisant  gtk_label_set_mnemonic_widget(). Voici un exemple simple où le label est dans le bouton :

  /* Presser sur Alt+B activera le bouton */
  bouton = gtk_button_new ();
  label = gtk_label_new_with_mnemonic ("_Bonjour");
  gtk_container_add (GTK_CONTAINER (bouton), label);

Il existe une fonction pratique pour créer des boutons avec un label mnémonique déjà intégré :

  /* Presser sur Alt+B activera le bouton */
   bouton = gtk_button_new_with_mnemonic ("_Bonjour");

Pour créer un mnémonique pour un widget qui se situe à côté d'un label, comme un  GtkEntry, vous devez pointer le label sur l'entrée avec gtk_label_set_mnemonic_widget():

  /* Presser sur  Alt+B will donne le focus à l'entrée*/
  entree = gtk_entry_new ();
  label = gtk_label_new_with_mnemonic ("_Bonjour");
  gtk_label_set_mnemonic_widget (GTK_LABEL (label), entree);

Balises  (texte stylisé)

Pour facilité le formatage d'un texte pour un label (changer les couleurs, les polices, etc.) le texte du label peut être fourni  au format balisé. Voici comment créer un label avec une petite police :

  label = gtk_label_new (NULL);
  gtk_label_set_markup (GTK_LABEL (label), "<small>Petit texte</small>");

(Voir la documentation complète  des balises valides dans le manuel de Pango.)

La balise passé à  gtk_label_set_markup() doit être valide; par exemple, le caractères litéraux </>/& doivent être associés  à &lt;, &gt;, et &amp;. Si vous passez un texte provenant de l'utilisateur, d'un fichier ou d'un réseau à  gtk_label_set_markup(), vous devez le formater avec des caractères d'échapement avec g_markup_escape_text() ou g_markup_printf_escaped().

Les chaînes balisées sont un mode simple et pratique pour définir les PangoAttrList  dans un label; gtk_label_set_attributes() peut s'avérer encore plus simple dans certains cas. Faites attention cependant, PangoAttrList a tendance à provoquer des problèmes d'initialisation, à moins que vous appliquiez  les attributs à la chaîne entière ( c'est à dire à moins que  vous définissiez le rang de chaque attribut à  [0, G_MAXINT)). La raison est que la définition de l'index de départ et de l'index de fin pour un  PangoAttribute demande que la chaîne qui s'affiche soit entièrement connue, aussi la traduction posera des problèmes.

Labels sélectionnables

Les labels peuvent être rendus sélectionnables avec  gtk_label_set_selectable(). Ces labels permettent à l'utilisateur de copier le contenu du label dans le presse papier. Seuls les labels contenant des informations utiles — comme des messages d'erreur— peuvent être rendus sélectionnables.

Mise en page du texte

Un label peut contenir un certain nombre de  paragraphes, mais il y aura des problèmes d'exécution s'il en contient plus d'un petit nombre. Les paragraphes sont séparés par des interlignes ou d'autres séparateurs  acceptés par  Pango.

Les labels peuvent automatiquement formater le texte si vous appelez  gtk_label_set_line_wrap().

gtk_label_set_justify() dit comment les lignes dans le label s'alignent entre elles; Si vous voulez définir la façon dont le label place le texte dans l'espace disponible, consultez gtk_misc_set_alignment().

GtkLabel

typedef struct _GtkLabel GtkLabel;

Cette structure n'est pas accessible directement. Utilisez les fonctions décrites ci-dessous.

gtk_label_new ()

GtkWidget*          gtk_label_new                       (const gchar *str);

Crée un nouveau label avec le texte fourni. Vous pouvez passer  NULL pour obtenir un widget label vide.

gtk_label_set_text ()

void                gtk_label_set_text                  (GtkLabel *label,
                                                         const gchar *str);

Définit le texte à l'intérieur du widget  GtkLabel. Il a la priorité sur tout autre texte étant à cette place précédemment.

Cette fonction annule également tout accélérateur mnémonique défini préalablement.

gtk_label_set_attributes ()

void                gtk_label_set_attributes            (GtkLabel *label,
                                                         PangoAttrList *attrs);

Définit un  PangoAttrList; les attributs de la liste sont appliqués au texte du label. Les attributs définis avec cette fonction seront ignorés si la propriété  "use_underline"ou la propriété  "use_markup" est  TRUE.

gtk_label_set_markup ()

void                gtk_label_set_markup                (GtkLabel *label,
                                                         const gchar *str);

Analyse str qui est balisé avec  le langage Pango pour baliser le texte, les résultats de cette analyse définit le texte du label et la liste des attributs.  Si  str est une donnée externe, vous pourrez avoir besoin de l'échapper avec  g_markup_escape_text() ou g_markup_printf_escaped():

char *markup;

markup = g_markup_printf_escaped ("<span style=\"italic\">%s</span>", str);
gtk_label_set_markup (GTK_LABEL (label), markup);
g_free (markup);

gtk_label_set_markup_with_mnemonic ()

void                gtk_label_set_markup_with_mnemonic  (GtkLabel *label,
                                                         const gchar *str);

Analyse str qui est balisée avec  le langage Pango pour baliser le texte, les résultats de cette analyse définit le texte du label et la liste des attributs. Si les caratères de str sont précédés d'un underscore, ils seront soulignés pour indiquer qu'ils représentent un accélérateur clavier appelé mnémonique.

La touche mnémonique peut être utilisée pour activer un autre widget, choisit automatiquement ou explicitement en utilisant gtk_label_set_mnemonic_widget().

gtk_label_set_pattern ()

void                gtk_label_set_pattern               (GtkLabel *label,
                                                         const gchar *pattern);

Modèle de soulignement  pour le texte qui est à l'intérieur du widget  GtkLabel. Par exemple si le texte courant du label est "FooBarBaz" en passant le modèle "___ ___",  "Foo" et "Baz" seront soulignés mais pas "Bar".

gtk_label_set_justify ()

void                gtk_label_set_justify               (GtkLabel *label,
                                                         GtkJustification jtype);

Définit l'alignement des ligne du texte du label entre elles. GTK_JUSTIFY_LEFT est la valeur par défaut pour un widget is the default value quand le widget est créé avec  gtk_label_new(). Si vous voulez définir à la place un alignement du label dans son ensemble utilisez gtk_misc_set_alignment(). gtk_label_set_justify() n'a pas d'effet sur des labels contenant une seule ligne.

gtk_label_set_ellipsize ()

void                gtk_label_set_ellipsize             (GtkLabel *label,
                                                         PangoEllipsizeMode mode);

Définit le mode utilisé pour ajouter des points de suspension ("...") au texte s'il n'y a pas assez de place pour afficher  chaîne en entier.

Depuis  2.6

gtk_label_set_width_chars ()

void                gtk_label_set_width_chars           (GtkLabel *label,
                                                         gint n_chars);

Définit la largeur désirée en caractères pour le label en n_chars.

Depuis  2.6

gtk_label_set_max_width_chars ()

void                gtk_label_set_max_width_chars       (GtkLabel *label,
                                                         gint n_chars);

Définit la largeur maximum en caractère pour le  label en n_chars.

Depuis  2.6

gtk_label_get ()

void                gtk_label_get                       (GtkLabel *label,
                                                         gchar **str);

Renvoie la chaîne courante du texte du  GtkLabel et l'écrit dans l'argument donné str. It does not make a copy of this string so you must not write to it.

gtk_label_parse_uline ()

guint               gtk_label_parse_uline               (GtkLabel *label,
                                                         const gchar *string);

Analyse la chaîne donnée pour souligner et convertir le caractère qui suit en caractère souligné.La valeur de la touche minuscule  d'accélérateur su dernier caractère souligné sera retournée (c'est à dire que pour "_Fichier" la valeur de la touche  "f" sera retournée). Probablement, cela est utilisé seulement dans la bibliothèque GTK+ pour des items de menu par exemple.

gtk_label_set_line_wrap ()

void                gtk_label_set_line_wrap             (GtkLabel *label,
                                                         gboolean wrap);

Formate une ligne à l'intérieur du widget  GtkLabel . TRUE casse les lignes si le texte excède la taille du widget. FALSE laisse couper le bord du widget s'il excède la taille du widget.

Notez que le formatage de la ligne par  TRUE  n'implique pas que le label s'adapte  à la largeur de son  parent conteneur, parce que les widgets de  GTK+   ne peuvent pas demander à dépendre de la taille du parent conteneur. Pour qu'un label s'adapte à une position spécifique, définissez sa largeur avec gtk_widget_set_size_request().

gtk_label_set_line_wrap_mode ()

void                gtk_label_set_line_wrap_mode        (GtkLabel *label,
                                                         PangoWrapMode wrap_mode);

Si la ligne formaté est à l 'intérieur (voir gtk_label_set_line_wrap()) cette fonction contrôle comment le formatage se fait. Par défaut le mode est  PANGO_WRAP_WORD  ce qui correspond à un formatage  on word boundaries. (limites du mot).

Depuis  2.10

gtk_label_set

#define  gtk_label_set           gtk_label_set_text

Alias de  gtk_label_set_text(). Probablement utilisée pour revenir à une compatibilité avec  Gtk+ 1.0.x.

gtk_label_get_layout_offsets ()

void                gtk_label_get_layout_offsets        (GtkLabel *label,
                                                         gint *x,
                                                         gint *y);

Renvoie les coordonnées dans lesquelles le label dessinera le  PangoLayout représentant le texte du label ; cette fonction est utile pour convertir les événements de souris en coordonnées dans le  PangoLayout, par exemple pour amorcer certaines actions si on clique sur certaines parties du label. Bien sûr, vous aurez besoin de créer un  GtkEventBox pour recevoir les événements, et placer le label dedans puisque les labels son des widgets GTK_NO_WINDOW . Rappelez vous utilisez les fonctions de PangoLayout vous devez faire une conversion et utiliser  PANGO_PIXELS() ou PANGO_SCALE.

gtk_label_get_mnemonic_keyval ()

guint               gtk_label_get_mnemonic_keyval       (GtkLabel *label);

Si le label a été défini avec une touche mnémonique cette fonction retourne la valeur de la touche utilisée pour l'accélérateur mnémonique. S'il n'y a pas de mnémonique elle retourne GDK_VoidSymbol.

gtk_label_get_selectable ()

gboolean            gtk_label_get_selectable            (GtkLabel *label);

Renvoie la valeur définie par gtk_label_set_selectable().

gtk_label_get_text ()

const gchar*        gtk_label_get_text                  (GtkLabel *label);

Recherche le texte dans un widget label, comme il est affiché sur l'écran. Cela n'inclue aucun underscore signalant un mnémonique et aucune balise Pango. (voir gtk_label_get_label())

gtk_label_new_with_mnemonic ()

GtkWidget*          gtk_label_new_with_mnemonic         (const gchar *str);

Crée un nouveau  GtkLabel dont le texte est contenu dans   str.

Si les caractères de strsont précédés par un  underscore, ils sont soulignés. Si vous avez besoin d'un caractère underscore litéral dans la label, utilisez  '__' (deux underscores). Le premier soulignera le caractère représentant l'accélérateur clavier appelé mnémonique. La touche mnémonique peut être utilisée pour activer un autre widget choisi automatiquement ou explicitement en utilisant gtk_label_set_mnemonic_widget().

Si gtk_label_set_mnemonic_widget() n'est pas appelée, alors le premier ancêtre activable de  GtkLabelsera choisi comme widget mnémonique. Par exemple, si le label est dans un bouton ou un item de menu, le bouton ou l'item de menu deviendra automatiquement le widget mnémonique et sera activé par le mnémonique.

gtk_label_select_region ()

void                gtk_label_select_region             (GtkLabel *label,
                                                         gint start_offset,
                                                         gint end_offset);

Sélectionne une chaîne de caractères dans le label si le label est sélectionnable. Voir gtk_label_set_selectable(). Si le label n'est pas sélectionnable cette fonction n'aura pas d'effet. Si  start_offset ou end_offset sont à -1, alors la fin du label sera substituée.

gtk_label_set_mnemonic_widget ()

void                gtk_label_set_mnemonic_widget       (GtkLabel *label,
                                                         GtkWidget *widget);

Si un label a été définit avec une touche mnémonique (en utilisant par exemple  gtk_label_set_markup_with_mnemonic(), gtk_label_set_text_with_mnemonic(), gtk_label_new_with_mnemonic()ou la propriété "use_underline") le label peut être associé avec un widget qui sera la cible du mnémonique. Quan le label est à l'intérieur d'un widget (comme un  GtkButton ou une table  GtkNotebook ) il sera automatiquement associé avec le widget correct, mais quelques fois (par exemple quand la cible est une GtkEntry placée à côté d'un label) vous devez définir la cible explicitement en utilisant cette fonction.

Le widget cible sera accéléré en éméttant sur lui  "mnemonic_activate". Le gestionnaire pas défaut pour le signal activera le widget  s'il n'y a pas de collision mnémonique et de  focus à bascule entre les widgets qui sont au contact d'une autre façon.

gtk_label_set_selectable ()

void                gtk_label_set_selectable            (GtkLabel *label,
                                                         gboolean setting);

Les labels sélectionnables premettent à l'utilisateur de sélectionner du texte dans le label pour le copier-coller.

gtk_label_set_text_with_mnemonic ()

void                gtk_label_set_text_with_mnemonic    (GtkLabel *label,
                                                         const gchar *str);

Définit le texte du label de la chaîne str. Si les carcatères dans strsont précédés d'un underscore, ils sont soulignés ce qui indique qu'ils représente,t un accélérateur clavier appelé mnémonique. La touche mnémonique peut être utilisée pour activer un autre widget choisi automatiquement ou explicitement en utilisant gtk_label_set_mnemonic_widget().

gtk_label_get_attributes ()

PangoAttrList*      gtk_label_get_attributes            (GtkLabel *label);

Renvoie la liste d'attributs qui a été définie pour le label en utilisant  gtk_label_set_attributes() s'il y en a une. Cette fonction ne renvoie pas les attributs qui proviennent des balises des labels (voir gtk_label_set_markup()). Si vous voulez obtenir les attributs effectifs d'un label, utilisez  pango_layout_get_attribute (gtk_label_get_layout (label)).

gtk_label_get_justify ()

GtkJustification    gtk_label_get_justify               (GtkLabel *label);

Retourne la justification du label. Voir gtk_label_set_justify().

gtk_label_get_ellipsize ()

PangoEllipsizeMode  gtk_label_get_ellipsize             (GtkLabel *label);

Retourne la position de l'ellipse (...) du label. Voir gtk_label_set_ellipsize().

Depuis  2.6

gtk_label_get_width_chars ()

gint                gtk_label_get_width_chars           (GtkLabel *label);

Recherche la largeur désirée du  label, en caractères. Voir gtk_label_set_width_chars().

Depuis  2.6

gtk_label_get_max_width_chars ()

gint                gtk_label_get_max_width_chars       (GtkLabel *label);

Recherche la largeur maximale du of label, en caractères. Voir gtk_label_set_width_chars().

Depuis  2.6

gtk_label_get_label ()

const gchar*        gtk_label_get_label                 (GtkLabel *label);

Cherche le texte d'un widget label incluant toutes indication de soulignement et toutes balises Pango. (Voir gtk_label_get_text()).

gtk_label_get_layout ()

PangoLayout*        gtk_label_get_layout                (GtkLabel *label);

Renvoie le  PangoLayout affiché dans le label. Le calque est utile par exmple pour convertir les positions su texte en pixels, conjointement à l'utilisation de gtk_label_get_layout_offsets(). Le calque retourné appartient au label et ne doit pas être libéré par l'utilisateur.

gtk_label_get_line_wrap ()

gboolean            gtk_label_get_line_wrap             (GtkLabel *label);

Retourne si les lignes dans le label sont automatiquement formatées. Voir gtk_label_set_line_wrap().

gtk_label_get_line_wrap_mode ()

PangoWrapMode       gtk_label_get_line_wrap_mode        (GtkLabel *label);

Retourne le mode de formatage de ligne utilisé par le label. Voir gtk_label_set_line_wrap_mode().

Depuis  2.10

gtk_label_get_mnemonic_widget ()

GtkWidget*          gtk_label_get_mnemonic_widget       (GtkLabel *label);

Recherhe la cible du mnémonique (raccouirci clavier) du label. Voir gtk_label_set_mnemonic_widget().

gtk_label_get_selection_bounds ()

gboolean            gtk_label_get_selection_bounds      (GtkLabel *label,
                                                         gint *start,
                                                         gint *end);

Renvoie ma chaîne de caractères sélectionnée dans le label, retournant  TRUE s'il y a une sélection.

gtk_label_get_use_markup ()

gboolean            gtk_label_get_use_markup            (GtkLabel *label);

Retourne si le texte du label est interprété en tant que texte balisé avec le langage de balises Pango. Voir gtk_label_set_use_markup().

gtk_label_get_use_underline ()

gboolean            gtk_label_get_use_underline         (GtkLabel *label);

Retourne si un soulignement dans le label signale un mnémonique. Voir gtk_label_set_use_underline().

gtk_label_get_single_line_mode ()

gboolean            gtk_label_get_single_line_mode      (GtkLabel *label);

Retourne si le label ne peut contenir qu'une seule ligne.

Depuis  2.6

gtk_label_get_angle ()

gdouble             gtk_label_get_angle                 (GtkLabel *label);

Renvoie l'angle de rotation du label. Voir gtk_label_set_angle.

Depuis  2.6

gtk_label_set_label ()

void                gtk_label_set_label                 (GtkLabel *label,
                                                         const gchar *str);

Définit le texte du label. Le label est interprété comme incluant un soulignement et / ou des balises Pango suivant les valeurs de  label->utilise_soulignement et  label->utilise_balises.

gtk_label_set_use_markup ()

void                gtk_label_set_use_markup            (GtkLabel *label,
                                                         gboolean setting);

Définit si le texte du label contient des balises en langage balisé de Pango . Voir gtk_label_set_markup().

gtk_label_set_use_underline ()

void                gtk_label_set_use_underline         (GtkLabel *label,
                                                         gboolean setting);

Si true, un soulignement dans le texte signal que le carcatère qui suis doit être utilisé comme touche d'accélérateur mnémonique.

gtk_label_set_single_line_mode ()

void                gtk_label_set_single_line_mode      (GtkLabel *label,
                                                         gboolean single_line_mode);

Définit si le label est en mode "une ligne".

Depuis  2.6

gtk_label_set_angle ()

void                gtk_label_set_angle                 (GtkLabel *label,
                                                         gdouble angle);

Définit l'angle de rotation du label. Un angle de 90 définit une lecture de bas en haut, un angle de 270, une lecture de haut en bas. La définition de l'angle d'un l'abel est ignorée si le label est selectionnable,  wrapped, ou en mode elliptique(...).

Depuis  2.6

La propriété  "angle" 

  "angle"                    gdouble               : Lire /Ecrire

Angle que la base du label fait avec l'horizontale, en degrés, dans le sens des aiguilles d'une montre. The angle that the baseline of the label makes with the horizontal, in degrees, measured counterclockwise. Un angle de 90 définit une lecture de bas en haut, un angle de 270, une lecture de haut en bas. La définition de l'angle d'un l'abel est ignorée si le label est selectionnable,  wrapped, ou en mode elliptique(...).

Valeur possibles: [0,360]

Default value: 0

Depuis  2.6

La propriété  "attributes" 

  "attributes"               PangoAttrList         : Lire /Ecrire

Liste des attributs de style à appliquer au texte du label.

La propriété  "cursor-position" 

  "cursor-position"          gint                  : Lire

Position courante du curseur inserré en chars.

Valeurs possibles: >= 0

Default value: 0

La propriété  "ellipsize" 

  "ellipsize"                PangoEllipsizeMode    : Lire /Ecrire

 Place souhaîtée pour mettre des pint de suspension dans la chaîne si le label n'a pas assez de place pour afficher la chaîne entière ; spécifié comme un mode  PangoEllisizeMode.

Notez que la définition de cette propriété à une autre valeur que  PANGO_ELLIPSIZE_NONE sera respectée seulement s'il y a assez d'espace pour afficher l'esllipse  "...". En particulier , les labels avec ellipse ne fonctionne pas bien dans les tables des blocks-note, sauf si la propriété de table  ::tab-expand est définie à  TRUE. D'autres moyens de définir la largeur des labels est  gtk_widget_set_size_request() et gtk_label_set_width_chars().

Default value: PANGO_ELLIPSIZE_NONE

Depuis  2.6

La propriété  "justify" 

  "justify"                  GtkJustification      : Lire /Ecrire

L'alignement des lignes d'un texte de label l'une par rapport aux autres. Cela ne concerne pas l'alignement du label à l'intérieur de son contenant; pour cela voir GtkMisc::xalign .

Valeur par défaut : GTK_JUSTIFY_LEFT

La propriété  "label" 

  "label"                    gchararray            : Lire /Ecrire

Texte du label

Valeur par défaut: NULL

La propriété  "max-width-chars" 

  "max-width-chars"          gint                  : Lire /Ecrire

Largeur maximale désirée pour le label en caractères. Si cette propriété  est définie à  -1, la largeur sera calculer automatiquement, autrement le label demandera juste assez d'espace pour le nombre de caractères demandé. Si la propriété width-chars est définie à une valeur positive, alors la propriété  max-width-chars est ignorée.

Valeurs possibles: >= -1

Valeur par défaut: -1

Depuis  2.6

La propriété  "mnemonic-keyval" 

  "mnemonic-keyval"          guint                 : Lire

Touche d'accélérateur mnémonique pour ce label.

Valeur par défaut: 16777215

La propriété  "mnemonic-widget" 

  "mnemonic-widget"          GtkWidget             : Lire /Ecrire

Widegt à activer quand la touche mnémonique du label est préssée.

La propriété  "pattern" 

  "pattern"                  gchararray            : Ecrire

Valeur par défaut: NULL

La propriété  "selectable" 

  "selectable"               gboolean              : Lire /Ecrire

Si le texte du label peut être sélectionné avec la souris.

Valeur par défaut: FALSE

La propriété  "selection-bound" 

  "selection-bound"          gint                  : Lire

Position de la fin de la sélection, opposée au curseur en chars. 

Valeurs possibles: >= 0

Valeur par défaut: 0

La propriété  "single-line-mode" 

  "single-line-mode"         gboolean              : Lire /Ecrire

Si le label est en mode "ligne simple". En mode ligne simple, la hauteur du label ne dépend pas du texte, elle est toujours définit en fonction de la police. Cela peut être avantageux pendant le redimensionnement du label parce que les modification du texte peuvent être perturbantes, par exemple dans la barre des status.

Valeur par défaut: FALSE

Depuis  2.6

La propriété  "use-markup" 

  "use-markup"               gboolean              : Lire /Ecrire

Texte du label incluant des balises XML. Voir  pango_parse_markup().

Valeur par défaut: FALSE

La propriété  "use-underline" 

  "use-underline"            gboolean              : Lire /Ecrire

Si cette propriété est définie, un soulignement dans le texte indique que le prochain caractère est utilisé pour la touche d'accélérateur mnémonique.

Valeur par défaut: FALSE

La propriété  "width-chars" 

  "width-chars"              gint                  : Lire /Ecrire

La largeur désirée pour le label en caractères. Si cette propriété est définit à  -1, la largeur sera calculée automatiquement, autrement le label  demandera soit 3 caractères ou soit la valeur de la propriété qui sera plus grande. Si la propriété  width-chars  est définie à une valeur positive alors la propriété  max-width-chars est ignorée.

Valeurs possibles: >= -1

Valeur par défaut: -1

Depuis  2.6

La propriété  "wrap" 

"wrap"                     gboolean              : Lire /Ecrire

Si elle est définie, le lignes sont formatées si le texte est trop large.

Valeur par défaut: FALSE

La propriété  "wrap-mode" 

  "wrap-mode"                PangoWrapMode         : Lire /Ecrire

Si le formatage de la ligne est définit (voir la propriété de formatage (wrap) cette propriété contrôle comment le formatage est réalisé. La valeur par défaut est  PANGO_WRAP_WORD qui signifie formatage dans la limite des mots.

Valeur par défaut: PANGO_WRAP_WORD

Depuis  2.10

Le signal "copy-clipboard" 

void                user_function                      (GtkLabel *label,
                                                        gpointer  user_data)      : Exécuter Dernier / Action

Le signal "move-cursor" 

void                user_function                      (GtkLabel       *label,
                                                        GtkMovementStep arg1,
                                                        gint            arg2,
                                                        gboolean        arg3,
                                                        gpointer        user_data)      : Exécuter Dernier / Action

Le signal "populate-popup" 

void                user_function                      (GtkLabel *label,
                                                        GtkMenu  *arg1,
                                                        gpointer  user_data)      : Exécuter Dernier