Discussion :

[Babylonne]

Bonjour ,

J’ai développé deux interfaces graphiques distinctes A, B
Je voulais savoir s’il existe un contrôle c++ (genre container) que je peux rajoute à l’interface graphique A et qui permet d’affiche (inclure directement) l’interface graphique B.

Merci pour votre aide

[koala01]

Salut,

Cela dépend énormément de plein de choses...

Si l'interface A et B utilisent la même bibliothèque, il peut devenir assez facile d'intégrer des parties de l'une dans l'autre.

Si ce sont deux interfaces créées avec des bibliothèques IHM différentes, il n'existe, à ma connaissance, rien qui permette d'une quelconque manière d'intégrer une interface créée avec la bibliothèque X dans la bibliothèque Y, et ce, quelle que soient les bibliothèque X et y

Il faut, aussi, voir ce que tu veux intégrer, car, a priori, il serait toujours possible d'utiliser les collections de la STL en les spécialisants pour qu'elles contiennent des pointeurs, mais il faut alors trouver la "bonne granularité" de ce que tu introduira dedans

[Babylonne]

Merci Koala01 pour votre réponse,


Mon besoin est de trouver un contrôle qui peut afficher carrément l'interface d'un application et qui continue a fonctionner normalement sans qu'il est une modification du code.
Pour mieux expliquer mon besoin : je prends l'exemple de deux pages html complètement distinctes. il est possible d'inclure dans la première page un zone qui affiche la deuxième page. C’est exactement ce que je souhaite faire mais avec les interface graphique.

Donc si j'ai bien compris , il n’est pas possible de faire ceci.

Supposant qu'il utilise les mêmes bibliothèques, pouvez vous m'indiquer comme on peut faire cet intégration.

Merci d'avance pour votre aide.

[Bousk]

Bonjour,

dans le cas d'un logiciel IHM Qt, wxWidget et d'un autre OpenGL, on peut intégrer le context OpenGL à l'intérieur de l'application Qt, wxWidget. C'est une opération un peu complexe toutefois.
Intégrer une application wxWidget dans une application Qt par contre, ça me parait encore plus complexe (irréalisable ?). Surtout sans modifier le code de l'application wxWidget.
De même, intégrer une application Qt dans une application Qt me semble fort peu aisé.

[Babylonne]

Bonjour,
Merci pour la reponse,
je vais regarder ces parties : IHM Qt, wxWidget et d'un autre OpenGL

Est ce que vous connaissez le OLE container? il est facile a utiliser mais pour afficher des worpad, excel , word...

est ce que vous pensez que cela peut permettre d'afficher des interface d'autres applications ?

perso j'ai pas reussi , car il affiche tout le temps les interface dans une fenetre separée et ce n'est pas l'objectif.

faut-il que ces interfaces respectent certaines conditions pour qu'elle soient integrables dans le container ?

Merci

[gbdivers]

dans le cas d'un logiciel IHM Qt, wxWidget et d'un autre OpenGL, on peut intégrer le context OpenGL à l'intérieur de l'application Qt, wx

HS : Qt propose déjà par défaut un classe pour créer des contextes OpenGL dans Qt : QGLWidget

Pour la question : il faut que l'application que tu souhaites intégré dans une autre soit prévu dès le départ pour être intégré. C'est le cas effectivement des applications Offices, qui peuvent communiquer entre elles. Ce n'est pas le cas de la majorité des applications.

Une solution classique est de créer une application "front-end" qui va appeler les applications en arrière plan (en mode console) et afficher le résultat (on retrouve souvent ça sous linux). Cela permet d'utiliser les fonctionnalités des applications back-end, mais pas leurs interfaces

[Babylonne]

Merci pour votre reponse,

justement qu'est ce qu'il faut faire pour rendre une application (interface) integrable. (comme word ou autre). y atil de la doc ladessu ..

malheureusement mon 1ere objectif est d'afficher l'interface et pas seulement utiliser les fonctionnalités en arrire plan.

Merci

[koala01]

Je vais etre plus précis:

Il est généralement assez facile d'appeler une application depuis une autre, par contre, si l'idée est réellement d'intégrer un élément de l'interface de l'une dans l'autre, il faudra, généralement, travailler de manière particulièrement réfléchie...

La plupart des bibliothèque IHM travaillent sur un principe basé sur le widget: tout ce que l'on peut afficher et avec quoi l'on peut interagir est considéré comme un widget et, tant que l'on n'est pas qu niveau de la "fenêtre principale", n'importe quel "widget" peut, à peu près, contenir n'importe quel autre (grâce à son / ses layer(s) )

Si l'on prend l'exemple de Qt, il est possible d'intégrer une bonne partie de l'interface d'une application dans une autre, pour autant que l'application soit correctement "modularisée".

ainsi, si tu modularise l'application dont l'interface doit etre insérée dans une autre sous la forme de

1. l'application elle meme avec QMainWindow (ou similaire) et QApplication
2. une bibliothèque contenant des widget et ou des boites de dialogues

il peut devenir possible d'intégrer la bibliothèque à une autre application, et de l'utiliser:

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
54
55
56
 
/* Module.lib */
class MySpecialWidget : public QWidget
{
    Q_OBJECT
    /* ...*/
};
/* ApplicationA */
class MainWindow : public QMainWindow
{
    Q_OBJECT
    private : 
    MySpecialWidget * msw;
};
class ApplicationA : public QApplication
{
    /* ...*/
};
int main()
{
    ApplicationA app;
    MainWindow win;
    win.exec();
}
/* ApplicationB */
class AnotherDialog : public QDialog
{
    Q_OBJECT
    public:
        AnotherDialog() : QDialog()
        {
             msw = new  MySpecialWidget;
             edit = new QLineEdit;
             QGroupBox * box = new QGroupBox;
             box->layout()->addWidget(msw);
             box->setTitle("Imported part");
             QHLayout * layout;
             layout->addWidget(edit);
             layout->addWidget(box);
             setLayout(layout);
        }
    private :
        MySpecialWidget * msw;
        QLineEdit * edit; 
}
 
class ApplicationB : public QApplication
{
    /* ...*/
};
int main()
{
    ApplicationB app;
    AnotherDialog diag;
    diag.show();
}

Il ne faut cependant pas perdre de vue que l'interface graphique d'une application ne représente jamais que la "couche supérieure" de celle-ci...

Il est en effet généralement conseillé de mettre en place ce que l'on appelle le modèle "MVC" (Model, View, Controler).

L'idée est que l'interface graphique représente la vue (ce qui permet à l'utilisateur d'appréhender les données qu'il manipule), qu'elle est directement reliée à une série de contrôleurs (qui s'assurent que ce que l'utilisateur essaye de faire respecte les règles qui sont imposées) et que ces controleurs sont eux même reliés à la partie "métier" de l'application (les données plus ou moins brutes).

On peut donc très facilement se retrouver avec quatre projets, si pas plus:

1. un projet "bibliothèque" pour la partie métier
2. un projet "bibliothèque" pour la partie controleur
3. un projet "bibliothèque" pour la partie interface
4. un projet "application" pour lancer le tout

Par exemple, je travaille actuellement sur une solution dans laquelle il y a une vingtaine de projet "bibliothèques", plus ou moins dépendants les uns des autres et un grand nombre d'applications dont certaines sont toute intégrées dans une application "principale".

Toutes les bibliothèques qui ne sont pas spécifiques à l'interface graphique sont, en outre, testée par une bibliothèque de tests unitaiires dont dépend une application "stand alone", et toutes les bibliothèques de tests unitaires sont enfin utilisées par une dernière application qui va lancer l'ensemble des tests unitaires

Le problème, c'est que je sachant pas exactement ce que tu veux faire, il nous est particulièrement difficile de te guider correctement

Je te conseillerais donc de relire ma signature (surtout la deuxième ligne ), de réfléchir un peu à la manière de nous présenter ce que tu veux obtenir, et de revenir nous voir