Discussion :

[bilred]

Bonjour,

Voila j’ai besoin de faire un équivalant à des Thread
Si c’est possible de me dire si sa existe en GTK+

Si oui, si c’est possible de me donnés un exemple de code avec des Thread en GTK+

Merci d’avance.

[bilred]

En faite voila :

Se que je veux réaliser c’est un mini éditeur de mon mini compilateur (Réaliser avec Flex et Bison)

Mais bon j’ai fait une l’interface avec un bouton Compiler (qui fait appelle à un programme extérieur)

mais lorsque je click sur le bouton, l’interface bloc totalement (le temps de la compilation même chausse pour le bouton Run) c’est pour sa que je vaux séparés les deux processus.

[gerald3d]

je suppose que tu lances ton application avec la fonction system();. La Glib met à ta disposition des fonctions qui te permettent de garder la main de ton application GTK+ tout en éxécutant une application externe. Toutes les fonctions associées se trouvent ici.

Bonne lecture.

[bilred]

Merci pour ta répance


Bonsoir,

si c'est passible de donnée un lien ou un mini code pour
intégré la console dans une fenêtre GTK.

Merci d'avance

[gerald3d]

Quel est le but de ton application au juste?

[bilred]

Bonjour,

Je voudrai réaliser un éditeur de Code Source Simple avec un bouton Compiler et Exécuter.

Bon pour le Compilateur il est déjà intégré à l’éditeur et il me manque juste pour voire le Résulta de la compilation et de l’exécution dans le Terminale (Console) Sa marche déjà mais

Pour faire vrais il faut que je l’intègre dans la fenêtre GTK+.

Merci pour tout les répance d’avance.

[gerald3d]

Ok. Ce qu'il te faut c'est fabriquer ta console.

Par exemple pour lancer ton compilateur tu peux utiliser gboolean g_spawn_command_line_sync(const gchar *command_line, gchar **standard_output, gchar **standard_error, gint *exit_status, GError **error);.
Elle est synchrone. Ce qui va provoquer un gel de l'interface Gtk+ mais ce n'est pas grave en soit pour commencer. Tu pourras par la suite d'aventurer plus avant avec la fonction g_spawn_async_with_pipes(); qui elle est asynchrone.

Phase 1:
Revenons donc à notre première fonction. Comme tu peux le voir tu peux transmettre deux pointeurs sur des pointeurs char. Ils vont te permettre de communiquer à l'application lancée, ici ton compilateur.
La variable gchar **standard_output va te permettre de récupérer toutes les sorties console de ton compilateur.

Phase 2:
Insère dans ton application un GtkTextView. Une fois fait, il ne te reste plus qu'à "écrire" tout ce qui arrive sur gchar **standard_output dans ton GtkTextView.

[gege2061]

Par exemple pour lancer ton compilateur tu peux utiliser gboolean g_spawn_command_line_sync(const gchar *command_line, gchar **standard_output, gchar **standard_error, gint *exit_status, GError **error);.
Elle est synchrone. Ce qui va provoquer un gel de l'interface Gtk+ mais ce n'est pas grave en soit pour commencer. Tu pourras par la suite d'aventurer plus avant avec la fonction g_spawn_async_with_pipes(); qui elle est asynchrone.

Je rajouterai utiliser GIOChannel pour la capture des messages puisqu'il est possible d'utiliser la fonction g_io_add_watch pour appeler une fonction lorsque des données sont reçues. Ça peut semblais être superflue mais ça résout pas mal de problème d'affichage

Phase 2:
Insère dans ton application un GtkTextView. Une fois fait, il ne te reste plus qu'à "écrire" tout ce qui arrive sur gchar **standard_output dans ton GtkTextView.

Par expérience, je conseillerai plutôt un GtkTreeView, ça demande quelques lignes de plus pour la mise en place, mais ensuite les fonctionnalités sont plus simple à mettre en place.

[bilred]

Merci,

Peut tu me donner un exemple d'utilisation de g_io_add_watch pour une commande ls par exemple car j'ai pas très bien compris sur ton lien en anglais

[gerald3d]

De mon côté j'ai décidé, dans ma grande bonté de t'écrire un tout petit code d'exemple sans tenir compte des très bonnes remarques de gege2061 qui a raison d'ailleurs .

Comme je suis fatigué il n'y a aucun commentaire sur ce code. C'est pas grave tu vas comprendre de toute façon. Donc ce code fabrique une fenêtre avec un bouton ouvrir. Lorsque tu cliques dessus il lance la fonction LsStart. Dedans je lance la fonction "ls". Je récupère la sortie console de cette fonction que j'affiche dans un textview. Pour faire tout de même propre le textview est insérer dans un GtkScrolledWindow histoire de ne pas se retrouver avec une fenêtre inutilisable.

Je fini ici pour dire que ce code est loin d'être forcément l'exemple à suivre. Ce que dit gege2061 est bien mieux adapté pour avoir une interaction totale entre l'affichage et le soft lancé. Mais j'ai plus la force d'écrire un code avec les gio_channel ce soir.

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
#include <gtk/gtk.h>
#include <string.h>
 
void LsStart(GtkButton *button, GtkWidget *textview)
{
	gchar *standard_output;
	gchar *standard_error;
	GtkTextBuffer *buffer;
 
	g_spawn_command_line_sync("ls", &standard_output, &standard_error, NULL, NULL);
 
 
	buffer=gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
	gtk_text_buffer_insert_at_cursor(buffer, standard_output,strlen(standard_output));
	gtk_widget_show_all(textview);
}
 
int main(int argc, char *argv[])
{
  gtk_init(&argc, &argv); // Démarrage de GTK+
 
  GtkWidget *ecran=NULL;
  GtkWidget *vBoxPrincipale=NULL;
  GtkWidget *button=NULL;
  GtkWidget *scroll=NULL;
  GtkWidget *textview=NULL;
 
  /* Creation de la fenetre */
  ecran = gtk_window_new(GTK_WINDOW_TOPLEVEL);  
  gtk_window_set_default_size(GTK_WINDOW(ecran), 640, 480);
  gtk_container_set_border_width(GTK_CONTAINER(ecran), 10);
  gtk_window_set_position(GTK_WINDOW(ecran), GTK_WIN_POS_CENTER);
  gtk_window_set_title(GTK_WINDOW(ecran), "console gtk");
  vBoxPrincipale =  gtk_vbox_new(FALSE, 0);
  gtk_container_add(GTK_CONTAINER(ecran), vBoxPrincipale);
	button=gtk_button_new_from_stock(GTK_STOCK_OPEN);
 
	scroll=gtk_scrolled_window_new(NULL, NULL);
  textview=gtk_text_view_new();
  gtk_text_view_set_editable(GTK_TEXT_VIEW(textview), FALSE);
  gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), textview);
  gtk_box_pack_start(GTK_BOX(vBoxPrincipale), button, FALSE, TRUE, 0);
  gtk_box_pack_start(GTK_BOX(vBoxPrincipale), scroll, TRUE, TRUE, 0);
 
  g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(LsStart), textview);
  g_signal_connect(G_OBJECT(ecran), "destroy", G_CALLBACK(gtk_main_quit), NULL);
 
  gtk_widget_show_all(ecran); // On affiche les widgets  
 
  gtk_main();  
 
  return 0;
}

[bilred]

ha! si tout les jour été des jour de bonté.

voila j'attant votre avie. (la suit la prochene émision pour demain)

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
 
#include <sys/wait.h>
#include <glib.h>
 
int main (int argc,char **argv)
{
  GError *err = NULL;   // erreur
  gchar  *result;       // sortie standard de la commande
  gint    exit_status;  // code d'erreur pour la commande
  const gchar *command = "/bin/df -h -x tmpfs -x usbfs";
 
  if (! g_spawn_command_line_sync (command, &result, NULL, &exit_status, &err))
  {
    g_warning ("Failed to spawn command: %s: %s", command, err->message);
    g_error_free (err);
  }
  else
  {
    /* attention, WIFEXITED() et WEXITSTATUS() sont des macros POSIX, BSD 4.3 et
     * SVr4, peut-être pas disponibles sous Windows, je ne sais pas.
     * Si tu n'as pas besoin de savoir si la commande a réussie ou non, tu n'as
     * pas besoin d'utiliser exit_status, afficher stdout et stderr suffisent
     * sans doutes. */
    if (! WIFEXITED (exit_status) || WEXITSTATUS (exit_status) != 0)
      g_warning ("command '%s' failed", command);
    else
    {
      g_print ("%s\n", result);
    }
    /* libération du résultat de la commande (stdout) */
    g_free (result);
  }
 
  return 0;
}

Merci une fois encor. ( je vais tante de prendre en conte vaux remarque )