Discussion :

[pvincent]

Bonjour à tous,

Depuis trois ans, je consacre une partie de mes activités de retraité au développement de GraceGTK (http://gracegtk.sourceforge.net), la version GTK de Grace (http://en.wikipedia.org/wiki/Xmgr et http://plasma-gate.weizmann.ac.il/Grace/)
Mes deux principales motivations sont:

• apprendre GTK,
• ne pas laisser dépérir pour cause de désaffection pour Motif le travail commencé il y a trente ans par Paul J. Turner, poursuivi ensuite par d'autres et concentré dans 75000 lignes de code.

Ce logiciel permet de tracer des graphes (courbes, "bar charts",...), d'exploiter ces résultats ("nonlinear fit", transformation de Fourier,...), et d'obtenir une figure publiable dans une revue scientifique.
Avec l'apparition de GTK-3 je me pose la question: quand faudra-t-il prévoir de rendre compatible le code avec GTK-3, sachant que, si je me base sur mon cas personnel, les utilisateurs de longue date répugnent au changement, tant pour le système d'exploitation que pour les logiciels qu'ils utilisent. Cette attitude est normale, car n'étant pas réellement des informaticiens, une fois qu'ils ont réussi après de long efforts, à obtenir une configuration à leur goût, il n'ont pas envie de recommencer trop souvent, sans parler des nouveaux bogues qui ne sont jamais résolus.

A ce sujet, je déplore que le bogue décrit dans

System beep broken in Karmic despite heroic efforts to fix it
https://bugs.launchpad.net/ubuntu/+s...io/+bug/486154

et que l'on retrouve en fait à de multiples endroits pour un grand nombre de distributions Linux, ne semble toujours pas résolu:

Fixing a bug in Ubuntu is like moving a mountain - System bell/PC speaker bug still plaguing Ubuntu after years
(http://www.reddit.com/r/programming/...ng_a_mountain/)

apparemment, on ne sait pas vraiment quelle bibliothèque rend l'émission du caractère ASCII 7 (BELL, qui de tout temps a permis d'émettre un beep sur le terminal) inopérante. Par exemple Emacs n'émet plus de beep en guise de protestation dans la Debian-6 aussi bien que dans les diverses versions récentes d'Ubuntu. Les responsables des bibliothèques en question pensent évidement que la faute n'est pas la leur mais celle du voisin et ne font rien, alors que ce bogue me semble digne du plus grand intérêt.

Tout ceci me rend bien méfiant viv-à-vis du passage à GTK-3 et finalement la vrai question est: quand GTK+-2 deviendra-t-elle vraiment vieillotte?

[mvvvv]

bonjour

Tout ce que je sais c'est que pour eclipse, GTK3 est loin d'être une priorité

[gerald3d]

Je ne connais pas du tout Grace mais si j'ai bien compris c'est une application pour tracer des courbes paramétrables (je fais simple). Donc le moteur interne de cette application ne regarde pas l'utilisateur final. Je me trompe ?

Si je ne suis pas dans l'erreur rien ne t'empêche de convertir le code en Gtk+3.0 tout en gardant l'apparence visuelle, et ainsi ne pas perturber les habitudes des utilisateurs.

[gerald3d]

J'ai téléchargé le projet pour voir un peu de quoi il en retourne .

[edit] Je viens de compilé le projet avec Gtk+3.0. Finalement il y a peu d'erreurs. Je suis sûr que tu pourrais passer rapidement à Gtk+3.0 sans trop de problèmes.

[gerald3d]

En regardant d'un peu plus prés le code tu n'utilises pas forcément les possibilités de la glib (qui est incluse dans Gtk+).

Il y a en plus beaucoup de créations de boutons qui utilisent les bitmaps. Il serait plus facile d'utiliser ici les GdkPixbuf. Le code serait bien plus court, bien plus lisible et surtout plus facile à porter.

Par exemple (le code en commentaire est le code d'origine) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
void gw_pannel_bitmap_button_set (Gw_pannel *ttt ,GtkWidget *button ,gint n)
{
  GdkPixbuf *pixbuf = NULL;
  /* GdkPixmap *pixmap; */
  GtkWidget *image;
  gint width ,height ,ni;
  ni = (ttt->size_vary) ? n : 0 ;
 
  if (ttt->mask[ni] == NULL) {
    g_error ("gw_pannel_bitmap_button_set called with mask=NULL");
  }
  if (ttt->buttons[n] != NULL) {
    width = ttt->width[ni];
    height = ttt->height[ni];
    /* pixmap = gdk_pixmap_create_from_data (ttt->win  //17 NULL */
    /* 					  ,ttt->bitmaps[n] */
    /* 					  ,width ,height */
    /* 					  ,ttt->depth ,ttt->fg ,ttt->bg[0]); */
 
    pixbuf = gdk_pixbuf_new_from_data (ttt->bitmaps[n],
				       GDK_COLORSPACE_RGB, FALSE,
				       8, width, height, width*3, NULL, NULL);
    image = gtk_image_new_from_pixbuf (pixbuf);
    g_object_unref (pixbuf);
    /* image = gtk_image_new_from_pixmap (pixmap ,ttt->mask[ni]); */
    gtk_widget_show (image);
    gtk_button_set_image (GTK_BUTTON(button) ,image);  
    gtk_button_set_image_position (GTK_BUTTON(button) ,GTK_POS_RIGHT);
  }
}

en utilisant les GdkPixbuf tu pourrais ainsi supprimer toute la gestion des mask d'avant plan et d'arrière plan.

[gerald3d]

J'enfonce le clou . La suite logique est l'utilisation de Glade pour réduire tout ce code. Je me suis permis de modifier le fonction qui gère l'affichage de "l'À propos...".

J'ai donc créé un fichier Glade qui utilise un gtkAboutDialog avec le texte de base. Puis j'ai créé un répertoire "glade" dans le dossier du projet dans lequel j'ai placé le fichier généré.

Comme l'À propos..." comporte des données en temps réel j'ai pris cette considération en compte pour obtenir le même résultat que l'original. Seul petit bémol je n'ai pas géré la couleur du fond de chaque frame. Actuellement tout est unis.

Voila le code résultant pour que tu vois l'avantage du procédé. J'ai volontairement gardé le code d'origine commenté pour pouvoir comparer :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
void gg_print_version_CB ()
{
  /* GtkWidget *about ,*fr ,*vbox; */
  /* char buf[1024]; */
  GtkBuilder *builder = gtk_builder_new();
  GError *error = NULL;
  gchar *label = NULL;
 
  if (!gtk_builder_add_from_file (builder, "glade/aboutdialog.glade", &error))
    {
      g_printerr ("GraceGTK : error in void gg_print_version_CB ();\n");
      g_printerr ("%s\n", error->message);
      exit (error->code);
    }
 
#ifdef HAVE_LIBPDF
  label = g_strdup_printf ("%s\nPDFlib library, Copyright (c) 1997-2004 Thomas Merz and PDFlib GmbH", gtk_label_get_label (GTK_LABEL (gtk_builder_get_object (builder, "labelthirdparty"))));
  gtk_label_set_label (GTK_LABEL (gtk_builder_get_object (builder, "labelthirdparty")));
  g_free (label);
  /* gg_label_new (fr, "PDFlib library, Copyright (c) 1997-2004 Thomas Merz and PDFlib GmbH"); */
#endif
 
  /* Completion the BuildInfo label */
  label = g_strdup_printf ("Host: %s\nTime: %s\nGUI toolkit:  GTK+ %d.%d.%d \nGlib %d.%d.%d \nT1lib: %s ", bi_system(), bi_date(),gtk_major_version
	   ,gtk_minor_version
	   ,gtk_micro_version,glib_major_version
	   ,glib_minor_version
	   ,glib_micro_version, bi_t1lib());
  gtk_label_set_label (GTK_LABEL (gtk_builder_get_object (builder, "BuildInfo")), label);
  g_free (label);
 
  /* FFTW and FFTW3 must be exclusive one from the other */
#ifdef HAVE_FFTW3
  label = g_strdup_printf ("%s\n%s",
			   gtk_label_get_label (GTK_LABEL (gtk_builder_get_object (builder, "BuildInfo"))),
			   bi_fft ());
  gtk_label_set_label (GTK_LABEL (gtk_builder_get_object (builder, "BuildInfo")), label);
  g_free (label);
#endif
#ifdef HAVE_FFTW
  label = g_strdup_printf ("%s\n%s",
			   gtk_label_get_label (GTK_LABEL (gtk_builder_get_object (builder, "BuildInfo"))),
			   bi_fft ());
  gtk_label_set_label (GTK_LABEL (gtk_builder_get_object (builder, "BuildInfo")), label);
  g_free (label);
#endif
 
  gtk_dialog_run (GTK_DIALOG (gtk_builder_get_object (builder, "aboutdialog")));
 
  gtk_widget_destroy (GTK_WIDGET (gtk_builder_get_object (builder, "aboutdialog")));
  g_object_unref (G_OBJECT (builder));
 
/*   about = gtk_dialog_new (); */
/*   /\* vbox = GTK_DIALOG(about)->vbox; *\/ */
/*   vbox = gtk_dialog_get_content_area (GTK_DIALOG(about)); */
/*   gg_label_new (vbox ,bi_version_string() ); */
/*   gg_label_new (vbox ,"This is a beta version, not for production\n"); */
/*   gg_label_new (vbox ,"GraceGTK is an evolution of Grace using the GTK+2 API"); */
/*   gg_label_new (vbox ,"         first proposed by Patrick VINCENT in 2009"); */
/*   gg_label_new (vbox ,"GraceGTK home is htpp://gracegtk.sourceforge.net"); */
/*   fr = gg_frame (vbox ,"Legal stuff" ,&wheat ,0 ,1); */
/*   gg_label_new (fr ,"Portions copyright (c) 1991-1995 Paul J Turner"); */
/*   gg_label_new (fr ,"Portions copyright (c) 1996-2008 Grace Development Team"); */
/*   gg_label_new (fr ,"GraceGTK is distributed under the terms of the GNU General Public License"); */
 
/*   gg_label_new (about ," "); */
/*   fr = gg_frame (vbox ,"Third party copyrights" ,&wheat ,0 ,1); */
/*   gg_label_new (fr ,"Raster driver based on the GD-1.3 library,"); */
/*   gg_label_new (fr ,"      Portions copyright (c) 1994-1998 Cold Spring Harbor Laboratory"); */
/*   gg_label_new (fr ,"      Portions copyright (c) 1996-1998 Boutell.Com, Inc"); */
/*   gg_label_new (fr ,"X-splines and some icons from Xfig (see files)"); */
/* #ifdef HAVE_LIBPDF */
/*   gg_label_new (fr, "PDFlib library, Copyright (c) 1997-2004 Thomas Merz and PDFlib GmbH"); */
/* #endif */
 
 
/*   fr = gg_frame(vbox, "Build info" ,&wheat ,0 ,1); */
 
/*   sprintf (buf, "Host: %s", bi_system()); */
/*   gg_label_new (fr, buf); */
/*   sprintf (buf, "Time: %s", bi_date()); */
/*   gg_label_new (fr, buf); */
 
/*   sprintf (buf ,"GUI toolkit:  GTK+ %d.%d.%d " */
/* 	   ,gtk_major_version */
/* 	   ,gtk_minor_version */
/* 	   ,gtk_micro_version); */
/*   gg_label_new (fr ,buf); */
 
/*   sprintf (buf ,"Glib %d.%d.%d " */
/* 	   ,glib_major_version */
/* 	   ,glib_minor_version */
/* 	   ,glib_micro_version); */
/*   gg_label_new (fr ,buf); */
/*   sprintf (buf, "T1lib: %s ", bi_t1lib()); */
/*   gg_label_new (fr, buf); */
 
/*   /\* FFTW and FFTW3 must be exclusive one from the other *\/ */
/* #ifdef HAVE_FFTW3 */
/*   sprintf (buf, "%s" ,bi_fft ()); */
/*   gg_label_new (fr, buf); */
/* #endif */
/* #ifdef HAVE_FFTW */
/*   sprintf (buf, "%s" ,bi_fft ()); */
/*   gg_label_new (fr, buf); */
/* #endif */
 
/*   gtk_widget_show_all (about); */
 
}

[pvincent]

@gerald3d: merci pour tes suggestions.

Mes réflexions font intervenir d'autres paramètres que ceux évoqués par toi.

Tout d'abord, l'exemple de grace-5.99 me rend prudent: vers l'an 2000, Evgeny Stambulshik, le mainteneur de Grace, c'est lancé dans un grand travail d'amélioration de grace-5.22 sur plusieurs fronts. Il avait mal mesuré l'ampleur de la tâche, et son projet est gelé depuis 2005. Comme il repose sur Motif, il n'y a pas de candidat pour l'aider, et comme la dernière version, n'est pas stable et a perdu un certain nombre de fonctionnalités de Grace-5.22 (et aussi que la programmation, (non pas commentée), n'est pas toujours évidente à comprendre), j'ai préféré partir de Grace-5.22.
C'est aussi ce qu'a fait Andwin qui c'est lancé dans une version Qt de Grace http://qtgrace.sourceforge.net/

Ceci pour dire qu'il ne faut pas avoir plus gros yeux que gros ventre et qu'une démarche prudente et progressive s'impose pour transformer pas à pas un logiciel de 75000 lignes avec un couplage assez fort.

Un autre point, c'est la dépendance vis à vis des bibliothèques. L'excellente séparation entre l'interface graphique (GUI) et le noyau (logiciel métier) de Grace m'a permis de passer de Motif à GTK en passant par une phase de cohabitation des deux, indispensable pour éviter le travail de recréation intégrale du GUI, ce qui serait un travail considérable, et éviter le découragement. Il n'y a pas que pour l'interface graphique que la continuité a été mon fil directeur (http://plasma-gate.weizmann.ac.il/Gr...php?f=3&t=2035)

Je me suis un temps posé la question d'utiliser gtk+extra comme support, mais les difficultés du mariage des deux m'ont fait reculer. La aussi, le problème du suivi dans le temps me semble important: si, indépendamment de son intérêt intrinsèque, Xmgr/Grace est toujours en vie après trente années d'existence, c'est aussi parce qu'il ne dépend pas de nombreuses bibliothèques dont l'adaptation aux nouveaux OS ou compatibilité ascendante ne sont pas toujours assurées. Il faut remarquer que grace-5.22 à 10 ans d'âge et compile toujours sans problème (même si son utilisation de automake n'est plus conforme aux préconisations actuelles).

Sur des points plus précis:

Le widget gw_pannel fait partie de mon auto_initiation pédagogique: je voulais apprendre à créer de nouveaux widgets. Étant parvenu à un résultat fonctionnel correct, je n'ai pas l'intention de revenir dessus. En fait, à partir du moment où l'interface graphique fonctionne correctement, m'a politique est de m'occuper de choses plus intéressantes de mon point de vue, comme rajouter de nouvelles fonctionnalités (LOESS fit, transformée en ondelettes, Follow-me mode...). D'autre part, j'essaye de préserver autant que possible les habitudes des vieux utilisateurs de Grace, donc les menus existants, et le plus simple c'est de transposer directement le code de Motif en GTK.

Je ne sais pas si c'est le cas pour Glade, mais je n'aime pas les outils qui produisent des fichiers intermédiaires souvent peu lisibles (exemple f2c: il vaut mieux garder le fichier Fortran que se coltiner un fichier en C qui n'est pas maintenable).

Pour gg_print_version_CB () même remarque que plus haut: le code est une transposition directe de celui contenu dans Grace.

Pour l'utilisation de la GLib, c'est un peu la même chose: il y a dans Grace une gestion directe et fine des pipes pour la communication avec la bibliothèque d'interfacage libgrace_np (pour le C et le Fortran). L'utilisation de la GLib permettrai sans doute de rendre ceci compatible avec la version MS-Windows, mais je n'ai ni les connaissances, ni le goût pour me lancer dans ce genre de transformation. De plus, m'a paranoïa sur la pérennité des bibliothèques joue sans doute aussi un rôle dans cette attitude.

Mon idée n'est pas de "passer à GTK-3", mais de faire une version compilable aussi bien avec GTK+-2 qu'avec GTK-3 (comme je l'ai fait pour FFTW-2 et FFTW-3). Je sais par expérience que simplement le fait d'avoir à rajouter une nouvelle version d'une bibliothèque peut être dissuasif pour l'utilisateur de GraceGTK. En effet, si il utilise déjà pour d'autres besoins une autre version, il va avoir ensuite à gérer le choix de la bonne version de cette bibliothèque pour ses autres utilisations. Comme ce n'est en général pas un informaticien, ce n'est pas forcément évident pour lui, surtout si les logiciels qu'il utilise sont développés par des scientifiques peut versés dans l'usage des autotools auquel il ne connaît rien lui même.

[gerald3d]

...Je ne sais pas si c'est le cas pour Glade, mais je n'aime pas les outils qui produisent des fichiers intermédiaires souvent peu lisibles (exemple f2c: il vaut mieux garder le fichier Fortran que se coltiner un fichier en C qui n'est pas maintenable).

Glade génère un fichier au format xml. Nul besoin d'aller y mettre les mains. Comme toi j'ai longtemps écrit mes GUI directement en C. Cette démarche est intéressante pour apprendre et comprendre la bibliothèque Gtk+.
Aujourd'hui j'utilise Glade. Je gagne un temps important à l'agencement des GUI et le code C devient minimaliste. Je peux donc me consacrer directement au cœur du programme.

...Pour l'utilisation de la GLib, c'est un peu la même chose: il y a dans Grace une gestion directe et fine des pipes pour la communication avec la bibliothèque d'interfacage libgrace_np (pour le C et le Fortran). L'utilisation de la GLib permettrai sans doute de rendre ceci compatible avec la version MS-Windows, mais je n'ai ni les connaissances, ni le goût pour me lancer dans ce genre de transformation. De plus, m'a paranoïa sur la pérennité des bibliothèques joue sans doute aussi un rôle dans cette attitude.

La Glib fait partie intégrante de Gtk+. C'est une boite à outils qui simplifie grandement la vie. Sans penser à tout changer de nombreuses fonctions te faciliteraient la vie.

...Mon idée n'est pas de "passer à GTK-3", mais de faire une version compilable aussi bien avec GTK+-2 qu'avec GTK-3 (comme je l'ai fait pour FFTW-2 et FFTW-3).

Pour arriver à ce genre de chose il te faut compiler avec les options -DGTK_DISABLE_DEPRECATED=1 -DGDK_DISABLE_DEPRECATED=1 -DGDK_PIXBUF_DISABLE_DEPRECATED=1 -DG_DISABLE_DEPRECATED=1
La dernière version de Gtk+2.0 prépare au passage à Gtk+3.0. Donc toutes les fonctions qui n'existent plus dans la version 3.0 sont passées en obsolètes dans la version 2.0. Ca pourrait te donner une bonne base départ.

[pvincent]

Je peux donc me consacrer directement au cœur du programme.

Je pense que c'est ici que réside notre différence de point de vue: pour moi, le GUI ne pose pas de problème et j'ai déjà une série de fonctions qui sont des adaptations et développement de celles qui existaient pour interfacer Motif dans Grace et qui simplifient l'écriture des popup de façon satisfaisante, donc inutile de refaire à nouveau le travail, surtout que je n'ai pas l'intention de modifier les menus existants.
En fait, j'ai plus de difficulté pour comprendre le fonctionnement de certaines parties purement numériques (Levenberg-Marquardt m'a donné du fil à retordre) non commentées et pas toujours évidentes.

[gerald3d]

Je comprends ta réflexion.

Histoire d'arrêter là ma tentative de te convaincre je me suis amusé à écrire une petite routine de création d'icône. Comme ton code utilise des pixmaps pour créer les images de tes boutons j'ai observé une quantité de lignes de codes juste pour faire ca. Voila ce que ca peux donner sur une de tes fonctions :

Tout d'abord la routine qui va réduire le reste du code et surtout ne plus passer par des GdkPixmaps obsolètes :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
GtkWidget *create_button_icon (const guchar *icon)
{
  GdkPixbuf *pixbuf = NULL;
  GtkWidget *image = NULL;
  gint i,j,k;
  gint offset;
  guchar *pixels = NULL;
  guchar bit;
 
  /* Création d'un pixbuf en fonction du tableau de guchar fourni */
  pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, 16, 16);
  pixels = gdk_pixbuf_get_pixels (pixbuf);
  for (j=0,k=0; j<32; j+=2, k++)
    {
      for (i=7, offset=128; i>=0; i--, offset = offset >> 1)
	{
	  if (icon[j]&offset) bit = 0; else bit = 255;
	  pixels[(i*gdk_pixbuf_get_n_channels (pixbuf))+(k*gdk_pixbuf_get_rowstride(pixbuf))]=
	    bit;
	  pixels[(i*gdk_pixbuf_get_n_channels (pixbuf))+(k*gdk_pixbuf_get_rowstride(pixbuf))+1]=
	    pixels[(i*gdk_pixbuf_get_n_channels (pixbuf))+(k*gdk_pixbuf_get_rowstride(pixbuf))];
	  pixels[(i*gdk_pixbuf_get_n_channels (pixbuf))+(k*gdk_pixbuf_get_rowstride(pixbuf))+2]=
	    pixels[(i*gdk_pixbuf_get_n_channels (pixbuf))+(k*gdk_pixbuf_get_rowstride(pixbuf))];
	  if (bit==0) pixels[(i*gdk_pixbuf_get_n_channels (pixbuf))+(k*gdk_pixbuf_get_rowstride(pixbuf))+3]=255;
 
	  if (icon[j+1]&offset) bit = 0; else bit = 255;
	  pixels[((i+8)*gdk_pixbuf_get_n_channels (pixbuf))+(k*gdk_pixbuf_get_rowstride(pixbuf))]=
	    bit;
	  pixels[((i+8)*gdk_pixbuf_get_n_channels (pixbuf))+(k*gdk_pixbuf_get_rowstride(pixbuf))+1]=
	    pixels[((i+8)*gdk_pixbuf_get_n_channels (pixbuf))+(k*gdk_pixbuf_get_rowstride(pixbuf))];
	  pixels[((i+8)*gdk_pixbuf_get_n_channels (pixbuf))+(k*gdk_pixbuf_get_rowstride(pixbuf))+2]=
	    pixels[((i+8)*gdk_pixbuf_get_n_channels (pixbuf))+(k*gdk_pixbuf_get_rowstride(pixbuf))];
	  if (bit==0) pixels[((i+8)*gdk_pixbuf_get_n_channels (pixbuf))+(k*gdk_pixbuf_get_rowstride(pixbuf))+3]=255;
	}
    }
  image = gtk_image_new_from_pixbuf (pixbuf);
  g_object_unref (pixbuf);
  return image;
}

Cette routine est capable d'utiliser les déclarations des images dans bitmaps.h. Elle gère en plus la transparence de l'icône.

Ensuite prenons la fonction suivante pour voir ce que devient le code :

L'originale :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
GtkWidget *gg_buttonB (GtkWidget *parent ,int side ,int depth
		      ,const unsigned char *bits
		      ,void (*cb) (GtkWidget *w ,gpointer p)
		      ,gint action
		      ,const gchar *tip)
{
  GtkWidget *w_but;
  int i;
  unsigned char *bmask;
  gint nbits = side * side;
  GdkBitmap *mask;
  GdkPixmap *pixmap;
  GtkWidget *image;
  GdkDrawable *win;
  win = gg_get_win ();
  bmask = malloc (nbits * sizeof(char));
  for (i=0; i<nbits; i++) bmask[i] = 0xff;
  mask = gdk_bitmap_create_from_data (win ,(char *)bmask ,side ,side);
  free (bmask);
  pixmap = gdk_pixmap_create_from_data (win
					,(char *)bits
					,side ,side ,depth
					,&gg_colors[1] ,&gg_colors[0]);
  image = gtk_image_new_from_pixmap (pixmap ,mask);
  w_but = gtk_button_new ();
  gtk_button_set_image (GTK_BUTTON(w_but) ,image);
  gg_frame_attach (parent ,w_but);
  g_signal_connect (w_but ,"clicked" , G_CALLBACK (cb) ,GINT_TO_POINTER (action));
  gtk_widget_set_tooltip_text (w_but ,tip);
  return w_but;
}

Le code modifié :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
GtkWidget *gg_buttonB (GtkWidget *parent ,int side ,int depth
		      ,const unsigned char *bits
		      ,void (*cb) (GtkWidget *w ,gpointer p)
		      ,gint action
		      ,const gchar *tip)
{
  GtkWidget *w_but;
 
  w_but = gtk_button_new ();
  gtk_button_set_image (GTK_BUTTON(w_but) , create_button_icon (bits));
  gg_frame_attach (parent ,w_but);
  g_signal_connect (w_but ,"clicked" , G_CALLBACK (cb) ,GINT_TO_POINTER (action));
  gtk_widget_set_tooltip_text (w_but ,tip);
  return w_but;
}

Voila. Promis maintenant j'arrête .

[pvincent]

Je suis admiratif de l'énergie que tu as déployée pour me convaincre des vertus de Glade.

Après tout, je suis peut-être toujours traumatisé par ma première tentative de fabriquer une interface graphique pour un de mes programmes Fortran, il y a une quinzaine d'années. Cette tâche devait être une détente au milieu de mes activités principales d'enseignement et de recherche et QtCreator me semblait être l'outil adéquat. Hélas, je me suis vite aperçu que, si il était facile d'obtenir une fenêtre statique rempli de widgets harmonieusement répartis, la difficulté consistait à la rendre dynamique en interaction étroite avec mon programme, ce qui était indispensable vu le but poursuivi.

Il faut dire qu'a l'époque je ne connaissait rien au C++ et que le module Fortran ISO_C_BINDING n'existait pas encore. Pour couronner le tout, un changement majeur de version de Qt a été fait à ce moment là par Trolltech (Qt2 à Qt3 si mes souvenirs sont exacts).

Finalement, je me suis rabattu sur tix/tcl/tk/swig et je me suis contenté d'une interface plus sommaire que celle dont j'avais rêvé, obtenue après y avoir passé bien plus de temps que prévu, mais qui fonctionne.

Il y a en moi un démon qui murmure: "pourquoi continuer avec ce logiciel mal foutu, maintenant que tu as une vision assez complète de Grace, repart de zéro et construit un programme bien structuré, facile à maintenir,..."
C'est dans cette optique que Glade pourrait être envisagé, mais après deux ou trois heures de cet exercice, on s'aperçoit vite:
* que Grace n'est pas si mal foutue que ça,
* que des compromis sont inévitables quand on définit sa silhouette,
* que la somme de travail pour simplement retrouver les fonctionnalités existantes est très élevée,
* que l'on va introduire de nouveaux bogues,
...

Voilà les raisons qui me poussent à continuer dans la voie actuelle.

[gerald3d]

Ma dernière tentative n'était pas de te convertir à Glade mais de transformer ton code source pour un passage de Gtk2 à Gtk3 en douceur.

Lorsqu'on compile les sources avec les options dépréciés on s'aperçoit qu'une majorité de warnings sont liés à la gestion des GdkGc et autres GdkDrawable. Une première modification tendant à supprimer les GdkDrawable lors de la création de l'interface permet cette conversion sans pour autant complètement dé-structurer l'application.

(Finalement je n'arrive pas à m'arrêter. Faut que je consulte...)

[troumad]

Je suis admiratif de l'énergie que tu as déployée pour me convaincre des vertus de Glade.

C'est un fan de Glade

[gerald3d]

C'est un fan de Glade

J'aime bien c'est vrai

En même temps je ne propose cette solution qu'à des gens qui ont dépassé le stade de l'apprentissage de Gtk+.
Une fois compris la construction d'une interface en pure C il devient intéressant de se pencher sur Glade.

[pvincent]

Dans Grace et GraceGTK l'impression de l'image ("canvas") se fait à travers des pilotes qui permettent de standardiser les appels.
Dans Grace certains des pilotes utilisent des bibliothèques externes (PDFLite, libpng, Jpeg). GTK/Cairo, procure les mêmes fonctionnalités pour un certain nombre de formats et j'ai écrit une version Cairo pour PS, PDF, PNG et SVG (fichier cairo_drv.c) tout en conservant les anciens pilotes. Ceci peut se voir comme un premier pas vers GTK-3.

Le premier problème, c'est que l'écriture des chaînes de caractères dans Grace attaque directement la bibliothèque T1Lib et que Cairo utilise FreeType2 si je ne me trompe pas, donc il faut réécrire l'interface correspondante (fichier t1fonts.c). Pour l'instant, j'utilise une cote mal taillée en gardant l'interface T1Lib et en écrivant les caractères pixel par pixel, ce qui n'est évidemment pas optimal. L'inconvénient, c'est que le logiciel jusqu'ici capable de fournir une version "bundled" de T1Lib devient dépendant de l'installation préalable de FreeType2.

Le deuxième point, c'est de remplacer le pilote GTK actuel (gg_gtkdrv.c) par un pilote Cairo. J'ai toujours un bogue dans mon travail préliminaire, lié au rafraîchissement d'une partie du canvas qui se fait jusqu'ici avec gdk_image_put_pixel(), fonction qui ne doit plus être appelé si on veut utiliser directement Cairo.

Ces points concernent aussi bien GTK+-2 que GTK-3 et il faut que je les règles avant de songer à la suite.

En attendant, je vais poster une nouvelle version (0.5.1) qui étend le mode Follow-me et corrige certains bogues.
En fait un de mes problèmes, c'est que j'ai très peu de retours de bogues. Une des causes est sans doute l'état déplorable de mon site sur sourceforge.net, mais gérer un site WEB n'est définitivement pas ma tasse de thé et je suis envieux de la qualité de celui de Andwin pour QtGrace (http://qtgrace.sourceforge.net/).

[pvincent]

Gérald,
Ton travail n'aura pas été inutile: finalement je me suis débarrassé du GdkPixmap dans gg_buttonB en m'inspirant de ton code.
Comme ta fonction create_button_icon ne fonctionne pas correctement chez moi, j'ai pondu xbitmap_to_gtkimage

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
/**
 * xbitmap_to_gtkimage:
 * @bits: the array in XBM format (Xbitmap)
 * @nx ,ny: the number of bits along Ox and Oy
 *
 * returns the GtkImage in GDK_COLORSPACE_RGB with no alpha channel
 *
 * Note that XBM pad rows to a multiple of 8
 **/
static GtkWidget *xbitmap_to_gtkimage (const unsigned char *bits ,int nx ,int ny)
{
  GtkWidget *image;
  int j ,x ,y;
  GdkPixbuf *pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB ,FALSE ,8 ,nx ,ny);
  guchar    *pixels = gdk_pixbuf_get_pixels 	(pixbuf);
  int    n_channels = gdk_pixbuf_get_n_channels (pixbuf);
  int 	  rowstride = gdk_pixbuf_get_rowstride  (pixbuf);
  int 	        nx8 = rint (ceil ((double)nx/8.0)) * 8;  /* the ceil multiple of 8 for nx */
  int p0 ,p1 ,p2;
  for (y = 0 ,j = 0; y < ny; y++) {
    for (x = 0; x < nx8; x++) {
      if (x < nx) {
	p0 = y*rowstride + x*n_channels; p1 = p0+1; p2 = p1+1;
	if ((bits[j/8] >> (j%8)) & 0x01) {
	  pixels[p0] = pixels[p1] = pixels[p2] = (guchar)0x00;
	} else {
	  pixels[p0] = pixels[p1] = pixels[p2] = (guchar)0xff;
	}
      }
      j++;
    }
  }
  image = gtk_image_new_from_pixbuf (pixbuf);
  g_object_unref (pixbuf);
  return image;
}
 
/**
 *  Create button with bitmap image, callback and tooltip.
 *         Assume square bitmap.
 *  Replace    CreateBitmapButton   motifutils.c  933
 */
GtkWidget *gg_buttonB (GtkWidget *parent ,int side ,int depth
		       ,const unsigned char *bits
		       ,void (*cb) (GtkWidget *w ,gpointer p)
		       ,gint action
		       ,const gchar *tip)
{
  GtkWidget *w_but;
  GtkWidget *image = xbitmap_to_gtkimage (bits ,side ,side);
  w_but = gtk_button_new ();
  gtk_button_set_image (GTK_BUTTON(w_but) ,image);
  gg_frame_attach (parent ,w_but);
  g_signal_connect (w_but ,"clicked" , G_CALLBACK (cb) ,GINT_TO_POINTER (action));
  gtk_widget_set_tooltip_text (w_but ,tip);
  return w_but;
}

qui me donne satisfaction.

Merci pour ta contribution.

[gerald3d]

Content que cette petite discussion t'ai apporté un plus.

Au plaisir de se retrouver sur le forum...