GtkEntry

typedef struct _GtkEntry GtkEntry;

La structure  GtkEntry contient seulement des données privées.

gtk_entry_new ()

GtkWidget*          gtk_entry_new                       (void);

Crée une nouvelle entrée.

gtk_entry_new_with_max_length ()

GtkWidget*          gtk_entry_new_with_max_length       (gint max);

Crée une nouveau widget GtkEntry avec une longueur maximale donnée.

Note: L'existance de cette fonction  est contradictoire  avec le reste de l'API GTK+. La configuration normale devrait seulement demander à l'utilisateur de faire un appel supplémentaire de gtk_entry_set_max_length() à la place. La suppression de cette fonction n'est pas à l'ordre du jour mais il est préférable de ne pas l'utiliser.

gtk_entry_set_text ()

void                gtk_entry_set_text                  (GtkEntry *entry,
                                                         const gchar *text);

Définit le text du le widget à une valeur donnée  remplaçant le contenu courant.

gtk_entry_append_text ()

void                gtk_entry_append_text               (GtkEntry *entry,
                                                         const gchar *text);

Ajoute le texte donné au contenu du widget.

gtk_entry_prepend_text ()

void                gtk_entry_prepend_text              (GtkEntry *entry,
                                                         const gchar *text);

Ajoute au début un texte donné au contenu du widget.

gtk_entry_set_position ()

void                gtk_entry_set_position              (GtkEntry *entry,
                                                         gint position);

Définit la position du curseur dans l'entrée à une valeur donnée. Cette fonction est obsolète. Vous devez utiliser  gtk_editable_set_position() à la place.

gtk_entry_get_text ()

const gchar*        gtk_entry_get_text                  (GtkEntry *entry);

Recherche le contenu d'un widget d'entrée. Voir aussi gtk_editable_get_chars().

gtk_entry_select_region ()

void                gtk_entry_select_region             (GtkEntry *entry,
                                                         gint start,
                                                         gint end);

Sélectionne une région du texte. Les carcatères sélectionnés  sont les carcatères qui se situent aux positions comprise entre  start_pos et  end_pos non inclus. Si  end_pos estnégatif alors les caractères sélectionnés seront les caractères compris entre  start_pos et le fin du texte. Cette fonction est onsol_te; Vous devez utiliser  gtk_editable_select_region() à la place.

gtk_entry_set_visibility ()

void                gtk_entry_set_visibility            (GtkEntry *entry,
                                                         gboolean visible);

Définit si le contenu de l'entrée est visible ou non. Quand la visibilité est définie à FALSE, les caractères sont affichés  en caractères invisibles, et apparaîtront également comme cela quand le texte du widget d'entrée sera copié quelque part.

Le carcatère invisible par défaut est l'asterisque '*',  mais il peut être changé avec  gtk_entry_set_invisible_char().

gtk_entry_set_invisible_char ()

void                gtk_entry_set_invisible_char        (GtkEntry *entry,
                                                         gunichar ch);

Définit le caractère utilisé à la place du texte quand  gtk_entry_set_visibility() a été appelée pour définir la visibilité du texte à FALSE, ainsi c'est le caractère utilisé en mode "mot de passe" pour montrer à l'utilisateur combien de caractères ont déjà été entrés. Le caractère invisible par défaut est l'astérisque ('*'). Si vous définissez le caractère d'invisibilité à  0, alors l'utilisateur n'aura aucun retour; le texte ne sera pas affiché quand il sera tapé.

gtk_entry_set_editable ()

void                gtk_entry_set_editable              (GtkEntry *entry,
                                                         gboolean editable);

Détermine si l'utilisateur peut éditer ou non le texte dans un widget éditable. Cette fonction est obsolète.Vous devez utiliser  gtk_editable_set_editable() à la place.

gtk_entry_set_max_length ()

void                gtk_entry_set_max_length            (GtkEntry *entry,
                                                         gint max);

Définit la longueur maximale possible pour le contenu du widget. Si le contenu courant est plus long que la longueur donnéealors il sera tronqué pour s'adapter.

gtk_entry_get_activates_default ()

gboolean            gtk_entry_get_activates_default     (GtkEntry *entry);

Recherche la valeur définie par gtk_entry_set_activates_default().

gtk_entry_get_has_frame ()

gboolean            gtk_entry_get_has_frame             (GtkEntry *entry);

Renvoie la valeur définie par  gtk_entry_set_has_frame().

gtk_entry_get_inner_border ()

const GtkBorder*    gtk_entry_get_inner_border          (GtkEntry *entry);

Cette fonction retourne les propriétés de l'intérieur des bords de l'entrée. Voir  gtk_entry_set_inner_border() pour plus d'informations.

Depuis 2.10

gtk_entry_get_width_chars ()

gint                gtk_entry_get_width_chars           (GtkEntry *entry);

Renvoie la valeur définie par  gtk_entry_set_width_chars().

gtk_entry_set_activates_default ()

void                gtk_entry_set_activates_default     (GtkEntry *entry,
                                                         gboolean setting);

Si  setting est TRUE, en pressant Entrée pour l'entryqui activera le widget par défaut pour la fenêtre contenant l'entrée. Cela signifie généralement que la boîte de dialogue contenant l'entrée sera fermée, puisque le widget par défaut est généralement un des boutons de la boîte de dialogue.

(Pour les experts : si setting est TRUE, l'entrée appelle  gtk_window_activate_default() sur la fenêtre contenant l'entrée, dans le gestionnaire par défaut pour le signal "activate".)

gtk_entry_set_has_frame ()

void                gtk_entry_set_has_frame             (GtkEntry *entry,
                                                         gboolean setting);

Définit si l'entrée est entourée de bords biseautés.

gtk_entry_set_inner_border ()

void                gtk_entry_set_inner_border          (GtkEntry *entry,
                                                         const GtkBorder *border);

Définit les propriétés des bords internes de l'entry à border, ou les efface si NULL est passé. Le bord interne est l'aire autour de l'entrée de texte, mais pour son cadre intérieur.

Si elle est définie, cette propriété est prioritaire sur la propriété du style des bords interne. Cette priorité  est utile quand vous voulez éditer sur place du texte dans un   canvas ou un widget de liste, où le positionnement exact en pixel de l'entrée est important.

Depuis 2.10

gtk_entry_set_width_chars ()

void                gtk_entry_set_width_chars           (GtkEntry *entry,
                                                         gint n_chars);

Remplace la taille demandée pour une entrée par la taille nécessaire pour  n_chars caractères. Notez que pour ce changement de taille demandée, la taille dépendra de la façon dont le widget est placé dans les containers. Si n_chars est -1, la taille sera la taille par défaut de l'entrée.

gtk_entry_get_invisible_char ()

gunichar            gtk_entry_get_invisible_char        (GtkEntry *entry);

Recherche le caractère affiché à la place des vrais caractères pour des entrées définies avec une visibilité à false. Voir  gtk_entry_set_invisible_char().

gtk_entry_set_alignment ()

void                gtk_entry_set_alignment             (GtkEntry *entry,
                                                         gfloat xalign);

Définit l'alignement du contenu dans l'entrée. Cela contrôle la position horizontale du contenu quand le texte affiché est plus court que la largeur de l'entrée.

Depuis 2.4

gtk_entry_get_alignment ()

gfloat              gtk_entry_get_alignment             (GtkEntry *entry);

Renvoie la valeur définie par gtk_entry_set_alignment().

Depuis 2.4

gtk_entry_get_layout ()

PangoLayout*        gtk_entry_get_layout                (GtkEntry *entry);

Renvoie le  PangoLayout  utilisé pour afficher l'entrée. Le dispositif est utile  par exemple pour convertir les positions  texte à en positions en pixels, en association avec  gtk_entry_get_layout_offsets(). Le dispositif retourné appartient à l'entrée et ne doit pas être modifié ou libéré par l'appelant.

Gardez en  mémoire que le dispositif du texte contient une chaîne pré-éditée, aussi gtk_entry_layout_index_to_text_index() et gtk_entry_text_index_to_layout_index() sont nécessaires pour convertir les indices de byte dans le dispositif en indices de byte dans le contenu de l'entrée.

gtk_entry_get_layout_offsets ()

void                gtk_entry_get_layout_offsets        (GtkEntry *entry,
                                                         gint *x,
                                                         gint *y);

Obtient la position du PangoLayout utilisé pour rendre le texte dans l'entrée,ceci dans les coordonnées du widget. Cela est utile si vous voulez aligner le texte dans l'entrée avec un autre texte, par exemple en utilisant une entrée pour appliquer des cellules éditables dans un widget feuille.

C'est aussi utile pour convertir des événements de souris en coordonnées dans le PangoLayout, par exemple pour réaliser certaines actions si on clique sur une partie de l'entrée.

Notez quand l'utilisateur provoquera des glissements à l'intérieur de l'entrée, les offsets changeront; vous aurez besoin de connecter le signal "notify::scroll-offset" pour détecter cela. Rapellez vous que quand on utilise les fonctions  PangoLayout il est nécessaire de convertir  en pixels et  convertir des pixels en utilisant PANGO_PIXELS() ou PANGO_SCALE.

Retenez que le dispositif du texte doit contenir une chaîne pré-éditée, aussi  gtk_entry_layout_index_to_text_index() et gtk_entry_text_index_to_layout_index()sont nécessaires pour convertir les indices de byte dans le dispositif vers des indices de bytes dans le contenu de l'entrée.

gtk_entry_layout_index_to_text_index ()

gint                gtk_entry_layout_index_to_text_index
                                                        (GtkEntry *entry,
                                                         gint layout_index);

Convertit une position dans le contenu de l'entrée (retourné par  gtk_entry_get_text()) en position dans le  PangoLayout de l'entrée (retournée par  gtk_entry_get_layout(), avec le texte trouvé via  pango_layout_get_text()).

gtk_entry_text_index_to_layout_index ()

gint                gtk_entry_text_index_to_layout_index
                                                        (GtkEntry *entry,
                                                         gint text_index);

Converti une position du  PangoLayout de l'entrée (retournée par  gtk_entry_get_layout()) en position dans le contenu de l'entrée (retournée par gtk_entry_get_text()).

gtk_entry_get_max_length ()

gint                gtk_entry_get_max_length            (GtkEntry *entry);

Trouve la largeur maximale permise pour un texte dans  entry. Voir gtk_entry_set_max_length().

gtk_entry_get_visibility ()

gboolean            gtk_entry_get_visibility            (GtkEntry *entry);

Trouve si le texte dans l' entry est visible. Voir gtk_entry_set_visibility().

gtk_entry_set_completion ()

void                gtk_entry_set_completion            (GtkEntry *entry,
                                                         GtkEntryCompletion *completion);

Définit  completion pour qu'il soit l'objet auxiliaire d'accomplissement à utiliser avec  entry.Tout autre  configuration de méchanisme d'accomplissement est réalisé sur completion en utilisant l'API GtkEntryCompletion . L'accomplissement est désactivé si  completion est défini à  NULL.

Depuis 2.4

gtk_entry_get_completion ()

GtkEntryCompletion* gtk_entry_get_completion            (GtkEntry *entry);

Retourne l'objet auxiliaire d'accomplissement courant utilisé par  entry.

Depuis 2.4

The "activates-default" property

  "activates-default"        gboolean              : Lire / Ecrire

Si le widget par défaut est activé (comme un bouton par défaut dans une boîte de dialogue) quand Entrée est  pressé.

Valeur par défaut: FALSE

The "cursor-position" property

  "cursor-position"          gint                  : Lire

Position courante en chars du curseur inserré.

Valeurs permises  : [0,65535]

Valeur par défaut: 0

The "editable" property

  "editable"                 gboolean              : Lire / Ecrire

Si le contenu de l'entrée peut être édité.

Valeur par défaut: TRUE

The "has-frame" property

  "has-frame"                gboolean              : Lire / Ecrire

FALSE supprime le biseau extérieur de l'entrée.

Valeur par défaut: TRUE

The "inner-border" property

  "inner-border"             GtkBorder             : Lire / Ecrire

Définit les bords de l'aire du texte entre le texte et le cadre.

Depuis 2.10

The "invisible-char" property

  "invisible-char"           guint                 : Lire / Ecrire

Caractère utilisé quand le contenu de l'entrée est masqué (dans les "mots de passe").

Valeur par défaut: '*'

The "max-length" property

  "max-length"               gint                  : Lire / Ecrire

Nombre maximum de caractères pour l'entrée. Zéro s'il n'y a pas de maximum.

Valeurs permises  : [0,65535]

Valeur par défaut: 0

The "scroll-offset" property

  "scroll-offset"            gint                  : Lire

Nombre de pixels de l'entrée déplacé vers la gauche.

Valeurs permises  : >= 0

Valeur par défaut: 0

The "selection-bound" property

  "selection-bound"          gint                  : Lire

Position en chars de la fin opposée à la sélection du curseur.

Valeurs permises  : [0,65535]

Valeur par défaut: 0

The "text" property

  "text"                     gchararray            : Lire / Ecrire

Contenu de l'entrée.

Valeur par défaut: ""

The "truncate-multiline" property

  "truncate-multiline"       gboolean              : Lire / Ecrire

Quand TRUE est défini, pasted multi-line text is truncated to the first line.

Valeur par défaut: FALSE

Depuis 2.10

The "visibility" property

  "visibility"               gboolean              : Lire / Ecrire

FALSE affiche le "caractère invisible" à la place du texte actuel (mode mot de passe).

Valeur par défaut: TRUE

The "width-chars" property

  "width-chars"              gint                  : Lire / Ecrire

Nombre de caractères pour lesquels il faut laisser une place dans l'entrée.

Valeurs permises  : >= -1

Valeur par défaut: -1

The "xalign" property

  "xalign"                   gfloat                : Lire / Ecrire

Alignement horizontal, de 0 (gauche) à 1 (droite). Inversé pour le dispositif  RTL.

Creates a new GtkEntry widget.

Valeurs permises  : [0,1]

Valeur par défaut: 0

Depuis 2.4

The "inner-border" style property

  "inner-border"             GtkBorder             : Lire

Définit les bords de l'aire du texte entre le texte et le cadre.

The "activate" signal

void                user_function                      (GtkEntry *entry,
                                                        gpointer  user_data)      : Exécute Dernier / Action

The "backspace" signal

void                user_function                      (GtkEntry *entry,
                                                        gpointer  user_data)      : Exécute Dernier / Action

The "copy-clipboard" signal

void                user_function                      (GtkEntry *entry,
                                                        gpointer  user_data)      : Exécute Dernier / Action

The "cut-clipboard" signal

void                user_function                      (GtkEntry *entry,
                                                        gpointer  user_data)      : Exécute Dernier / Action

The "delete-from-cursor" signal

void                user_function                      (GtkEntry     *entry,
                                                        GtkDeleteType arg1,
                                                        gint          arg2,
                                                        gpointer      user_data)      : Exécute Dernier / Action

The "insert-at-cursor" signal

void                user_function                      (GtkEntry *entry,
                                                        gchar    *arg1,
                                                        gpointer  user_data)      : Exécute Dernier / Action

The "move-cursor" signal

void                user_function                      (GtkEntry       *entry,
                                                        GtkMovementStep arg1,
                                                        gint            arg2,
                                                        gboolean        arg3,
                                                        gpointer        user_data)      : Exécute Dernier / Action

The "paste-clipboard" signal

void                user_function                      (GtkEntry *entry,
                                                        gpointer  user_data)      : Exécute Dernier / Action

The "populate-popup" signal

void                user_function                      (GtkEntry *entry,
                                                        GtkMenu  *arg1,
                                                        gpointer  user_data)      : Exécute Dernier

The "toggle-overwrite" signal

void                user_function                      (GtkEntry *entry,
                                                        gpointer  user_data)      : Exécute Dernier / Action