Tiré de GTK+ Reference Manual

Questions Communes

Questions Communes — Trouver des réponses aux questions communes dans le manuel GTK+.

Questions et réponses

Voici l' "index" du manuel de référence organisé par questions communes "comment je fais ...".  Si vous n'êtes pas certain de savoir ou trouver une réponse à une question dans la documentation, cette liste est un bon départ.

1. General
1.1. Comment puis-je commencer avec GTK+ ?
Le site Web  de GTK+ offre un  tutoriel et un  FAQ. Vous pourrez trouver sur  le site de développeurs de GNOME  encore plus de documentation allant des livres sur papier aux livres en ligne. Après l'étude de cette documentation vous devriez être correctement préparer pour revenir consulter le manuel de référence pour les détails.
1.2. Où puis-je trouver de l'aide au sujet de GTK+, soumettre un rapport de bogue, ou faire une proposition de dispositif ?
Voir la documentation dans ce sujet.
1.3. Comment passer d'une version de GTK+ à une autre ?
Voir la liste des changements incompatibles  de 1.2 à 2.0. Voir ausi, le guide du "portage" de GNOME 2.0  sur http://developer.gnome.org pour consulter quelques discussions détaillées aus sujet du portage de 1;2 à 2.0. Vous pouvez aussi trouver des informations utiles dans la documentation pour des widgets et des fonctions spécifiques.

Si vous avez une question à laquelle ce manuel ne répond pas, ne vous génez pas pour poser cette question dans les listes d'adresses mails et s'il vous plaît enregistrez un rapport de bigue  au sujet de la documentation.
1.4. Comment la gestion de la mémoire fonctionne dans GTK+ ? Dois-je libérer les données retournées par les fonctions ?
Voir la documentation pour GObject et GtkObject . Pour GObject  considérez  particulièrement  g_object_ref() et g_object_unref()GtkObject est une sous-classe de GObject  aussi les même points s'appliquent, sauf s'il a l'état "flottant" (c'est expliqué dans la documentation). 
1.5. Pourquoi mon programme perd de la mémoire, si je détruis un widget immédiatement après l'avoir créé ?
Si GtkFoo n'est pas une fenêtre de niveau supérieur, alors
foo = gtk_foo_new ();
gtk_widget_destroy (foo);
Il y a de la mémoire qui fuit parce que rien n'a assumé la référence flottante initiale. Si vous avez utilisé un widget et que vous ne l'avez pas immédiatement placé dans un container, alors  vous voulez  probablement un compte de référence standard, et non un compte de référence flottante.

Pour l'obtenir, vous devez acquérir une référence pour le widget et abandonner la référence flottante  (“ref and sink” dans le langage de  GTK+) après l'avoir créé :

foo = gtk_foo_new ();
g_object_ref (foo); gtk_object_sink (GTK_OBJECT (foo));

Quand vous voulez  vous débarrassé du widget, vous devez appeler gtk_widget_destroy() pour casser toutes les connexions internes du widget avant de de supprimer votre référence :

gtk_widget_destroy (foo); g_object_unref (foo); 

Quand vous ajoutez immédiatement un widget à un container, il prend à son compte d'assumer la référence initiale flottante et vous n'avez pas besoin de vous soucier du compte de référence... appelez jusue gtk_widget_destroy() pour vous  débarrassé du widget.
1.6. Comment dois-je utiliser GTK+ avec les threads (tâches légères) ?
Ceci est traîté dans la documentation des threads dans GDK  . Voir aussi la documentation de GThread pour portable threading primitives.
1.7. Comment puis-je internationaliser  un programme GTK+ ? 
Beaucoup de personnes utilisent GNU gettext, qui a déjà été utilisé pour installer GLib. Sur un système UNIX ou Linus avec gettext installé, tapez info gettext  pour lire la documentation.

La courte liste de contrôle sur la façon dont employer gettext est : appeler  bindtextdomain() ainsi gettext peut trouver les fichiers contenant vos traductions dans le domaine par défaut. Conventionellement , les gens définissent des macros par commodité ainsi :
#define _(x) gettext (x)
#define N_(x) x
Utilisez N_() (N pour no-op)  pour marquer une chaîne à traduire dans un contexte qui ne permet pas un appel de fonction  gettext() comme dans un tableau initialiseur. Vous pouvez éventuellement avoir à appeler
gettext() sur une chaîne pour trouver réellement la traduction. _() Les deux marquent la chaîne pour la traduire et la traduisent effectivement. (très peu clair....à retraduire !)

De nos jours, GLib fournit des macros communes dans le fichier header gi18n.h, ainsi vous n'avez pas à les définir vous même, vous devez juste inclure ce header.

Le code utilisant ces macros ressemble à ceci :

#include <gi18n.h>

static const char *global_variable = N_("Traduire cette phrase");
static void

make_widgets (void)
{
GtkWidget *label1;
GtkWidget *label2;
label1 = gtk_label_new (_("Une autre phrase à traduire"));
label2 = gtk_label_new (_(global_variable));
...

Les bibliothèques utilisant gettext devraient utiliser dgettext() à la place de gettext(), cela leur permet de sépcifier le domaine de traduction chaque fois qu'elles demandent une traduction. Les bibliothèques devraient aussi éviter d'appeler textdomain(), puisqu'elles  spécifieront le domaine au lieux d'utiliser le default.
Pour dgettext() le  _() macro peut être défini ainsi :

#define _(x) dgettext ("MyDomain", x)

Encore, GLib vient avec le gi18n-lib.h, vous protéger du trouble que pourrait causer la définition des macros à la main. Les macros de ce header prévoient que le domaine de traduction soit spécifié dans la macro GETTEXT_PACKAGE.
1.8. Comment dois-je utiliser les caractères non-ASCII dans les programmes GTK+ ?
GTK+ utilise Unicode (plus exactement UTF-8) pour tous les textes. UTF-8 encode chaque point de code Unicode comme une séqence de un à six bytes et possèdes pas mal de propriétés qui sont autant de bonne raisons de travailler avec du texte Unicode dans les programmes en C:
  • Les caractères ASCII  sont encodés par leurs points code ASCII familier

  • Les caractères ASCII n'apparaissent jamais comme étant une partie d'autres caractères.

  • Le byte zéro ne se produit pas en tant qu'élément d'un caractère, ainsi les chaînes UTF-8 peuvent être manipulées avec la bibliothèque  de fonctions usuelle de C  de manipulation de chaînes terminées par 0.
Plus d'informations au sujet d4Unicode et de UTF-8 peuvent être trouvée dans le FAQ de UTF-8 et d'Unicode pour Unix/Linux . GLib fournit des fonctions pour convertir les chaînes entre UTF-8 et un autre encodage, voir g_locale_to_utf8() et g_convert().

Le texte provenant de source externe ( par exemple des fichiers ou des données utilisateur), doit être converti vers UTF-8 avant d'être manipulé par GTK+.  L'exemple qui suit écrit le contenu d'un fichier texte encodé en ISO-8859-1 to stdout:

gchar *text, *utf8_text;
gsize length;
GError *error = NULL;

if (g_file_get_contents (filename, &text, &length, NULL))
{
utf8_text = g_convert (text, length, "UTF-8", "ISO-8859-1", NULL, NULL, &error);
if (error != NULL)
{
fprintf ("Couldn't convert file %s to UTF-8\n", filename);
g_error_free (error);
}
else
g_print (utf8_text);
}
else
 fprintf (stderr, "Unable to read file %s\n", filename);

Pour des chaînes textuelles dans le code source, il y a plusieurs alternatives pour manipuler un contenu non-ASCII :
direct UTF-8 Si votre éditeur et votre compilateur sont capables de manipuler des sources encodées en UTF-8, il est vraiment plus commode d'utiliser simplement  UTF-8 pour les chaînes textuelles,  puisque  cela vous permet d'éditer les chaînes dans "wysiwyg". Notez que le choix de cette option peut réduire la portabilité de votre code.
escaped UTF-8 Si votre matériel pour chaînes ne peut pas manipuler directerment UTF-8, vous pouvez encore encoder vos chaînes textuelles en UTF-8 en utilisant l' échapement octal ou hexadécimal comme \212 ou \xa8 pour encoder chaque byte. C'est prtable, mais modifier les chaînes avec échapements n'est pas vraiment commode. Faites attention quand vous mélangez des "escapes" héxadécimaux avec du texte ordinaire; "\xa8abcd" est une chaîne de longueur 1 !
runtime conversion Si la chaîne textuelle votre chaîne est représntée dans un encodage que votre matériel pour chaîne peut manipuler (par exemple ISO-8859-1), vous pouvez écrire vos fichiers sources dans cette encodage et utiliser  g_convert() pour convertir les chaînes dans UTF-8 pendant l'exécution. Notez que cela peut être un peu coûteux à l'exécution,ainsi vous pouvez vouloir déplacer la conversion hors des boucles internes.

 Voici un exmple qui montre les trois approches pour utiliser le signe copyright © qui a un point code 169 en Unicode et en ISO-8859-1 et il est représenté dans UTF-8 par les deux bytes 194,169 :

g_print ("direct UTF-8: ©");
g_print ("escaped UTF-8: \302\251");
text = g_convert ("runtime conversion: ©", -1, "ISO-8859-1", "UTF-8", NULL, NULL, NULL);
g_print(text);
g_free (text);

1.9.

Comment utiliser GTK+ avec  C++?

Il y a deux façon d'approcher cela. Les fichiers header de  GTK+ utilisent le sous-ensemble de C qui est aussi valide pour C++, aussi vous pouvez simplement utiliser L'API normal de GTK+ dans un programme C++. Vous pouvez également utiliser un "Raccourcis C++" comme  gtkmm  qui fournit un API natif pour C++.

Quand vous utilisez directement  GTK+, gardez à l'esprit que seules les fonctions peuvent être connectées aux signaux, et non les méthodes. Aussi vous aurez besoin d'utiliser des fonctions globales ou des fonctions de classe "static" pour les connexions des signaux.

Une autre considération commune quand vous utilisez GTK+ directement, est que C++ ne convertira pas implicitement un entier en une énumération.   This comes up when using bitfields;  en  C vous pouvez écrire le code suivant :

gdk_window_set_events (gdk_window, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);

Tandis qu'en  C++ vous devez écrire :

gdk_window_set_events (gdk_window, (GdkEventMask) GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);

Cependant, il y a très peu de fonctions qui demande cet cast.

1.10.

Comment dois-je utiliser  GTK+ avec une autre langage que C ?

Voir la liste des liens de  language  sur http://www.gtk.org.

1.11.

Comment puis-je charger une image ou une animation depuis un fichier ?

Pour charger un fichier image directement dans un widget d'affichage, utilisez  gtk_image_new_from_file() [1]. Pour charger pour un autre but, utilisez  gdk_pixbuf_new_from_file(). Pour charger une animation, utilisez gdk_pixbuf_animation_new_from_file(). gdk_pixbuf_animation_new_from_file() peut aussi charger une image non animée, aussi utilisez la en association avec gdk_pixbuf_animation_is_static_image() pour charger un fichier de type inconnu.

Pour charger une fichier  image ou  animation de façon asynchrone (sans bloquage),  utilisez GdkPixbufLoader.

1.12.

Comment puis-je dessiner du texte ?

Pour dessiner une portion de texte, utilisez un afficheur de document Pango et gdk_draw_layout(), en utilisant un code comme celui-ci:

afficheur = gtk_widget_create_pango_layout (widget, texte);
policedesc = pango_font_description_from_string ("Luxi Mono 12");
pango_layout_set_font_description (afficheur, policedesc); gdk_draw_layout (..., afficheur);
pango_font_description_free (policedesc);
g_object_unref (afficheur);

N'utilisez pas  GdkFont et  gdk_draw_text() qui sont dépréciés.

Voir aussi la section "Text Handling in GTK 2"( Manipulation de texte dans GTK2)  de Portage des applications vers la plateforme GNOME 2.0 .

1.13.

Comment puis-je mesurer la taille d'une portion de text ?

Pour obtenir la taille d'un protion de texte, utilisez le dispositif de Pango et  pango_layout_get_pixel_size(), en utilisant le code suivant :

layout = gtk_widget_create_pango_layout (widget, text);
fontdesc = pango_font_description_from_string ("Luxi Mono 12");
pango_layout_set_font_description (layout, fontdesc); pango_layout_get_pixel_size (layout, &width, &height);
pango_font_description_free (fontdesc);
g_object_unref (layout);

N'utilisez pas la fonction dépréciée gdk_text_width().

Voir aussi la section "Text Handling in GTK 2"( Manipulation de texte dans GTK2)  de Portage des applications vers la plateforme GNOME 2.0 .

1.14.

Pourquoi les types ne sont pas enregistrés si j'utiliser leur macro GTK_TYPE_BLAH  ?

Les macros GTK_TYPE_BLAH sont définies  comme des appels de  gtk_blah_get_type(), et les fonctions  _get_type() sont déclarées comme G_GNUC_CONST  qui permet au compilateur d'optimiser l'appel (call away) s'il apparaît que la valeur n'a pas été utilisée. 

Un solution  commune à ce problème est de placer le résultat dans une variable volatile, qui empêchera le compilateur d'optimiser l'appel (call away).

volatile GType dummy = GTK_TYPE_BLAH;

1.15.

Comment puis-je créer une fenêtre de niveau supérieur transparente ?

Pour rendre une fenêtre transparent, il afut utiliser un visuel qui le supporte. C'est possible en obtenant la carte de couleur RGBA de l'écran avec gdk_screen_get_rgba_colormap() et en le  définissant  dans la fenêtre.Notez que  gdk_screen_get_rgba_colormap() retournera NULL si les fenêtres transparentes ne sont pas supportées sur l'écran; notez aussi que cela peut d'un écran à l'autre, aussi cela  nécessite d'être répété si la fenêtre est déplacée sur un autre écran.

GdkColormap *colormap;

colormap = gdk_screen_get_rgba_colormap (screen);
if (!colormap)
colormap = gtk_screen_get_rgb_colormap (screen);

gtk_widget_set_colormap (widget, colormap);

Une possibilité pour remplir le canal alpha sur une fenêtre est d'utiliser  gdk_draw_rgb_32_image().

Notez  que la présence d'un visuel RGBA ne garantit pas que la fenêtre apparaisse transparente sur l'écran. Sur X, cela requiert un  compositing manager pour fonctionner. Voir gtk_widget_is_composited()   une façon de trouver si le canal alpha sera respecté.

2. Quel widget  dois-je utiliser...
2.1.

...pour les listes et les arbres ?

Voir  vue général des widgets arbre —  vous devez utiliser le widget GtkTreeView . (Une liste est juste un arbre sans branche, aussi le widget arbre est utilisé également.) N'utilisez pas les widgets dépréciés GtkTree ou GtkCList/GtkCTree  dans du code nouvellement écrit, ils sont moins flexibles et il en résulte un interface utilisateur inférieur.

2.2.

...pour l'affichage ou l'édition de texte multi-lignes  ?

Voir  vue générale du  widget texte — vous devez utiliser le widget GtkTextView . N'utilisez pas le widget déprécié  GtkText dans un code nouvellement écrit, il y a un certain  nombre de problèmes qu'il vaut mieux éviter.

Si vous avez seulement une petite quandtité de texte,  GtkLabel peut aussi être approprié bien sûr.  On peut le sélectionnable avec gtk_label_set_selectable(). Pour une entrée  texte d'une seule ligne, voir  GtkEntry.

2.3.

...pour afficher une image ou une animation ?

GtkImage peut afficher des images seulement dans les format que GTK+ comprend. Vous pouvez aussi utiliser  GtkDrawingArea  si vous avez besoin de faire quelque chose de plus complexe, comme dessiner un texte ou un graphique par dessus  l'image.

2.4.

... pour présenter un ensemble de choix exclusifs mutuellement, où Windows utiliserait une combobox ?

Avec  GTK+, un GtkComboBoxest le widget recommandé pour cet usage. Ce widget ressemble soit à une combobox ou  à un menu d'option courant, cela dépend du theme courant. Si vous avez besoin d'une entrée d'éditeur de texte, utilisez GtkComboBoxEntry.

3. GtkWidget
3.1.

Comment puis-je changer la couleur d'un widget ?

Voir gtk_widget_modify_fg(), gtk_widget_modify_bg(), gtk_widget_modify_base(), et gtk_widget_modify_text(). Voir les fichier ressources GTK+ pour plus de détails. Vous pouvez aussi changer la couleur du widget en installant un fichier ressource et en l'analysant avec gtk_rc_add_default_file(). L'avantage du fichier ressource est que les utilisateurs peuvent remplacer la couleur que vous avez choisie.

Pour modifier la couleur de fond d'un widget comme GtkLabel qui n'a pas de fond, placez le dans un  GtkEventBox et définissez  la couleur de fond de event box (boîte d'événements).

3.2.

Comment puis-je changer la police d'un widget ?

Il y a plusieurs réponses possibles, selon ce que vous voulez réaliser exactement. Une des options est gtk_widget_modify_font(). Notez que cette fonction peut être utilisée pour modifier uniquement la taille de la police, comme dans l'éxemple suivant :

PangoFontDesc *font_desc = pango_font_description_new (); 
pango_font_description_set_size (font_desc, 40); //définir la taille de la police
gtk_widget_modify_font (widget, font); //modifier la police dans le widget
pango_font_description_free (font_desc);

Si vous voulez faire modifier le texte d'un  label, vous pouvez utiliser gtk_label_set_markup():

gtk_label_set_markup (label, "<big>big text</big>");

C'est préférable pour beaucoup d'application parce c'est une taille relative au choix de police de l'utilisateur. Voir g_markup_escape_text() si vous construisez ce type de chaînes (en marche).  on the fly. 

Vous pouvez aussi changer le type police d'un widget en plaçant :

gtk-font-name = "Sans 30"

dans un fichier ressource, en l'analysant  avec  gtk_rc_add_default_file().  L'avantage d'un fichier ressource est que les utilisateurs peuvent modifier la police que vous avez choie.  Voir aussi les fichier ressources GTK+ pour plus de détails.

3.3.

Comment dois-je faire pour désactiver/ How do I disable/transformer en fantôme/désensibiliser un  widget?

Dans GTK+ un widget désactivé est  dit "insensitive." Voir gtk_widget_set_sensitive().

4. GtkTextView
4.1.

Comment puis-je obtenir le contenu d'un widget texte entier dans une chaîne ?

Voir gtk_text_buffer_get_bounds() et gtk_text_buffer_get_text() ou gtk_text_iter_get_text().

GtkTextIter debut, fin;
GtkTextBuffer *buffer;
char *text;
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view));
gtk_text_buffer_get_bounds (buffer, &debut, &fin);
text = gtk_text_iter_get_text (&debut, &fin);
/* use text */
g_free (text);

4.2.

Comment faire pour qu'un widget texte affiche entièrement son contenu avec une police spécifique ?

Si vous utilisez gtk_text_buffer_insert_with_tags()avec les tags appropriés pour séléctionner la police, le texte inserré aura l'apparence souhaitée, mais le texte tapé dans le widget par l'utilisateur avant ou après le bloc avec les tags apparaîtra dans les style par défaut.

Pour s'assurer que tout le texte aura l'apparence souhaitée, utilisez  gtk_widget_modify_font() pour modifier la police par défaut du widget.

4.3.

Comment faire en sorte qu'un visualiseur de texte glisse jusqu'à la fin du buffer automatiquement ?

Une bonne solution pour faire en sorte qu'un buffer de texte glisse à la fin, sera de placer une  marque à la fin du buffer, et de lui donner la bonne "gravité". La gravité a pour effet d'inserrer le texte  au niveau de la marque  et avant elle, gardant ainsi la marque à la fin.

Pour vous assurer que la fin du buffer reste visible, utilisez  gtk_text_view_scroll_to_mark() pour glisser jusqu'à la marque après avoir inserré un nouveau texte.

L'application  gtk-demo contient un exemple de cette technique.

5. GtkTreeView
5.1.

Comment associer des donées avec une ligne dans un arbre ?

Rappelez -vous que les colonnes de  GtkTreeModel ne doivent pas nécessairemement  être affcihées. Ainsi vous pouvez placer des données utilisateurs non visibles dans votre modèle comme d'autre données, et les retrouver avec  gtk_tree_model_get(). Voir  la vue générale des widgets arbre.

5.2.

En quoi  GtkTreeView est équivalent à gtk_clist_find_row_from_data()?

Comme il n'y a pas de colonne de données séparée dans  GtkTreeModel, il n'y a pas de construction dans la fonction pour trouver le iter des données. Vous pouvez écrire une fonction spéciale de recherche pour parcourir l'arbre et trouver les données, ou utiliser  gtk_tree_model_foreach()

(As there is no separate data column in the GtkTreeModel, there's no built in function to find the iter from data. You can write a custom searching function to walk the tree and find the data, or use gtk_tree_model_foreach().)
5.3.

Comment puis-je placer une image et un texte dans la même colonne ?

Vous pouvez placer plus d'un GtkCellRenderer dans un simple  GtkTreeViewColumn en utilisant gtk_tree_view_column_pack_start() ou  gtk_tree_view_column_pack_end(). Aussi placez un  GtkCellRendererPixbuf et un GtkCellRendererText dans la colonne.

5.4.

Je peux définir des données facilement dans mes modèles  GtkTreeStore/GtkListStore en utilisant gtk_list_store_set() et gtk_tree_store_set(), mais puis-je les relire ensuite ?

 GtkTreeStore et  GtkListStore appliquent l'interface  GtkTreeModel. Par conséquent, vous pouvez utiliser n'importe quelle fonction que cette interface utilise.La façon la plus simple pour relire l'ensemble des données est d'utiliser  gtk_tree_model_get().

5.5.

Comment puis-je changer la manière dont les nombres sont formatés par  GtkTreeView?

Utilisez gtk_tree_view_insert_column_with_data_func() ou gtk_tree_view_column_set_cell_data_func() et faites la conversion des nombres en chaînes vous-même ( with, say, g_strdup_printf()).

L'exemple qui suit démontre cela :

enum 
{
DOUBLE_COLUMN,
N_COLUMNS
};

GtkListStore *mycolumns;
GtkTreeView *treeview;


void
 my_cell_double_to_text (GtkTreeViewColumn *tree_column,
GtkCellRenderer *cell, GtkTreeModel *tree_model,
GtkTreeIter *iter, gpointer data)
{
GtkCellRendererText *cell_text = (GtkCellRendererText *)cell;
gdouble d;
gchar *text;

/* Pour obtenir la valeur double du modèle. */
gtk_tree_model_get (tree_model, iter, (gint)data, &d, -1);
/* Maintenant nous pouvons formater la valeur nous même. */
text = g_strdup_printf ("%.2f", d);
g_object_set (cell, "text", text, NULL);
g_free (text);
}


void
set_up_new_columns (GtkTreeView *myview)
{
GtkCellRendererText *renderer;
GtkTreeViewColumn *column;
GtkListStore *mycolumns;

/* Créer le modèle de données et l'associer avec le visualiseur d'arbre donné*/
mycolumns = gtk_list_store_new (N_COLUMNS, G_TYPE_DOUBLE);
gtk_tree_view_set_model (myview, GTK_TREE_MODEL (mycolumns));

/* Créer un GtkCellRendererText */
renderer = gtk_cell_renderer_text_new ();

/* Créer une nouvelle colonne qui aura le titre ("Colonne Exemple"),
* elle utilise le rendu créé plus haut qui doublera la valeur
* dans le texte des lignes du modèle associé.
 */
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, "Colonne Exemple");
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, TRUE);

/* Placer la nouvelle colonne après les colonnes précédentes de GtkTreeView. */
gtk_tree_view_append_column (GTK_TREE_VIEW (myview), column);
/* Comme nous avons créé la colonne à la main, nous pouvons la définir à notre
* convenance, par exemple définir sa largeur minimum et maximum, etc.
*/
/* Créer une fonction adaptée qui sera appelée que le contenu de la colonne
* sera affiché. Nous utilisons un pointeur sur func_data comme un index dans notre
* modèle. Cela est commode quand on utilise des listes multi-colonnes.
*/
gtk_tree_view_column_set_cell_data_func (column, renderer,
my_cell_double_to_text,
 (gpointer)DOUBLE_COLUMN, NULL);
}

5.6.

Comment puis-je cacher les flèches de développement dans mon visualiseur d'arbre ?

Définissez la propriété des colonne de développement du visualiseur d'arbre à cacher la colonne. Voir  gtk_tree_view_set_expander_column() et gtk_tree_view_column_set_visible().

6. Utiliser cairo avec GTK+
6.1.

Comment puis-je utiliser cairo pour dessiner dans les application  GTK+  ?

Utilisez gdk_cairo_create() pour obtenir un contexte cairo pour dessiner dans une fenêtre GDK ou pixmap. Voir  Interaction de Cairo  pour plus de fonctions utiles.

6.2.

J'ai créé un contexte cairo avec gdk_cairo_create(), mais quand je l'utilise ensuite, mon dessin ne se voit pas. Pourquoi ?

Tous le dessin dans GTK+ est normalement fait dans un handler d'exposition, et GTK+ créé un pixmap (image 3D)  temporaire  pour utiliser le double buffering pour dessin. Si vous créez un contexte cairo en dehors du handler d'exposition, il sera soutenu par la fenêtre  GDK elle-même, et non par le pixmap de double buffering. Par conséquent, tous les dessins que vous faites avec ce contexte cairo seront remplacés au final par le handler d'exposition, quand le pixmap de double buffering sera recopié.

Solutions possibles à ce problème :

  • Fermer le double buffering, avec gtk_widget_set_double_buffered(). Ce n'est pas l'idéal, car cela peut provoquer des  scintillements.

  • Créer un contexte cairo dans le handle d'exposition. Si vous faites cela,  gdk_create_cairo() fera en sorte que le contexte soit soutenu par le pixmap de double-buffering. C'est la meilleure solution, et elle est utilisée dans tout  GTK+ lui-même.

6.3.

Puis-je  améliorer la performance de mon application en utilisant le backend de Glitz de Cairo ?

Non.  Le backend GDK X11 utiliser le backend cairo X (et les autres backends utilisent leurs backends cairo natifs respectifs). Les développeurs de GTK+ pensent que la meilleure façon d'améliorer la performence graphique de GDK est d'optimiser le backend X de cairo et les chemins de code appropriés dans le serveur X qui est utilisé (particulièrement l'extension du rendu).(pas compris :) )

6.4.

Puis-je utiliser cairo pour dessiner dans un  GdkPixbuf ?

Non, pas encore. La surface de l'image cairo ne supporte pas le format pixel utilisé par GdkPixbuf.



[1] Si le chargement de fichier échoue, gtk_image_new_from_file() n'affichera pas d'image graphique — pour détecter une erreur pour un de vois propres chargements, utilisez  gdk_pixbuf_new_from_file() directement, puis  gtk_image_new_from_pixbuf().