Discussion :

[Clorish]

Je cherche a creer des composant possedant des sous objets fixes, comme par exemple un panel avec 4 boutons dessus.

Je declare mon composant de la maniere suivante :

Code :

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

1
2
3
4
5
6
7
 
Type TMonCompo = Class(TPanel)
         Private
            Bouton1 : TButton;
            Bouton2 : TButton;
            ...
        End;

Je dois donc creer mes objets dans le constructeur :

Code :

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

1
2
3
4
5
6
7
 
Constructor TMonCompo.Create(AOwner : TComponent);
Begin
Bouton1 := TButton.Create(Self);
Bouton2 := TButton.Create(self);
...
End;

Mon soucis serait de pouvoir definir la valeur des proprietees de mes objets quelque part, (comme dans les fichiers DFM pour les forms) pour eviter de devoir toujours creer et renseigner les prop de ces objets ....

Ca existe ? ou c'est utopique ?


D'autre part, a quoi cela sert de definir les Objet/Methodes entre la ligne "TMonCompo = Class(TPanel)" et "private" (ie : types fichies remplie par delphi). Est ce specifique aux fiches qui s'appuie sur les DFM pour parametrer et construire les objets de cette section ?

Bref, si qqun peut eclairer ma lanterne ....

[Pierre Castelain]

Le prlus "propre", mais pas le plus rapide est de "surfacer" les propriétés. C'est à dire de créer dans la classeur conteneur une propriété pour chaque propriété de la classe contenue. Un exemple sera plus clair.

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
 
interface
 
type
  TContenu = class;
 
  TConteneur = class
  private
    FContenu: TContenu;
    function GetContenuText: string;
    procedure SetContenuText(const Value: string);
  published
    property ContenuText: string read GetContenuText write SetContenuText;
  end;
 
  TContenu = class
  private
    FText: string;
  published
    property Text: string read FText write FText;
  end;
 
implementation
 
{ TConteneur }
 
function TConteneur.GetContenuText: string;
begin
  result:= FContenu.Text;
end;
 
procedure TConteneur.SetContenuText(const Value: string);
begin
  FContenu.Text:= Value;
end;

Les déclarations de membres en dehors des sections private, protected, public ou published sont considérées comme publiques. C'est donc strictement équivalent à les mettre dans public.

[Clorish]

J'ai du mal a saisir .... Enfin je comprends l'idee generale, mais dans cela demanderais de redefinir tous les objets deja present sous Delphi (Labels, Panels, etc .. ) a chaques fois que j'en ai besoin.

Je cherchais qque chose de plus simple pour parametrer les valeurs de mes objets, sans avaoir a alourdir mon code ....
Sinon je passe par une proprietee 'InitLabel', 'InitButton', etc ... dans laquelle je cree mes objets, les parametres et renvoie le pointeur.

Ce que je trouvais bien dans les DFM c'est le fait que chaques objets est present dans le code souce sous forme d'une seule ligne declarative (Button1 : TButton) et que ses parametres de creation n'encombrent pas le code source.

Je pourrais aussi Creer des Compos persos derivant de l'objet initial, avec certaines props redeclarees avec des valeurs par defaut propres, ce qui me permetrais de garder que la ligne de creation de l'objet ....


De plus j'aimerais savoir si il existe une methode meilleur que la mienne pour inclure des images dans un composant sans qu'elles necessite la presence du ficheir sur le DD.
Je creer un fichier .Res avec mes BMP que j'inclue dans le code de mon composant. Cela entraine l'integration dans le code de l'exe

Au depart je pensais utiliser les DFM avec la prop DATA mais mes espoir se sont vites effondres ...

[Pedro]

Salut
Je ne comprends pas pourquoi tu n'initialises pas tes objets dans le Create... Il est fait pour ça!

Bonne chance

[Clorish]

Simplement pour supprimer du code source le code de parametrage des composants.

Simple supposition :
10 objets a initialiser avec 20 proprietees chaques = 200 lignes rien que d'initialisations ....
L'avantage des DFM c'est que l'initialisation se situe en dehors de l'unitee de conception.

C'ets peut etre bete .... mais ca met plus de clartee dans le code du programme. ;pp

[Pedro]

N'oublie pas qu'il y a des propriétés par défaut qui n'ont pas besoin d'être modifiées si elles te conviennt... Tu verras alors que ta liste de 200 lignes maigrira énormément

Bonne chance

[Clorish]

Justement ;ppp l'interet de la solution que je cherche est d'eviter d'avoir bcp de lignes de codes pour parametrer un objet dont mes parametres par defaut sont majoritairement differents de celles du composant de base. Cela eviterait d'avoir bcp de lignes de configuration et/ou de creer un objet derivé qui n'a pour but que de changer les props de base ....

En tout cas merci de ta contribution ..

[Pedro]

Bonnben si tu tiens à écarter les 200 lignes d'initialisation, mets-les dans une autres unité!

[Clorish]

C'est pas que j'y tiens .... C'est que je ne me considere pas comme etant un Dieu du Delphi ^^
Les DFM faisaient exactrement ce que je voulais .. mais marchaient pas dans mon cas. De plus je trouvais ca un peu 'lourd' de passer par le parametrage manuel des proprietes alors que delphi avait mis en place un systeme performant en creation assitee ...

Donc l'un dans l'autre me suis dit qu'il devait y avoir un truc que je sais pas ^^ ... visiblement non :op

Merci a tous pour vos reponses ..

Bye, Eric.

[Pedro]

Le problème, dans ton cas, c'est que les DFM se créent et se modifient uniquement lors du DesignTime... Un composant ne peut pas agir directement dessus.

[Clorish]

Les dfms sont integres dans l'exe avec la commande {$R *.dfm} et Delphi "lie" se base dessus pour renplir les valeurs initiales des composants d'un objet TForm dont la declaration se situe juste en dessous de "Class".

Je pensais ecrire qque chose comme :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
type TMonCompo = Class(TPanel)
            Label : TLabel;
            ListBox : TListBox;
       Private
       Public
       Published
            MaProp : TString;
            Monint : Integer;
       End;
 
{$R *.dfm}

et generer un DFM du genre :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
Object Compo : TMonCompo
      MaProp = 'toto'
      MonInt = 5
      Object Label : TLabel
              ....
      end
      Object ListBox : TListBox
              ....
      End
End

Mais cela ne s'applique que pour des comps derives de TForm .... enfin je crois :/

[sjrd]

Je pense avoir la solution, mais ne vous emballez pas trop vite, je n'en suis pas certain

Le but est d'utiliser les procédure WriteComponent et ReadComponent de l'objet TStream. A partir de là, tu crées un petit programme qui positionne par code toutes les propriétés et qui fait un TFileStream.WriteComponent(MonComposant).
Tu obtiens ainsi un fichier contenant tes informations et qui est au même format que les DFM (c'éti pas magnifique ?).
Puis dans le Create de ton composant, après avoir créé tous tes composants encapsulés, tu fait un TFileStream.ReadComponent(Self).
Le tour est joué

J'espère que ça fonctionne.