Discussion :

[noahsaga]

Bonjour à tous,

Aujourd'hui je souhaite améliorer 2 composants : TTreeView et TTreeNode.
Je les ai appelé TClrTreeView (code récup sur le net et modifié) et TTreeFNode.
TClrTreeView permet de colorer le texte d'un noeud
TTreeFNode ajoute la propriété Fonction (un int tout bête)

J'aimerai que mon composant TClrTreeView utilise des TTreeFNode au lieu de tous les TTreeNode qu'il possède dans ses propriétés par héritage de la classe TTreeView. J'ai donc commencé à modifier Items, puis j'ai rajouté Item[] dans le TTreeFNode.

Voici le header de ce que j'ai fait :

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
#ifndef page_essaiH
#define page_essaiH
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include "pop_statusbar.h"
#include "pop_titrebar.h"
#include <ComCtrls.hpp>
#include <ExtCtrls.hpp>
#include "pop_titre_fonc.h"
//---------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//Creation d'une classe de treenode pour mémorisé le numéro de la fonction associé
//-----------------------------------------------------------------------------
class PACKAGE TTreeFNode : public TTreeNode
{
private:
  int FNumFonction;
  TTreeFNode *FItem[];
protected:
 
public:
  __fastcall TTreeFNode(TObject* Owner);
 
__published:
  __property int NumFonction = {read=FNumFonction,write=FNumFonction,default=0};
  __property TTreeFNode* TTreeFNode::Item[] = {read=GetItem,write=SetItem};
};
//-----------------------------------------------------------------------------
//Creation d'une classe de treeview pour faire de  l'affichage plus propre
//-----------------------------------------------------------------------------
class PACKAGE TClrTreeView : public TTreeView
{
private:
  TControlCanvas *cnvs;
  TList *ColorNodes;
  TColor FNodeColor;
  int FNodeActif;
  int FNodeAncien;
  TNotifyEvent FOnActifChange;
  TTreeFNode *FItems;
 
protected:
  virtual void __fastcall ChangeActif();
public:
  __fastcall TClrTreeView(TComponent* Owner);
  __fastcall ~TClrTreeView();
  void __fastcall PaintIt(TMessage &msg); //gère la coloration
  bool __fastcall IsColored(TTreeFNode *node); //permet de tester les éléments colorés
  void __fastcall SetColored(TTreeFNode *node, bool which); //désigne le type de couleur de l'élément
  void __fastcall SetNodeActif(int index); //mise en actif d'un noeud
  void __fastcall TreeNodeBold(int index); //mise en gras d'un noeud
 
BEGIN_MESSAGE_MAP
MESSAGE_HANDLER(WM_PAINT,TMessage,PaintIt)
END_MESSAGE_MAP(TTreeView);
 
__published:
  __property TColor HighlightColor = {read=FNodeColor,write=FNodeColor}; //couleur de l'élément Actif
  __property int NodeActif = {read=FNodeActif,write=SetNodeActif}; //élément actif
  __property int NodeAncien = {read=FNodeAncien,write=FNodeAncien}; //élément anciennement actif
  __property TNotifyEvent OnActifChange = {read=FOnActifChange, write=FOnActifChange};
  __property TTreeFNode *Items = {read=FItems, write=FItems};
 
};
//------------------------------------------------------------------------------

et le point cpp :

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
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//ON TRAVAIL ICI SUR LA CLASS COLORED TREE VIEW
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//---------------------------------------------------------------------------
__fastcall TClrTreeView::TClrTreeView(TComponent* Owner)
  : TTreeView(Owner)
{
  cnvs = new TControlCanvas();
  cnvs->Control = this;
  cnvs->Brush->Style = bsClear;
  ColorNodes = new TList();
}
//---------------------------------------------------------------------------
//destruction du canvas et de la list contenant les noeuds colorés
//---------------------------------------------------------------------------
__fastcall TClrTreeView::~TClrTreeView()
{
  delete cnvs;
  delete ColorNodes;
}
//---------------------------------------------------------------------------
// Gestion du canvas qui va "peindre" le texte des éléments colored
//---------------------------------------------------------------------------
void __fastcall TClrTreeView::PaintIt(TMessage &msg)
{
  TTreeView::Dispatch(&msg);
  //TClrTreeView::Dispatch(&msg);
 
  for (int i=0; i<Items->Count; i++)
  {
    if (ColorNodes->IndexOf(((void *)Items->Item[i])) != -1)
    {
      TRect noderct = Items->Item[i]->DisplayRect(true);
      cnvs->Font = Font;
      cnvs->Font->Color = FNodeColor;
 
      cnvs->TextOut(noderct.Left + 2, noderct.Top + 1,Items->Item[i]->Text);
    }
  }
}
//---------------------------------------------------------------------------
//Interrogation sur un élément pour savoir s'il est coloré
//---------------------------------------------------------------------------
bool __fastcall TClrTreeView::IsColored(TTreeFNode *node)
{
  if (ColorNodes->IndexOf(node) != -1)
    return true;
  else return false;
}
//---------------------------------------------------------------------------
//Détermination de la couleur d'un node actif
//---------------------------------------------------------------------------
void __fastcall TClrTreeView::SetColored(TTreeFNode *node,bool which)
{
  if (which)
  {
    if (ColorNodes->IndexOf(node) == -1)
      ColorNodes->Add(node);
  }
  else
    ColorNodes->Remove(node);
  Repaint();
}
//---------------------------------------------------------------------------
//Event sur le changement du node actif
//---------------------------------------------------------------------------
void __fastcall TClrTreeView::ChangeActif()
{
  if(FOnActifChange) FOnActifChange(this);
}
//----------------------------------------------------------------------------
//Changement du node actif
//---------------------------------------------------------------------------
void __fastcall TClrTreeView::SetNodeActif(int index)
{
  //TTreeFNode *node;
  FNodeActif = index;
  //Items->Item
  //node = ((TTreeFNode *)Items->Item[NodeAncien]);
  //SetColored(Items->Item[NodeAncien],false);
  //SetColored(node,false);
 
  //node = ((TTreeFNode *)Items->Item[NodeActif]);
  //SetColored(Items->Item[NodeActif],true);
  //SetColored(node,true);
 
 
 
  NodeAncien = NodeActif;
  FullCollapse();
  Items->Item[NodeActif]->Expand(true);
  ChangeActif();
}
//---------------------------------------------------------------------------
//Permet de mettre en gras l'élément actif (index) du tree
//---------------------------------------------------------------------------
void __fastcall TClrTreeView::TreeNodeBold(int index)
{
  TTreeNode *node;
  node = Items->Item[index];
 
  TTVItem* tvi = new TTVItem();
  tvi->hItem = node->ItemId;//node est le TNode à mettre en gras
  tvi->mask = TVIF_STATE;
  tvi->stateMask = TVIS_BOLD;
  tvi->state = TVIS_BOLD;
  TreeView_SetItem(node->Handle, tvi);
}
//-----------------------------------------------------------------------------
 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//ON TRAVAIL ICI SUR LA CLASS Fonction TREE Node
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//---------------------------------------------------------------------------
/*__fastcall TTreeFNode::TTreeFNode(TObject* Owner)
  : TTreeNode(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TTreeFNode::Set_Item(TTreeFNode* AItem[])
{
  FItem = AItem;
  //FItem[]->Assign(AListe);
}
//---------------------------------------------------------------------------
TTreeFNode* __fastcall TTreeFNode::Get_Item()
{
  return *FItem;
} */

Comme vous pouvez le voir beaucoup de commentaires car beaucoup de choses qui ne marchent pas.
Dans l'état que vous avez plus haut, ça compile mais si je veux utiliser :

Items->Item[]

Je me retrouve avec un TTreeNode et non un TTreeFNode...
Et cela va être le même problème avec toute les fonctions de Items : GetChild, AddChild, etc...

Je me rate qqpart mais je ne vois pas où.

existe-t-il un moyen pour modifier la classe de tous les noeuds utilisés par TClrTreeView en un seul coup?
Comment corriger mon code pour obtenir ce que je souhaite?

A bientôt.

Bon Premier constat, j'ai fait un amalgame entre les TTreeNode et les TTreeNodes

J'ai simplifié le code pour que ce soit plus lisible mais je n'arrive toujours pas à compiler :

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
class TNode : public TTreeNode
{
private:
        int FNum;
protected:
        virtual void __fastcall SetNum(int ANum);
public:
        __fastcall TNode();
 
__published:
        __property int Num = {read=FNum,write=SetNum};
};
 
class PACKAGE TTree : public TTreeView
{
private:
        TNode *FItem[];
protected:
 
public:
        __fastcall TTree(TComponent* Owner);
__published:
        __property TNode *TTreeNodes::Item[] ={read=GetItem,write=SetItem};
};
//---------------------------------------------------------------------------
#endif

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
static inline void ValidCtrCheck(TTree *)
{
        new TTree(NULL);
}
//---------------------------------------------------------------------------
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//---------------------------------------------------------------------------
__fastcall TNode::TNode() : TTreeNode()
{
        FNum = 0;
}
//---------------------------------------------------------------------------
void __fastcall TNode::SetNum(int ANum)
{
        FNum = ANum;
        //Invalidate();
}
//---------------------------------------------------------------------------
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//---------------------------------------------------------------------------
__fastcall TTree::TTree(TComponent* Owner)
        : TTreeView(Owner)
{
}
//---------------------------------------------------------------------------
/*void __fastcall TTree::SetNoeud(TNode *ANoeud)
{
        FNoeud = ANoeud;
} */
//---------------------------------------------------------------------------
namespace Tree
{
        void __fastcall PACKAGE Register()
        {
                 TComponentClass classes[1] = {__classid(TTree)};
                 RegisterComponents("Samples", classes, 0);
        }
}

Je crois que ne comprend pas vraiment comment fonctionne :

TTreeNodes::Item

Help please


Nouvelle évolution toujours pas de compile et je crois que la fatigue m'empeche de réfléchir et de comprendre voici 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
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
class TNode : public TTreeNode
{
private:
        int FNum;
protected:
        virtual void __fastcall SetNum(int ANum);
public:
        __fastcall TNode();
 
__published:
        __property int Num = {read=FNum,write=SetNum};
};
 
class TNodes : public TTreeNodes
{
private:
        TNode *FItem[];
protected:
        virtual void __fastcall SetItem(TNode *AItem[]);
        //virtual TNode __fastcall GetItem();
public:
        __fastcall TNodes();
 
__published:
        __property TNode *Item[] ={read=FItem,write=SetItem};
};
 
class PACKAGE TTree : public TTreeView
{
private:
        TNodes *FItems;
protected:
        virtual void __fastcall SetItems(TNodes *AItems);
        //virtual TNodes __fastcall GetItems();
public:
        __fastcall TTree(TComponent* Owner);
__published:
        __property TNodes *Items ={read=FItems,write=SetItems};
};
//---------------------------------------------------------------------------
#endif

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
static inline void ValidCtrCheck(TTree *)
{
        new TTree(NULL);
}
//---------------------------------------------------------------------------
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//---------------------------------------------------------------------------
__fastcall TNode::TNode() : TTreeNode()
{
        FNum = 0;
}
//---------------------------------------------------------------------------
void __fastcall TNode::SetNum(int ANum)
{
        FNum = ANum;
}
//---------------------------------------------------------------------------
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//---------------------------------------------------------------------------
__fastcall TNodes::TNodes() : TTreeNodes()
{
        FItem[] = new TNode();
}
//---------------------------------------------------------------------------
void __fastcall TNodes::SetItem(TNode *AItem[])
{
        &FItem[] = &AItem[];
}
/*TNode __fastcall TNodes::GetItem()
{
        return *FItem[];
}*/
//---------------------------------------------------------------------------
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//---------------------------------------------------------------------------
__fastcall TTree::TTree(TComponent* Owner)
        : TTreeView(Owner)
{
        FItems = new TNodes();
}
//---------------------------------------------------------------------------
void __fastcall TTree::SetItems(TNodes *AItems)
{
        FItems = AItems;
}
/*TNodes __fastcall TTree::GetItems()
{
        return FItems;
}*/
//---------------------------------------------------------------------------
namespace Tree
{
        void __fastcall PACKAGE Register()
        {
                 TComponentClass classes[1] = {__classid(TTree)};
                 RegisterComponents("Samples", classes, 0);
        }
}
//---------------------------------------------------------------------------

A la compile j'obtiens :

[C++ Error] Tree.h(35): E2346 read access specifier of property Item must be a member function
[C++ Error] Tree.h(35): E2347 Parameter mismatch in write access specifier of property Item
[C++ Error] Tree.cpp(21): E2285 Could not find a match for 'TTreeNode::TTreeNode()'
[C++ Error] Tree.cpp(33): E2285 Could not find a match for 'TTreeNodes::TTreeNodes()'
[C++ Error] Tree.cpp(35): E2188 Expression syntax
[C++ Error] Tree.cpp(40): E2188 Expression syntax
[Linker Fatal Error] Fatal: Unable to open file 'TREE.OBJ'



Please help me...

[noahsaga]

Bonjour à tous,

Le WE est passé par là, j'ai cassé un bout de ma cuisine, planté du gazon et j'ai la tête un peu plus fraiche.

Oublions le code déjà réalisé et repartons de zéro et posons LA question :

Comment doit-on procéder pour ajouter une propriété de type INT aux nœuds d'un TTreeView? Ca ne doit quand même pas être si compliqué...

A bientôt

[ShaiLeTroll]

Propriété Data du TTreeNode est un pointeur, tu peux l'utiliser comme un stockage 32bits ou pour stocker un pointeur sur un struct ou class !

Pour la couleur, voir les evènements tel que OnDraw, OnAdvancedDraw... tu en as un bon nombre !

n'oublie pas l'aide via la touche F1 !

Si tu es en BSD2007 ou plus, regarde si tu peux ajouter un class helper Delphi dans C++ ? j'ai un doute à ce sujet !

Sinon, pour ton héritage, tu as loupé un truc important, c'est d'étudier les méthodes virtuelles disponibles dont les "factory"

Sachant que Borland a été très sympa, ils ont prévu un évènement OnCreateNodeClass qui permet de redéfinir une classe héritée de TTreeNode
sans devoir passer par l'héritage ( tu devrais te contenter de cela pour le moment !)

Mais tu peux très bien surchargé (override en Delphi) ces méthodes

Code :

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

1
2
    function CreateNode: TTreeNode; virtual;
    function CreateNodes: TTreeNodes; virtual;

ainsi que redéfinir Items comme tu l'avais fait pour forcer la classe de la collection de noeud et des noeuds

Ensuite, tu as redifini trop d'éléments, inutile d'ajouter un tableau FItem[], il vient en double de celui déjà présent dans TTreeNodes !
en plus, du coup, tu ajoute des noeuds en double ? cela n'a aucun sens !

Tu as oublié totalement la notion POO de réutilisabilité, si tu hérite sans utiliser les méthodes ou membres d'une classe, c'est qu'il y a un gros problème de conception !

[noahsaga]

Salut et merci pour ta réponse.

Propriété Data du TTreeNode est un pointeur, tu peux l'utiliser comme un stockage 32bits ou pour stocker un pointeur sur un struct ou class !

Le Data du TTreeNode pourrait effectivement faire l'affaire pour mon projet mais là n'est plus la question. J'ai vraiment besoin de comprendre mes erreurs.

Pour la couleur, voir les evènements tel que OnDraw, OnAdvancedDraw... tu en as un bon nombre !

Mon code pour la couleur fonctionne mais je vais regarder.

Si tu es en BSD2007 ou plus, regarde si tu peux ajouter un class helper Delphi dans C++ ? j'ai un doute à ce sujet !

Je suis en BCB6

n'oublie pas l'aide via la touche F1 !

Sinon, pour ton héritage, tu as loupé un truc important, c'est d'étudier les méthodes virtuelles disponibles dont les "factory"

Sachant que Borland a été très sympa, ils ont prévu un évènement OnCreateNodeClass qui permet de redéfinir une classe héritée de TTreeNode
sans devoir passer par l'héritage ( tu devrais te contenter de cela pour le moment !)

Alors effectivement je me suis encore fait avoir par l'inspecteur d'objet et par ma fatigue et par mon aveuglement qui n'a pas vu que dans l'aide (F1) les Event étaient différents de l'inspecteur d'objet.
Je vais regarder ces méthodes virtuelles de plus prêt.

Mais tu peux très bien surchargé (override en Delphi) ces méthodes
Code :

function CreateNode: TTreeNode; virtual;
function CreateNodes: TTreeNodes; virtual;

ainsi que redéfinir Items comme tu l'avais fait pour forcer la classe de la collection de noeud et des noeuds

Ensuite, tu as redifini trop d'éléments, inutile d'ajouter un tableau FItem[], il vient en double de celui déjà présent dans TTreeNodes !
en plus, du coup, tu ajoute des noeuds en double ? cela n'a aucun sens !

Tu as oublié totalement la notion POO de réutilisabilité, si tu hérite sans utiliser les méthodes ou membres d'une classe, c'est qu'il y a un gros problème de conception !

Si je ne m'abuse c'est un peu (en maladroit je te l'accorde) ce que j'ai essayé de faire sur le 3ème bout de code, celui avec du texte en vert. Mon objectif était de surchargé Item dans Items et de surchargé Items dans TTreeView

[noahsaga]

Après plusieurs essais, je ne parviens pas à utiliser l'event :

Code :

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

1
2
3
4
5
6
 
void __fastcall Tecran_essai::tree_somCreateNodeClass(
      TCustomTreeView *Sender, TTreeNodeClass &NodeClass)
{
  NodeClass = &TNode;
}

C'est plus une histoire de syntaxe. Comment lui dire de changer la class des nœuds qu'il construit par la classe TNode?

[ShaiLeTroll]

Je te confirme, je ne fais du C++ que depuis 3 mois et c'est vrai que l'opérateur pour obtenir la MetaClass de BCB n'est pas évident à trouver !
En delphi, il n'y a pas besoin de mot clé !

Code :

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

  NodeClass = __classid(TNode);

[noahsaga]

ok merci super info.

Et maintenant la question à 1000 € :

Comment appeler cet Even si on veut créer le TTreeView de façon dynamique? D'habitude, l'inspecteur d'objet m'écrit le lien lorsque je double clic. Là en dynamique...

voici ce que me donne l'aide :

Code :

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

1
2
3
4
 
typedef void __fastcall (__closure *TTVCreateNodeClassEvent)(TCustomTreeView* Sender, TMetaClass* &NodeClass);
 
__property TTVCreateNodeClassEvent OnCreateNodeClass = {read=FOnCreateNodeClass, write=FOnCreateNodeClass};

[ShaiLeTroll]

Mon Numéro de compte en Suisse est le 9753 8642 9510 7530 1672

quelque par dans le code

Code :

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

TreeView1->OnCreateNodeClass = this->tree_somCreateNodeClass;

this étant ton Tecran_essai

[noahsaga]

Ok je pense que là je comprends que je suis un boulet car en fait je savais le faire...

Merci

Question subsidiaire:

L'intérêt du "this" ? Si je ne m'abuse je peux très bien (si je suis dans une fonction de Tecran_essai) ne pas le mettre :

Code :

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

1
2
3
4
5
6
7
 
__fastcall Tecran_essai::Tecran_essai(TComponent* Owner)
  : TForm(Owner)
{
 
...
TreeView1->OnCreateNodeClass = tree_somCreateNodeClass;

[ShaiLeTroll]

Tout à fait this est implicite, il m'arrive souvent de le mettre, je viens du Delphi ou le self (équivalent du this) est aussi implicite, mais mes gestionnaires d'évènements en Delphi lorsqu'ils sont affectés en RunTime, peuvent provenir de l'objet (this), d'un autre (souvent un Controller) ou même une méthode static d'une classe (TBidule::EventHandler) faut que je le teste en C++ ça d'ailleurs !

Mais avant de passer au C++ depuis décembre, je suis passé par un an de PHP, le $this est obligatoire ! du coup, j'ai pris l'habitude !
en plus le this te permet d'avoir uniquement les fonctions concernant ton objet lors de la complétion de code !

[noahsaga]

C'est vrai que le this aide bien pour la complétion du code.

Pour le moment je met ce bout de code en pause car j'ai des urgences ailleurs mais je mettrai mon code une fois terminé... ou lorsque je serai à nouveau bloqué.

To be continued