Discussion :

[Eric.H]

Bonjour

Je possède un object TParser qui possède un evenement OnGetVar : TGetVarEvent

Il s'agit bien entendu d'une procedure of object

Code :

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

1
2
3
 
TGetVarEvent = procedure(Sender : TObject; VarName : string; var
    Value : Extended; var Found : Boolean) of object;

Mon problème et que je voudrais connecter une procedure local qui n'est dnc pas une procedure of objects

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
FUNCTION TFenetre.Preparer_affichage_resultats:Boolean;
 
    PROCEDURE Evt_Remplir_Variables(Sender : TObject; VarName : string;
var Value : Extended; var Found : Boolean);
    BEGIN
      Value:=0;
    END;
 
BEGIN
  Mon_Parser.OnGetVar:=Evt_Remplir_Variables
  .....
END;

Bien entendu cela ne fonctionne pas, j'ai essayais diverses options (Addr, @, transtypage) mais rien n'y fait. Pourtant j'ai souvenir d'avir déjà fait ce genre de manip et que c'était simple .... mais j'ai un trou (où alors je rêve )

Si une bonne âme pouvait me dépanner, merci

N.B. Je ne peux pas mettre ma proc Evt_Remplir_Variables au niveau de TFenetre, ce qui résoudrai le "problème". Le contexte de calcul se trouve dans Preparer_affichage_resultats et pas ailleurs

[EDIT]
Je pense avoir trouvé, en tant cas cela compile...

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
 
FUNCTION TFenetre.Preparer_affichage_resultats:Boolean;
VAR
  POnGetVar : ^Parser_Math.TGetVarEvent;
 
    PROCEDURE Evt_Remplir_Variables(Sender : TObject; VarName : string;
var Value : Extended; var Found : Boolean);
    BEGIN
      Value:=0;
    END;
 
BEGIN
  POnGetVar :=@Evt_Remplir_Variables;
  Mon_Parser.OnGetVar:=POnGetVar^;
  .....
END;

[EDIT]
Non cela plante majestueusement...

[edit] Modifié par Pascal Jankowski pour éviter la déformation du forum [/edit]

[Bestiol]

Je ne pense pas te dire de bêtise en t'affirmant que c'est impossible de faire autrement que de passer une procedure d'objet !

Entre une procédure et une procédure d'objets, il y a un certain nombre de différences internes (gestion mémoire, type d'appel je pense...) qui les rendent incompatibles.... d'où ton plantage très certainement ^^

Mais pourquoi ne peux-tu pas passer ta procédure en procédure d'objet en lui donnant les paramètres qu'elle nécessite pour son calcul ?

[sjrd]

Je ne pense pas te dire de bêtise en t'affirmant que c'est impossible de faire autrement que de passer une procedure d'objet !

Entre une procédure et une procédure d'objets, il y a un certain nombre de différences internes (gestion mémoire, type d'appel je pense...) qui les rendent incompatibles.... d'où ton plantage très certainement ^^

Ben... Tu dis des bêtises

D'abord, demande-toi si tu ne peux pas simplement déclarer ton TGetVarEvent sans le of object :

Code :

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

1
2
TGetVarEvent = procedure(Sender : TObject; VarName : string;
  var Value : Extended; var Found : Boolean);

Parce que si c'est le cas, tu peux y affecter une routine (mais plus de méthode !).

Sinon, la seule différence qu'il y a entre une routine et une méthode est qu'une méthode possède un paramètre implicite supplémentaire au début qui est d'un type objet : il contient la référence à l'objet (c'est Self, si vous voulez).

Donc éventuellement, tu pourrais déclarer ta routine Evt_Remplir_Variables comme suit :

Code :

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

1
2
3
4
5
procedure Evt_Remplir_Variables(Self : TObject; Sender : TObject;
  VarName : string; var Value : Extended; var Found : Boolean);
begin
  Value := 0;
end;

Ensuite, tu peux l'affecter comme ceci :

Code :

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

1
2
3
4
5
var Method : TMethod;
...
Method.Code := @Evt_Remplir_Variables;
Method.Data := nil;
MonParser.OnGetData := TGetVarEvent(Method);

Bon tout cela reste très bidouille... Mieux vaudrait t'arranger pour que Evt_Remplir_Variables soit une méthode.

[Bestiol]

Ben... Tu dis des bêtises

Pas tout à fait, moi je gardais le of object dans mes explications !
Mais bon si seul le Self suffit pour rendre "compatible", alors ok

[Eric.H]

Code :

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

1
2
3
4
5
var Method : TMethod;
...
Method.Code := @Evt_Remplir_Variables;
Method.Data := nil;
MonParser.OnGetData := TGetVarEvent(Method);

En debugguant mon POnGetVar avait 3 Valeurs
Addr $55DDE4 L'adresse de Evt_Remplir_Variables;
Code $51EC8B55
Data $9B9

On mon plantage est une violation d'accès à $51EC8B55

C'est donc une bonne piste et je vait essayer avec le TMethod

[Eric.H]

Mais pourquoi ne peux-tu pas passer ta procédure en procédure d'objet en lui donnant les paramètres qu'elle nécessite pour son calcul ?

Vieux programme de calcul ou je ne peux pas encore tous extraire, donc cette procedure doit etre local pour utiliser les paramètres initialiser DANS la proceduree principale et pas ailleurs

Modifier le composant m'embete (pour le moment, c'est ma dernière option), car utilisé a donf par d'autre programme de calcul

[Eric.H]

Code :

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

1
2
3
4
5
var Method : TMethod;
...
Method.Code := @Evt_Remplir_Variables;
Method.Data := nil;
MonParser.OnGetData := TGetVarEvent(Method);

Ben cela marche un peu..... Je rentre bien dans ma proc Evt_Remplir_Variables, mais avec des parametres totalement bidon ce dont je me doutais (Method.Data := nil;)

Method.Data:=Method.Code+4 ?? 8??

Mais bon cela fait avancer le smilblique

Reste plus car trouver l'adresse des datas.... mais à la fin je n'utiliserai pas cette methode c'est plus pour ma culture générale

Meric pour votre aide a tous

[sjrd]

Ben cela marche un peu..... Je rentre bien dans ma proc Evt_Remplir_Variables, mais avec des parametres totalement bidon

Euh Chez moi ça fonctionne :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
procedure TFormMain.FormCreate(Sender: TObject);
  procedure Button4Click(Self : TObject; Sender : TObject);
  begin
    if Self = nil then ShowMessage('Self = nil') else ShowMessage('Self <> nil');
    ShowMessage(Sender.ClassName);
    ShowMessage(TButton(Sender).Caption);
  end;
begin
  Method.Code := @Button4Click;
  Method.Data := nil;
  Button4.OnClick := TNotifyEvent(Method);
end;

M'affiche bien Self = nil, pui TButton et enfin Button4 quand je clique sur le bouton 4. Y compris si je sors Button4Click de FormCreate pour le mettre en routine globale.

ce dont je me doutais (Method.Data := nil;)

Method.Data:=Method.Code+4 ?? 8??

Mais non rien à voir Le champ Data de TMethod contient l'adresse de l'objet auquel se rapporte la méthode. C'est cette valeur qui se retrouve dans le paramètre Self.

[e-ric]

Salut

Votre discussion devient compliquée. Une des grande différence entre un type de procédure et un type de méthode est le passage implicite pour la seconde de la référence de l'objet sur lequel l'appel de méthode s'appliquera.

Je pense qu'une solution simple serait de transformer ta routine imbriquée (local comme tu le dis) en méthode privée de ta fenêtre. Cela ne coûte pas cher mais ne correspond peut-être pas à ce que tu cherches.

cdlt

e-ric

[Bestiol]

Je pense qu'une solution simple serait de transformer ta routine imbriquée (local comme tu le dis) en méthode privée de ta fenêtre. Cela ne coûte pas cher

cela ne coûte pas cher de lire le topic non plus...

[e-ric]

Oups , je viens de relire et c'est ben vrai, sorry...

Bon, je vais tâcher de me racheter, on va donc créer une classe bidon destinée à transformer la simple procédure normal en procédure d'objet.

Remarque : par manque de temps, je n'ai rien testé, notamment cela n'a pas été compilé, j'ai fait cela de tête.

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
57
58
59
 
implementation
 
type 
  // Le type procédural de ta procédure locale
  TTempProc = procedure(Sender : TObject; VarName : string; var
    Value : Extended; var Found : Boolean);  
 
// Classe bidon
TTempProcCaller = Class
private
  FProc: TTempProc;
public
  procedure setProc(p: TTempProc);
  procedure CallProc(Sender : TObject; VarName : string; var
    Value : Extended; var Found : Boolean);
end;
 
var
  TempProcCaller: TTempProcCaller;
 
procedure TTempProcCaller.setProc(p: TTempProc);
begin
  FProc := p;
End;
 
// Déclenche l'appel de ta simple procédure par une méthiode de notre classe
// bidon
procedure TTempProcCaller.CallProc(Sender : TObject; VarName : string; var
    Value : Extended; var Found : Boolean);
begin
  if Assigned(FProc) then
    FProc(Sender,VarName, Value, Found);
End;
 
 
// et dans ton code
FUNCTION TFenetre.Preparer_affichage_resultats:Boolean;
 
     PROCEDURE Evt_Remplir_Variables(Sender : TObject; VarName : string;
var Value : Extended; var Found : Boolean);
    BEGIN
      Value:=0;
    END;
 
BEGIN
  TempProcCaller.setProc(Evt_Remplir_Variables);
  Mon_Parser.OnGetVar:= TempProcCaller.CallProc;
  .....
END;
 
 
initialization
  // Création d'un objet local par nécessité
  TempProcCaller := TTempProcCaller.Create;
 
initilization
  // Shoot'em up
  TempProcCaller.Free;

Est-ce que cela résoud ton problème ? C'est de la bidouille mais ça dépanne.

cdlt

e-ric

[e-ric]

Salut

Réflexion faite, la création d'une classe spécifique n'est pas nécéssaire, il suffit de déplacer les consituants de la classe temporaire dans la classe de la fiche.

cdlt

e-ric

[Eric.H]

Réflexion faite, la création d'une classe spécifique n'est pas nécéssaire, il suffit de déplacer les consituants de la classe temporaire dans la classe de la fiche.

A vue d'oeil cela doit fonctionner, je teste

[e-ric]

Cela donne un truc dans ce genre-là :

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
 
interface
 
type 
  // Le type procédural de ta procédure locale
  TTempProc = procedure(Sender : TObject; VarName : string; var
    Value : Extended; var Found : Boolean);  
 
 
TFenetre = class(TForm)
private
  FProc: TTempProc;  
protected
  Proc: TTempProc read FProc write FProc;
  procedure CallProc(Sender : TObject; VarName : string; var Value : Extended; var Found : Boolean);
public
 
end;
 
 
implementation
 
 
procedure TFenetre.CallProc(Sender : TObject; VarName : string; var
    Value : Extended; var Found : Boolean);
begin
  if Assigned(FProc) then
    FProc(Sender,VarName, Value, Found);
End;
 
// et dans ton code
FUNCTION TFenetre.Preparer_affichage_resultats:Boolean;
 
     PROCEDURE Evt_Remplir_Variables(Sender : TObject; VarName : string;
var Value : Extended; var Found : Boolean);
    BEGIN
      Value:=0;
    END;
 
BEGIN
  Proc := @Evt_Remplir_Variables
  Mon_Parser.OnGetVar:= CallProc;
  .....
END;

Cela devrait fonctionner et c'est plus simple

cdlt

e-ric

[Eric.H]

Cela devrait fonctionner et c'est plus simple

Cela fonctionne nickel (avec un p'tit property devent Proc )

C'est un peu bodouille, mais plus propre que de trafiquer les pointeurs

Merci a tous, et "Résolu"