Discussion :

[QAYS]

Bonjour,

Comme le titre l'indique je souhaiterais appeler dynamiquement des procedure et des fonctions, un peu comme on fait avec des Dll (lors du chargement dynamique) sauf que là mes fonction et mes procedure sont dans mon exe.

Je m'explique, j'ai un menu dynamique qui est constitué à partir d'un fichier texte (.inf) dont voici la structure :

Code :

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

Nom_menu;Image_menue;

et je veux rajouter la procedure ou fonction appelé pour avoir kune structure du fichier .inf comme ci-dessous :

Code :

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

Nom_menu;Image_menue;Nom_procedure_menu

Ainsi lorsque de la constitution de mon menu j''aurais, le nom du menu, l'image et la procédure (ou fonction) associé à ce menu.

en résumé voici le pseudo code que je souhaite mettre en place :

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
 
 
1.  Lecture du fichier .inf
2. création du menu
          2.1 Création bouton_1
                   2.1.1 Bouton_1.caption := Nom_menu
                   2.1.2 Bouton_1.glyph := Image_menue
                   2.1.3 Bouton_1.onClick :=  ChargerEtAppelerMAprocedure(' Nom_procedure_menu');
         2.2 Création bouton_2
                   2.2.1 Bouton_2.caption := Nom_menu
                   2.2.2 Bouton_2.glyph := Image_menue
                   2.2.3 Bouton_2.onClick :=  ChargerEtAppelerMAprocedure(' Nom_procedure_menu');
          2.3 Création bouton_3
          2.4 Création bouton_4
....

PS la création du menu dynamque est aujourd'hui opérationnel le problème est qu'aujourd'hui la gestion du menu est comme ci-dessous :

if Nom_menu = Calendrier then Affiche_calendrier
else if Nom_menu = Messagerie then Affiche_calendrier

ce qui n'est pas térrible et génant à gérer.


j'ai pensé au code suivant, que je n'ai pas encore essayer, car je n'es pas DELPHI sur mon poste pour le moment, je ferais le test ce soir chez moi, par contre si vous avec des idées ou autre je suis preneur

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
 
 
procedure ChargerEtAppelerMAprocedure(NOM_PROCEDURE:String);
var
  // Affiche_Fontionnalité est le nom de ma procedure dans mon exe
  MAprocedure: Affiche_Fontionnalité (Libelle: String);
begin
 
  Somme := nil;
  //le Handle de l'exe
  If Handle = 0 then Exit;
 
  //Récupération de l'adresse de la fonction nommée NOM_PROCEDURE
  MAprocedure:= GetProcAddress(Handle, pAnsiChar(NOM_PROCEDURE));
 
  //Appel de la fonction si on a bien récupéré son adresse
  If Assigned(MAprocedure) then MAprocedure('');
end;

merci de votre aide.

Cordialement
Qays

[Clorish]

J'avais bien pensé a une solution a base de GetProcAddress comme pour les Dlls en se basant sur le handle hInstance (qui pointe vers le handle du module courrant, donc l'exe).

Mais d'une part, ca ne marche pas pour les methodes (OnClick requiere uen methode) et d'autre part, il faut exporter les procedures a charger. Ce qui n'est peut etre pas possible depuis l'exe et surtout pas franchement tres interessant !

Donc je vois actuelement 3 solutions :
1 - les RTTI
2 - Creer fonction procedure avec un parametre TMenuItem et un parametre String (nom de l'evenement) et qui affecte apres comparaison de la claine le bon evenement :

Code :

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

1
2
 
If EvtName = 'Action1' Then MenuItem.OnClick := Self.action1;

3 - passer par une Dll et un gestionaire OnClick unique. Mais la faut vouloir passer par les Dlls .. si c'ets interessant je detaillerais.

[QAYS]

Merci de cette réponse,

en fait la solution 3 c'est ce que je fa

[QAYS]

Merci de cette réponse,

Pour la solution 2 : C'est ce que je fais aujourd'hui, le problème c'est que si je suis tributaire de l'orthographe de mes menues, en effet si pour une raison ou une autre le libellé change dans mon fichier .inf mais pas dans mon code alors le click uti sur le bouton ou menu seras "vide" (j'en est fait l'expérience), par contre si je réussie à mettre en place cette gestion (via fichier .inf) alors quelques soit le libellé de mon menu ce dernier sera toujours affecté a une procédure, donc pas de risque de bugg (orthographique)

Pour la solution 3 : Concernant la Dll j'ai essayer mais je l'avoue ce n'est pas facile d'extraire l'ensemble de mes fonctionnalité:
Agendas,Messagries,blocNotes,Stockage de doc en bdd, requeteur, gestion de comptes banquaires etc....



Pour la solution 1: Les RTTI, je vais voir ce qui est possible de faire

Merci

[Clorish]

Et si ... plutot que de passer par une chaine tu ne passerais pas plutot par des ID (des codes actions) ?

[anapurna]

salut

je n'ai qu'un seul mots : MethodAdress

@+ Phil

[CapJack]

Pour ce problème, il me semble qu'il y a une solution simple, souple et conçue pour : les listes d'actions, composant TActionList.

Dans un TActionList, on peut ajouter autant d'actions qu'on veut en mode conception, on peut même pour chacune définir une image et un Hint ! Ensuite peut retrouver une action à partir du nom, en utilisant une simple boucle qui ne changera jamais :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
function  TUtilForm.FindAction(const AName : string) : TContainedAction;
var I:Integer;
 begin
  Result := nil;
  with ActionList1 do // Ma liste d'actions
  for I := 0 to ActionCount-1 do
   if Actions[I].Name = AName then
    Result := Actions[I]
 end;

Si on veut juste se servir de la liste d'action pour stocker les évènements, on utilisera ensuite des codes du genre :

Code :

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

1
2
 
MenuAgenda.OnClick := FindAction('Agenda').OnExecute;

Mais il sera plus astucieux de faire directement...

Code :

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

MenuAgenda.Action := FindAction('Agenda');

...les titres, Hints et images étant directement stockées dans la liste d'action, ce qui permet de mettre à jour automatiquement aussi bien les menus que les boutons de raccourci d'une seule instruction !

C'est génial, les listes d'action. Depuis que j'ai découvert ça, je me force à les utiliser. On passe du temps au début, mais quel temps gagné quand on veut mettre à jour l'interface de son logiciel !

[QAYS]

Super capJack je vais tenter dès ce soir de faire ce que tu propose

Je vous donnerais des nouvelles dès demain
Cordialement
Qays

[CapJack]

J'ajoute quelques informations : en plus du "Caption", du "Hint", et d'une image définie sous la forme d'un indice dans un TImageList associé à la liste d'actions, tu peux aussi associer des touches de raccourcis.

Pour bien faire, à mon avis, il faudrait retoucher ton code, en séparant bien :

1. la liste d'images (à priori non localisable)
2. la liste d'actions (localisable)
3. la liste d'associations menus/boutons <-> actions (fonctionnelle)

Si tu tiens à tout sauvegarder, il faudrait à mon avis prévoir trois sauvegardes, ou trois parties dans une même sauvegarde.

1. La liste d'images : pour commencer, stocke toutes tes images dans un TImageList. Dans un premier temps, si tu veux faire les choses par étape, tu affecteras cette liste à la propriété SubMenuImages de chaque sous-menu, avec une valeur ImageIndex, ce sera plus efficace que d'accéder à la propriété Bitmap, ce que je te soupçonne de faire. Ceci juste le temps de faire des essais. Si tu veux pouvoir changer les images, les sauvegarder ou les charger, opère sur le TImageList.

2. La liste d'actions : ensuite, une fois définie ta liste d'actions, tu pourras effacer les propriétés SubMenuImages et ImageIndex de chaque élément du menu, et laisser la liste d'actions attribuer automatiquement les images via sa propriété Images, et la propriété ImageIndex de chaque action. Si tu n'envisages pas de localiser ton application, tu peux en rester là, sinon, il faudra écrire une routine de sauvegarde/chargement/modification des propriétés "Caption", "Hint" et "Shortcut" de chaque action. En général, les images ne changent pas, mais de toutes façon, elles seront définies par un index fixe qui ne devra pas être modifié. Mais on peut très bien sauvegarder cet indice, au cas où. Et, en cas de changement d'image pour un indice donné, c'est sur le TImageList qu'il faudra opérer. C'est déjà une grande modification par rapport au code du départ...

3. Les associations : étape finale, attribution des actions aux menus et aux boutons de raccourcis, et là c'est royal : il n'y a qu'à sauvegarder le nom de l'action pour chaque item, et c'est tout !

[QAYS]

Bonsoir,

j'ai essayer la methodeAddress et j'y suis presque arrivé, presque car les fonction et procedure que j'appel sont dans d'autre unit (autre objet), je continu les recherches

Cordialement

[anapurna]

salut
pas de soucis majeur

Code :

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

1
2
3
4
5
6
7
8
var
   Address: TMethod;
begin
  {pour chaque menu item créé}
  Address.Code := MonObj.MethodAddress('MenuItemClick');
  Address.Data := MonObj;
  NouveauMenuItem.OnClick := TNotifyEvent(Address);
end;

attention les propriete doivent etre published

@+ Phil

[QAYS]

anapurna vous êtes un , merci de vos conseils, toutefois, je constate les points suivants:

Voici le code de ma fonction AppelRoutine

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
procedure TMENU_UTIL.ExecuteRoutine(Instance: TObject; Name: string);
var
  Routine: TMethod;
  Execute: TExecute;
begin
  Routine.Data := Pointer(Instance);
  // Returns the address of a published method.
  Routine.Code := Instance.MethodAddress(Name);
  if Routine.Code = nil then Exit;
  Execute := TExecute(Routine);
  Execute;
end;

et voici l'appel à Execute Routine :

Si la procedure est dans la même unit c'est OK sinon c'est KO, je m'explique(je schematise le code):

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
 
Unit Unit1
 
Type
Tform1 = class(Tform)
   procedure Bouton1Click(sender:Tobject)
   procedure Bouton2Click(sender:Tobject)
   procedure Bouton3Click(sender:Tobject)
 
end;
 
Implementation
 
Uses Unit1;
 
procedure Tform1.Bouton1Click(sender:Tobject)
begin
    ShowMessage('OK Tform1.Bouton1Click')
end
 
procedure Tform1.Bouton2Click(sender:Tobject)
begin
      ExecuteRoutine(Form1,'Bouton1Click') ===>Bonne execution du programme
end
 
procedure Tform1.Bouton3Click(sender:Tobject)
begin
      //Objet dans la unit2
      My_LANCEUR_FORM := LANCEUR_FORM.Create;
      ExecuteRoutine(My_LANCEUR_FORM,'LANCER_FORM') ===>Ko  Routine.Code = nil et ne fait donc rien
end
 
end.

Pour la unit2

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
 
Unit Unit2
 
Type
LANCEUR_FORM = class
   Constructor Create;	
   procedure LANCER_FORM
 end;
 
Implementation
 
Uses Unit1;
 
Constructor LANCEUR_FORM.Create;
begin
end
 
procedure LANCEUR_FORM.LANCER_FORM;
begin
      ShowMessage('OK LANCEUR_FORM.LANCER_FORM')
end
 
end.

A votre avis pour quelle raison cela ne fonctionne pas ?

Merci de votre
Cordialement

[QAYS]

A y est je pense avoir trouve les raison de ce dysfonctionnement.

En effet j'utilise MethodAddress pour retrouver l'adresse de ma methode mais ma fonction n'est pas une méthode (enfin je crois) il s'git d'une procedure d'une class, je vais donc essayer GetProcAddress

Cf FAQ Delphi

auteurs : Nono40, delphiprog
Les procédures n'étant pas des méthodes d'objet il n'est pas possible d'utiliser RTTI pour en trouver les adresses. Cependant il existe une ruse pour forcer le compilateur à garder une trace des noms des procédures et fonctions voulues afin que l'on puisse les appeler par leur nom.

Cette méthode consiste à exporter les noms de procédure comme on le ferait dans une dll. Une fois les fonctions exportées on utilise la même méthode pour les appeler que la méthode utilisée pour l'appel d'une fonction de dll.
Function Additionner(x, y: Integer): Integer;
Begin
Result:=x+y;
End;

Function Soustraire(x, y: Integer): Integer;
Begin
Result:=x-y;
End;

Function Multiplier(x, y: Integer): Integer;
Begin
Result:=x*y;
End;

Exports Additionner,SousTraire,Multiplier;

procedure TForm1.Button1Click(Sender: TObject);
var H: HModule;
F: Function(X,Y:Integer):Integer;
begin
H := GetModuleHandle(nil);
if H <> 0 then
begin
F := GetProcAddress(H, PChar(Edit1.Text));
if Assigned(F) then
ShowMessage(IntToStr(F(SpinEdit1.Value,SpinEdit2.Value)))
Else
ShowMessage('Fonction non trouvée !');
End;

// SetWindowLong(Memo1.Handle,GWL_STYLE,GetWindowLong(Memo1.Handle,GWL_STYLE)Or ES_UPPERCASE);
end;


Notez l'ajout de la clause Exports pour déclarer les fonctions comme on le ferait dans une dll.

Cordialement

[CapJack]

Au risque de passer pour lourd, j'insiste : l'utilisation d'une liste d'actions, pour difficile à saisir au début, vous fera perdre moins de temps en bidouillages. Mais c'est vous qui voyez.

[QAYS]

Bonjour,

Il n'y a pas de souci, je suis preneur de tous les conseils,

en fait je vous explique plus précisement les raisons de ce choix, je suis fan du tout dynamique et des parametrages et je souhaite donc créer des modules ou objets que ne necessite pas trop de code (dans leur utilisation)
certes bcp de code dans leur conception, mais leur utilisation après est simplifé.

Donc j'ai créé un objet qui en fonction d'un fichier INI var me creer un menu (graphique style menu windows) et je veux avoir que tout ce passe automatiquemet sans être obligé de modifier mon source.

Ainsi pour la prise en compte d'un nouvelle fonctionnalité, écran ou que sais-je il me suffirais de rajouter :

1. Ma Unit (ecra, fonctionnalité etc...)
2. Une information dans mon fichier INI (nom du menu, image,et procedure à appeler)

Cordialement

[CapJack]

Un système de plug-ins en somme. C'aurait été important de le dire dès le départ, car alors la démarche est très différente. Mais alors je me demande pourquoi vous cherchez midi à quatorze heures ?

La démarche naturelle pour ce genre de technique est d'utiliser des dll : avec LoadLibrary, et surtout GetProcAddress, vous aurez tout ce qu'il vous faut !

Moi, voilà ce que je ferais : j'utiliserai des dll, chacune comportant au moins une fonction FunctionList renvoyant la liste des procédures disponibles avec leur nom. A chaque chargement d'un nouveau Plug-In, un appell à FunctionList, une boucle de GetProcAddress, un tableau pour stocker les noms et les adresses des procédures, et le tour est joué !

[QAYS]

A y est c'est OK:

voila le code ça oeut servir:

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
 
//============================================================================//
procedure TMENU_UTIL.ExecuteRoutine(Instance: TObject; Name: string);
var
  Routine: TMethod;
  Execute: TExecute;
begin
  Routine.Data := Pointer(Instance);
  // Returns the address of a published method.
  Routine.Code := Instance.MethodAddress(Name);
  if Routine.Code = nil then Exit;
  Execute := TExecute(Routine);
  Execute;
end;
//===================================//
procedure TMENU_UTIL.ExecuteRoutine(FctName1: string;FctName2:string);
var H: HModule;
    My_Procedure : procedure(Name_s:String);
begin
  H := GetModuleHandle(nil);
  if H <> 0 then
  begin
    @My_Procedure := GetProcAddress(H, PChar(FctName1));
    if Assigned(My_Procedure) then My_Procedure(FctName2)
    Else ShowMessage('Fonction non trouvée !');
  End;
end;

Merci à tous de votre aide et conseils

COrdialement