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.

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

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.

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 .

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 .

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;

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);

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é.

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.

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.

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.

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.

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).

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.

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

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);

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.

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.

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.

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(). 

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.

 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().

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);
}

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().

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.

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 :

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 :) )

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