Programmation sous Linux

[mogwai93]

Bonjour

j'ai developpé en C/C++ une mini appli sous Windows

et j'ai des amis qui seraient interessés de l'avoir sous Linux....

ne connaissant pas Linux

j'aimerais avoir quelques conseils sur comment porter le programme (qui à le recoder si besoin)

je n'ai pas de contraintes de durée !

1) mon programme est codé en Win32

--> comment porter ce genre de code ?

2) est-il nécessaire d'installer Linux ?

peut-on simuler le resultat sous Windows ? (si utilisation d'une librairie fonctionnant sur les 2 OS)

un LiveCD peut-il être suffisant ?

3) quel(s) editeur/compilateur(s) utiliser ?

j'utilise DevCpp sous Windows

4) toute autre information utile....

Merci

[Daemonium]

Si tu envoie seulement tes sources aux gens sous linux ils devraient pouvoir se débrouiller pour compiler le programme... sinon ouais, c'est possible de le faire avec un live-cd

[mogwai93]

mais ils ne sont pas développeurs, d'où ma question

[Daemonium]

Faut pas être développeur pour compiler un programme sous linux d'où ma réponse

Mais je pense qu'il va falloir attendre d'autres réponses. C'est quoi comme programme? Il a une interface graphique? Là je sais pas du tout comment ça se passe pour qu'il soit compatible linux...

[tsubasaleguedin]

Faut pas être développeur pour compiler un programme sous linux d'où ma réponse

Mais je pense qu'il va falloir attendre d'autres réponses. C'est quoi comme programme? Il a une interface graphique? Là je sais pas du tout comment ça se passe pour qu'il soit compatible linux...

1- Tous les appels win32 ( ou mfc ) tu dois les remplacer par un GUI portable ( QT, GTK, wxwidget )

2- Si tu utilise DevCpp il y a de forte chance que tu est la version mingw/gcc, donc deja niveau portabilité du code c'est un bon point, tu aura que la partie "graphique" a developper.

3- Pour la distribution c'est un autre soucis, tu peux utiliser Anjuta sous linux qui est un IDE qui sur ton projet va greffer autogen/autoconf, qui permettra de recompiler/installer ton programme sur n'importe quel linux a coup de ./configure, make, make install. Sinon tu peux fournir le binaire directement mais il faut que toute les personnes ciblé par le binaire est plus ou moins les meme version de la LibC, de Gcc, Gtk etc ... par exemple.

Enfin une chose est claire est que pour faire un programme portable il est largement plus simple de le prevoir des le debut, surtout un programme windows en Win32 qui utilise la pompe a message, le register class et tout le bordel.

Car sous GTK par exemple il y a rien de tout ca, tout est masqué par le moteur ... donc ce qui veut dire que l'on est loin du ifdef...

A titre d'exemple le dernier programme que j'ai fais en GTK/OpenGL sous linux, la seul chose que j'ai du modifier pour marcher sans probleme sous windows et de faire un ifdef sur les path des fichiers ( dialogue de selection de fichiers ) pour au lieu d'avoir des /, mettre des \ sous windows.

Sinon tout le reste est passé comme une lettre a la poste avec gcc sous windows ....

[mogwai93]

1- Tous les appels win32 ( ou mfc ) tu dois les remplacer par un GUI portable ( QT, GTK, wxwidget )

ca va pas, pas de mfc

que du win32

2- Si tu utilise DevCpp il y a de forte chance que tu est la version mingw/gcc, donc deja niveau portabilité du code c'est un bon point, tu aura que la partie "graphique" a developper.

oui c'est surtout la partie graphique là qui m'interesse,

le reste devant normalement fonctionner, vu que c'est du calcul et traitement d'informations

Enfin une chose est claire est que pour faire un programme portable il est largement plus simple de le prevoir des le debut, surtout un programme windows en Win32 qui utilise la pompe a message, le register class et tout le bordel.

Car sous GTK par exemple il y a rien de tout ca, tout est masqué par le moteur ... donc ce qui veut dire que l'on est loin du ifdef...

c'etait pas prévu à l'origine, sinon c'est sûr que j'aurais commencé par un truc + portable dès le début

il y a des sites (ou autre) qui montrent sous Linux :

- comment coder une fenetre basique

- gerer les objets que l'on met en ressource

- affichage de widgets

- "la pompe a message, le register class et tout le bordel."

- ...

merci encore

[tsubasaleguedin]

il y a des sites (ou autre) qui montrent sous Linux :

- comment coder une fenetre basique

- gerer les objets que l'on met en ressource

- affichage de widgets

- "la pompe a message, le register class et tout le bordel."

- ...

merci encore

1- http://www.gtk-fr.org/wakka.php?wiki=LesFenetres

2- Les fichiers ressources meme si je les utilises de maniere abusive sous windows ,j'ai jamais cherché sous linux a faire de RC, je lis mes bitmap directement depuis le GUI.

3- http://www.gtk-fr.org/wakka.php?wiki=LesEntreesDeSaisie

4- Oublie la programmation merdeuse a la windows ( register class et tout le bordel ), avec GTK tout ce merdier est masqué sous windows par un simple GTK_init() et Gtk_main... De meme que sur tes bouton tu assigne un CALLBACK ( fonction declenché sur evenement ), ce qui est entre nous beaucoups plus simple et naturel que de traiter un message WM_ pour extraire le bouton cliqué et affecter une action.

5- Je saurais trop te conseiller dans un premier temps de lire http://www.gtk-fr.org/wakka.php?wiki=PageAccueil qui te mettra le pied a l'etrier et ensuite le reste revele du yakafokon :)

good luck

PS: En Gtk et autres lib "bien pensé" tu traite pas de message WM_xx directement, tu est sur une couche au dessus, car effectivement malgré les mauvaise habitude que l'on peut avoir en programmation Win32 c'est pas a toi de gerer le message WM_Paint par exemple car celui devrait etre implicite de par le fait de tes declarations d'objet visible, il en va de meme pour les evenements clavier/souris.

Autre petit details, sous win32 tu creer une fenetre et tu place des objet en X-Y ce qui est pas forcement bien quand tu veux gerer le redimensionnement ( faut tout recalculer les position toussa, enfin le truc bien casse couille ), alors quand GTK par exemple tu declare des "layout" et dans un layout tu met un widget qui a une regle de positionnement par rapport au layout ( center, fit, margin etc .... ), et grace a ca tu peux redimensionner ton application, le layout est respecté et toi tu n'a rien a faire.

PS2: Gtk+DevCpp sous windows http://www.gtk-fr.org/wakka.php?wiki=DevCpp

[Sentinel]

<troll>

Sinon il te reste Java : niveau portabilité c'est quand même plus simple

</troll>

Enfin c'est pas si trollesque que ça, quand on y réfléchit :)

[tsubasaleguedin]

PS3: Si tu cherche l'efficacité a tout prix je te conseil libglabe qui te permet d'utiliser glade3 afin de generer un XML de l'interface graphique.

Quand tu edite ton interface graphique avec glade tu assigne des callback sur les evenement possible d'un widget.

Xml_gui_load("data/interface.glade","window1");

le fichier .glade est un fichier xml.

typedef struct

{

GtkWidget *window1;

GtkWidget *table1;

GtkWidget *menubar;

GtkWidget *button1;

GtkWidget *button2;

GtkWidget *image1;

GtkWidget *image2;

}

Interface;

extern Interface XmlWidget;

void Xml_gui_load (char *path, char *root) {

gui_glade_xml = glade_xml_new(path, root, NULL);

/* chargement de l'interface

le premier paramètre est le nom du fichier glade. Si le deuxième est à NULL,

la fonction chargera TOUT le projet et affichera d'un coup TOUTES les fenètres qu'il contient.

Si l'on souhaite éviter cela on précise en deuxième paramètre le nom du widget racine.

ici "main" est le nom d'une fenêtre du projet. On accèdera donc via le pointeur gui_glade_xml

à cette fenètre et à TOUS les widgets qu'elle contient.

Pour accéder à d'autres fenêtres on répètera l'opération glade_xml_new sur un autre

pointeur.

Une autre technique consiste à charger toute l'interface (2ème paramètre à NULL) et à positionner

les autres fenêtres en propriété caché par défaut (je trouve cela un peu goret mais cela peut servir).

*/

// test de réussite de chargement

if( !gui_glade_xml ) {

Xml_gui_error("Xml.glade loading error\n");

}

/* ici on charge les widgets dans la structure globale

pour cela il faut fournir le nom du widget nommé dans Glade.

On ne nommera donc dans Glade que les widgets chargés par la libglade en laissant le nommage par défaut

pour les autres (pourquoi se fatiguer à renommer tous les widgets. De plus cela permet de voir tout de suite

depuis Glade quels sont les widgets impactés par le code. Un utilisateur ou un développeur y fera plus attention

s'il veut bricoler l'interface).

*/

Xml_widget_load (gui_glade_xml, "window1", &XmlWidget.window1);

Xml_widget_load (gui_glade_xml, "menubar", &XmlWidget.menubar);

Xml_widget_load (gui_glade_xml, "button1", &XmlWidget.button1);

Xml_widget_load (gui_glade_xml, "button2", &XmlWidget.button2);

Xml_widget_load (gui_glade_xml, "image1", &XmlWidget.image1);

Xml_widget_load (gui_glade_xml, "image2", &XmlWidget.image2);

/*Xml_widget_load (gui_glade_xml, "checkbutton1", &XmlWidget.checkbutton1);

Xml_widget_load (gui_glade_xml, "label2", &XmlWidget.label2);*/

/*Handle des widget en poche je peux les reconfigurer si je veux */

/**Couleur et style de la fenetre**/

GdkColor Color = {0, 0xffff, 0xffff, 0xffff};

GtkStyle *windowstyle;

/**Modification du style de la fenetre**/

windowstyle = gtk_style_copy (gtk_widget_get_style (XmlWidget.window1));

windowstyle->bg[GTK_STATE_NORMAL] = Color;

gtk_widget_set_style(XmlWidget.window1,windowstyle);

/* On lie les signaux définis dans Glade à leur fonction de callback */

glade_xml_signal_autoconnect(gui_glade_xml);

return;

}

Dans le bout de code ci dessus je charge le fichier XML passé en argument, et je recupere les handles des widget qui m'interresse dans l'immediat.

Je les stocks dans une structure, afin de pouvoir les manipuler plus tard, bien entendu je suis pas obliger de recuperer TOUT les handles de mon rush de fenetre :)

Libglade marche aussi tres bien sur win32, la seul difference notoire que j'ai rencontré est que sous windows il faut dans mes .h ou j'ai mes callback mettre un G_MODULE_EXPORT devant

/* Describe the interface's events*/

G_MODULE_EXPORT void OnAboutBtn(GtkWidget *pBtn, gpointer data);

G_MODULE_EXPORT void OnQuitInterface(GtkWidget *pWidget, gpointer pData);

G_MODULE_EXPORT void OnSelectA(GtkWidget *pWidget, gpointer Widget);

G_MODULE_EXPORT void OnSelectB(GtkWidget *pWidget, gpointer Widget);

G_MODULE_EXPORT void AddImage(GtkWidget *pWidget, gpointer Widget);

G_MODULE_EXPORT void OnOption(GtkWidget *pBtn, gpointer data);

G_MODULE_EXPORT void CloseOptEvent(GtkWidget *Widget, gpointer data);

G_MODULE_EXPORT void OnStartGL(GtkWidget *pBtn, gpointer data);

Car sinon les boutons de la fenetre n'executé pas leur callback sur windows :)

http://glade.gnome.org/

http://glade.gnome.org/screenshots.html ( La gestion des callback sur les evenements c'est dans signal )

[mogwai93]

<troll>

Sinon il te reste Java : niveau portabilité c'est quand même plus simple

</troll>

Enfin c'est pas si trollesque que ça, quand on y réfléchit :)

Java merci je connais, sinon je n'aurais pas posté

mais niveau "sécurité" ca ne me convient pas

je vais voir le site de GtkFr

pour les ressources, va falloir que je trouve un moyen

car mon programme extrait des fichiers en fonction de certains criteres

[lorinc]

le truc, c'est ça, c'est qu'il y a un paquet de libraries graphique sous linux, et pas une qui est par défaut. Donc il faut que tu en choississe une, et que tu te recode l'interface avec elle.

Aux choix : QT, GTK, wxwidget, avec chacune des avantage et inconvéniants.

GTK, c'est moche à programmer (l'espèce de C pseudo objet bien gruikk, j'aime pas du tout). Par contre, c'est assez léger.

QT, c'est pour moi la plus facile. C++, bien organisée avec des signaux et des slots, rapide (le designer permet de faire des interface rapidement). Mais, c'est lourd. Les libs font ~50Mo, donc obliger les gens à avoir 50Mo de libs pour une appli de trois lignes...

wxWidgets, je connais pas trop. De ce que j'ai vu, c'est assez facile, pas trop lourd, avec un gestionnaire d'évennement à la java (tu as une queue d'évenment dans laquelle tu enregistres des events associés à un id, et des fonctions à appeler associées aux id). assez léger aussi.

[theocrite]

On peut faire du tk ou du sdl aussi.

amsn est en tcl/tk, mais je ne sais pas si il y a des bon bindings en C.

frozen-bubble utilise sdl. Et sdl peut être utilisé avec du C/C++.

Les deux sont multiplateformes.

[tuXXX]

SDL c'est plutôt pour les jeux, pas trop pour faire une interface avec des boutons.

[mogwai93]

question (peut-etre bete) :

comment on sait quelle librairie est installée sur la version de Linux que l'on teste ?

[16ar]

question (peut-etre bete) :

comment on sait quelle librairie est installée sur la version de Linux que l'on teste ?

Ca dépend de ta distribution Linux.

Sous Debian/Ubuntu/Knoppix, un

dpkg -l | grep LENOMDELALIBRAIRIE

(dpkg -l | grep gtk2 : ca me donne tout ce qui contient gtk2 dans le nom du paquet... Ca peut etre python-gtk2 ou bien la vraie librairie de dev : libgtk2-dev)

Si tu recherches si la librairie de dev est installé, en général, tout linux confondu, les include sont dans /usr/include/

Donc faire un ls /usr/include permettra de voir si des repertoire GTK, QT, WxWidget existent :) Si oui, la librairie de dev doit etre présente sur ta machine.

[tuXXX]

Il y a pkg-config :

 $ pkg-config gtk+-2.0 --modversion
$ pkg-config qt-mt --modversion
$ pkg-config QtCore --modversion

(respectivement pour GTK+2, Qt3 et Qt4)

[16ar]

Il y a pkg-config :

 $ pkg-config gtk+-2.0 --modversion
$ pkg-config qt-mt --modversion
$ pkg-config QtCore --modversion

(respectivement pour GTK+2, Qt3 et Qt4)

Oh j'oubliais pkg-config, c'est vrai que c bien utile ! :)

D'ailleurs, si quelqu'un a des lien vers un bon tuto sur les autotools, ca me dit :)

[theocrite]

pkg-config ce n'est pas vraiment lié aux autotools. Tu peux les utiliser pour n'importe quelle compil. Même dans un make tout simple.

Les autotools (autoconf, automake, autoheader, libtool) permettent de faire un configure et de générer des makefiles portables sur différents systèmes.

Comme tutorial, tu as l'autobook (entre autre, il y en a plein le net des tutos) : http://sources.redhat.com/autobook/autobook/autobook.html

[tibtib17]

As-tu essayé d'emuler ton exe windows via Wine?

[16ar]

pkg-config ce n'est pas vraiment lié aux autotools. Tu peux les utiliser pour n'importe quelle compil. Même dans un make tout simple.

Les autotools (autoconf, automake, autoheader, libtool) permettent de faire un configure et de générer des makefiles portables sur différents systèmes.

Comme tutorial, tu as l'autobook (entre autre, il y en a plein le net des tutos) : http://sources.redhat.com/autobook/autobook/autobook.html

Oui je sais que c pas lié aux auto tools, mais c le genre de truc super pratique pour packager une appli ^^

En tout cas, merci pour le lien