Comment utiliser g_application_run

Version imprimable

Bonjour

J'ai essayé de disséquer l'exemple suivant : http://developer.gnome.org/gio/stabl...xample-cmdline

Mon problème, c'est qu'il n'a pas l'air de marcher :(

J'ai rajouté des commentaires dans leur main et un test pour voir plus loin :
Code:

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 int main (int argc, char **argv) { GApplication *app; int status; printf("bon nom : %d\n",g_application_id_is_valid("org.troumad.perso")); app = g_application_new ("org.troumad.perso", G_APPLICATION_HANDLES_COMMAND_LINE); g_signal_connect (app, "command-line", G_CALLBACK (command_line), NULL); g_application_set_inactivity_timeout (app, 10); status = g_application_run (app, argc, argv); /* attend un retour de l'application mère si elle existe */ printf("status = %d\n",status); /* 0 si première, 1 sinon */ if (!status) { printf("Entrez un nombre non nul pour sortir : "); while (!status) { /* sinon, on sort aussitôt du programme et on ne voit rien */ scanf("%d",&status); } } g_object_unref (app); /* fait disparaitre l'application */ return status; }
La seconde application lancée fait toujours l'erreur quand la première s'arrête (rentrer une valeur non nulle) :

Code:

GDBus.Error:org.freedesktop.DBus.Error.NoReply: Message did not receive a reply (timeout by message bus)status = 1

Bonjour

Voici l'état actuel de mon code :

Code:

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
#include <gtk/gtk.h>
 
static void
command_line (GtkApplication *app,
              GApplicationCommandLine *cmdline,gpointer                 user_data)
{
  gchar **argv;
  gint argc;
  gint i;
  GtkWidget *window;
 
  argv = g_application_command_line_get_arguments (cmdline, &argc);
  for (i = 0; i < argc; i++)
    printf("%s\n",argv[i]);
  window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
  gtk_window_set_application (GTK_WINDOW (window), app);
  gtk_widget_show_all (window);
 
  (void)app;
  (void)cmdline;
  (void)user_data;
}
 
 
int
main (int argc, char *argv[])
{
  GApplication *app;
  gint status;
 
  gtk_init (&argc, &argv);
printf("bon nom : %d\n",g_application_id_is_valid("org.troumad.perso"));
  app = g_application_new ("org.troumad.perso",
                           G_APPLICATION_HANDLES_COMMAND_LINE);
  g_signal_connect (app, "command-line", G_CALLBACK (command_line), NULL);
  g_application_set_inactivity_timeout (app, 10);
 
  status = g_application_run (app, argc, argv); /* attend un retour de l'application mère si elle existe */
 
  printf("status = %d\n",status);
  gtk_main ();
  g_object_unref (app);
 
  return status;
}

La seconde fois que je lance le programme, j'ai bien les arguments qui arrivent à la première session.
Mais, j'ai des problèmes au niveau de gtk_window_set_application (GTK_WINDOW (window), app);, de la fin du programme qui tourne en rond.
Il faudrait aussi que je repère la première fois que je lance le programme pour n'exécuter qu'une seule fois gtk_main();. Ceci résoudrait peut-être aussi le problème de fin d'arrêt du programme.

Maintenant, la seconde application rend la main dès qu'elle a passé ses arguments. Il me reste à gérer la fermeture du programme.

Code:

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
#include <gtk/gtk.h>
 
void fonction(GtkApplication *app,int argc, char *argv[])
{
  gint i;
  GtkWidget *window;
 
  for (i = 0; i < argc; i++)
    printf("%s\n",argv[i]);
  window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
  gtk_window_set_application (GTK_WINDOW (window), app);
  gtk_widget_show_all (window);
 
}
 
void fin(GtkWidget *p_widget, gpointer param)
{
  gtk_main_quit();
 /* parametres inutilises */
 (void)p_widget;
 (void)param;
}
 
static void
command_line (GtkApplication *app,
              GApplicationCommandLine *cmdline,gpointer                 user_data)
{
  gchar **argv;
  gint argc;
 
  argv = g_application_command_line_get_arguments (cmdline, &argc);
  fonction(app,argc,argv);
  (void)app;
  (void)cmdline;
  (void)user_data;
}
 
int
main (int argc, char *argv[])
{
  GtkApplication *app;
  gint status;
  gboolean vrai;
 
  gtk_init (&argc, &argv);
printf("bon nom : %d\n",g_application_id_is_valid("org.troumad.perso"));
  app = gtk_application_new ("org.troumad.perso",
                           G_APPLICATION_HANDLES_COMMAND_LINE);
  vrai=g_application_register(G_APPLICATION(app),NULL,NULL);
  printf("vrai = %d\n",vrai);
  vrai=g_application_get_is_remote(G_APPLICATION(app));
  printf("vrai = %d\n",vrai);
  g_signal_connect (app, "command-line", G_CALLBACK (command_line), NULL);
  g_application_set_inactivity_timeout (G_APPLICATION(app), 10);
 
  status = g_application_run (G_APPLICATION(app), argc, argv); /* attend un retour de l'application mère si elle existe */
  printf("status = %d\n",status); /* 0 si première, 1 sinon */
  if (!vrai)
  {
    g_signal_connect (app, "destroy", G_CALLBACK (fin), NULL);
    gtk_main ();
  }
 
  g_object_unref (app);
 
  return status;
}

Bon... ça tourne... Mais uniquement sous Linux !
Sous windows, ça me lance autant d'applications différentes que d'ouvertures de fichiers :(

Voici le corps de mon programme :

Code:

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
#include <gtk/gtk.h>
 
void command_line (GtkApplication *app,   GApplicationCommandLine *cmdline,gpointer param);
 
 
int main (int argc, char *argv[])
{
  gpointer * param; /* pour le passage des paramètres */
[... plein de choses ...]
 GtkApplication *app;
 gboolean vrai;
 
 /* initialisation GTK */
 gtk_init (&argc, &argv);
 param=(void **)malloc(MAX_MAIN*sizeof(void *)) ; /* pour le passage des paramètres */
 param[MAIN_FILS]=NULL;
 param[MAIN_NB_FILS]=(gpointer)malloc(sizeof(unsigned short));
 param[MAIN_WIN]=NULL;
 ((unsigned short **)param)[MAIN_NB_FILS][0]=0;
 
 app = gtk_application_new ("org.troumad.perso",
                           G_APPLICATION_HANDLES_COMMAND_LINE);
 g_application_register(G_APPLICATION(app),NULL,NULL);
 vrai=g_application_get_is_remote(G_APPLICATION(app));
 g_signal_connect (app, "command-line", G_CALLBACK (command_line), param);
 g_application_set_inactivity_timeout (G_APPLICATION(app), 10);
 
 g_application_run (G_APPLICATION(app), argc, argv); /* attend un retour de l'application mère si elle existe */
 if (vrai)
 {
  g_object_unref (app);
  return 0;
 }
 
  gtk_widget_show_all (win);
 
 
 
  [... plein de choses ...]
  win = gtk_window_new (GTK_WINDOW_TOPLEVEL); /* déclaration d'une fenêtre complète */
  param[MAIN_WIN]=(void *)win;
  [... plein de choses ...]
 
  for (i=1;i<argc;i++) /* lors de l'appel de la première session de command_line, la fenêtre mère n'est pas encore connue, */
  {                    /* on repousse ici la création des fenêtre fille en fonction des paramètres */
      faire_liste_fils(ouvre_fichier(win,param,argv[i],0),param);
  }
 
  gtk_main ();
  g_object_unref (app);
 
  return 0;
}
 
void command_line (GtkApplication *app, GApplicationCommandLine *cmdline,gpointer param)
{
  gchar **argv;
  gint argc;
  unsigned short i;
 
  if (((gpointer *)param)[MAIN_WIN]==NULL) return; /* éviter lors de l'ouverture de la première session l'appel à une fenêtre mère inexistante */
  argv = g_application_command_line_get_arguments (cmdline, &argc);
  for (i=1;i<argc;i++)
  {
      faire_liste_fils(ouvre_fichier(((GtkWidget **)param)[MAIN_WIN],param,argv[i],0),param);
  }
  (void)app;
  (void)cmdline;
}

20/03/2012, 14h51
liberforce

Troumad, tu nous dis juste "Comment utiliser g_application_run", mais tu ne nous dis pas ce que tu cherches à faire exactement, donc on ne peut pas vraiment t'aider... Tu essaies de remplacer libunique c'est ça ?
20/03/2012, 15h44
troumad

Je décris un peu dans ce cas...

Mon programme présente une fenêtre principale qui s'ouvre. Après, à partir de cette fenêtre, je peux ouvrir des fenêtres d'éditions de personnages (ou de groupes de personnages). Si j'ouvre mon programme avec comme paramètre un fichier de personnage (ou de groupe), le programme s'ouvre alors avec la fenêtre principale et d'édition associée au fichier.
Cette manipulation avec paramètre permet, par exemple, d'ouvrir des fichiers pour édition directement en cliquant dessus avec un navigateur (thunar, konqueror, explorer...) si l'association est bien faîte avec mes extensions (pers ou grp).
Si on ouvre un fichier à l'édition alors que le programme est déjà lancé avec une fenêtre principale, je souhaite que la fenêtre d'édition du personnage (ou du groupe) soit associée à la fenêtre principale déjà ouverte.
Ceci permet si on ouvre un fichier déjà ouvert de ne pas l'ouvrir à nouveau, mais de mettre au premier plan la fenêtre d'édition déjà ouverte. Ceci permet aussi quand on a ouvert un personnage et qu'ensuite on ouvre un groupe dans lequel il est, d'associer la fenêtre déjà ouverte au groupe plutôt que de l'ouvrir une nouvelle fois. Ceci marche bien sous Linux avec mon programme, mais pas sous windows où c'est comme si je n'avais pas utilisé g_application_run et tout ce qui va avec.

POur info, mon programme est récupérable sur : http://troumad.org/Mes_regles/perso.php (j'ai parlé ici des fenêtres 1, 2 et 3 visibles sur la copie d'écran).
20/03/2012, 22h30
troumad

Une autre description plus simple hors contexte :

J'ai une fenêtre principale et plusieurs petites fenêtres rattachées à la principale.
Ses petites fenêtres ouvrent soit avec un paramètre de la ligne de commande, soit avec la menu de la fenêtre principale.

Quand mon programme se lancent, il vérifie qu'il n'est pas déjà lancé sur le système (même session ? ou même utilisateur ?).
Cas 1 : s'il est la première occurrence il ouvre la fenêtre principale pour regarde les paramètres pour ouvrir si c'est demandé les petites fenêtres.
Cas 2 : s'il n'est pas la première session, il envoie ces paramètres à la première session qui va ouvrir à son compte les petites fenêtres si la ligne de commande le demandait. Après, il se ferme et laisse la première session continuer de tourner.
03/09/2012, 21h00
troumad

J'utilise gtk_application_new qu imarche sous Linux, mais qui sans fonctionner sous windows, n'est pas bloquant.
Enfin, il y a peut-être une astuce pour le faire marcher sous windows...