Discussion :

[DebiloBob]

Bonjour

Actuellement je développe un petit logiciel permettant (si cela est possible) d'extraire les fichiers audio d'une playlist au format m3u (les autres format viendront par la suite).
Pour l'instant celui-ci fonctionne via la console en passant deux arguments (fichier m3u, répertoire de destination) mais j'aurais voulu par la suite que si l'envie me prenait de faire une interface graphique en GTK pour ce programme, je pourrai le faire sans avoir trop à modifier le code initial.

J'ai vu assez souvent des programmes sous Linux où il existait une version console du logiciel et où l'on pouvait si l'on souhaitait télécharger une version graphique qui venait se "coller" par dessus.

J'aimerais donc savoir si il y a une façon spécifique de concevoir l'implémentation de notre logiciel afin de prévoir ce genre d'évolution par la suite.

Merci d'avance pour vos réponses.

[ironzorg]

Tu pourrais utiliser le principe des plugins: tu codes ton application en mode console, et dedans tu places des '#ifdef' aux endroits ou tu geres l'affichage.
Ainsi, dans ton plugin tu inclues toutes les fonctione d'affichage sur ta GUI. Pour utiliser le plugin il ne te reste plus qu'a le linker avec la version console (le -D de gcc aide).

[LittleWhite]

Bonjour,

Je pense que ce qui est fait, c'est une forte préparation du core de l'application ( la partie qui n'est pas du tout lié à l'utilisateur ), afin de pouvoir communiquer ( envoie d'informations, reception d'evenement ) avec une interface. Du coup on crée un core extremement indépendant, et après on construit une interface autour.
Je ne pense pas que l'utilisation des ifdef soit la meilleure des choses, mais cela peut marcher.

[aurelman]

Pour reprendre l'idée des réponses précédentes.

Pourquoi ne pas implémenter une lib indépendante qui fournit le Core des fonctionnalités de ton outil.
Puis par dessus :
- Puis un programme console linké avec la librairie pour un fonctionnement en mode console.
- Et un programme en mode GUI linké avec la lib pour un fonctionnement en mode GUI.

[pfeuh]

Salut,

J'ai vu assez souvent des programmes sous Linux où il existait une version console du logiciel et où l'on pouvait si l'on souhaitait télécharger une version graphique qui venait se "coller" par dessus.

Je crois que le fait d'encapsuler graphiquement une application console s'appelle du vamping. Dans le principe, l'application console doit pouvoir recevoir en paramètre stdin, stdout et stderr. L'application graphique appelle l'application console en ayant reconfiguré stdin, stdout et stderr, puis se contente de traduire les clicks utilisateurs en commandes console. Dans le principe, c'est assez simple. Le vamping a été très utilisé il y a une quinzaine d'année pour faire croire à de nouvelles versions, alors qu'il ne s'agissait que de l'encapsulation de moteurs ayant fait leurs preuves, en particulier dans le domaine de la base de données.

A+

Pfeuh

[souviron34]

pas forcément...

Il y a aussi le fait d'avoir la même fonctionalité, mais une fois accessible par l'utilisateur sur sa station/son PC, de l'autre disponible en script automatique.. ou en daemon..
(par exemple garantissant le calcul une fois par jour à la même heure)


Et dans ce cas, c'est effectivement le cas dans lequel on programme toute la fonctionalité de manière indépendante, et dans le main on entoure les 2 cas par des ifdef, qui sont appliqués dans le Makefile, et ne font que linker ou non la partie graphique, a partie non-graphique étant elle-même une biblothèque qui par exemple formatte et sort un fichier...

[DebiloBob]

Tout d'abord merci pour toutes vos réponses !

Ensuite désolé pour le retard mais j'ai eu quelques problèmes de logement et de voiture d'où mon absence ces derniers temps.

Maintenant que tout est réglé je vais reprendre le développement de ce petit programme.
Je pense que même si ce n'est pas la meilleure façon de faire, je vais le développer uniquement en mode console pour l'instant et essayerai par la suite de rajouter par dessus un interface graphique car n'ayant jamais fait de graphique en C je ne sais vraiment pas comment m'y prendre d'autant plus que je découvre pas mal de nouvelles choses au travers de ce programme qui me prennent plus de temps à bien comprendre que prévu.

Pour ceux que cela intéresse une fois celui-ci fini je le mettrai en partage afin d'avoir des avis sur la façon que j'ai eu de le développer et celle qu'il faudra adopter afin de rajouter cette fameuse GUI par dessus.

Encore merci à tous d'avoir prit le temps de me répondre.
Bonne soirée.

[AsPrO]

J'utiliserai le design pattern observateur, observé.

1 observé -> ton modèle
n observateur -> ce qui permet de voir ton modèle (console, interface graphique)

Tu dois donc ne surtout pas mélanger modèle et couche graphique.