GtkWindow

typedef struct _GtkWindow GtkWindow;

gtk_window_new ()

GtkWidget* gtk_window_new (GtkWindowType type);

Crée une nouvelle GtkWindow, qui est une fenêtre de niveau supérieur qui peut contenir d'autes widgets. Le type de la fenêtre est presque toujours  GTK_WINDOW_TOPLEVEL. Si vous appliquez un menu popup  from scratch (ce qui n'est pas une bonne idée, utilisez plutôt GtkMenu),  vous pouvez utiliser  GTK_WINDOW_POPUP. GTK_WINDOW_POPUP n'est pas fait pour les boîtes de dialogue, cependant dans certaines boîtes à outils les boîtes de dialogue sont appelées "popups". Dans GTK+, GTK_WINDOW_POPUP correspond à un menu  pop-up  ou à une boîte à outils  pop-up . Sur X11, les fenêtres popup  sont contrôlées par le gestionnaire de fenêtre.

Si vous voulez une fenêtre sans décoration ( pas de bords), utilisez  gtk_window_set_decorated(), n'utilisez pas GTK_WINDOW_POPUP.

gtk_window_set_title ()

void                gtk_window_set_title                (GtkWindow *window,
                                                         const gchar *title);

Définit le titre de  GtkWindow. Le titre d'une fenêtre est affiché dans sa barre de titre; dans le système X Window, la barre de titre est rendue par le gestionnaire de fenêtre,  ausi l'apparence exacte du titre peut varier en fonction de la configuration exacte de l'utilisateur. Le titre doit aider l'utilisateur à distinguer cette fenêtre des autres fenêtres ouvertes. Un bon titre peut inclure le nom de l'application et le nom de fichier du document courant, par exemple.

gtk_window_set_wmclass ()

void                gtk_window_set_wmclass              (GtkWindow *window,
                                                         const gchar *wmclass_name,
                                                         const gchar *wmclass_class);

N'utilisez pas cete fonction. Elle définit la "classe" du Système  X Window et le nom conseillé pour une fenêtre.  Selon l' ICCCM, vous devriez toujours configurer ces données à la même valeur pour toutes les fenêtres de l'application, et GTK+ les définit à une valeur par défaut, aussi l'appel de cette fonction est injustifié. Cependant, vous pouvez vouloir appeler  gtk_window_set_role()sur chaque fenêtre de l'application, on each window in your application, pour le gestionnaire de session. La configuration du rôle permet au gestionnaire de fenêtre de restorer la position d'une fenêtre pendant le chargement d'une session sauvegardée.

gtk_window_set_policy ()

void                gtk_window_set_policy               (GtkWindow *window,
                                                         gint allow_shrink,
                                                         gint allow_grow,
                                                         gint auto_shrink);

Modifie la réaction d'une fenêtre de niveau supérieur aux tentatives de redimensionnement par l'utilisateur. Il y a deux façon correctes d'appeler cette fonction :

La première méthode est la méthode par défaut, c'est à dire que les fenêtres par défaut sont dessinées pour être redimensionnées par les utilisateurs.

Cette fonction devrait simplement être: void gtk_window_set_resizable (GtkWindow* window, gboolean setting); ...c'est pourquoi GTK+ 2.0 a introduit gtk_window_set_resizable(), qui devrait être utilisée à la place de gtk_window_set_policy().

Si le paramètre allow_grow est  TRUE, l'utilisateur peut agrandir la fenêtre au delà des besoins de ses widgets enfants.  Si allow_grow est TRUE, assurez-vous  que vos widgets enfants fonctionnent correctement quand la fenêtre est redimensionnée.

Une fenêtre de niveau supérieur changera toujours de taille pour assurer à ses widgets enfants d'être à la taille demandée. Cela signigie que si vous ajoutez des widgets enfants, la fenêtre de niveau supérieur s'agrandira pour les recevoir. Cependant, une fenêtre de niveau supérieur ne réduit pas sa taille pour s'adapter à la taille de ses enfants si elle est trop grande; le paramètre auto_shrink provoque la réduction de la fenêtre quand les widgets enfants ont trop de place. auto_shrink est utilisé normalement avec la deuxième méthode mentionnée plus haut. Ainsi, définissez auto_shrink à TRUE si vous voulez que la fenêtre ait toujours une taille optimale déterminée par votre programme.

Notez que  auto_shrink ne fera rien si  allow_shrink et allow_grow sont tous les deux à FALSE.

Ni l'une ni l'autre des deux méthodes proposées ne définit le paramètre  allow_shrink à TRUE. Si allow_shrink est TRUE, l'utilisateur peut réduire la fenêtre et ainsi arriver à ce que les enfants ne puissent plus avoir la taille demandée; ce n'est pas une bonne chose parce que beaucoup de widgets s'afficheront mal si cela arrive. De plus GTK+ aura tendance à réagrandir la fenêtre si la taille est recalculée pour une raion ou une autre. Finalement  allow_shrink doit toujours être défini à  FALSE.

Quelques fois quand vous pensez avoir besoin d'utiliser  allow_shrink, le réel problème réside dans le fait qu'un  widget enfant spécifique demande trop de place, aussi l'utilisateur ne peut pas réduire la fenêtre suffisamment. Vous avez peut-être appelé  gtk_widget_set_size_request() pour un widget enfant en lui donnant une taille trop grande. A la place de définir la taille utilisateur d'un enfant,  employez gtk_window_set_default_size() pour que l'enfant obtienne un espace plus grand que ce qui est demandé.

gtk_window_set_resizable ()

void                gtk_window_set_resizable            (GtkWindow *window,
                                                         gboolean resizable);

Définit si l'utilisateur peut redimensionner la fenêtre. Les fenêtres sont redimensionnables pas l'utilisateur par défaut.

gtk_window_get_resizable ()

gboolean            gtk_window_get_resizable            (GtkWindow *window);

Donne la valeur définie par  gtk_window_set_resizable().

gtk_window_add_accel_group ()

void                gtk_window_add_accel_group          (GtkWindow *window,
                                                         GtkAccelGroup *accel_group);

Associe  accel_group avec window, pour qu'en appelant gtk_accel_groups_activate() sur window  les accélérateurs soient activées  dans accel_group.

gtk_window_remove_accel_group ()

void                gtk_window_remove_accel_group       (GtkWindow *window,
                                                         GtkAccelGroup *accel_group);

Inverse les effets de  gtk_window_add_accel_group().

gtk_window_position

#define	gtk_window_position			gtk_window_set_position

Alias déprécié de  gtk_window_set_position().

gtk_window_activate_focus ()

gboolean            gtk_window_activate_focus           (GtkWindow *window);

Active le widget courant qui a le focus dans la fenêtre.

gtk_window_activate_default ()

gboolean            gtk_window_activate_default         (GtkWindow *window);

Active la  widget par défaut pour la fenêtre, à moins que le widget courant qui a le focus ait été configuré pour recevoir l'action par défaut (voir GTK_RECEIVES_DEFAULT dans GtkWidgetFlags), dans ce cas le widget qui a le focus est activé.

gtk_window_set_modal ()

void                gtk_window_set_modal                (GtkWindow *window,
                                                         gboolean modal);

Définit une fenêtre modale ou  non modale. Une fenêtre modale empêche les interactions avec les autres fenêtres dans la même application. Pour garder des boîtes de dialogue au dessus de la fenêtre principale d'une application, utilisez  gtk_window_set_transient_for() rendre la boîte de dialogue transitoire pour le parent; la plupart des  gestionnaires de fenêtre ne permettront pas alors le passage de la boîte de dialoge en dessous du parent.

gtk_window_set_default_size ()

void                gtk_window_set_default_size         (GtkWindow *window,
                                                         gint width,
                                                         gint height)

Définit la taille par défaut de la fenêtre. Si la taille "naturelle"( la taille demandée) de la fenêtre est plus grande que la taille par défaut, la taille par défaut sera ignorée. Plus généralement, si la taille par défaut  n'obéit pas aux indices géométrique (hints) pour la fenêtre ( (gtk_window_set_geometry_hints() peut être utilisée pour les définir explicitement), la taille par défaut sera ajustée au plus près à la taille permise.

Contrairement à  gtk_widget_set_size_request(), qui définit la taille demandée pour un widget et ainsi empêches les utilisateur de réduire la fenêtre, cette fonction définit seulement la taille initiale, comme si l'utilisateur avait redimensionné lui-même la fenêtre. Les utilisateurs peuvent encore réduire la fenêtre normalement. La définition de la taille par défaut à -1 signifie que l'utilisateur utilise la taille "naturelle" par défaut ( la taille demandée par la fenêtre).

Pour plus de contrôle sur la taille initiale de la fenêtre et sur le fonctionnement du redimensionnement, étudiez  gtk_window_set_geometry_hints().

Pour certains usages, gtk_window_resize() est plus appropriée. gtk_window_resize()change la taille courante de la fenêtre, changes the current size of the window, plutôt que de modifier la taimme utilisée pour l'affichage initial. gtk_window_resize() affecte toujours la fenêtre elle-même, et non la géométrie des widgets.

La taille par défaut d'une fenêtre est utilisée seulement la première fois qu'une fenêtre est montrée; si la fenêtre est cachée et remontrée, la taille de la fenêtre  avant qu'elle soit cachée sera mémorisée et utilisée à la place de la taille par défaut.

Les fenêtres ne peuvent pas prendre la taille 0x0, elles doivent être au minimum à  1x1, mais on peut mettre  width et  height à 0, il en résultera un taille par défaut de  1x1.

gtk_window_set_geometry_hints ()

void                gtk_window_set_geometry_hints       (GtkWindow *window,
                                                         GtkWidget *geometry_widget,
                                                         GdkGeometry *geometry,
                                                         GdkWindowHints geom_mask);

Cette fonction définit les indices à partir desquels la fenêtre pourra être redimensionnée par l'utilisateur. Vous pouvez définir une taille  minimum  et maximum;  permettre le redimensionnement par incréments (par exemple  pour xterm, vous pouvez uniquement redimensionner la taille d'un caractère); l'aspect  ratio; et plus. Voir la structure  GdkGeometry .

gtk_window_set_gravity ()

void                gtk_window_set_gravity              (GtkWindow *window,
                                                         GdkGravity gravity);

La gravité de la fenêtre définit la signification des coordonnées passées à gtk_window_move(). Voir gtk_window_move() et GdkGravity pour plus de détails.

La gravité par défaut d'une fenêtre est GDK_GRAVITY_NORTH_WEST qui spécifiquement "fait ce sque vous voulez dire".

gtk_window_get_gravity ()

GdkGravity          gtk_window_get_gravity              (GtkWindow *window);

Obtient la valeur définie par  gtk_window_set_gravity().

gtk_window_set_position ()

void                gtk_window_set_position             (GtkWindow *window,
                                                         GtkWindowPosition position);

Définit une contrainte de  position  pour une fenêtre. Si l'ancienne ou la nouvelle contrainte est  GTK_WIN_POS_CENTER_ALWAYS, elle repositionnera aussi la fenêtre pour satisfaire la nouvelle contrainte.

gtk_window_set_transient_for ()

void                gtk_window_set_transient_for        (GtkWindow *window,
                                                         GtkWindow *parent);

Le boîtes de dialogue doivent être définies transitoires pour la fenêtre principale dont elles sont issues. Cela permet aux gestionnaires de fenêtres, par exemple, de garder la boîte de dialogue au dessus, ou de la centrer par rapport à de la fenêtre principale. gtk_dialog_new_with_buttons() et d'autres fonctions pratiques dand GTK+ appelleront quelques fois  gtk_window_set_transient_for() à votre place.

Dans Windows, cette fonction place la fenêtre fille sur la fenêtre parent,  put the child window on top of the parent, much as the window manager would have done on X.

gtk_window_set_destroy_with_parent ()

void                gtk_window_set_destroy_with_parent  (GtkWindow *window,
                                                         gboolean setting);

Si setting est TRUE, alors cette fonction détruit le parent transitoire de  window ainsi que  windowelle-même. C'est utile, par exemple, pour les boîtes de dialogue qui ne doivent pas persister après la fenêtre principale à laquelle elles sont associées.

gtk_window_set_screen ()

void                gtk_window_set_screen               (GtkWindow *window,
                                                         GdkScreen *screen);

Définit le GdkScreen où window est affichée; si la fenêtre est déjà mappée, elle sera "non-mappée", et ensuite re-mappée sur le nouvel écran.

Depuis 2.2

gtk_window_get_screen ()

GdkScreen*          gtk_window_get_screen               (GtkWindow *window);

Retourne le GdkScreen associé à window.

Depuis 2.2

gtk_window_is_active ()

gboolean            gtk_window_is_active                (GtkWindow *window);

Retourne si la fenêtre fait partie du niveau supérieur actif.(C'est à dire du niveau supérieur qui reçoit les frappes de touches) La valeur retournée est TRUE si la fenêtre est le niveau supérieur actif, mais aussi si c'est un GtkPlug compris dans ce niveau supérieur. Vous pouvez utiliser cette fonction si vous voulez dessiner un widget défféremment selon qu'il est dans une fenêtre active ou inactive. Voir  gtk_window_has_toplevel_focus()

Depuis 2.4

gtk_window_has_toplevel_focus ()

gboolean            gtk_window_has_toplevel_focus       (GtkWindow *window);

Retourne si le focus d'entrée est dans la GtkWindow. Pour le niveau supérieur réel, cela revient au même que d'utiliser gtk_window_is_active(), mais pour des fenêtre incorporées, comme GtkPlug, le résultat sera différent.

Depuis 2.4

gtk_window_list_toplevels ()

GList*              gtk_window_list_toplevels           (void);

Retourne la liste de tous les fenêtres de niveau supérieur existantes. Les widgets ne sont pas référencés individuellement dans la liste.   If you want to iterate through the list et effectuer des actions impliquant des callbacks qui peuvent détruire les widgets, pour devez appeler g_list_foreach (result, (GFunc)g_object_ref, NULL) en premier , et supprimer la référence de tous les widgets  après.

gtk_window_add_mnemonic ()

void                gtk_window_add_mnemonic             (GtkWindow *window,
                                                         guint keyval,
                                                         GtkWidget *target);

Ajoute un mnémonique à la fenêtre.

gtk_window_remove_mnemonic ()

void                gtk_window_remove_mnemonic          (GtkWindow *window,
                                                         guint keyval,
                                                         GtkWidget *target);

Supprime un mnémonique de la fenêtre

gtk_window_mnemonic_activate ()

gboolean            gtk_window_mnemonic_activate        (GtkWindow *window,
                                                         guint keyval,
                                                         GdkModifierType modifier);

Active la cible associée au mnémonique.

gtk_window_activate_key ()

gboolean            gtk_window_activate_key             (GtkWindow *window,
                                                         GdkEventKey *event);

Active les mnémoniques et les accélérateurs pour  GtkWindow. Généralement, par défaut, le gestionnaire ::key_press_event est appelé  pour les fenêtres de niveau supérieur, cependant dans certains cas il faut l'appeler directement quand il y a priorité sur la touche standard d'une fenêtre de niveau supérieur.

gtk_window_propagate_key_event ()

gboolean            gtk_window_propagate_key_event      (GtkWindow *window,
                                                         GdkEventKey *event);

Répercute la pression d'une touche ou libère un événement pour un widget qui a le focus et up the focus container chain jusqu'à ce qu'un widget traite  event. Cela appelle généralement par défaut  les gestionnaires ::key_press_event et ::key_release_event pour des fenêtre de niveau supérieur, cependant dans certains cas il est utile de les appeler directement quand il y a priorité sur la touche standard d'une fenêtre de niveau supérieur.

gtk_window_get_focus ()

GtkWidget*          gtk_window_get_focus                (GtkWindow *window);

Recherche le widget courant qui a le focus à l'intérieur de la fenêtre. Notez que  le widget  a le focus  si la fenêtre de niveau supérieur a le focus; si elle ne l'a pas alors GTK_WIDGET_HAS_FOCUS (widget) ne sera pas à  TRUE  pour le widget.

gtk_window_set_focus ()

void                gtk_window_set_focus                (GtkWindow *window,
                                                         GtkWidget *focus);

SI focus n'est pas le widget qui a le focus, et s'il peut l'obtenir, cette fonction lui donne le focus pour la fenêtre. Si focus est NULL, enlève le  focus au widget pour la fenêtre.  Pour définir le focus pour un widget particulier dans un niveau supérieur, il est plus pratique d'utiliser  gtk_widget_grab_focus() à la place de cette fonction.

gtk_window_set_default ()

void                gtk_window_set_default              (GtkWindow *window,
                                                         GtkWidget *default_widget);

Le widget par défaut est le widget qui est activé quand l'utilisateur presse Entrée dans une boîte de dialogue (par exemple). Cette fonction définit ou supprimer le widget par défaut pour GtkWindow . Pendant la définition (plus que la suppression) du widget par défaut il est plus facile d'appeler  gtk_widget_grab_focus() sur le widget. Avant de créer un widget par défaut, vous devez définir le flag  GTK_CAN_DEFAULT sur le widget que vous voulez définir comme widget par défaut en utilisant GTK_WIDGET_SET_FLAGS().

gtk_window_present ()

void                gtk_window_present                  (GtkWindow *window);

Présente une fenêtre à l'utilisateur. Cela peut signifier que la fenêtre est placée devant les autres fenêtres,qu'elle n'est plus minimisée, qu'elle est déplacée sur le bureau, et/ou qu'elle a le focus clavier, cela dépend de la plateforme, du gestionnaire de fenêtre et des préférences.

Si  window est cachée, cette fonction appelle gtk_widget_show().

Cet fonction doit être utilisée quand l'utilisateur essaie d'ouvrir une fenêtre qui est déjà ouverte. Par exemple si un boîte de dialogue des préférences est ouverte et que l'utilisateur choisit Préférences dans le menu une seconde fois; utilisez  gtk_window_present() pour mobiliser la boîte de dialogue déjà ouverte pour que l'utilisateur puisse la voir.

Si vous avez appelé cette fonction en réponse à une interaction de l'utilisateur, il est préférable d'utiliser gtk_window_present_with_time().

gtk_window_present_with_time ()

void                gtk_window_present_with_time        (GtkWindow *window,
                                                         guint32 timestamp);

Présente une fenêtre à l'utilisateur en réponse à une interaction. Si vous avez besoin de présenter une fenêtre sans timestamp, utilisez  gtk_window_present(). Voir  gtk_window_present() pour plus de détails.

Depuis 2.8

gtk_window_iconify ()

void                gtk_window_iconify                  (GtkWindow *window);

Demande de minimiser (icônifier) la fenêtre window. Notez que  vous devez être conscient que la fenêtre n'est pas définitivement minimisée après l'appel de la fonction, parce que d'autres entités ( par exemple l'utilisateur ou le gestionnaire de fenêtres) peuvent l'agrandir à nouveau, ou il peut ne pas y avoir de gestionnaire de fenêtres et dans ce cas la minimisation n'est pas possible, etc. Mais normalement la fenêtre sera  minimisée.  Il faut juste ne pas écrire un code d'erreur si ce n'est pas le cas.

Il est permis d'appeler cette fonction avant de montrer une fenêtre, dans ce cas la fenêtre sera minimisée avant d'apparaître sur l'écran.

Vous pouvez trouver la minimisation via le signal  "window_state_event" sur  GtkWidget.

gtk_window_deiconify ()

void                gtk_window_deiconify                (GtkWindow *window);

Demande de "desicônifier" la fenêtre window. Notez que  vous devez être conscient que la fenêtre n'est pas définitivement agrandie après l'appel de la fonction, parce que d'autres entités ( par exemple l'utilisateur ou le gestionnaire de fenêtres) peuvent la minimiser  à nouveau, avant que le code qui provoque l'agrandissement s'exécute. 

Vous pouvez trouver la minimisation via le signal  "window_state_event" sur  GtkWidget.

gtk_window_stick ()

void                gtk_window_stick                    (GtkWindow *window);

Demande de coller la fenêtre (stick)  window, ce qui signifie qu'elle va apparaître sur tous les nureau de l'utilisateur. Notez que vous devez être conscient que la fenêtre n'est pas définitivement collée après l'appel de la fonction, parce que d'autres entités ( par exemple l'utilisateur ou le gestionnaire de fenêtres) peuvent la décoller à nouveau, et certains gestionnaires de fenêtres n'acceptent pas les fenêtres collées. Mais normalement le fenêtre sera finalement collée.   Il faut juste ne pas écrire de code d'erreur si ce n'est pas le cas.

Il est permis d'appeler cette fonction avant de montrer une fenêtre.

Vous pouvez trouver le collage via le signal "window_state_event" sur  GtkWidget.

gtk_window_unstick ()

void                gtk_window_unstick                  (GtkWindow *window);

Demande de décoller la fenêtre  window, ce qui signifie qu'elle va apparaître uniquement sur des bureaux de l'utilisateur. Notez que vous devez être conscient que la fenêtre n'est pas définitivement décollée après l'appel de la fonction, parce que d'autres entités ( par exemple l'utilisateur ou le gestionnaire de fenêtres) peuvent la redécoller. Mais normalement la fenêtre sera finalement décollée.   Il faut juste ne pas écrire de code d'erreur si ce n'est pas le cas.

Vous pouvez trouver le collage via le signal "window_state_event" sur  GtkWidget.

gtk_window_maximize ()

void                gtk_window_maximize                 (GtkWindow *window);

Demande de maximiser la fenêtre window, ainsi elle va prendre tout  l'écran .  Notez que vous devez être conscient que la fenêtre n'est pas définitivement maximisée après l'appel de la fonction, parce que d'autres entités ( par exemple l'utilisateur ou le gestionnaire de fenêtres) peuvent la réduire à nouveau, et tous les gestionnaires de fenêtre ne supportent pas de maximiser les fenêtre. Mais normalement la fenêtre sera finalement maximisée.   Il faut juste ne pas écrire de code d'erreur si ce n'est pas le cas. 

Il est permis d'appeler cette fonction avant de montrer une fenêtre. Dans ce cas la fenêtre sera maximisée quand elle apparaîtra intialement sur l'écran.

Vous pouvez trouver l'option fenêtre maximisée  via le signal "window_state_event" sur  GtkWidget.

gtk_window_unmaximize ()

void                gtk_window_unmaximize               (GtkWindow *window);

Demande que  la fenêtre  window  ne soit plus maximisée. Notez que vous devez être conscient que la fenêtre n'est pas définitivement réduite après l'appel de la fonction, parce que d'autres entités ( par exemple l'utilisateur ou le gestionnaire de fenêtres) peuvent la maximiser à nouveau, et tous les gestionnaires de fenêtres ne répondent pas à cette requête . Mais  la fenêtre finalement  ne sera plus maximisée.   Il faut juste ne pas écrire de code d'erreur si ce n'est pas le cas. 

Vous pouvez trouver l'option fenêtre maximisée  via le signal "window_state_event" sur  GtkWidget.

gtk_window_fullscreen ()

void                gtk_window_fullscreen               (GtkWindow *window);

Demande de mettre la fenêtre window en mode plein écran. Notez que vous devez être conscient que la fenêtre n'est pas définitivement en plein écran après l'appel de la fonction, parce que d'autres entités ( par exemple l'utilisateur ou le gestionnaire de fenêtres) peuvent  retirer cet état à nouveau, et tous les gestionnaires de fenêtres ne répondent pas à cette requête . Mais  la fenêtre finalement  sera en mode plein écran.   Il faut juste ne pas écrire de code d'erreur si ce n'est pas le cas.

Vous pouvez trouver le mode plein écran  via le signal "window_state_event" sur  GtkWidget.

Depuis 2.2

gtk_window_unfullscreen ()

void                gtk_window_unfullscreen             (GtkWindow *window);

Demande d'enlever le mode plein écran de la fenêtre window . Notez que vous devez être conscient que le mode plein écran n'est pas enlevé  définitivement après l'appel de la fonction, parce que d'autres entités ( par exemple l'utilisateur ou le gestionnaire de fenêtres) peuvent  remettre le plein écran à nouveau, et tous les gestionnaires de fenêtres ne répondent pas à cette requête . Mais  le mode plein écran  finalement  sera énlevé.   Il faut juste ne pas écrire de code d'erreur si ce n'est pas le cas.

Vous pouvez trouver le mode  plein écran  via le signal "window_state_event" sur  GtkWidget.

Depuis 2.2

gtk_window_set_keep_above ()

void                gtk_window_set_keep_above           (GtkWindow *window,
                                                         gboolean setting);

Demande de laisser la fenêtre window au premier plan,  de sorte qu'elle reste au dessus. Notez que vous devez être conscient que la fenêtre n'est pas définitivement au premier plan après l'appel de la fonction, parce que d'autres entités ( par exemple l'utilisateur ou le gestionnaire de fenêtres) peuvent  ne pas la garder ainsi, et tous les gestionnaires de fenêtres ne répondent pas à cette requête . Mais  normalement la fenêtre apparaîtra au premier plan. Il faut juste ne pas écrire de code d'erreur si ce n'est pas le cas. 

Il est permis d'appeler cette fonction avant de montrer une fenêtre. Dans ce cas la fenêtre au premier plan quand elle apparaîtra intialement sur l'écran.

Vous pouvez trouver le mode  premier plan  via le signal "window_state_event" sur  GtkWidget.

Notez que, selon les spécification de Extended Window Manager Hints (conseils pour les gestionnaires de fenêtre) , le mode premier plan concerne plutôt les préférences de l'utilisateur et ne devrait pas être utilisé par les applications, par exemple pour drawing attention to their dialogs.

Depuis 2.4

gtk_window_set_keep_below ()

void                gtk_window_set_keep_below           (GtkWindow *window,
                                                         gboolean setting);

Demande de laisser la fenêtre  window en arrière plan de sorte qu'elle reste dans le fond.  Notez que vous devez être conscient que la fenêtre n'est pas définitivement en arrière plan après l'appel de la fonction, parce que d'autres entités ( par exemple l'utilisateur ou le gestionnaire de fenêtres) peuvent  ne pas la garder ainsi, et tous les gestionnaires de fenêtres ne répondent pas à cette requête . Mais  normalement la fenêtre apparaîtra en arrière plan. Il faut juste ne pas écrire de code d'erreur si ce n'est pas le cas. 

Il est permis d'appeler cette fonction avant de montrer une fenêtre. Dans ce cas la fenêtre en arrière plan quand elle apparaîtra intialement sur l'écran.

Vous pouvez trouver le mode arrière plan  via le signal "window_state_event" sur  GtkWidget.

Notez que, selon les spécification de Extended Window Manager Hints(conseils pour les gestionnaires de fenêtre) , le mode premier plan  concerne plutôt les préférences de l'utilisateur et ne devrait pas être utilisé par les applications, par exemple pour drawing attention to their dialogs.

Depuis 2.4

gtk_window_begin_resize_drag ()

void                gtk_window_begin_resize_drag        (GtkWindow *window,
                                                         GdkWindowEdge edge,
                                                         gint button,
                                                         gint root_x,
                                                         gint root_y,
                                                         guint32 timestamp);

Commence le redimensionnement d'une fenêtre. Cette fonction est utilisée si une application a des contrôles de redimensionnement de fenêtre. Quand GDK peut le supporter, le redimensionnement s'effectuera en utilisant le mécanisme standard du gestionnaire de fenêtre ou du système de fenêtrage. Autrement, GDK essaiera d'émuler le redimensionnement de la fenêtre,  quelques fois de façon partielle, en fonction du système de fenêtrage.

gtk_window_begin_move_drag ()

void                gtk_window_begin_move_drag          (GtkWindow *window,
                                                         gint button,
                                                         gint root_x,
                                                         gint root_y,
                                                         guint32 timestamp);

Commence le déplacement d'une fenêtre. Cette fonction est utilisée si une application possède des prises pour mobiliser la fenêtre. Quand GDK peut le supporter, le déplacement de la fenêtre s'effectuera en utilisant le mécanisme standard du gestionnaire de fenêtre ou du système de fenêtrage. Autrement, GDK essaiera d'émuler le déplacement de la fenêtre,  quelques fois de façon partielle, en fonction du système de fenêtrage.

gtk_window_set_decorated ()

void                gtk_window_set_decorated            (GtkWindow *window,
                                                         gboolean setting);

Par défaut , la fenêtre est décorée avec une barre de titre, des contrôles de redimensionnement, etc. Certains  gestionnaires de fenêtres permettent à GTK+  de désactiver ces décorations, et de créer une fenêtre sans bord. Si vous mettez la propriété de décoration à  FALSE à l'aide de cette fonction, GTK+ fera son possible pour convaincre le gestionnaire de fenêtre de ne pas décorer la fenêtre. Dépendante du système, cette fonction peut avoir aucun effet  si la fenêtre est déjà affichée, aussi vous devez l'appeler avant   gtk_window_show().

Dans Windows, cette fonction fonctionne toujours, puisqu'il n'y a pas de gestionnaire de fenêtre impliqué. 

gtk_window_set_deletable ()

void                gtk_window_set_deletable            (GtkWindow *window,
                                                         gboolean setting);

Par défaut, la fenêtre a un bouton de fermeture. Certains gestionnaires de fenêtrespermettent à GTK+ de désactiver ce bouton. Si vous définissez la propriété de suppression à  FALSE à l'aide de cette fonction, GTK+ fera de son mieux pour convaincre le gestionnaire de fenêtre de ne pas montrer le bouton de fermeture. Dépendante du système, cette fonction peut avoir aucun effet  si la fenêtre est déjà affichée, aussi vous devez l'appeler avant  gtk_window_show().

Dans Windows, cette fonction fonctionne toujours, puisqu'il n'y a pas de gestionnaire de fenêtre impliqué. 

Depuis 2.10

gtk_window_set_frame_dimensions ()

void                gtk_window_set_frame_dimensions     (GtkWindow *window,
                                                         gint left,
                                                         gint top,
                                                         gint right,
                                                         gint bottom);

(Note: cette fonction a un but particulier, elle est destinée au port du framebuffer; voir gtk_window_set_has_frame(). Elle n'aura aucun effet sur le bord d'une fenêtre dessinée par le gestionnaire de fenêtre ce qui est la marche normale en utilisant un système X Window.)

Pour des fenêtre avec des frames (voir gtk_window_set_has_frame()) cette fonction peut être utilisée pour changer la taille des bords des frames.

gtk_window_set_has_frame ()

void                gtk_window_set_has_frame            (GtkWindow *window,
                                                         gboolean setting);

(Note:cette fonction a un but particulier, elle est destinée au port du framebuffer; ainsi GTK+ dessine les bords de ses propres fenêtres. Pour la plupart des application, vous utiliserez  gtk_window_set_decorated() à la place pour dire au gestionnaire de fenêtre ou dessiner les bords de la fenêtre.)

Si cette fonction est appelée sur une fenêtre avec la configuration  TRUE, avant d'être libérée ou montrée,  il y aura une  "frame" window around window->window, accessible dans window->frame. En utilisant le signal frame_event vous pouvez recevoir tous les événement ciblés dans la frame.

Cette fonction est utiliser par le port  linux-fb pour impélenter la gestion des fenêtres, mais elle peut être utilisée par les  programmes X qui veulent créer leur propre décoration de fenêtre.

gtk_window_set_mnemonic_modifier ()

void                gtk_window_set_mnemonic_modifier    (GtkWindow *window,
                                                         GdkModifierType modifier);

Définit le modificateur mnémonique pour la fenêtre.

gtk_window_set_role ()

void                gtk_window_set_role                 (GtkWindow *window,
                                                         const gchar *role);

Cette fonction est utilisée seulement pour X11, et pas avec les autres cibles GTK+.

En association avec le titre de la fenêtre, le groupe (role) de la fenêtre permet au gestionnaire de fenêtred'identifier "la même " fenêtre quand une application est redémarée. Ainsi par exemple vous pouvez définir le groupe de  "boîte à outils" dans la fenêtres  de boîte à outils de votre application, de sorte que, quand l'utilisateur redémarre la session, le gestionnaire de fenêtre peut remettre la boîte à outils à la même place.

Si une fenêtre possède déjà un titre unique, vous n'avez pas besoin de définir le groupe, le gestionnaire de fenêtre peut utiliser le titre pour identifier la fenêtre quand la session est restaurée.

gtk_window_set_type_hint ()

void                gtk_window_set_type_hint            (GtkWindow *window,
                                                         GdkWindowTypeHint hint);

En définissant l'indice du type pour une fenêtre, vous permettez au gestionnaire de fenêtre de décorer et de manipuler la fenêtre de façon adaptée à l'utilisation de cette fenêtre dans votre application.

Cette fonction doit être appelée avant que la fenêtre ne soit visible.

gtk_dialog_new_with_buttons() et d'autres focntion pratiques dans GTK+ vont quelques fois appeler gtk_window_set_type_hint() à votre place.

gtk_window_set_skip_taskbar_hint ()

void                gtk_window_set_skip_taskbar_hint    (GtkWindow *window,
                                                         gboolean setting);

Les fenêtre peuvent définir un indice demandant à l'environnement du bureau de ne pas afficher la fenêtre dans la barre des tâches. Cette fonction définit cet indice.

Depuis 2.2

gtk_window_set_skip_pager_hint ()

void                gtk_window_set_skip_pager_hint      (GtkWindow *window,
                                                         gboolean setting);

Les fenêtre peuvent définir un indice pour demander à l'environnement du bureau de ne pas afficher la fenêtre dans le pager. Cette fonction définit cet indice. ( Un "pager " est un outil de navigation comme un onglet de permutation  pour passer d'un bureau virtuel à un autre et qui peut représenter  un mini apperçu de la fenêtre dans l'écran.)

Depuis 2.2

gtk_window_set_urgency_hint ()

void                gtk_window_set_urgency_hint         (GtkWindow *window,
                                                         gboolean setting);

Les fenêtres peuvent définir un indice pour demander à l'environnement du bureau d'appeler l'attention de l'utilisateur sur la fenêtre. Cette fonction définit cet indice.

Depuis 2.8

gtk_window_set_accept_focus ()

void                gtk_window_set_accept_focus         (GtkWindow *window,
                                                         gboolean setting);

Les fenêtres peuvent définir un indice pour demander à l 'environnement du bureau de ne ma pas recevoir le focus d'entrée. Cette fonction difinit cet indice.

Depuis 2.4

gtk_window_set_focus_on_map ()

void                gtk_window_set_focus_on_map         (GtkWindow *window,
                                                         gboolean setting);

Les fenêtres peuvent définir un indice pour demander à l'environnement du bureau de ne pas revoir le focus d'entrée quand la fenêtre est mappée. Cette fonction définit cet indice.

Depuis 2.6

gtk_window_get_decorated ()

gboolean            gtk_window_get_decorated            (GtkWindow *window);

Retourne si la fenêtre a été définie pour recevoir des décorations comme une barre de titre via gtk_window_set_decorated().

gtk_window_get_deletable ()

gboolean            gtk_window_get_deletable            (GtkWindow *window);

Retourne si la fenêtre a été définie pour recevoir un bouton fermer via  gtk_window_set_deletable().

Depuis 2.10

gtk_window_get_default_icon_list ()

GList*              gtk_window_get_default_icon_list    (void);

Obtient la valeur définie par  gtk_window_set_default_icon_list(). La liste est une copie et doit être libérée avec g_list_free(), mais le compteur de référence des  pixbufs de la liste  n'est pas incrémenté.

gtk_window_get_default_size ()

void                gtk_window_get_default_size         (GtkWindow *window,
                                                         gint *width,
                                                         gint *height);

Obtient la taille par défaut de la fenêtre. Une valeur de -1 pour la largeur ou la hauteur indique que la taille par défaut n'a pas été définie pour la dimension, aussi la taille "naturelle" de la fenêtre sera utilisée.

gtk_window_get_destroy_with_parent ()

gboolean            gtk_window_get_destroy_with_parent  (GtkWindow *window);

Retourne si la fenêtresera détruite  avec son parent transitoire. Voir gtk_window_set_destroy_with_parent().

gtk_window_get_frame_dimensions ()

void                gtk_window_get_frame_dimensions     (GtkWindow *window,
                                                         gint *left,
                                                         gint *top,
                                                         gint *right,
                                                         gint *bottom);

(Note: cette fonction a un but particulier, elle est destinée au port du framebuffer; voir gtk_window_set_has_frame(). Elle ne retourne pas la taille des bords de la fenêtre dessinée par le gestionnaire de fenêtres, ce qui est normal quand un système de fenêtrafe. Voir gdk_window_get_frame_extents() pour obtenir des bords de fenêtre standards agrandis.)

Recherche les dimensions de la fenêtre frame pour le niveau supérieur considéré. Voir gtk_window_set_has_frame(), gtk_window_set_frame_dimensions().

gtk_window_get_has_frame ()

gboolean            gtk_window_get_has_frame            (GtkWindow *window);

Pour définir si fenêtre a une fenêtre frame extérieure à  window->window. Obtient la valeur définie par  gtk_window_set_has_frame().

gtk_window_get_icon ()

GdkPixbuf*          gtk_window_get_icon                 (GtkWindow *window);

Donne la valeur définie par  gtk_window_set_icon() (ou si vous avez appelé  gtk_window_set_icon_list(), donne la première icône de la iste des icônes.)

gtk_window_get_icon_list ()

GList*              gtk_window_get_icon_list            (GtkWindow *window);

Recherhce la liste des icônes définies par  gtk_window_set_icon_list(). La liste est copiée, mais le compteur de référence sur chaque membre n'est pas incrémenté.

gtk_window_get_icon_name ()

gchar*              gtk_window_get_icon_name            (GtkWindow *window);

Retourne le nom de l'icône de thème pour la fenêtre, voir gtk_window_set_icon_name().

Depuis 2.6

gtk_window_get_mnemonic_modifier ()

GdkModifierType     gtk_window_get_mnemonic_modifier    (GtkWindow *window);

Retourne le modificateur mnémonique pour la fenêtre. Voir gtk_window_set_mnemonic_modifier().

gtk_window_get_modal ()

gboolean            gtk_window_get_modal                (GtkWindow *window);

Retourne si la fenêtre est modale. Voir gtk_window_set_modal().

gtk_window_get_position ()

void                gtk_window_get_position             (GtkWindow *window,
                                                         gint *root_x,
                                                         gint *root_y);

Cette fonction retourne la position que vous devez passer à  gtk_window_move() pour garder  window dans sa position courante. La signification de la valeur retournée varie avec la gravité de la fenêtre. Voir  gtk_window_move() pour plus de détails.

Si vous n'avez pas modifié la gravité de la fenêtre, cette gravité sera  GDK_GRAVITY_NORTH_WEST. Cela signifie que  gtk_window_get_position() donnera la position du coin supérieur gauche de la frame du gestionnaire de fenêtre pour la fenêtre. gtk_window_move() définit la position du même coin supérieur gauche.

gtk_window_get_position()n'est pas à 100% fiable parce que le système X Window ne spécifie pas la façon d'obtenir la géométrie des décorations placées sur la fenêtre pour le gestionnaire de fenêtre.  De ce fait GTK+ emploie la « meilleure conjecture » pour fonctionner  avec la plupart des gestionnaires de fenêtres.

D'ailleurs, à peu près tous les gestionnaires de fenêtres sont historiquement arrêtés ( historically broken) en respectant la manipulation de la gravité de la fenêtre. Ainsi, mobiliser une fenêtre à la  position courante retournée par  gtk_window_get_position() provoque un léger déplacement de la fenêtre. Les gestionnaires de fenêtre sont (are slowly getting better over time.)

Si une fenêtre a une gravité  GDK_GRAVITY_STATIC la frame du gestionnaire de fenêtre n'est pas appropriée, et ainsi  gtk_window_get_position() poduira toujours des résultats précis. Cependant vous ne pouvez pas utiliser la gravité statique pour placer une fenêtre dans un coin de l'écran, parce que la gravité statique ignore les décorations des gestionnaires de fenêtres.

Si vous avez sauvegardé et restauré les positions de la fenêtre de votre application, vous devez savoir qu'il est impossible pour les applications de me faire sans que ce soit un peu faussé parce que les applicatopns n'ont pas assez  de connaissances au sujet de l'état de gestionnaire de fenêtre. La meilleure façon de procéder est de soutenir le protocole de gestion de la session (voir le l'objet "GnomeClient" dans les bibliothèques GNOME par exmple ) et de demander au gestionnaire de fenêtre de sauvegarder les dimensions et la position de la fenêtre.

gtk_window_get_role ()

const gchar*        gtk_window_get_role                 (GtkWindow *window);

Retourne le groupe (role) de la fenêtre. Voir  gtk_window_set_role() pour plus d'explications.

gtk_window_get_size ()

void                gtk_window_get_size                 (GtkWindow *window,
                                                         gint *width,
                                                         gint *height);

Donne la taille courante de la fenêtre window. Si  window n'est pas sur l'écran, elle retourne la taille que GTK+ proposera au gestionnaire de fenêtrespour la taille initiale de la fenêtre (mais cette taille ne sera pas exactement la même que celle que le gestionnaire de fenêtre choisira réellement). La taille obtenue avec gtk_window_get_size() est la dernière taille reçue dans un GdkEventConfigure, c'est à dire que GTK+ utilise les tailles stockées localement plutôt que de questionner le serveur X à ce sujet. Il en résulte que, si vous appelez  gtk_window_resize() puis immédiatement après  gtk_window_get_size(), la taille ne prendra pas effet tout de suite. Quand le gestionnaire de fenêtre a répondu à la demande de redimensionnement, GTK+ reçoit une notification, via un événenement configuré, l'informant que la taille a changée,  et la taille de la fenêtre est réactualisée.

Note 1: Presque toutes les utilisations de cette fonction créent une "situation de compétition" parce que la taille de la fenêtre peut changer entre le moment où vous la trouvez et le moment où vous réalisez certaines actions donnant à cette taille une valeur courante. Pour éviter la situation de compétition", connectez  "configure_event" sur la fenêtre et ajustez l'état size-dependent  pour associer la taille délivrée dans le  GdkEventConfigure.

Note 2: La taille retournée ne doit pas inclure la taille des décorations du gestionnaire de fenêtres (frame de fenêtre où bords). Elles ne sont pas dessinées par GTK+ et GTK+ n'a pas de méthode fiable pour définir leurs tailles.

Note 3: Si vous cherchez la taille d'une fenêtre pour la positionner  sur un écran, il y a une méthode plus appropriée.  Cette méthode est de définir simplement le type sémantique de la fenêtre avec gtk_window_set_type_hint(), ce qui va permettre au gestionnaire de fenêtre de centrer une boîte de dialogue par exemple. Aussi, si vous définissez un parent transitoire pour des boîtes de dialogue avec gtk_window_set_transient_for() les gestionnaires de fenêtre centreront souvent la boîte de dialogue sur sa fenêtre parent. Il est préférable de laisser le gestionnaire de fenêtre manipuler cela plutôt que de le faire vous-même parce que toutes les applications  se comportent de façon à correspondre aux préférences de l'utilisateur si le gestionnaire de fenêtre les traîte. Ainsi le gestionnaire de fenêtre peut prendre en compte la taille des décorations/ bords de la fenêtre ce que votre application ne peut pas faire.

Dans tous les cas, si vous insistez pour positionner la fenêtre via l'application, il y a encore une meilleure façon pour le faire vous-même,  gtk_window_set_position() traîtera fréquemment les détails pour vous.

gtk_window_get_title ()

const gchar*        gtk_window_get_title                (GtkWindow *window);

Recherche le titre de la fenêtre. Voir gtk_window_set_title().

gtk_window_get_transient_for ()

GtkWindow*          gtk_window_get_transient_for        (GtkWindow *window);

Cherche le parent transitoire pour cette fenêtre. Voir gtk_window_set_transient_for().

gtk_window_get_type_hint ()

GdkWindowTypeHint   gtk_window_get_type_hint            (GtkWindow *window);

Donne l'indice (hint)  type pour cette fenêtre. Voir gtk_window_set_type_hint().

gtk_window_get_skip_taskbar_hint ()

gboolean            gtk_window_get_skip_taskbar_hint    (GtkWindow *window);

Donne la valeur définie par  gtk_window_set_skip_taskbar_hint()

Depuis 2.2

gtk_window_get_skip_pager_hint ()

gboolean            gtk_window_get_skip_pager_hint      (GtkWindow *window);

Donne la veleur définie par  gtk_window_set_skip_pager_hint().

Depuis 2.2

gtk_window_get_urgency_hint ()

gboolean            gtk_window_get_urgency_hint         (GtkWindow *window);

Donne la valeur définie par  gtk_window_set_urgency_hint()

Depuis 2.8

gtk_window_get_accept_focus ()

gboolean            gtk_window_get_accept_focus         (GtkWindow *window);

Donne la valeur définie par  gtk_window_set_accept_focus().

Depuis 2.4

gtk_window_get_focus_on_map ()

gboolean            gtk_window_get_focus_on_map         (GtkWindow *window);

Donne la valeur définie par gtk_window_set_focus_on_map().

Depuis 2.6

gtk_window_get_group ()

GtkWindowGroup*     gtk_window_get_group                (GtkWindow *window);

Retourne le groupe pour  window ou le groupe par défaut, si  window est NULL ou si window n'a pas de groupe de fenêtres explicite.

Depuis 2.10

gtk_window_move ()

void                gtk_window_move                     (GtkWindow *window,
                                                         gint x,
                                                         gint y);

Demande au gestionnaire de fenêtre de déplacer la fenêtre  window à un endroit donné. Les gestionnaires de fenêtres sont libres d'ignorer cela; la plupart ignorent la requête pour la  position initiale de la fenêtre (à la place utilisez un algorithme de placement définit par l'utilisateur) et   acceptent la requête après que la fenêtre ait été déjà montrée. 

Note: la position est la position du point de référence défini par gravité pour la fenêtre. La gravité détermine deux choses : premièrement, la localisation du point de référence dans les coordonnées racine de la fenêtre; et deuxièmement, quel point dans la fenêtre est placé au point de référence.

Par défaut la gravité est  GDK_GRAVITY_NORTH_WEST, le point de référence est simplement  x, y fournit à  gtk_window_move(). Le coin supérieur gauche des décorations de fenêtre ( frame de fenêtre ou bords) sera placé à  x, y. Par conséquent, pour positionner une fenêtre au dessus et à gauche de l'écran, vous allez utiliser la gravité par défaut (qui est  GDK_GRAVITY_NORTH_WEST) et placer la fenêtre à 0,0.

Pour positionner une fenêtre en bas et à droite de l'écran, définissez  GDK_GRAVITY_SOUTH_EAST,ce qui signifie que le point de référence est à  x + la largeur de la fenêtre et y+ la hauteur de la fenêtre, et le coin inférieur droit du bord de la fenêtre sera placé au point de référence. Ainsi, pour placer une fenêtre au coin  inférieur droit vous devez d'abord définir la gravité sud est, pui écrire : gtk_window_move (window, gdk_screen_width() - window_width, gdk_screen_height() - window_height) (notez que cet exemple ne prends pas en compte les multi-head scenarios).

Les explications des "Conseil étendus du gestionnaire de fenêtre" sur  http://www.freedesktop.org/Standards/wm-spec présente une table des gravités dans la section "implementation notes".

La documentation de gtk_window_get_position() peut aussi être pertinante.

gtk_window_parse_geometry ()

gboolean            gtk_window_parse_geometry           (GtkWindow *window,
                                                         const gchar *geometry);

Analyse une chaîne géométrique standard du Système X Window -  voir la page du manuel pour X( ype 'man X') pour plus de détails à ce sujet.  gtk_window_parse_geometry()ne fonctionnement pour tous les ports de GTK+ incluant Win32,  elle est prévue principalement pour un environnement X.

Si soit une taille soit une position peut être extraite d'une chaîne géométrique,  gtk_window_parse_geometry() retourne  TRUE et appelle  gtk_window_set_default_size() et / ou  gtk_window_move() pour redimensionner / déplacer la fenêtre.

Si  gtk_window_parse_geometry() retourne TRUE, elle définira aussi  GDK_HINT_USER_POS et/ ou les indices GDK_HINT_USER_SIZE indiquant au gestionnaire de fenêtre que la taille/ position de la fenêtre est définie par l'utilisateur. Cela implique que la plupart des gestionnaires de fenêtres acceptent la géométrie.

Notez que pour que gtk_window_parse_geometry()fonctionne comme prévu, elle doit être appelée quand la fenêtre est a sa taille définitive, c'est à dire, après avoir appelé  gtk_widget_show_all() sur le contenu et gtk_window_set_geometry_hints() sur la fenêtre.

#include <gtk/gtk.h>
   
static void
fill_with_content (GtkWidget *vbox)
{
  /* fill with content... */
}
   
int
main (int argc, char *argv[])
{
  GtkWidget *window, *vbox;
  GdkGeometry size_hints = {
    100, 50, 0, 0, 100, 50, 10, 10, 0.0, 0.0, GDK_GRAVITY_NORTH_WEST  
  };
   
  gtk_init (&argc, &argv);
  
  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  vbox = gtk_vbox_new (FALSE, 0);
  
  gtk_container_add (GTK_CONTAINER (window), vbox);
  fill_with_content (vbox);
  gtk_widget_show_all (vbox);
  
  gtk_window_set_geometry_hints (GTK_WINDOW (window),
	  			    window,
				    &size_hints,
				    GDK_HINT_MIN_SIZE | 
				    GDK_HINT_BASE_SIZE | 
				    GDK_HINT_RESIZE_INC);
  
  if (argc > 1)
    {
      if (!gtk_window_parse_geometry (GTK_WINDOW (window), argv[1]))
        fprintf (stderr, "Failed to parse '%s'\n", argv[1]);
    }
   
  gtk_widget_show_all (window);
  gtk_main ();
   
  return 0;
}

gtk_window_reshow_with_initial_size ()

void                gtk_window_reshow_with_initial_size (GtkWindow *window);

Cache  window, puis la remontre en la redéfinissant à la taille  et à la position  par défaut de la fenêtre. Utilisée uniquement  par les constructeurs GUI. 

gtk_window_resize ()

void                gtk_window_resize                   (GtkWindow *window,
                                                         gint width,
                                                         gint height);

Redimensionne la fenêtre comme si l'utilisateur l'avait fait, en obeissant aux contraintes géométriques. Les contraintes  géométriques par défaut veut que la taille de la fenêtre ne soit pas plus petite que la taille nécessaire.  Pour modifier cette contrainte, appelez gtk_widget_set_size_request() pour définir la demande de la fenêtre à une valeur plus petite.

Si  gtk_window_resize()est appelée avant que la fenêtre ne soit montrée pour la première fois, elle modifie toutes les tailles par défaut définies avec gtk_window_set_default_size().

Les fenêtres peuvent ne pas être plus petites que 1 x 1 pixels.

gtk_window_set_default_icon_list ()

void                gtk_window_set_default_icon_list    (GList *list);

Définit une liste d'icônes utilisées comme solution de rechange (fallback) pour les fenêtres sur lesquelles  gtk_window_set_icon_list() n'a pas été appelée pour définir une liste d'icônes spécifiques à la fenêtre. Cette fonction vous permet de définir les icônes de toutes les fenêtres de votre application à la fois.

Voir  gtk_window_set_icon_list() pour plus de détails.

gtk_window_set_default_icon ()

void                gtk_window_set_default_icon         (GdkPixbuf *icon);

Définit une icône à utiliser comme solution de rechange pour les fenêtres sur lesquelles  gtk_window_set_icon() n'a pas été appelée pour un pixbuf.

Depuis 2.4

gtk_window_set_default_icon_from_file ()

gboolean            gtk_window_set_default_icon_from_file
                                                        (const gchar *filename,
                                                         GError **err);

Définit une îcone à utiliser comme solution de rechange pour les fenêtres sur lesquelles  gtk_window_set_icon_list() n'a pas été appelée pour un fichier du disque. Avertit d'un échec si err is NULL (c'est la traduction mais ça m'étonne, c'est pas l'inverse ?)

Depuis 2.2

gtk_window_set_default_icon_name ()

void                gtk_window_set_default_icon_name    (const gchar *name);

Définit une icône qui va être utilisée comme solution de rechange pour les fenêtres pour lesquelles  gtk_window_set_icon_list() n'a pas été appelée pour une icône de thème nommée, voir  gtk_window_set_icon_name().

Depuis 2.6

gtk_window_set_icon ()

void                gtk_window_set_icon                 (GtkWindow *window,
                                                         GdkPixbuf *icon);

Définit une icône représentant une  GtkWindow. Cette icône est utilisée quand la enêtre est minimisée (icônifiée).  Certains gestionnaires de fenêtre ou environnements de bureau peuvent aussi la placer dans le cadre de  la fenêtre, ou l'afficher dans d'autres contextes.

L'icône doit être fournie dans sa taille naturelle, ne la redimensionnez pas avant de la passer à  GTK+. Le redimensionnement est remis à la dernière minute, quand la taille finale voulue est connue, pour apporter la meilleure qualité.

Si votre icône préfabriquée existe sous différentes tailles, utilisez  gtk_window_set_icon_list(). Alors la meilleure taille sera utilisée.

Appeler cette fonction est équivalent à appeler  gtk_window_set_icon_list() avec une liste à 1 élément.

Voir aussi gtk_window_set_default_icon_list() pour définir l'icône pour toutes les fenêtres de l'application à la fois.

gtk_window_set_icon_list ()

void                gtk_window_set_icon_list            (GtkWindow *window,
                                                         GList *list);

Définit l'icône représentant une GtkWindow. L'icône sert pour la fenêtre minimisée (aussi connue en tant que fenêtre icônifiée). Certains gestionnaires de fenêtres ou environnements de bureau peuvent aussi la placer dans le cadre de la fenêtre, ou l'afficher dans d'autres contextes.

gtk_window_set_icon_list() vous permet de passer dans la même icône plusieurs tailles préfabiquées. La liste devra contenir les tailles naturelles dans lesquelles votre icône sera valide; c'est à dire qu'il ne faut pas redimensionner l'image avant de la passer à GTK+. Le redimensionnement  est remis à la dernière minute, quand la taille finale voulue est connue, pour apporter la meilleure qualité.

En passant plusieurs tailles, vous pouvez améliorer la qualité de l'image finale de l'icône, en réduisant ou éliminant le redimensionnement automatique.

Les tailles recommandées à fournir sont :16x16, 32x32, 48x48 au minimum, et des images plus grandes (64x64, 128x128) si vous les avez.

Voir aussi  gtk_window_set_default_icon_list() pour définir l'icône de toutes les fenêtres de votre application à la fois.

Notez que les fenêtres transitoires (celles que vous avez définies transitoires pour une autre fenêtre avec gtk_window_set_transient_for()) hériteront  leurs icônes de leur parent transitoire. Ainsi il n'est pas besoin de définir explicitement l'icône dans les fenêtres transitoires.

gtk_window_set_icon_from_file ()

gboolean            gtk_window_set_icon_from_file       (GtkWindow *window,
                                                         const gchar *filename,
                                                         GError **err);

Définit l'icône pour window. Avertit d'une erreur si err est NULL.

L'appel  de cette fonction est équivalent à appeler  gtk_window_set_icon() avec un  pixbuf créé en chargeant l'image depuis filename.

Depuis 2.2

gtk_window_set_icon_name ()

void                gtk_window_set_icon_name            (GtkWindow *window,
                                                         const gchar *name);

Définit l'icône pour la fenêtre à partir d'une icône de thème. Voir la documentation de  GtkIconTheme pour plus de détails.

Notez que ça n'a rien à voir avec la propriété  WM_ICON_NAME qui est mentionnée dans le ICCCM.

Depuis 2.6

gtk_window_set_auto_startup_notification ()

void                gtk_window_set_auto_startup_notification
                                                        (gboolean setting);

Par défaut, après que l'affichage de la première fenêtre GtkWindow, GTK+ appelle gdk_notify_startup_complete(). Appelez cette fonction pour désactiver la notification du démarrage automatique. Vous pouvez faire cela si votre première fenêtre est un screen splash, et que vous voulez  retarder la notification jusqu'à ce que votre fenêtre principale soit affichée, par exemple.

Dans cet exemple, vous pouvez désactiver la notification de démarrage temporairement, montrer le splash screen, puis réactiver la notification de sorte que la notification soit le resultat automatique de l'affichage de la fenêtre principale.

Depuis 2.2

gtk_decorated_window_init ()

void                gtk_decorated_window_init           (GtkWindow *window);

gtk_decorated_window_calculate_frame_size ()

void                gtk_decorated_window_calculate_frame_size
                                                        (GtkWindow *window);

gtk_decorated_window_set_title ()

void                gtk_decorated_window_set_title      (GtkWindow *window,
                                                         const gchar *title);

gtk_decorated_window_move_resize_window ()

void                gtk_decorated_window_move_resize_window
                                                        (GtkWindow *window,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height);

La propriété "accept-focus" 

  "accept-focus"             gboolean              : Lire/ Ecrire

TRUE si la fenêtre peut recevoir le focus d'entrée.

Valeur par défaut: TRUE

La propriété "allow-grow" 

  "allow-grow"               gboolean              : Lire/ Ecrire

Si  TRUE, les utilisateur peuvent agrandir la fenêtre au delà de sa taille minimum.

Valeur par défaut: TRUE

La propriété "allow-shrink" 

 "allow-shrink"             gboolean              : Lire/ Ecrire

SI TRUE, la fenêtre n'a pas de taille minimale. Cette définition à TRUE est  99% du temps une mauvaise idée.

Valeur par défaut: FALSE

La propriété"decorated" 

 "decorated"                gboolean              : Lire/ Ecrire

SI la fenêtre peut être décorée par le gestionnaire de fenêtres.

Valeur par défaut: TRUE

Depuis 2.4

La propriété "default-height" 

  "default-height"           gint                  : Lire/ Ecrire

Hauteur par défaut de la fenêtre utilisée quand l'affichage de la fenêtre est initialisé.

Valeur possibles : >= -1

Valeur par défaut: -1

La propriété "default-width" 

 "default-width"            gint                  : Lire/ Ecrire

La largeur par défaut de la fenêtre utilisée quand l'affichage de la fenêtre est initialisé.

Valeurs possibles : >= -1

Valeur par défaut: -1

La propriété "deletable" 

"deletable"                gboolean              : Lire/ Ecrire

Valeur par défaut: TRUE

Depuis 2.10

La propriété  "destroy-with-parent" 

 "destroy-with-parent"      gboolean              : Lire/ Ecrire

Si la fenêtre doit être détruite quand le parent est détruit.

Valeur par défaut : FALSE

La propriété  "focus-on-map" 

 "focus-on-map"             gboolean              : Lire/ Ecrire

TRUE si la fenêtre doit recevoir le focus d'entrée quand elle est mappée.

Valeur par défaut: TRUE

La propriété "gravity" 

  "gravity"                  GdkGravity            : Lire/ Ecrire

La gravité de la fenêtre. Voir gtk_window_move() et GdkGravity pour avoir plus de détails au sujet de la gravité de la fenêtre.

Valeur par défaut : GDK_GRAVITY_NORTH_WEST

Depuis 2.4

La propriété "has-toplevel-focus" property

  "has-toplevel-focus"       gboolean              : Lire

Si le focus d'entrée est dans la fenêtre  GtkWindow.

Valeur par défaut: FALSE

La propriété  "icon"

  "icon"                     GdkPixbuf             : Lire/ Ecrire

Icône pour la fenêtre.

La propriété  "icon-name" 

  "icon-name"                gchararray            : Lire/ Ecrire

La propriété  :icon-name définit le nom de l'icône de thème à utiliser comme icône de fenêtre. Voir GtkIconTheme pour plus de détails.

Valeur par défaut: NULL

Depuis 2.6

La propriété "is-active" 

  "is-active"                gboolean              : Lire

Si le niveau supérieur est la fenêtre active.

Valeur par défaut: FALSE

La propriété "modal" 

  "modal"                    gboolean              : Lire/ Ecrire

Si TRUE, la fenêtre est modale ( les autres fenêtres ne sont pas utilisables tant que celle-ci est affichée).

Valeur par défaut : FALSE

La propriété "resizable" 

  "resizable"                gboolean              : Lire / Ecrire

Si TRUE, les utilisateurs redimensionnent la fenêtre.

Valeur par défaut: TRUE

La propriété  "role" 

  "role"                     gchararray            : Lire / Ecrire 

Identificateur unique pour la fenêtre qui sera utilisé quand la session sera restaurée.

Valeur par défaut: NULL

La propriété  "screen"

  "screen"                   GdkScreen             : Lire / Ecrire 

L'écran où la fenêtre sera affichée.

La propriété "skip-pager-hint" 

  "skip-pager-hint"          gboolean              : Lire / Ecrire

TRUE si la fenêtre ne doit pas être dans le pageur.

Valeur par défaut: FALSE

La propriété  "skip-taskbar-hint" 

  "skip-taskbar-hint"        gboolean              : Lire / Ecrire

TRUE si la fenêtre ne doit pas apparaître dans la barre des tâches.

Valeur par défaut: FALSE

La propriété "title" 

  "title"                    gchararray            : Lire / Ecrire 

Le titre de la fenêtre 

Valeur par défaut : NULL

La propriété "transient-for" 

  "transient-for"            GtkWindow             : Mire / Ecrire / Construit 

Le parent transitoire de la fenêtre. Voir gtk_window_set_transient_for() pour plus de détails au sujet des fenêtres transitoires.

Depuis 2.10

La propriété  "type"

  "type"                     GtkWindowType         : Lire / Ecrire / Construit seulement

Le type de fenêtre.

Valeur par défaut :  GTK_WINDOW_TOPLEVEL

La propriété "type-hint" 

  "type-hint"                GdkWindowTypeHint     : Lire / Ecrire 

Indice (hint) pour aider l'environement du bureau à comprendre quel genre de fenêtre  se présente et comment la traîter.

Valeur par défaut : GDK_WINDOW_TYPE_HINT_NORMAL

La propriété  "urgency-hint" 

  "urgency-hint"             gboolean              : Lire / Ecrire

TRUE si la fenêtre doit être portée à l'attention de l'utilisateur.

Valeur par défaut: FALSE

La propriété "window-position" 

  "urgency-hint"             gboolean              : Lire / Ecrire

La position initiale de la fenêtre.

Valeur par défaut : GTK_WIN_POS_NONE

Le signal  "activate-default" 

void                user_function                      (GtkWindow *window,
                                                        gpointer   user_data)      : Exécuté Dernier /  Action

Le signal  "activate-focus" 

void                user_function                      (GtkWindow *window,
                                                        gpointer   user_data)      : Exécuté Dernier / Action

Le signal  "frame-event" 

gboolean            user_function                      (GtkWindow *window,
                                                        GdkEvent  *event,
                                                        gpointer   user_data)      : Exécuté Dernier

Le signal "keys-changed" 

void                user_function                      (GtkWindow *window,
                                                        gpointer   user_data)      : Exécuter Premier

Le signal "move-focus" 

void                user_function                      (GtkWindow       *window,
                                                        GtkDirectionType arg1,
                                                        gpointer         user_data)      : Exécuté Dernier / Action

Le signal  "set-focus" 

void                user_function                      (GtkWindow *window,
                                                        GtkWidget *widget,
                                                        gpointer   user_data)      : Exécuté Dernier