Discussion :

[QAYS]

Bonjour,

J'espère ne pas me tromper de forum

Je vais tenter de la rendre claire, ce n’est pas facile

Je souhaite appeler différents écrans depuis un menu, mais je ne souhaite pas faire l'usage des USES

Exemple j'ai 3 forms, Form1, Form2, Form3 et je veux appeler Form2 et Form3 depuis Form1.

Aujourd’hui dans l'implémentation de Form1 j’utilise Uses Form2, Form3 ; ensuite j'affiche ou travail sur la Form2 la Form3.

Ce que je veux faire c’est la chose suivante :

Je veux avoir un fichier de config dans lequel je spécifie pour ce choix j’appel la form1, pour tel autre le form3 etc..

En résumé :
Fichier.config

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
Menu1;Charger_Form1(parametres…. );
Menu2;Charger_Form2(parametres…. );
.
MenuN;Charger_FormN(parametres…. );

En résumé voila le code que je souhairais avoir (si cela est possible bien sure) :
Je schematise :

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
Unit Unit1
Uses…….
type
Form1 = class(Tform1)
Private
Public
Procedure Gestion_menu(sender :Tobject)
End;
 
Implementation
 
Procedure Form1.Gestion_menu(sender :Tobject)
Begin
If Menu = ‘MENU1’ then Charger_Form1(parametres…. )
Else If Menu = ‘MENU2’ then Charger_Form2(parametres…. )
Else If Menu = ‘MENU3’ then Charger_Form3(parametres…. )
Ect….End ;
 
End.

J’ai pensé au Dll intérressant mais et je souhaiterais voir une autre solution : de fichier bpl,dpk etc.. (ps je ne connais pas grand-chose de ce coté là )

Question 1 Que pensez-vous de cette option
Question 2 avez-vous une autre idée pour ce que je cherche à faire.

PS: j'ai bien vue dansle forum cette discussion http://www.developpez.net/forums/sho...&highlight=bpl mais sui vous avez d'autres info.

Pour information
Form1 mon menu
Form2 est un agenda
Form3 est une messagerie
Form4 est un requeteur
Form5 est un carnet d'adresse
etc....

merci de vos conseils
Merci
Qays

[Clorish]

Tout d'abord ce ci est un bon debut
http://sjrd.developpez.com/delphi/tutoriel/compoplugin/

Ensuite pour ce qui est des packages j'en suis revenu (du moins sous certaines formes) car c'est assez particulier a compiler et puis ca oblige a livrer des paquets supplementaires ...

Sinon pour ce qui est des Dlls, tant que tu reste sur l'affichage de forms independantes, ou de traitements non graphique, c'est plutot tres simple.

Voici de quoi bien debuter :

Coté Dll :
1 - Creer une interface :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
IPlugin = Interface
  [...]  // Tapper Ctrl+Shift+G
  PRocedure CreateForm; Stdcall;
  PRocedure ReleaseForm; Stdcall;
  Procedure ShowForm; Stdcall;
  etc...
End;

2 - Creer une classe "plugin"

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
TPlugin = Class(TInterfacedObject, IPlugin)
Private 
  _Form : TForm1;
Public
  {  Interface IPlugin  }
  PRocedure CreateForm; Stdcall;
  PRocedure ReleaseForm; StdCall;
  Procedure ShowForm; StdCall;
End;

3 - Implemnter les focntions de l'interface

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
 
PRocedure TPlugin.CreateForm;
Begin
Self._Form := TForm1.Create(Nil);
<Initialisation>
End;
 
PRocedure TPlugin.ReleaseForm;
Begin
Self._Form.Release;
End;
 
Procedure TPlugin.ShowForm;
Begin
Self._Form.Show;
End;

4 - Creer une fonction pour recuperer l'interfac eet l'exporter :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
Function GetPluginInterface : IPlugin; Stdcall;
Begin
Result := TPlugin.Create;
End;
 
Exports
  GetPluginInterface name 'GetPluginInterface';

Coté EXE :
1 - Importer l'unitee contenant l'interface (le mieux est qu'elle soit dans un fichier toute seule)

2 - Charger la Dll et la methode Get :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
Var 
  PluginH : THandle;
  GetPluginInterface : IPlugin;
  Plugin : IPlugin;
 
[..]
PluginH := LoadLibrary('...');
If PluginH = 0 Then Raise Exception.Create('Erreur chargement Dll');
@GetPluginInterface := GetProcAdress(PluginH, 'GetPluginInterface');
If not Assigned(GetPluginInterface) Then Raise Exception.Create('Erreur chargement plugin');
Plugin := GetPluginInterface;

3 - MAnipuler le plugin :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
Plugin.CreateForm;
Plugin.ShowForm;
[...]

[QAYS]

merci beaucoup, je vais regardé, cela rapidement, et vous donne des nouvelles

[Clorish]

PRecision : Tu peux creer un plugin par form ...
ou moduler ta classe plugin pour creer Telle ou Telle Form ....

Tu peux aussi definir une interface commune a toutes tes forms et certaines (derivant de la premiere) specialise sur la manipulation de telle ou telle fonctions.

Pour cela il suffit de rajouter les interfaces a la classe plugin et de les implementer :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
TPlugin )= Class(TInterfacedObject, IPlugin, IPluginMessagerie, ...);

Tu peux passer d'une interface a l'autre via l'operateur "As"

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
Var MessPlug : IPluginMessagerie;
Plugin : IPlugin;
 
MessPlug := Plugin as IPluginMessagerie;

[QAYS]

merci,

Petite précision est il possible de transformer ma forme(agenda, messagerie etc...) en package.

En effet j'ai un fichier Agenda.DPR, messagerie.DPR etc... et je voudrais donc créer un fichier Agenda.BPL, messagerie.BPL etc... est ce que cela est possible ?

Cordialement

[Clorish]

oui mais je te deconseille de le faire
La gestion sous forme de BPL est assez acasse pieds et selon la proposition de SJRD sur le tuto proposé, tu passera quand meme par des Interfaces

Personnelement je n'utilise plus que des Dlls ... les packages sont a usage limité.

Sinon tu fait : "Nouveaux/ autres / Paquets" et tu ajoute toutes les unitees que tu as dans ton projet dans ce paquets.

[Lung]

Ensuite pour ce qui est des packages j'en suis revenu (du moins sous certaines formes) car c'est assez particulier a compiler et puis ca oblige a livrer des paquets supplementaires ...

Pareil que toi pour les mêmes raisons. C'est pour ça que ton système de plugins m'intéresse.
Par contre, je n'ai jamais utilisé les interfaces, et je ne comprend pas à quoi elles servent.
Tu pourrais développer un peu ...

[Clorish]

Disons que sur le principe, chaque language code et gere ses objets a sa facon de telle maniere qu'un objet "Delphi" ne peut pas etre transmis a une application code en C++ car meme si les classes sont code de maniere rigoureusement identique (meme procedures, memes variables, etc ...) elles n'en sont pas moins code differement en memoire.

donc affecter l'adresse d'un objet delphi dans une variable de son homologue C++ entrainera des erreurs car la lecture et le traitement des données a partir de cette adresse sera fait differement selon qu'on se trouve du code Delphi ou du cote C++.

C'est le meme principe que l'on retrouve avec les directives stdcall, cdecl, safecall, etc ... car l'odre des parametre reelement traité differement selon que l'on code en C ou en Pascal. Stdcall etant une gestion "standard" des appels.

De meme, Creer une interface cree une sorte "d'espace memoire" rigoureusement identique pour chaques langages dans lequel sera stocké les informations relatives aux fonctions implementee dans la classe.
Chaque language utilisant les interfaces doit respecter ce "standard".

Du coup quand on manipule un objet via son interface, on est sur que les fonctions appelles et definie dans l'interface seront accessible et traitee correctemetn d'un language a l'autre.

Pour la technique je crois que ca se passe dans la table viruelle des fonctions ....

Du coup, on peux ainsi transmettre des "Objets" d'une Dll a un exe (en fait une serie de fonctions) sans problemes.

Voila pour les bases,
Si tu veux en saoir plus ya pas de soucis, mais guide moi sur les points que tu souhaites car c'est un dommaine tres vague

[Lung]

Du coup, on peux ainsi transmettre des "Objets" d'une Dll a un exe (en fait une serie de fonctions) sans problemes.

Même un TDatabase ?

[Clorish]

Bha ouais pkoi pas

En fait tu ne transmet pas directement l'objet en lui meme ....
Tu transmet un moyen de l'utiliser.

D'ailleur les interfaces ne cervent qui tres rarement a exporter directement l'objet ciblé.

C'est a dire que pour exporter un "TButton" par exemple, on n'exporte pas un objet du type :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
TExportedButton = Class(TButton, IButton)

Mais plutot une classe de la sorte :

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
 
IButton = Interface
  Procedure SetCaption(ACaption :TCaption); StdCall;
  Fucntion GetCaption : TCaption; Stdcall;
  Property Caption : TCaption Read GetCaption Write SetCaption;
  // Et oui les prop sont aussi exportables :) mais c'ets special ...
  // Je prefere les Focntions.
End;
 
TExporterButton = Class(TInterfacedObject, IButton)
Private
  _Button : TButton;
Public
  Cosntructor Create;
  DEstructor Destroy; Overide;
[...]
End;
 
Constructor TExportedButton.Create;
Begin
Inherited Create;
Self._Button := TButton.Create(Nil);
[...]
End;
 
Destructor TExportedButton.DEstroy;
Begin
Self._Button.Free;
Inherited Destroy;
End;
 
Procedure TExportedButton.SetCaption(ACaption : String);
Begin
Self._Button.Caption := ACaption;
End;

Pour la simple raison que si l'on souhaite manipuler un bouton, un edit, etc ... depuis l'applciation hote de maniere commune (donc en tant que "TControl") il faudra que les 2 objets puissent etre stockés dans une variable de meme type.
IButton et IEdit ne peuvent pas faire l'affaire pour les memes raison qu'un TEdit et un TButton ne peuvent pas l'etre non plus.
Une interface de type "ICOntrol" serait l'ideal pour n'avoir que les fonctions communes.

Donc on peux developper IConrol, puis IButton et IEdit derivant de IControl :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
IControl = Interface
[...]
End;
 
IButton = Interface(IControl)
[...]
End;
 
IEdit = Interface(IControl)
[...]
End;
 
// ET oui l'heritage marche aussi :)

De cette maniere TExported button implementant IButton devra egalement fournir les methodes de IControl ....
Donc etre stocké dans une variable de type IControl dans l'exe.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
Var 
  Ctrl : IControl;
  Btn : IButton;
 
Btn := TExportedButton.Create;
Ctrl := Btn as IControl;

Or si TExportedButton et TExportedEdit implementent IControl via IButton ou IEdit, cela oblige a reegrire les methodes de IControl dans les 2 classes, ce qui fini par etre assez fastidieux ...
Donc on aimerais les coder directement dans TControl, ce qui est impossible. Enfin si mais recompiler une unite Borland entraine la necessite de recompiler un TRES grand nombre d'units, et la reconstructions des paquets, leur instalation ... bref oublie

Creer un derive de TControl : "TExportedControl" qui implemente IControl serait bien mais derriver un TExportedButton de TExportedControl entraine cette fois ci la reecriture de tout TButton .... logique.

Donc la seule solution c'est de recreer une hierarchie parallele a celle de la VCL
TExportedCotnrol (IControl)
|_TExportedButton (IButton)
|_TExportedEdit (IEdit)

Possedant un champs privé de type TControl, TEdit, TButton, donc les methodes/Property sont appelées depuis les methodes TExprotedXXX


DE maniere plus generale, un plugin est en fait compose d'un ensemble d'objet standard effectuant en interne une serie d'action classiques, et il existe une (ou plusieurs) classes interfacees qui "pilote" via les methodes de l'interface les objets iterne classiques.

Apres ya plus subtil mais on va peut etres pas avancer trop vite

D'autres questions ?

[Rayek]

Du coup quand on manipule un objet via son interface, on est sur que les fonctions appelles et definie dans l'interface seront accessible et traitee correctemetn d'un language a l'autre.

peux tu faire ce schéma avec les DLL ?

[Clorish]

peux tu faire ce schéma avec les DLL ?

Oui, je ne vois pas en quoi ca gene

MainProg Charge une Dll qui s'occupe de creer une form de l'affichage de requetes BdD.

Elle fourni donc a MainProg une interface qui s'occupe de creer/Liberer/afficher et effectuer des operations sur la fenetre d'affichage (entre autre)
mais aussi d'enregistrer de nouveaux "plugins" de requettes.
MAis elle implemente aussi un objet interface qui permet de "piloter" les composants BdD


MAinForm peut independement charger dynamiquement des Dll Plugin et d'en recuperer l'interface.
L'interface est transmise a la Dll d'affichage qui recupere le nom, un commentaire etc ... du plugin grace aux methodes de l'interface fournie par le plugin pour generer sa liste (combobox je suppose ou autre type de selection).

Une fois que le client active la requete, L'interface de pilotage de la BdD est transmise a la DllPlugin qui peut anisi faire des operation sur les composants de la BdD grace a cette interface.


Voila en gros la trame. apres il faut d'un cote se familiariser avec les interfaces et ensuite en connaitre davantage sur la conception de l'application.

[Edit]
Ce que tu demande est d'ailleur une des fonctionnalité essentielle de bon nombre d'applciation.
J'irais meme jusqu'a dire qu'elle externalise dans une 3e dll le moteur de requette sur la BdD qui s'occupe d'effectuer des requette et renvoyer le resultat.