Publier des évènements dans l'inspecteur d'objet

**khaled-benloucif** · 19/03/2009, 10h44

Bonjour,
voila j'ai un petit soucis, je développe un composant dont l'une de ses propriétés est de type TPersistent (comme TFont par exemple).
J'ai besoin de publier des évènements de cet objet dans l'inspecteur d'objet, le problème que ces derniers ne s'affichent pas, quant aux propriétés ils s'affichent le plus normalement

Quelqu'un a une idée ?

**Kaféine** · 19/03/2009, 13h25

Salut,

Oui c'est possible mais il faut écrire du code

il faut notamment créer les éditeurs de propriétés en dérivant de TMethodProperty et TNestedProperty. Le premier servant aux propriétés et le deuxième aux evenements (ou le contraire je sais plus)

Bon courage.

**khaled-benloucif** · 19/03/2009, 13h31

oui, effectivement. TNestedProperty est celui qu'il faut utiliser pour les évènements.
J'espère que je vais pas encore rédiger 3 kilomètres de code source!

je vais essayer de le faire

**Yurck** · 19/03/2009, 14h12

Pour les propriétés comme TFont par exemple il suffit de la déclarer en published, pour les types énumérés ainsi que toutes les propriétés "classique" sous Delphi il n'y a rien de particulier à développer, seule la déclaration importe.

**khaled-benloucif** · 19/03/2009, 14h28

Les évènements sont déclarés dans la partie published, mais ils n'apparaissent pas dans l'inspecteur d'objet! contrairement au propriétés on peut les voir le plus normalement et je parle pour le cas d'un objet de type TPersistent

**khaled-benloucif** · 19/03/2009, 14h37

voici une portion de 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
		TCustomBugManager= class(TPersistent)
			private
			 fOnSiloFreeze: TOnSiloFreeze;
			 fbmSiloFreeze: Boolean;
			 procedure SetSiloFreeze(Val: Boolean);
			public
			 property bmSiloFreeze: Boolean read fbmSiloFreeze write SetSiloFreeze;
			 property OnSiloFreeze: TOnSiloFreeze read fOnSiloFreeze write fOnSiloFreeze;
		 end;
 
 
		 TBugManager= class(TCustomBugManager)
			published
			 property bmSiloFreeze;
			 property OnSiloFreeze;
		 end;

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
 TCustomSimulator= class(TComponent)
			private
			 fSilos: TSilos;
			 fOnAddSiloEvent: TOnAddSiloEvent;
			 fOnRemoveSiloEvent: TOnRemoveSiloEvent;
			 //
			protected
			 fBugManager: TBugManager;
			public
			 constructor Create(AOwner: TComponent); override;
			 destructor Destroy; override;
			 property Silos: TSilos read fSilos write fSilos;
			 property BugManager: TBugManager read fBugManager write fBugManager;
			 property OnAddSilo: TOnAddSiloEvent read fOnAddSiloEvent write fOnAddSiloEvent;
			 property OnRemoveSilo: TOnRemoveSiloEvent read fOnRemoveSiloEvent write fOnRemoveSiloEvent;
		 end;
 
		 TSimulator= class(TCustomSimulator)
			published
			 property Silos;
			 property BugManager;
			 //Events
			 property OnAddSilo;
			 property OnRemoveSilo;
		 end;

**Kaféine** · 20/03/2009, 14h14

Salut,

Voila je suis parti de ça qui correspond grosso-modo à ce que tu as exposé plus haut.

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
 
type
  TSilo = class;
 
  TOnSiloFreeze = procedure(Sender: TObject; ASilo: TSilo) of object;
 
  TCustomBugManager = class(TPersistent)
  private
    FOnSiloFreeze: TOnSiloFreeze;
    FSiloFreeze: Boolean;
  published
    property SiloFreeze: Boolean read FSiloFreeze write FSiloFreeze;
    property OnSiloFreeze: TOnSiloFreeze read FOnSiloFreeze write FOnSiloFreeze;
  end;
 
  TSilo = class
  end;
 
  TCustomSimulator = class(TComponent)
  private
    FBugManager: TCustomBugManager;
    FBugManagerEvents: TNotifyEvent;
  public
    constructor Create(AOwner: TComponent); override;
	  destructor Destroy; override;
  published
    property BugManager: TCustomBugManager read FBugManager;
    property BugManagerEvents: TNotifyEvent read FBugManagerEvents; // pour l'editeur
  end;
 
implementation
 
{ TCustomSimulator }
 
constructor TCustomSimulator.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  FBugManager := TCustomBugManager.Create;
end;
 
destructor TCustomSimulator.Destroy;
begin
  FBugManager.Free;
  inherited;
end;

voici l'unité d'enregistrement dans le package designtime.
Biensur ca reste perfectible mais au moins ca donne une piste.

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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
 
uses ...DesignIntf, DesignEditors, VCLEditors, TypInfo...;
 
type
  TBugManagerEventEditor = class(TMethodProperty)
  private
    function GetInstance: TPersistent;
  public
    function GetAttributes: TPropertyAttributes; override;
    function GetName: string; override;
    procedure GetProperties(Proc: TGetPropProc); override;
    function GetValue: string; override;
    property Instance: TPersistent read GetInstance;
  end;
 
  TEventProperty = class(TNestedProperty)
  private
    FParent: TPropertyEditor;
    FPropInfo: PPropInfo;
    function GetInstance: TPersistent;
  protected
    constructor Create(AParent: TPropertyEditor; APropInfo: PPropInfo); reintroduce;
  public
    procedure Edit; override;
    function GetName: string; override;
    function GetValue: string; override;
    procedure SetValue(const AValue: string); override;
  end;
 
procedure Register;
 
 
implementation
 
uses DesignConst;
 
procedure Register;
begin
  RegisterComponents('Kaféine Test', [TCustomSimulator]);
  RegisterPropertyEditor(TypeInfo(TNotifyEvent), TCustomSimulator, 'BugManagerEvents', TBugManagerEventEditor);
end;
 
{ TBugManagerEventEditor }
 
function TBugManagerEventEditor.GetAttributes: TPropertyAttributes;
begin
  Result := [paMultiSelect, paSubProperties, paReadOnly, paRevertable];
end;
 
function TBugManagerEventEditor.GetInstance: TPersistent;
begin
  Result := TCustomSimulator(GetComponent(0)).BugManager;
end;
 
function TBugManagerEventEditor.GetName: string;
begin
  Result := 'BugManager';
end;
 
procedure TBugManagerEventEditor.GetProperties(Proc: TGetPropProc);
var
  APropList: TPropList;
  I, ACount : Integer;
begin
  ACount := GetPropList(Instance.ClassInfo, [tkMethod], @APropList);
  for I := 0 to ACount - 1 do
    Proc(TEventProperty.Create(Self, APropList[I]));
end;
 
function TBugManagerEventEditor.GetValue: string;
begin
  Result := '(' + Instance.ClassName + ')';
end;
 
{ TEventProperty }
 
constructor TEventProperty.Create(AParent: TPropertyEditor;
  APropInfo: PPropInfo);
begin
  inherited Create(AParent);
  FPropInfo := APropInfo;
  FParent := AParent;
end;
 
procedure TEventProperty.Edit;
var
  NomMethode: string;
begin
  NomMethode := GetValue;
  if (NomMethode = '') or Designer.MethodFromAncestor(GetMethodValue) then
  begin
    if NomMethode = '' then
      NomMethode := Designer.GetObjectName(GetComponent(0)) + GetName;
    if NomMethode = '' then
      raise EPropertyError.Create(SCannotCreateName);
    SetValue(NomMethode);
  end;
  Designer.ShowMethod(NomMethode);
end;
 
function TEventProperty.GetInstance: TPersistent;
begin
  Result := nil;
  if FParent is TBugManagerEventEditor then
    Result := TBugManagerEventEditor(FParent).Instance;
end;
 
function TEventProperty.GetName: string;
begin
  Result := FPropInfo.Name;
end;
 
function TEventProperty.GetValue: string;
begin
  Result := Designer.GetMethodName(GetMethodProp(GetInstance, FPropInfo));
end;
 
procedure TEventProperty.SetValue(const AValue: string);
var
  IsNouvelle: Boolean;
  ValeurCourante: string;
  AncienneMethode: TMethod;
begin
  ValeurCourante:= GetValue;
  if (ValeurCourante <> '') and (AValue <> '') and ((CompareText(ValeurCourante, AValue) = 0) or
    not Designer.MethodExists(AValue)) and not Designer.MethodFromAncestor(GetMethodValue) then
    Designer.RenameMethod(ValeurCourante, AValue)
  else
  begin
    IsNouvelle := (AValue <> '') and not Designer.MethodExists(AValue);
    AncienneMethode := GetMethodValue;
    SetMethodProp(GetInstance, FPropInfo,
      Designer.CreateMethod(AValue, GetTypeData(FPropInfo.PropType^)));
    if IsNouvelle then
    begin
      Designer.ShowMethod(AValue);
    end;
    Designer.Modified;
  end;
end;

Voila le résultat c'est l'affichage de l'évenement OnSiloFreeze du TPersistent. en espérant que ca t'aide un peu.
A+

**khaled-benloucif** · 20/03/2009, 22h25

Merci pour le code mon ami, j'ai galéré hier et j'ai pas trouvé d'où il fallait commencer.

**Kaféine** · 23/03/2009, 20h43

Qu'est ce que tu n'as pas compris?

Il te suffit de copier le code de la deuxième partie et d'enregistrer l'éditeur dans ton package "designtime" de ton composant "TSimulator".

**khaled-benloucif** · 23/03/2009, 22h25

je voulais dire que je ne savais pas d'où il faillait commencer avant que tu m'envoie le code.

**Kaféine** · 23/03/2009, 23h27

As tu réussis à l'integrer dans ton code?

**khaled-benloucif** · 23/03/2009, 23h39

a vrai dire non
j'utilise le BDS2006 et il m'a causé 1 problème avec DesignEditors et VCLEditors, il me signale un message d'erreur, malgré elle sont ajoutées dans le chemin de recherche!

Le compilateur s'arrête à l'erreur "file not found 'Proxies.dcu'" dans l'unité DesignEditors.

**Kaféine** · 24/03/2009, 10h35

Tu n'as pas besoin de recompiler le source. Il te suffit d'ajouter la référence du paquet compilé "designide.dcp" dans la section "require" de ton paquet.
ce dcp doit normalement se trouver dans le dossier "Lib" du répértoire d'installation de ton delphi.

**khaled-benloucif** · 01/04/2009, 00h12

Je m'excuse Kaféine pour le retard de la confirmation, je me suis penché sur le développement du composant lui même.

j'ai compilé le paquet DesignTime mais l'événement ne s'affiche pas toujours!

Code :

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

RegisterPropertyEditor(TypeInfo(TNotifyEvent), TCustomSimulator, 'BugManagerEvents', TBugManagerEventEditor);

je ne dois pas mettre 'OnSiloFreeze' à la place de 'BugManagerEvents' ? malgré que je l'ai essayé et ça n'a pas marché!

**Kaféine** · 01/04/2009, 16h35

Salut,

Envoyé par khaled-benloucif

je ne dois pas mettre 'OnSiloFreeze' à la place de 'BugManagerEvents' ? malgré que je l'ai essayé et ça n'a pas marché!

Non effectivement ca marche pas...et c'est normal.
le but de "BugManagerEvents" est de simuler un event dans le "TCustomSimulator". avec cette event on "colle" les events du "TCustomBugManager" (en l'occurence le seul "OnSiloFreeze").

PS:As tu penser à ajouter le fameux event fantôme "BugManagerEvents" dans ton TCustomSimulator comme illustré dans le code ci-dessus?