Problème d'exécution selon le rep.

Version imprimable

07/04/2010, 10h45
ArnSpin

liaison exécutable et fichier .glade

Bonjour à tous,

Je vous parlais de mes problèmes de compilation d'un code GTK, je reviens à la charge pour vous parler de problèmes d'exécutions... Décidément je suis à la peine.

Voila donc mon tuto est compilé il porte le nom tuto.exe et il se lance merveilleusement bien lorsque le l'exécute depuis le répertoire où est installé Glade (dont je me suis servit pour le créer).

En revanche dès que je l'exécute hors de ce répertoire depuis un terminal (dans mon projet par exemple), ça foire et j'obtiens une belle erreur:

Code:

** (tuto.exe:2824): WARNING **: Élément racine non valide*: «*glade-interface*»

Voila, encore une fois, aucune idée de la provenance de ce warning.
Lors de l'exécution à la main (en cliquant quoi...) le terminal s'ouvre et se referme immédiatement.

Merci encore une fois pour votre aide.
07/04/2010, 15h33
teuf13

Moi j'ai un binaire sur mon système, il n'affiche pas ce message, tout fonctionne, donc tu ne dois pas voir de problème non plus à mon avis.
07/04/2010, 15h40
teuf13

Tout ça pour dire que je n'ai pas la moindre idée de ce que tu as pu faire, tu n'as pas donné de code, pas vraiment expliqué ce que t'essayais de faire, ... Je soupçonne que t'as utilisé l'API gtkbuilder avec un fichier au format glade. Les versions récentes de glade savent enregistrer un fichier au format gtkbuilder (qui est différent du format glade)
09/04/2010, 03h24
liberforce

À vue de nez c'est encore un problème de chemin vers le fichier glade ou gtkbuilder... Le chemin est sans doute relatif et quand l'exécutable est lancé depuis l'IDE, ça marche, et pas en dehors... Il y a des tonnes de questions de ce type dans le forums. Pour le savoir, utilisez la gestion d'erreur nom d'un petit bonhomme ! Les fonctions qui renvoient un GError ne sont pas faites pour les chiens, c'est justement ce qui permet d'avoir des informations sur les opérations qui se passent mal. Au passage, un message comme ça, sans code, c'est aussi utile que quelqu'un qui appelle les pompiers pour un incendie et raccroche sans donner l'adresse...
12/04/2010, 13h19
ArnSpin

le problème s'est résolu en modifiant les paramètres d'enregistrement du fichier Glade. J'ai bidouillé le choix du catalogue d'enregistrement, j'ai choisi 2.16 au lieu de 2.14 et ça s'est résolu...
Je comprends pas vraiment le pourquoi du comment, mais je vais partir du postulat qu'il faut utiliser le 2.16....
04/05/2010, 17h39
ArnSpin

En fait je reviens à la charge avec mon problème, mon incompréhension de Glade et du GTK faisait que je ne métrisais pas bien mon interrogation.
C'est désormais un peu plus le cas.

En fait, pour vous décrire rapidement les choses, j'ai un programme codé en C faisant appel à une interface GTK créée avec GLADE.

J'ai remarqué que l'exécutable de mon programme est dépendant du fichier GLADE contenant toute mon interface.

Cette dépendance m'ennuie.
Je dois pouvoir exécuter le .exe sans me trimbaler à côté le fichier Glade.

Comment procéder ?
04/05/2010, 17h58
gerald3d

Intégrer le texte xml du fichier glade dans ton code source C. Tu crées un const char *StringXml et tu copies en bloc tout le texte du fichier glade.
Ensuite tu peux utiliser cette donnée avec la fonction gtk_builder_add_from_string();

Ce système est très contraignant lors de la conception ou de la modification du programme. A chaque modification de l'interface par Glade il te faudra recopier le texte généré.
04/05/2010, 18h06
liberforce

Rajoute dans ton Makefile une étape avant la compilation :
génère à partir de ton fichier xml un fichier .c contenant une variable du genre:

Code:

const gchar * str_gui = " le contenu de ton fichier xml gtkbuilder généré avec Glade, avec les double quotes 'échappées', c'est à dire précédées d'un backslash pour éviter qu'elles ne soient interprétées.";

Un peu à la manière de ce que produit gdk-pixbuf-csource qui permet d'intégrer des images dans du code. Ensuite, il te suffit d'utiliser gtk_builder_add_from_string pour charger ton interface depuis le contenu de cette variable. Ainsi, tout le code de ton interface graphique se trouve dans l'exécutable.
04/05/2010, 18h31
gerald3d

Une petite question liberforce par rapport à ta réponse. Le fait de modifier le fichier Glade sera-t-il pris en compte lors de la prochaine compilation des sources?
04/05/2010, 19h12
liberforce

Si le Makefile est bien fait, oui. C'est à dire que l'étape de compilation des sources doit dépendre du fichier .c généré, qui lui même doit dépendre du fichier glade, tout ceci se faisant au niveau des règles du Makefile. C'est le même principe qui fait que quand tu modifies un fichier .c, make voit qu'il doit regénérer un fichier .o, appeler l'éditeur de lien, et regénérer l'exécutable final.

Tu peux t'inspirer d'un exemple d'utilisation de gdk-pixbuf-csource :
http://google.com/codesearch/p?hl=fr...pixbuf-csource
04/05/2010, 19h19
gerald3d

Très intéressant. Merci pour l'info.
05/05/2010, 09h10
ArnSpin

Citation:

Envoyé par liberforce

Rajoute dans ton Makefile une étape avant la compilation :
génère à partir de ton fichier xml un fichier .c contenant une variable du genre:

Code:

const gchar * str_gui = " le contenu de ton fichier xml gtkbuilder généré avec Glade, avec les double quotes 'échappées', c'est à dire précédées d'un backslash pour éviter qu'elles ne soient interprétées.";

Un peu à la manière de ce que produit gdk-pixbuf-csource qui permet d'intégrer des images dans du code. Ensuite, il te suffit d'utiliser gtk_builder_add_from_string pour charger ton interface depuis le contenu de cette variable. Ainsi, tout le code de ton interface graphique se trouve dans l'exécutable.

Je ne comprends pas bien, si je devais détailler un peu toutes les étapes, ça risque d'être un peu sommaire.

Donc dans un premier temps j'utilise un code qui va scanner tout ce qui est contenu dans mon fichier xml pour le placer dans un code C contenant une variable gchar * str_gui.....

J'inclue ce code dans mon exécutable et en retire les information depuis la variable gtk_builder_add_from_string...

Et le tour est joué ? Quel est le rôle du makefile dans tout ça ?
Autre question, tu parles bien des " contenues dans le fichier XML ?

[EDIT] Bon en fait j'ai réussi la seconde partie:
c'est à dire: inclure str_gui dans le builder...
Maintenant faudrait automatiser la création de mon fichier C dans le makefile et ça c'est plus délicat, j'ai pas vraiment comprit toute la syntaxe de l'exemple que tu donnes.

Je pense partir sur quelques lignes de codes qui vont à partir du makefile mettre à jour le fichier C en remplaçant les " par des \" et en plaçant \ à la fin de chaque ligne à l'aide de différents sed...
05/05/2010, 18h16
liberforce
Citation:

Envoyé par ArnSpin

Maintenant faudrait automatiser la création de mon fichier C dans le makefile et ça c'est plus délicat, j'ai pas vraiment comprit toute la syntaxe de l'exemple que tu donnes.

Je pense partir sur quelques lignes de codes qui vont à partir du makefile mettre à jour le fichier C en remplaçant les " par des \" et en plaçant \ à la fin de chaque ligne à l'aide de différents sed...

Tu crées un petit programme C qui
1. fait un g_file_get_contents pour lire le fichier
2. remplace les caractères à échapper avec g_strescape (jamais utilisé, mais ça devrait faire l'affaire)
3. crée le contenu de ton fichier .c
4. écrit le fichier sur le disque dur avec par exemple g_file_set_contents
Pour l'étape 3:

Code:

g_strdup_printf ("const gchar *strgui = \"%s\";", escaped_xml);

Et pour la syntaxe du Makefile:
http://gl.developpez.com/tutoriel/outil/makefile/
07/05/2010, 11h49
ArnSpin

Super Merci beaucoup Libforce. Je vais retenter le coup avec toutes ces explications.
J'avais un peu zappé depuis quelques jours je me suis lancé sur un autre problème.
(en fait je fais une mise à jour d'un code / logiciel gtk 1... en le passant sous glade et gtk 2, donc j'ai plein de petits soucis... en tant que débutant c'est pas évident ! Mais je suis tenace !)
01/09/2010, 11h59
ArnSpin

Bonjour à tous,

Je reprends un peu ce sujet parce que les problématiques développées ici que j'avais un temps laissées de coté réapparaissent.

Je me suis donc replongé dans la solution de Liberforce, 2 messages plus haut.
Ce qui ma permit de créer un code C fonctionnel permettant de créer un header contenant mon interface. Ensuite j'utiliser ce header avec un gtk_builder_from_string...

Jusque là tout va bien sauf que je ne sais pas encore comment interfacer ce nouveau code crée avec le makefile.

Actuellement je dois lancer un programme pour construire le .h puis compiler le programme principal.
Evidement j'aimerais que le tout se fasse en une seule étape.
C'est ce qui était proposé dans un lien donné plus haut s'inspirant des gdk_pixbuf_csource.

Problème 1: ce lien n'est plus actif.
Problème 2: je n'ai jamais comprit la syntaxe à utiliser dans mon cas particulier.
01/09/2010, 13h48
liberforce
Lis bien le tutoriel sur les makefiles dont j'ai donné le lien plus haut. Dans ton makefile, tu as une clible qui port le nom de l'exécutable.

Il faut ensuite tu dois générer le fichier .c et le .h qui décrivent ton interface graphique. Le .c contient la déclaration de la chaine (en const gchar *), le .h exporte le nom de la variable avec la directive extern. Tu crées donc une cible pour chacun de ces 2 fichiers, le nom de la cible étant le nom du fichier généré.

Ensuite, tu fais dépendre ces 2 cibles du fichier généré par glade.

Enfin, tu fais dépendre ton exécutable final de ton .c et .h générés.

L'important pour cela c'est de bien comprendre la syntaxe des makefiles pour la gestion des dépendances, qui est assez simple:
Code:

1 2 cible: dépendance1 dépendance2 dépendance3 commande_générant_la_cible

[EDIT] Problème résolu entièrement, ce que je propose plus bas marche aussi !
Merci beaucoup pour ton aide Liberforce :)

en fait je me suis mal exprimé, je vais détailler étapes par étapes ce que j'ai fait jusqu'alors ça sera plus simple pour se comprendre. Je te présente toutes mes excuses, tu me sembles clair, mais je n'arrive toujours pas bien a déterminer ce que tu veux me faire faire concrètement.

1. J'ai un fichier glade ou xml.
2. J'ai crée grâce à ton aide un exécutable qui prends en entrée deux arguments: le nom de fichier xml en entrée, le nom du fichier .h en sortie, pour au final créer la fameuse variable char contenant tout le xml.
(seulement un .h car je ne m'ennuie pas, je déclare tout le contenu de ma variable dans ce .h, je raffinerais plus tard avec un .c)

3. je copie colle le .h au bon endroit dans mon projet
4. je compile et fait l'édition de lien pour créer l'exécutable de mon projet.

Ce que je souhaite faire maintenant c'est automatiser mon étape 2 et 3. en placant ces étapes dans le makefile avec un truc du genre:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 INPUT_FILE = ./GLADE/XDS.xml OUTPUT_FILE = xds_gui.h XML_COMP = ../../cstr_gui_header_file [...] xml: @echo "Creation of $(OUTPUT_FILE)" @$(XML_COMP) $(INPUT_FILE) $(OUTPUT_FILE) [..]
Donc en fait je "à priori" bien utiliser les makefile, les questions que je pause se situent plus au niveau de l'automatisation de la génération des .h et .c en incluant ces phases dans un makefile.

Admettons que ton executable s'appelle hello comme dans l'exemple. Cela donnerait un truc du genre (non testé):
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 CC=gcc CFLAGS=-W -Wall -ansi -pedantic LDFLAGS= EXEC=hello all: $(EXEC) hello: hello.o ui.o $(CC) -o hello hello.o $(LDFLAGS) hello.o: hello.c $(CC) -o hello.o -c hello.c $(CFLAGS) ui.o: ui.c $(CC) -o ui.o -c ui.c $(CFLAGS) ui.c: hello.ui gtk-builder-csource hello.ui > ui.c clean: rm -rf *.o mrproper: clean rm -rf $(EXEC)
Le fichier xml glade au format GtkBuilder s'appelle hello.ui.

Pour générer l'exécutable "hello", tu as besoin de hello.o et ui.o. C'est ui.o le fichier objet qui contient ton interface graphique.

Pour générer ui.o, tu as besoin de ui.c, le fichier source qui contiendra ta variable de type "const gchar*" qui contient le fichier xml formaté comme il convient.

Pour générer ui.c, tu as besoin de hello.ui, ton fichier XML au format GtkBuilder généré par glade. Il contient la description de ton interface graphique. La commande gtk-builder-csource (je l'ai appelée comme ça sur le modèle de gdk-pixbuf-csource, c'est l'outil que tu as développé) regénère le fichier ui.c quand hello.ui est modifié.

Désolé si j'étais allé un peu vite dans les explications, mais ça prend du temps et on part toujours du postulat que la personne en face connait un peu ou s'est penché sur la question, quitte à préciser un peu plus si elle ne trouve pas. Là tu dis avoir trouvé, mais tu ne montres pas ce que tu as fait, donc je laisse ça là au cas où ça en aide quelques uns :D

03/09/2010, 12h05
ArnSpin

j'ai bien comprit tout ça Liberforce.
Je pense qu'il y avait quelques quiproquo dans nos explications :)
Je connaissais le système de cible et de dépendance, mon problème était dans la compréhension de cette ligne:

Code:

gtk-builder-csource hello.ui > ui.c

Je n'imaginais simplement pas utiliser mon exécutable ici... La source de mes questionnements. Pour le reste j'étais ok, mais ça transparaissait peut être pas dans mes explications, car bien que je connaisse quelques trucs, je n'ai pas toujours le langage approprié :)

Mais tout marche convenablement, merci beaucoup :)