gtk_set_locale ()

gchar*		 gtk_set_locale		 (void);

gtk_disable_setlocale ()

void 		gtk_disable_setlocale 		(void);

gtk_get_default_language ()

PangoLanguage* 		gtk_get_default_language 		(void);

Cette fonction est équivalente à  pango_language_get_default(). Voir cette fonction dans le détail.

gtk_parse_args ()

gboolean 		gtk_parse_args 		(int *argc,char ***argv);

Vous ne devez pas appeler cette fonction explicitement si vous avez utilisé gtk_init(), ou gtk_init_check().

gtk_init ()

void 		gtk_init 		(int *argc,char ***argv);

Notez qu'il y a des méthodes alternatives pour initialiser GTK+ : vous pouvez appeller gtk_parse_args(), gtk_init_check(), gtk_init_with_args() ou g_option_context_parse() avec l'option de groupe retournée par  gtk_get_option_group(), vous n'avez pas à appeler  gtk_init().

gtk_init_check ()

gboolean 		gtk_init_check 		(int *argc,char ***argv);

De cette façon l'application peut passer à d'autres méthodes de communication avec l'utilisateur - par exemple une interface de commandes en ligne.

gtk_init_with_args ()

gboolean 		gtk_init_with_args 		(int *argc,
							char ***argv,
							char *parameter_string,
							GOptionEntry *entries,
							char *translation_domain,
							GError **error);

Depuis  2.6

gtk_get_option_group ()

GOptionGroup* 		gtk_get_option_group 		(gboolean open_default_display);

Retourne un GOptionGroup pour les arguments de commande en ligne reconnu par GTK+ et GDK. Vous devez ajouter ce groupe à votre  GOptionContext avec g_option_context_add_group(), si vous avez utilisé  g_option_context_parse() pour analyser vos arguments de commande en ligne.

Depuis  2.6

gtk_exit ()

void 		gtk_exit 		(gint error_code);

Elle termine le programme et retourne le code de sortie à l'appelant. Cette fonction arrête le GUI et lébère toutes les ressources allouées pour GTK+.

gtk_events_pending ()

gboolean 		gtk_events_pending 		(void);

	/* déroulement de l'opération */
...
	while (gtk_events_pending ())
	gtk_main_iteration ();
...
	/*l'opération se poursuit */

gtk_main ()

void 		gtk_main		 (void);

gtk_main_level ()

guint 		gtk_main_level 		(void);

Demande  le niveau d'emboîtement de la boucle principale. Cela peut être utile quand on appelle gtk_quit_add().

gtk_main_quit ()

void gtk_main_quit (void);

gtk_main_iteration ()

gboolean		 gtk_main_iteration 		(void);

gtk_main_iteration_do ()

gboolean gtk_main_iteration_do (gboolean blocking);

Exécute une seule itération de la boucle principale. Si aucun événement n'est  disponible soit elle retourne ou bloque selon la valeur de blocking.

gtk_main_do_event ()

void gtk_main_do_event (GdkEvent *event);

Traite un seule événement GDK. Elle est publique pour permettre uniquement le filtrage des événements entre GDK et GTK+. Vous n'aurez pas  besoin habituellement d'appeler cette fonction directement.

Même si vous ne devez pas appeler cette fonction directement, vous pouvez vouloir savoir exactement  comment les événements sont manipulés. Voici ce que cette fonction fait avec les événements : 

GtkModuleInitFunc ()

void		 (*GtkModuleInitFunc) 		(gint *argc,gchar ***argv);

Chaque  module  GTK+ doit avoir une fonction gtk_module_init() avec ce prototype. Cette fonction est appelée après avoir charger le module avec  argc et argv nettoyés de tous arguments que GTK+ a manipulé lui même. 

GtkModuleDisplayInitFunc ()

void (*GtkModuleDisplayInitFunc) (GdkDisplay *display);

Depuis 2.2

gtk_true ()

gboolean gtk_true (void);

Cette fonction est faite pour renvoyer TRUE.  Cela peut être utile par exemple si vous voulez inhiber la suppression d'une fenêtre. Ien sûr vous ne  devrez pas faire cela si l'utilisateur s'attend a une réaction à la suite d'un clic sur l'icône de fermeture de la fenêtre.

##include <gtk/gtk.h>

int
main (int argc, char **argv)
{
   GtkWidget *win, *but;

   gtk_init( &argc, &argv );

   win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
   g_signal_connect (win, "delete-event",
				G_CALLBACK (gtk_true), NULL);
   g_signal_connect (win, "destroy",
				G_CALLBACK (gtk_main_quit), NULL);
   but = gtk_button_new_with_label ("Close yourself. I mean it!");
   g_signal_connect_swapped (but, "clicked",
				G_CALLBACK (gtk_object_destroy), win);
   gtk_container_add (GTK_CONTAINER (win), but);

   gtk_widget_show_all (win);
   gtk_main ();
   return 0;
}

gtk_false ()

gboolean gtk_false (void);

Analogue à gtk_true() cette fonction ne fait rien d'autre que de retourner  FALSE.

gtk_grab_add ()

void		 gtk_grab_add		 (GtkWidget *widget);

Fait du widget le widget d'interception courant. Cela signifie que l'interaction avec les autres widgets de l'application  sont bloqués ainsi que la souris , les événements du clavier sont délivés à ce widget.

gtk_grab_get_current ()

GtkWidget*	 gtk_grab_get_current 	(void);

gtk_grab_remove ()

void 		gtk_grab_remove 	(GtkWidget *widget);

gtk_init_add ()

void 		gtk_init_add 		(GtkFunction function,gpointer data);

gtk_quit_add_destroy ()

void 		gtk_quit_add_destroy 		(guint main_level,GtkObject *object);

gtk_quit_add ()

guint 		gtk_quit_add		 (guint main_level,
					GtkFunction function,
					gpointer data);

Déclare une fonction pour qu'elle soit appelée quand une instance de la boucle principale est laissée.

gtk_quit_add_full ()

guint 			gtk_quit_add_full 			(guint main_level,
								GtkFunction function,
								GtkCallbackMarshal marshal,
								gpointer data,
								GtkDestroyNotify destroy);

Déclare une fonction à appeler quand une instance de la boucle principale se termine. En comparaison de gtk_quit_add() cette fonction ajoute le dispositif pour passer un trieur (marshaller) et  une fonction appélée quand le manipulateur de sortie (quit handler) est libéré.

gtk_quit_remove ()

void 		gtk_quit_remove 		(guint quit_handler_id);

gtk_quit_remove_by_data ()

void 		gtk_quit_remove_by_data 		(gpointer data);

Supprime un handler de sortie identifié par son champ data.

gtk_timeout_add_full ()

guint 			gtk_timeout_add_full 			(guint32 interval,
								GtkFunction function,
								GtkCallbackMarshal marshal,
								gpointer data,
								GtkDestroyNotify destroy);

Déclare une fonction qui doit être appelée périodiquement. Cette fonction sera appelée de façon répétée après un interval en millisecondes jusqu'à ce qu'elle retourne FALSE , à ce moment le timeout est détruit et ne sera plus appelé.

gtk_timeout_add ()

guint 			gtk_timeout_add 			(guint32 interval,
								GtkFunction function,
								gpointer data);

Déclare une fonction à appeler  périodiquement. La fonction sera appelée de façon répétée après  interval en  millisecondes jusqu'à ce qu'elle retourne s FALSE , à ce moment le  timeout est détruit et ne sera plus appelé.

gtk_timeout_remove ()

void gtk_timeout_remove (guint timeout_handler_id);

Supprime le timeout donné, détruisant toutes les informations le concernant.

gtk_idle_add ()

guint 			gtk_idle_add 				(GtkFunction function,
								gpointer data);

Fait en sorte que la boucle principale appelle la fonction donnée si  aucun événement de haute priorité n' attend d'être effectué. La priorité par défaut est GTK_PRIORITY_DEFAULT, ce qui est assez bas.

gtk_idle_add_priority ()

guint 			gtk_idle_add_priority 			(gint priority,
								GtkFunction function,
								gpointer data);

Comme gtk_idle_add() cette fonction vous permet d'avoir un appel de fonction quand la boucle d'événements est ralentie. La différence est que vous pouvez donner une priorité différente avec GTK_PRIORITY_DEFAULT à la fonction ralentie.

gtk_idle_add_full ()

guint 			gtk_idle_add_full 			(gint priority,
								GtkFunction function,
								GtkCallbackMarshal marshal,
								gpointer data,
								GtkDestroyNotify destroy);

Comme gtk_idle_add() cette fonction vous permet d'avoir un appel de fonction quand la boucle d'événement est ralentie. La différence est que vous pouvez donner une priorité différente avec GTK_PRIORITY_DEFAULT  à la fonction ralentie.

gtk_idle_remove ()

void gtk_idle_remove (guint idle_handler_id);

Supprime la fonction ralentie avec l'identifiant donné.

gtk_idle_remove_by_data ()

void gtk_idle_remove_by_data (gpointer data);

Supprime l'identifiant de la fonction ralentie en utilisant les données.

gtk_input_add_full ()

guint 			gtk_input_add_full 			(gint source,
								GdkInputCondition condition,
								GdkInputFunction function,
								GtkCallbackMarshal marshal,
								gpointer data,
								GtkDestroyNotify destroy);

Déclare une fonction à appeler quand une condition devient vraie sur un descripteur de fichier.

gtk_input_remove ()

void gtk_input_remove (guint input_handler_id);

Supprime ma fonction avec l'identifiant donné.

GTK_PRIORITY_REDRAW

#define GTK_PRIORITY_REDRAW (G_PRIORITY_HIGH_IDLE + 20)

Utilisez cette priorité pour redessiner des éléments relatifs. Elle est utilisée de façon interne par GTK+ en attendant le redessinement. Cette priorité est plus faible que  GTK_PRIORITY_RESIZE  pour éviter de redessiner un widget juste avant son redimensionnement (et donc le redessiner encore une fois.). 

GTK_PRIORITY_RESIZE

#define GTK_PRIORITY_RESIZE (G_PRIORITY_HIGH_IDLE + 10)

Utilisez cette priorité pour redimensionner un élément relatif. Elle est utiliser par GTK+ pour calculer la taille des widgets. Cette priorité est plus forte que  GTK_PRIORITY_REDRAW pour éviter le redimensionnement d'un widget qui vient juste d'être redessiné.

GTK_PRIORITY_HIGH

#define GTK_PRIORITY_HIGH G_PRIORITY_HIGH

Utilisez ceci pour des timeouts de haute priorité. Cette priorité n'est jamais utilisée dans GTK+ ainsi tout ce qui est exécuté avec cette priorité devra être exécuté avant tout ce qui est dans la boîte à outils.

GTK_PRIORITY_INTERNAL

#define GTK_PRIORITY_INTERNAL GTK_PRIORITY_REDRAW

Cette priorité concerne les éléments internes de GTK+. Ne l'utilisez pas dans vos applications.

GTK_PRIORITY_DEFAULT

#define GTK_PRIORITY_DEFAULT G_PRIORITY_DEFAULT_IDLE

Priorité par défaut pour les fonctions lentes.

GTK_PRIORITY_LOW

#define GTK_PRIORITY_LOW G_PRIORITY_LOW

Priorité pour tous les tâches de fond très importantes.

gtk_key_snooper_install ()

guint 			gtk_key_snooper_install 		(GtkKeySnoopFunc snooper,
								gpointer func_data);

Installe une fonction espionne de touche qui sera appelée pour tous les événements de touche avant qu'ils soient délivrés normalement.

GtkKeySnoopFunc ()

gint 			(*GtkKeySnoopFunc) 			(GtkWidget *grab_widget,
								GdkEventKey *event,
								gpointer func_data);

Fonction espionne de touche qui est appelée avant qu'un événement normal soit délivré. Elles peuvent être utilisées pour implémenter la minipulation d'événements liés à des définitions de touches.

gtk_key_snooper_remove ()

void 		gtk_key_snooper_remove 			(guint snooper_handler_id);

Suprime la fonction espionne de touche avec l'identifiant donné.Removes the key snooper function with the given id.

gtk_get_current_event ()

GdkEvent* 		gtk_get_current_event 		(void);

Obtient une copie de l'événement courant mis en action par GTK+. Par exemple, si vous obtenez un signal "clicked" provenant de GtkButton, l'événement courant sera le GdkEventButton  qui aura déclenché le signal "clicked". L'événement retourné doit être l ibéré avec  gdk_event_free(). S'il n'y a pas d'événement courant, la fonction retourne NULL.

gtk_get_current_event_time ()

guint32 		gtk_get_current_event_time 		(void);

S'il y a une événement courant et qu'il a "timestamp" , retourne ce "timestamp" , autrement GDK_CURRENT_TIME.

gtk_get_current_event_state ()

gboolean 		gtk_get_current_event_state		 (GdkModifierType *state);

S'il y a un événement courant et qu'il a un champ d'état , met ce champ d'état dans  state  et retourne TRUE, autrement retourne FALSE.

gtk_get_event_widget ()

GtkWidget* 		gtk_get_event_widget		 (GdkEvent *event);

Si event est NULL ou l'événement n'est pas associé à un widget, retourne  NULL, autrement retourne le widget qui reçoit à l'origine l'événement.

gtk_propagate_event ()

void 			gtk_propagate_event			 (GtkWidget *widget,
								GdkEvent *event);

Envoie un événement au widget, propageant l'événement aux widgets parents si l'événement n'est pas traité. Les événementsreçus par GTK+ depuis GDK commencent normalement par gtk_main_do_event().Dépendant du type d'événement, de l'existance de boîtes de dialogue modale, d'interceptions? etc...,  les événements peuvent être propagés; si c'est le cas  cette fonction est utilisée. gtk_propagate_event()  appelle gtk_widget_event() sur chaque widget sur lesquels elle décide d'envoyer l'événement. Ainsi gtk_widget_event() est la fonction de niveau le plus bas; elle imite simplement l'événement et éventuellement un signal sur le widget spécifique à l'événement.  gtk_propagate_event() est de niveau légèrement supérieur, et  gtk_main_do_event() a le niveau le plus haut.

Ceci dit, vous ne devriez pas avoir à utiliser ces fonctions, All that said, you most likely don't want to use any of these functions; la  synthésisation  d'événements est rarement nécessaire.  Consider asking on the mailing list for better ways to achieve your goals. Par exemple, utilisez  gdk_window_invalidate_rect() ou gtk_widget_queue_draw() à la place de faire ce qui a été exposé plus haut.