Discussion :

[ChPr]

Bonjour à toutes et à tous,

Je suis en train de créer un composant dans lequel certaines propriétés sont optionnelles, du genre : si échelle automatique, je me fo... des valeurs Min et Max et donc je souhaite que si je choisis "Auto", les propriétés "Min" et "Max" ne s'affichent pas ou pour le moins, qu'elles soient désactivées.

Est-ce possible avec Lazarus, et si oui, comment fait-on ?

Merci de votre aide.

Pïerre

[Dr.Who]

non impossible comme cela.

une classe ne peut pas cacher ses propriétés ou méthode de façon dynamique encore moins dans l'IDE.

tout ce qui est published l'est définitivement.

par contre, tu peux tester ceci :

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
interface
 
type
  TCustomComponent = class(TComponent)
  private
    fAuto : boolean;
    fPropA : integer;
    fPropB : integer;
  protected
    property PropA : integer read fPropA write fPropA;
    property PropB : integer read fPropB write fPropB;
  public
    constructor Create(AOwner: TComponent; const IsAuto: boolean); override;
  end;
 
  TAutoComponent = class(TCustomComponent)
  published
    property PropB;
  public
    constructor Create(AOwner: TComponent); reintroduce; 
  end;
 
  TNormalComponent = class(TCustomComponent)
  published
    property PropA;
  public
    constructor Create(AOwner: TComponent); reintroduce;
  end;
 
 
implementation
 
constructor TCustomComponent.Create(AOwner: TComponent; const IsAuto: Boolean);
begin
  case IsAuto of
    false : result := TNormalComponent.Create(AOwner);
    true  : result := TAutoComponent.Create(AOwner);
  end;
end;
 
constructor TAutoComponent.Create(AOwner: TComponent);
begin
  inherited;
  fAuto := true;
end;
 
constructor TNormalComponent.Create(AOwner: TComponent);
begin
  inherited;
  fAuto := false;
end;
 
end.

et faire :

Code :

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

1
2
3
4
5
6
7
var
  AC : TCustomComponent;
  NC : TCustomComponent;
begin
  AC := TCustomComponent.Create(Self, true);
  NC := TCustomComponent.Create(Self, false);
end;

j'espere que je ne me suis pas trompé sur le sélécteur de classe à créé, c'est une technique que j'ai vus il y'a longtemps...

[ChPr]

Merci Dr.Who pour cette proposition.

J'ai essayé de créer un composant avec ton code. A la compilation, il y a des problèmes :

Code :

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

constructor Create(AOwner: TComponent; const IsAuto: boolean); override;

--> la classe ancètre TComposent ne dispose pas d'un tel constructeur. Donc, override ne peut être appliqué

Dans l'implémentation de ce constructeur, tu évoques la variable "result". Il n'y a pas de telle variable dans un constructeur.

Code :

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

1
2
3
4
5
6
7
constructor TCustomComponent.Create(AOwner: TComponent; const IsAuto: Boolean);
begin
  case IsAuto of
    false : result := TNormalComponent.Create(AOwner);
    true  : result := TAutoComponent.Create(AOwner);
  end;
end;

Je ne suis pas allé plus loin.

Mais pour autant que ces problèmes se résolvent, est-ce que je verrai soit l'une soit l'autre propriété dans l'inspecteur d'objet en créant l'un ou l'autre des composants Auto ou Normal ?

Cordialement.

Pierre

[chris37]

Salut,

Pour faire ce genre de choses

Il faut créer une propriété générique(Type d'affichage par exemple : Date,Currency,text) servant uniquement a appeller un éditeur de propriété de votre cru. En suite dans celui ci et en fonction de ce que vous voulez faire et du type, vous pourrez afficher les champs (ceux de la form de l'editeur) en fonction. Vous pourrez même piloter les autres propriété du composant

Je ne connais pas d'autre méthode mais en attendant, celle ci fonctionne

[Dr.Who]

oui désolé, j'ai pas tester l'implémentation.

en fait, il s'agit plus précisement de la stategie Design pattern.

par contre, je ne connais pas assé le concept pour dire s'il peu s'appliquer au objet.

mais le principe étant :

ObjetDeBase -> ObjA, ObjB
ObjetCreateur -> selon parametre propriété Obj = ObjA ou ObjB



sinon, question qu'on n'a pas posé, quel est le besoin réel ?
c'est a dire la finalité du composant ?
peut être y'a t'il d'autre solution qu'une implementation alambiqué.

[ChPr]

... Je ne connais pas d'autre méthode mais en attendant, celle ci fonctionne ...

Merci Chris pour ces précisions. Mais je ne vais pas en plus me lancer dans la création d'un éditeur spécialisé.

Cordialement.

Pierre

[chris37]

Bonsoir Pierre,

C'est vraiment tout balo, je peux t'aider si tu veux. Tu serais surpris de la simplicité de la choses.

Bonne soirée à tous

[ChPr]

... sinon, question qu'on n'a pas posé, quel est le besoin réel ?
c'est a dire la finalité du composant ?
peut être y'a t'il d'autre solution qu'une implementation alambiqué.

C'est une bonne question. Cependant, peu importe la finalité du composant. Le but recherché était de faire comme cela existe dans certain logiciel au niveau des menus, c'est-à-dire de spécialiser celui-ci en fonction d'un choix en amont.

Mais bon, je ne vais pas retourner ciel et terre pour y parvenir. Je voulais simplement savoir si une solution simple existait.

Cordialement.

Pierre

[Dr.Who]

en fait je me suis trompé mais pas trop.


tu peux faire un objet "encapsulable", j'etais pas loin avec mon vieux souvenir lointain :

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
 
 
unit CompOwner;
 
interface
 
uses
  SysUtils, Classes;
 
type
  TComponentBase = class(TComponent)
  private
 
  protected
 
  public
    // procedure AssignTo(source: TComponent); override;
    // constructor Create(AOwner: TComponent); override;
    // destructor Destroy; override;
  end;
 
  TComponentA = class(TComponentBase)
  private
    fA : integer;
  published
    property A: integer read fA write fA;
  public
 
  end;
 
  TComponentB = class(TComponentBase)
  private
    fB : integer;
  published
    property B: integer read fB write fB;
  public
 
  end;
 
  TComponentType = (
    ctA,
    ctB
  );
 
  TComponentOwner = class(TComponent)
  private
    fCompType  : TComponentType;
    fComponent : TComponentBase;
    procedure SetComponent(const Value: TComponentBase);
    procedure SetCompType(const Value: TComponentType);
  protected
    procedure CreateComponent; virtual;
    procedure ReleaseComponent; virtual;
  published
    property ComponentType : TComponentType read fCompType  write SetCompType default ctA;
    property Component     : TComponentBase read fComponent write SetComponent;
  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
  end;
 
 
procedure Register;
 
implementation
 
procedure Register;
begin
  RegisterComponents('Samples', [TComponentOwner]);
end;
 
 
{ TComponentOwner }
 
constructor TComponentOwner.Create(AOwner: TComponent);
begin
  inherited;
  fCompType  := ctA;
  CreateComponent;
end;
 
procedure TComponentOwner.CreateComponent;
begin
  ReleaseComponent;
  case fCompType of
    ctA: fComponent := TComponentA.Create(Self);
    ctB: fComponent := TComponentB.Create(Self);
  end;
end;
 
destructor TComponentOwner.Destroy;
begin
  ReleaseComponent;
  inherited;
end;
 
procedure TComponentOwner.ReleaseComponent;
begin
  if assigned(fComponent) then
    fComponent.Free;
end;
 
procedure TComponentOwner.SetComponent(const Value: TComponentBase);
begin
  Value.AssignTo(fComponent);
end;
 
procedure TComponentOwner.SetCompType(const Value: TComponentType);
begin
  if fCompType <> Value then
  begin
    fCompType := Value;
    CreateComponent;
  end;
end;
 
 
end.

[ChPr]

Merci Dr.Who pour le travail que tu t'es donné.

J'ai installé ce composant dans la palette sans aucun problème. Selon qu'on choisit l'un ou l'autre type de composant, apparaissent bien dans l'inspecteur d'objet les propriétés de l'un ou l'autre.

Mais si je ne me trompe, au final, tu as créé deux composants, l'un avec les propriétés A et l'autre avec les propriétés B auquel tu as rajouté un composant sélecteur.

C'est en fait ce que je voulais éviter. Néanmoins je retiens cette idée de sélecteur que je serai peut-être amené à utiliser dans une autre application.

Merci encore.

Pierre

[Dr.Who]

malheureusement, il y'a des limite à ce qu'on peut faire.

je doute fortement qu'il y ai une meilleur solution, plus simple à mettre en place.

surtout qu'il ne faut pas alourdir le code final resultant de la compilation de l'objet.
ajouter trop de code de gestion en mode design n'est jamais benefique pour le maintient du composant dans le futur.

fA et fB peuvent être intégrée à TComponentBase.
les propriété A et B peuvent être intégrée dans la partie protected de TComponentBase puis publiée dans TComponentA et TComponentB.

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
TComponentBase = class(TComponent)
  private
    fA : integer;
    fB : integer;
  protected
    property A: integer read fA write fA;
    property B: integer read fB write fB;
  public
    // procedure AssignTo(source: TComponent); override;
    // constructor Create(AOwner: TComponent); override;
    // destructor Destroy; override;
  end;
 
  TComponentA = class(TComponentBase)
  published
    property A; 
  end;
 
  TComponentB = class(TComponentBase)
  published
    property B; 
  end;
 
  TComponentAB = class(TComponentBase)
  published
    property A;
    property B;
  end;
 
  TComponentType = (
    ctA,
    ctB,
    ctAB 
  );
 
 
procedure TComponentOwner.CreateComponent;
begin
  ReleaseComponent;
  case fCompType of
    ctA: fComponent := TComponentA.Create(Self);
    ctB: fComponent := TComponentB.Create(Self);
    ctAB: fComponent := TComponentAB.Create(Self);
  end;
end;