Discussion :

[Franck26]

Bonjour à tous,
Je cherche à créer dynamiquement des bouttons qui sont afficher sur ma form Frm_Main. Pour celà j'utilise une TList de la façon suivante :

Code :

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

1
2
TButton *But1 = new TButton((void *)Frm_Main);
ButtonList->Add((void *)But1);

Tous celà fonctionne, sauf que je souhaiterais pouvoir controler la destruction de mon boutton, hors je pense qu'il est détrui automatiquement lors de la destruction de Frm_Main.

Est ce possible de lui spécifier que je souhaite garder la main pour la destruction ? (J'ai pas réussi avec NULL).

Merci.

[slylafone]

Code :

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

TButton *But1 = new TButton(NULL);

ou si ça passe pas à la compilation :

Code :

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

TButton *But1 = new TButton((TComponent *)NULL);

[Freeze]

pour créer un bouton :

Code :

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

1
2
3
 
TButton *But1 = new TButton((void *)Frm_Main);
ButtonList->Add((void *)But1);

pour récupérer le pointeur du bouton :

Code :

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

1
2
 
TButton *But1=(TButton *)ButtonList->Items[i];

pour le détruire :

Code :

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

1
2
3
 
delete But1;
ButtonList->Delete(i);

autre chose ??

[Franck26]

Merci à tous les 2,
Je pense que c'est le (TComponent *)NULL que je ne connaissait pas.

Mais j'ai toujours le probléme de la destruction du TButton qui me génére une erreur.

Le TButton est dans une classe que j'ai nommée Button, je vous donne le 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
17
18
19
20
21
Button::Button(void)
{
        TList* ButtonList = new TList;
}
 
Button::~Button(void)
{
        for (int i=0; i<ButtonList->Count; i++)
        {
                delete (TButton *)ButtonList->Items[i];
        }
        ButtonList->Clear();
        delete ButtonList;
}
 
void Button::Add(void)
{
        TButton *But1 = new TButton((TComponent *)NULL);
        But1->Parent = Frm_Main;
        ButtonList->Add((void *)But1);
}

L'erreur ce produit à la destruction de Frm_Main. Le systéme plante lorsque j'arrive sur "delete (TButton *)ButtonList->Items[i]".
Je suppose que c'est parce que le TButton à déjà été détruis.
Mais je voudrais garder le controle de la destruction.

Si vous avez une idée...

Merci.

[Freeze]

non ... ce que tu as écrit est bon ... je pense que ton erreur est ailleurs ... tu ferais pas un delete dans un autre endroit par hasard ??

[henderson]

Salut !

Pourquoi ne pas dériver de TComponent pour cette class ?
La liste des buttons serait alors celle d'un TComponent : Components.
Ca ne serait pas plus simple ?

A plus !

[Franck26]

Je ne pense pas le détruire avant, je viens de vérifier en débuggage.
Est ce possible que je ne puisse pas détruire mon TButton parce que la TForm Frm_Main sur laquelle il est est déjà détruite ?

Sinon, pour dériver un TComponent pour cette class, je crois qu'on arrive au bout de mes connaissance (sniff), mais je vais essayer de m'y pencher dessus.

A+.

[Freeze]

oui ... effectivement ... si ton Parent est déja détruit ... il y a des chances que tes objets soient aussi détruits !!

[Gilles Louïse]

Le problème c'est que vous écrivez ceci :

Code :

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

1
2
3
4
Button::Button(void)
{
TList* ButtonList = new TList; 
}

C'est évidemment fautif car votre variable ButtonList est locale au constructeur. Ce qu'il faut faire, c'est la déclarer dans la classe elle-même :

Code :

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

1
2
3
4
5
6
7
8
class Button
{
public:
TList* ButtonList; //<---- ICI
Button();
~Button();
void Add();
};

Le constructeur devient ceci :

Code :

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

1
2
3
4
Button::Button(void)
{
ButtonList = new TList;
}

Vous n'avez pas besoin de vider la liste, après destruction des composants, vous effacez la liste dans le destructeur :

Code :

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

1
2
3
4
5
Button::~Button(void)
{
for (int i=0; i<ButtonList->Count; i++) delete (TButton *)ButtonList->Items[i];
delete ButtonList;
}

Au moment de l'ajout, vous n'avez pas besoin d'indiquer void*

Code :

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

1
2
3
4
5
6
void Button::Add(void)
{
TButton *But1 = new TButton((TComponent *)NULL);
But1->Parent = Frm_Main;
ButtonList->Add(But1);
}

Il n'y a aucune raison que ça ne marche pas.

À bientôt
Gilles

[henderson]

Salut !

Pour indication, voici ce que devient cette class dérivée de TComponent :

Code :

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

1
2
3
4
5
6
7
class jButtons : public TComponent
{
public :
    __fastcall jButtons(TComponent *Owner);
    __fastcall ~jButtons();
    TButton*  __fastcall Add();
};

Les méthodes :

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
__fastcall jButtons::jButtons(TComponent *Owner)
    : TComponent(Owner)
{
}
 
__fastcall jButtons::~jButtons()
{
}
 
 
TButton*  __fastcall jButtons::Add()
{
TButton *NewButton  = new TButton(this);
if(Owner->InheritsFrom(__classid (TWinControl)))
    {
    NewButton->Parent = (TWinControl*)Owner;
    }
return NewButton;
}

A l'usage :

Code :

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

jButtons *ButtonsList;

Une séquence de créations dynamiques, que l'on suppose extraite du constructeur de la form :

Code :

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

1
2
3
4
5
6
7
ButtonsList = new jButtons(this); //this == La form
TButton *Button;
for(int j = 0; j < 4; j++)
    {
    Button = ButtonsList->Add();
    Button->SetBounds(10 + (j * 40), 20, 30, 21);
    }

Ajouter un button directement à Buttonslist se fait, ici depuis la form :

Code :

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

1
2
3
TButton *Button = new TButton(ButtonsList);
Button->SetBounds(10, 50, 30, 21);
Button->Parent = this; //this pour la form... dans tout les cas un TWinControl*

A noter que l'on peut rajouter des paramètres pour la méthode Add, ce qui rendrait son usage
encore plus simple !

A plus !

[Franck26]

oui ... effectivement ... si ton Parent est déja détruit ... il y a des chances que tes objets soient aussi détruits !!

Bon ben voilà d'où doit venir mon probléme...
Je devrais pouvoir me débrouiller pour ça. Merci

Le problème c'est que vous écrivez ceci :

Code:
Button::Button(void)
{
TList* ButtonList = new TList;
}

C'est évidemment fautif car votre variable ButtonList est locale au constructeur. Ce qu'il faut faire, c'est la déclarer dans la classe elle-même

Oui, c'est vrai, j'ai voulu symplifier pour vous donner le code, j'ai pas réagis qu'il n'était plus compilable. Merci.

Pour la class dérivée de TComponent, merci pour les info, ça m'a l'air pas mal interressant, je vais creuser ça, je pense que j'ai encore du boulot la dessus.

[gandf]

Pourquoi ne pas directement prendre un TComponentList puisqu'il gère tout ça? Il me semble qu'il détruit les composants qui sont ajoutés à sa liste lors de sa destruction.

Voici ce que en dit l'aide :

Utilisez la classe TComponentList pour stocker et gérer une liste de composants. TComponentList propose des propriétés et méthodes pour ajouter, supprimer, réorganiser, rechercher, trier et accéder aux composants. Comme TObjectList, TComponentList contrôle la mémoire de ses composants; à moins que la propriété OwnsObjects ne soit définie à false (ou que les composants soient retirés avec la méthode Extract). TComponentList libère ses composants lorsqu'ils sont retirés de la liste, ou quand l'instance de TComponentList est elle-même détruite.

De plus, TComponentList surveille ses composants. Quand un composant est libéré, TComponentList s'actualise automatiquement en supprimant la référence au composant supprimé et en compactant la liste.