La glib fournit de nombreuses fonctions et définitions utiles, prêtes à être utilisées lorsqu'on crée des applications GDK et GTK. Je les énumèrerais toutes avec une brève explication. Beaucoup sont des répliques des fonctions standards de la libc, et je ne les détaillerais donc pas trop. Ceci doit surtout servir de référence afin de savoir ce qui est disponible pour être utilisé.
Les définitions pour les bornes de la plupart des types standards sont :
G_MINFLOAT
G_MAXFLOAT
G_MINDOUBLE
G_MAXDOUBLE
G_MINSHORT
G_MAXSHORT
G_MININT
G_MAXINT
G_MINLONG
G_MAXLONG
Voici aussi les redéfinitions de types. Celles qui ne sont pas spécifiées sont configurées dynamiquement selon l'architecture. Évitez surtout de compter sur la taille d'un pointeur si vous voulez un programme portable ! Un pointeur sur un Alpha fait 8 octets, mais il en fait 4 sur un Intel.
char gchar;
short gshort;
long glong;
int gint;
char gboolean;
unsigned char guchar;
unsigned short gushort;
unsigned long gulong;
unsigned int guint;
float gfloat;
double gdouble;
long double gldouble;
void* gpointer;
gint8
guint8
gint16
guint16
gint32
guint32
Les fonctions suivantes servent à créer, gérer et détruire des listes doublement chaînées. Je suppose que vous savez ce qu'est une liste chaînée car leur explication n'entre pas dans le cadre de ce document. Bien sûr, il n'y a pas besoin de les connaître pour une utilisation générale de GTK, mais c'est bien de savoir comment elles fonctionnent.
GList* g_list_alloc (void);
void g_list_free (GList *list);
void g_list_free_1 (GList *list);
GList* g_list_append (GList *list,
gpointer data);
GList* g_list_prepend (GList *list,
gpointer data);
GList* g_list_insert (GList *list,
gpointer data,
gint position);
GList* g_list_remove (GList *list,
gpointer data);
GList* g_list_remove_link (GList *list,
GList *link);
GList* g_list_reverse (GList *list);
GList* g_list_nth (GList *list,
gint n);
GList* g_list_find (GList *list,
gpointer data);
GList* g_list_last (GList *list);
GList* g_list_first (GList *list);
gint g_list_length (GList *list);
void g_list_foreach (GList *list,
GFunc func,
gpointer user_data);
La plupart des fonctions pour les listes simplement chaînées ci-dessous sont identiques à celles vues plus haut. Voici une liste complète :
GSList* g_slist_alloc (void);
void g_slist_free (GSList *list);
void g_slist_free_1 (GSList *list);
GSList* g_slist_append (GSList *list,
gpointer data);
GSList* g_slist_prepend (GSList *list,
gpointer data);
GSList* g_slist_insert (GSList *list,
gpointer data,
gint position);
GSList* g_slist_remove (GSList *list,
gpointer data);
GSList* g_slist_remove_link (GSList *list,
GSList *link);
GSList* g_slist_reverse (GSList *list);
GSList* g_slist_nth (GSList *list,
gint n);
GSList* g_slist_find (GSList *list,
gpointer data);
GSList* g_slist_last (GSList *list);
gint g_slist_length (GSList *list);
void g_slist_foreach (GSList *list,
GFunc func,
gpointer user_data);
gpointer g_malloc (gulong size);
Remplace malloc(). On n'a pas besoin de vérifier la valeur de retour car cela est fait pour nous dans cette fonction.
gpointer g_malloc0 (gulong size);
Identique à la précédente, mais initialise la mémoire à zéro avant de retourner un pointeur vers la zone réservée.
gpointer g_realloc (gpointer mem,
gulong size);
Réalloue size octets de mémoire à partir de mem. Évidemment, la mémoire doit avoir été allouée auparavant.
void g_free (gpointer mem);
Libère la mémoire. Facile.
void g_mem_profile (void);
Produit un profil de la mémoire utilisée, mais requiert l'ajout de #define MEM_PROFILE au début de glib/gmem.c, de refaire un make et un make install.
void g_mem_check (gpointer mem);
Vérifie qu'un emplacement mémoire est valide. Nécessite que l'on ajoute #define MEM_CHECK au début de gmem.c que l'on refasse un make et un make install.
Fonctions des timers...
GTimer* g_timer_new (void);
void g_timer_destroy (GTimer *timer);
void g_timer_start (GTimer *timer);
void g_timer_stop (GTimer *timer);
void g_timer_reset (GTimer *timer);
gdouble g_timer_elapsed (GTimer *timer,
gulong *microseconds);
Un ensemble complet de fonction de gestion des chaînes. Elles semblent toutes très intéressantes et sont sûrement meilleures, à bien des égards, que les fonctions C standards, mais elle nécessitent de la documentation.
GString* g_string_new (gchar *init);
void g_string_free (GString *string,
gint free_segment);
GString* g_string_assign (GString *lval,
gchar *rval);
GString* g_string_truncate (GString *string,
gint len);
GString* g_string_append (GString *string,
gchar *val);
GString* g_string_append_c (GString *string,
gchar c);
GString* g_string_prepend (GString *string,
gchar *val);
GString* g_string_prepend_c (GString *string,
gchar c);
void g_string_sprintf (GString *string,
gchar *fmt,
...);
void g_string_sprintfa (GString *string,
gchar *fmt,
...);
gchar* g_strdup (const gchar *str);
Remplace la fonction strdup. Elle copie le contenu de la chaîne d'origine dans la mémoire venant d'être allouée et retourne un pointeur sur cette zone.
gchar* g_strerror (gint errnum);
Je recommande de l'utiliser pour tous les messages d'erreur. Elle est beaucoup plus propre et plus portable que perror() ou les autres. La sortie est habituellement de la forme :
nom du programme:fonction qui a échoué:fichier ou autre descripteur:strerror
Voici un exemple d'appel utilisé dans le programme « Bonjour tout le monde ! » :
g_print("bonjour_monde:open:%s:%s\n", filename, g_strerror(errno));
void g_error (gchar *format, ...);
Affiche un message d'erreur. Le format est comme printf, mais il ajoute « ** ERROR **: » au début du message et sort du programme. À n'utiliser que pour les erreurs fatales.
void g_warning (gchar *format, ...);
Comme au dessus, mais ajoute « ** WARNING **: », et ne termine pas le programme.
void g_message (gchar *format, ...);
void g_print (gchar *format, ...);
Remplace printf().
Enfin la dernière fonction :
gchar* g_strsignal (gint signum);
Affiche le nom du signal système Unix correspondant au numéro de signal. Utile pour les fonctions génériques de gestion de signaux.
Tout ce qui est ci-dessus est plus ou moins volé à glib.h. Si quelqu'un s'occupe de documenter une fonction, qu'il m'envoit un courrier !