A propos des modèles d'objet (avec sources)

Version imprimable

15/11/2002, 14h30
DevX

[Résolu] A propos des modèles d'objet (avec sources)

J'aimerais, un peu comme en VB, pouvoir créer un modèle puis obtenir des instances de ce modèle.

Par exemple, si je créé un bouton "Button1" avec un caption "OK", j'aimerais pouvoir faire TButton *T = new Button1(). Ainsi, automatiquement, T->Caption possède un caption contenant "OK" comme le modèle Button1.

Ca me parait pratique car pour l'instant je construit tout dynamiquement

Merci
15/11/2002, 18h08
gRRosminet

tu peux créer une copie d'un objet avec le constructeur :

Code:

TButton * B = new TButton(*Source);

Tu connais le langage C++ ???
16/11/2002, 07h43
DevX

Je fais de l'informatique depuis une dizaine d'années...
Je connais surtout le VB mais depuis la sortie de .NET j'ai décidé de passer au C++. J'en ai déjà fait un peu avec TC++ DOS 1.0 et TC++ WIN 3.0 ... Ca date un peu et j'ai pas fais de vrais programmes avec.

Mais bon, je préfère BC++ car .NET ne me satisfait vraiment pas.

:?
16/11/2002, 11h06
DjmSoftware

tu peux également créer un composant qui descent du type TButton avec sa property Caption fixée a la valeur désirée

Salutations
16/11/2002, 12h04
DevX
Citation:

TButton *B = new TButton(Button1);

Ca marche pas : :cry:

Je dépose un TButton (Button1) sur la TForm1 (Form1)
Dans l'evenement Click de Button1 je saisi :
Code:

1 2 3 4 5 6 TButton *T = new TButton(Button1); T->Parent = this; T->Left = 100; T->Top = 100; T->Visible = true;
Et ça m'affiche un bouton vide à la taille par défaut.

:?:

Ps:
En plus, mon problème est plus complexe puisque j'utilise un dérivé de TPanel qui contient plusieurs contrôles. L'objectif étant de construire le modèle visuellement puis de créer des instance de ce modèle visuel ensuite.
16/11/2002, 17h16
DevX

...

Copy constructors

Object Pascal does not have built-in copy constructors. Consequently, VCL style classes in C++Builder do not have built-in copy constructors. The following example code attempts to create a TButton pointer by using a copy constructor:

TButton *B = new TButton(ownerCtrl);

TButton *C = new TButton(*B); // not allowed for VCL style class objects

Do not write code that depends upon a built-in copy constructor for VCL classes. To create a copy of a VCL style class object in C++Builder, you can write code for a member function that copies the object. Alternatively, descendants of the VCL TPersistent class can override the Assign method to copy data from one object to another. This is typically done, for example, in graphics classes such as TBitmap and TIcon that contain resource images. Ultimately, the manner of copying an object can be determined by the programmer (component writer); but be aware that some of the copy methods used in standard C++ are not available for VCL style classes.

Enfin, bon, ça tue quand même de pas pouvoir dupliquer dynamiquement des controles containers. Alors que je peux faire un copier/coller avec le clavier..... Me reste plus qu'a faire des sendkey's

HAHAHAHA dites moi que je rêve ?

Bonsoir à toi DevX :)

Ne te décourage pas voici une soluce qui devrait répondre à ton Pb

Fichier Unit1.h

Code:

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
 
#ifndef Unit1H
#define Unit1H
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <ExtCtrls.hpp>
//---------------------------------------------------------------------------
class TForm1 : public TForm
{
__published:	// Composants gérés par l'EDI
        TPanel *Panel1;
        TButton *Buttoncreate;
        void __fastcall ButtoncreateClick(TObject *Sender);
        void __fastcall FormClose(TObject *Sender, TCloseAction &Action);
private:	// Déclarations de l'utilisateur
public:		// Déclarations de l'utilisateur
        __fastcall TForm1(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif

Fichier.cpp

Code:

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
 
void __fastcall TForm1::ButtoncreateClick(TObject *Sender)
{
  static short a = 10;
  TButton *Button1;
  Button1 = new TButton(Form1);
  Button1->Parent = Panel1;
  Button1->Caption = "Ok";
  Button1->Left = a;
  a+= 10;
}
//---------------------------------------------------------------------------
 
void __fastcall TForm1::FormClose(TObject *Sender, TCloseAction &)
{
   int        i;
   TComponent *Temp;
// Scrute les composants possèder par la forme
   for (i=0; i< Form1->ComponentCount-1; i++)
   {
     Temp = Form1->Components[i];
// Si un composant est du type requis 
     if(dynamic_cast<TButton*>(Temp) != NULL)
     {
// On transtype dans la classe correspondante...
       TButton *B = (TButton*)Temp;
// On détruit le composant crée dynamiquement
       delete(B);
     }
   }
}

Jespère t'avoir aidé

Amicalement Laurent :wink:

16/11/2002, 22h48
DevX

Merci Laurent, cela revient à ce que je faisais au départ d'une façon différente.

J'aurais aimé, comme en VB, ajouter un TButton (Button1) et ensuite pouvoir créer des instances de ce Button1 en faisant, par exemple, TButton *B = new Button1; et, pareil, pour des controles containers du genre TPanel contenant divers autres controles.

Au début, et bien je créé dynamiquement les boutons, etc que je stocke dans des structures elles mêmes contenues dans un TList. L'ennui, c'est que ça m'oblige à tout programmer. La position en pixel de tel ou tel bouton, etc....Un travail laborieux.

Enfin, je pense tenir une piste sérieuse car j'ai remarqué que les TFrames peuvent jouer à la fois le role de fenêtre et de container du genre TPanel. A priori, ça devrait marcher.

Merci pour votre aide à tous.
16/11/2002, 23h44
MadMakII

Dans ton cas, il serait peut-être intéressant de créer un descendant de TPannel contennant un tableau de boutons et ayant un constructeur prenant en paramètre le nombre de boutons que celui-ci doit contenir et ar exemple la dimension des boutons (hor et vert) et calculant la position de ceux ci en fonction de le dimention du pannel. Tu pourrais ajouter comme paramètre un TString list contenant les "Captions" de chaque TButton....
17/11/2002, 00h27
DevX

MadMakII

En fait, c'est plus compliqué que cela. Pour être précis, je travaille sur un logiciel d'analyse technique/graphique pour la bourse dont voici les principes de la structure.

un formulaire MDI capable d'afficher des instances de fenêtres chaque fenêtre contient un TScrollBox

Ce TScrollBox peut contenir un nombre indéterminé de TPanel Chaque TPanel contient un TGraphControl pour le dessin des graphiques, plus un TScrollbar, plus un TCheckBox, plus divers TButton Chaque TPanel peut être fermé, déplacé, agrandi... C'est donc une structure relativement plus complexe qu'un TPanel avec quelques boutons, surtout que les graphiques partagent les mêmes données boursières. Il aurait donc été plus pratique pour moi de concevoir visuellement ce TPanel (comme en vb) puis ensuite d'en creer des instances.... Je viens d'ailleurs de me rendre compte que TFrame ne peut répondre que partiellement à ce problème.

Dans tout cela, ce qui m'énerve le plus, c'est qu'avec le clavier je peut faire un copier/coller de ce TPanel et tout ce qu'il contient sans problème alors que mon code ne permet pas de le faire. Comme cité plus haut dans la doc de BCB, on ne peut pas utiliser de constructeur de copie avec les classes VCL. J'ai, malheureusement, l'impression que je ne pourrais pas réaliser cela autrement qu'en passant par le code, en placant chaque élément dans le TPanel au pixel prêt.

Je trouve étonnant qu'un langage aussi puissant que BCB ne soit pas capable de faire cela les doigts dans le nez...... :)
17/11/2002, 01h35
MadMakII

Ton projet semble beaucoups plus complexe que ce que je pensais à la base.
Cependant, j'essayerais de voir quels sont les composants remplissants le max de propriétés nécessaires (ce doit être ceux énoncés plus haut) et j'hériterais de ceux-ci pour travailler. Donc, pour le pannel, je persiste et signe ce que j'ai dit plus haut, parcontre, pour TScrollBox que je ne maitrise pas trop, je lui ajouterais un membre TPannel ou Tableau de
TPannel. En fait, n'étant pas trop courageux, j'essaie de récuperer un max de composants déjà développés par d'autres ce qui me permet en un temps reccord de faire des applications assez performantes.
17/11/2002, 14h23
Laurent GAUDILLIER

Bonjour à tous !! :)

DevX, ne serait il pas plus simple en ce qui concerne ton Pb de créer une appli MDI et de créer un modèle de "fiche enfant" ???
Ainsi tu pourrait instancier autant de fiches que tu veux sur le modèle créer
A méditer :wink:

Amicalement Laurent
17/11/2002, 14h29
DevX

Laurent,

non, j'ai besoin de controles qui soient précisement alignés les uns par rapport aux autres.

J'ai trouvé une réponse précise à mon problème. C'est tout à fait possible de faire des instances de n'importe quel modèle avec des objets comme TWriter, TReader, TStreamMemory, ReadComponent, etc...

Je buche actuellement sur cette solution en espérant créer une petite fonction du genre :

TComponent *CreateControlInstance(TComponent *Source, AnsiString &NewName)

Cette fonction devrait alors renvoyer une instance d'un objet avec tous les objets qu'il contenait lorsqu'il à été créé visuellement en RAD.
17/11/2002, 17h46
DevX

Après une longue recherche sur internet, j'ai trouvé une unité écrite en pascal résolvant, de façon propre, le problème que nous avons rencontré au sujet des instanciations de contrôles containers.

J'ai importé Unit2.pas dans mon projet C++. En ayant préalablement renommé l'unité et la directive Unit dans le fichier Unit2.pas avec un nom plus pratique. J'ai, ensuite, compilé l'unité, puis j'ai fait un include du .HPP, généré par la compilation, dans mon projet et - résultat - ça marche très bien.

Quand j'aurais un peu de temps je l'écrirais directement en C++

:D

Bonjour à tous :D

Pour ceux que ça interresse, voici le source pascal trouver par DevX retraduit en C++ BUILDER

Fichier .h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
 
#ifndef Unit_Duplicate_InstanceH
#define Unit_Duplicate_InstanceH
 
#include <Classes.hpp>
#include <Controls.hpp>
#include <sysutils.hpp>
 
extern TComponent* DuplicateComponents(TComponent *AComponent);
 
 
//---------------------------------------------------------------------------
#endif

Fichier .cpp

Code:

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
 
//---------------------------------------------------------------------------
#pragma hdrstop
 
#include "Unit_Duplicate_Instance.h"
 
//---------------------------------------------------------------------------
 
#pragma package(smart_init)
 
 
class TUniqueReader : public TReader
{
private:
  void __fastcall SetNameUnique(TReader *Reader, TComponent *Component, AnsiString  &Name);
public:
  TComponent *LastRead;
  void __fastcall ComponentRead(TComponent *Component);
  __fastcall virtual TUniqueReader(TStream *Stream, int BufSize);
};
 
//----------------------------------------------------------------------------------------------
__fastcall TUniqueReader::TUniqueReader(TStream *Stream, int BufSize): TReader(Stream, BufSize)
{
  OnSetName = SetNameUnique;
  LastRead = NULL;
}
//----------------------------------------------------------------------------------------------
void __fastcall TUniqueReader::ComponentRead(TComponent *Component)
{
  LastRead = Component;
}
//----------------------------------------------------------------------------------------------
void __fastcall TUniqueReader::SetNameUnique(TReader *, TComponent *Component, AnsiString  &Name)
{
  int i = 0;
  AnsiString tempname = Name;
  while(Component->Owner->FindComponent(Name)!= NULL)
  {
    i++;
    TVarRec v[2] = {tempname, i};
    Name = Sysutils::Format("%s%d", v, 2);
  }
}
//----------------------------------------------------------------------------------------------
void RegisterComponentClasses(TComponent *AComponent)
{
   int i;
   TWinControl *C;
   RegisterClass(AComponent->ClassType());
   if(dynamic_cast<TWinControl*>(AComponent)!= NULL)
   {
      C = dynamic_cast<TWinControl*>(AComponent);
      if(C->ControlCount > 0)
      {
         for (i=0; i< C->ControlCount-1; i++)
         {
            RegisterComponentClasses(C->Controls[i]);
         }
      }
   }
}
//----------------------------------------------------------------------------------------------
TComponent* DuplicateComponents(TComponent *AComponent)
{
  TMemoryStream *Stream       = NULL;
  TUniqueReader *UniqueReader = NULL;
  TWriter       *Writer       = NULL;
  TComponent    *MyComponent  = NULL;
  try
  {
    Stream = new TMemoryStream;
    RegisterComponentClasses(AComponent);
    try
      {
        Writer =  new TWriter(Stream, 4096);
        Writer->Root = AComponent->Owner;
        Writer->WriteSignature();
        Writer->WriteComponent(AComponent);
        Writer->WriteListEnd();
      }
    __finally
    {
        delete(Writer);
    }
    Stream->Position = 0;
    try
    {
      TWinControl *C = NULL;
      UniqueReader = new TUniqueReader(Stream, 4096);
      if(dynamic_cast<TWinControl*>(AComponent)!= NULL )
      {
         C = dynamic_cast<TWinControl*>(AComponent);
         UniqueReader->ReadComponents(C->Owner, C->Parent, UniqueReader->ComponentRead);
      }else UniqueReader->ReadComponents(AComponent->Owner, NULL, UniqueReader->ComponentRead);
      MyComponent = UniqueReader->LastRead;
    }
    __finally
    {
      delete(UniqueReader);
    }
  }
  __finally
  {
    delete(Stream);
  }
  return(MyComponent);
}

Voila

Amicalement Laurent