Discussion :

[Lucas Panny]

Bonjour !

Ce post paraît une question élémentaire puisque ce component existe depuis les 1ers BCB mais je me demande quel est le vrai interêt du composant TShape ?
Pour moi, c'est un composant avec six formes possibles : circle, roundrect, etc. qu'on peut colorier gràce à sa brush et son stylo (Pen). C'est tout, si on veut lui donner d'autres motifs de brosse, c'est plus compliqué car il faut manipuler la propriété Bitmap de sa propriété Brush.
Est-ce qu'on peut écrire du texte dessus ? COMMENT ?
Comment lui faire d'autres formes ex : triangle, losange, c-à-d polygone ????

[Lucas Panny]

Je répète encore un peu ma question : Comment faire à un TShape d'autres formes ex : triangle, losange, c-à-d polygone ????

[henderson]

Salut !

TShape n'est là que pour offrir aux utilisateurs des formes géométriques toute faites dont la particularité est de pouvoir se dessiner dans la zone client de l'objet lui-même.
Il est vrai que les concepteurs de BCB auraient pu faire un effort en ce qui concerne le losange.

A toi de devenir concepteur !

Il suffirait de dériver de TGraphicControl (dont dérive également TShape).

On dispose alors d'un canvas permettant de dessiner dans la zone client de l'objet.

C'est en surchargeant la méthode Paint (solicitée à chaque fois que l'objet doit se repeindre) que l'on peut dessiner ce que l'on veut.

Tu as le choix :
- soit développer une classe temporaire (juste pour ton projet, donc une simple unité (.cpp et .h))
- soit réaliser un composant qui viendra s'insérer dans la palette des composants de ton BCB.

A plus !

[Lucas Panny]

Bonjour,

Le truc du TGraphicControl, je l'ai vu dans un tuto de CGi et ben, c'est aussi une solution ! Mais je me demande que TShape est seulement des formes toutes faites et qu'on ne peut pas lui donner des formes perso ?

[henderson]

Salut !

Tu peux toujours dériver de TShape... mais ça revient aussi à le reécrire.

Il vaut mieux faire un nouveau composant, en tout cas c'est ce que je pense !

Par ailleurs, si on veut ajouter un triangle ça devient relativement compliqué pour le définir à l'aide de propriétés aussi simples que celle d'une énumération.
C'est la dessus que TShape est fondé !

A plus !

[henderson]

Salut !

Voici un exemple et c'est juste un exemple de composant !
Ca se présente ainsi chez moi :

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
 
enum jShapeType { ztRectangle=0, ztSquare, ztRoundRect, ztRoundSquare, ztEllipse, ztCircle , ztLosange, ztTriangle };
enum jTriangleType { ztLeft=0, ztTop, ztRight, ztBottom};
 
class PACKAGE jShape : public TGraphicControl
{
private:
jShapeType FShape;
jTriangleType FTriangle;
int FRatio;
 
TPenStyle FPenStyle;
TColor FPenColor;
 
TBrushStyle FBrushStyle;
TColor FBrushColor;
 
protected:
    void __fastcall DrawLosange();
    void __fastcall DrawSquare();
    void __fastcall DrawCircle();
    void __fastcall DrawTriangle();
 
    void __fastcall SetPenStyle(TPenStyle Value);
    void __fastcall SetPenColor(TColor Value);
    void __fastcall SetBrushStyle(TBrushStyle Value);
    void __fastcall SetBrushColor(TColor Value);
    void __fastcall SetShape(jShapeType Value);
    void __fastcall SetTriangle(jTriangleType Value);
    void __fastcall SetRatio(int Value);
    //Surcharge de la méthode Paint
    void __fastcall Paint();
 
public:
    __fastcall jShape(TComponent* Owner);
 
__published:
 
__property TPenStyle PenStyle = {read=FPenStyle, write=SetPenStyle};
__property TColor PenColor = {read=FPenColor, write=SetPenColor};
 
__property TBrushStyle BrushStyle = {read=FBrushStyle, write=SetBrushStyle};
__property TColor BrushColor = {read=FBrushColor, write=SetBrushColor};
 
__property jShapeType Shape = {read=FShape, write=SetShape, default=0};
 
__property jTriangleType Triangle = {read=FTriangle, write=SetTriangle, default=0};
 
__property int Ratio = {read=FRatio, write=SetRatio};
 
};

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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
 
// ValidCtrCheck est utilisé pour être sûr que les composants créés ne
// contiennent aucune fonction virtuelle pure.
//
 
static inline void ValidCtrCheck(jShape *)
{
    new jShape(NULL);
}
//---------------------------------------------------------------------------
__fastcall jShape::jShape(TComponent* Owner)
    : TGraphicControl(Owner)
{
if(Owner->InheritsFrom(__classid(TWinControl))) Parent = (TWinControl*)Owner;
Width = 60;
Height = 60;
}
//--
namespace Jshape
{
    void __fastcall PACKAGE Register()
    {
        TComponentClass classes[1] = {__classid(jShape)};
        RegisterComponents("Exemples", classes, 0);
    }
}
//--
 
void __fastcall jShape::SetShape(jShapeType Value)
{
FShape = Value;
Repaint();
}
//--
void __fastcall jShape::SetPenStyle(TPenStyle Value)
{
FPenStyle = Value;
Repaint();
}
//--
void __fastcall jShape::SetPenColor(TColor Value)
{
FPenColor = Value;
Repaint();
}
//--
void __fastcall jShape::SetBrushStyle(TBrushStyle Value)
{
FBrushStyle = Value;
Repaint();
}
//--
void __fastcall jShape::SetBrushColor(TColor Value)
{
FBrushColor = Value;
Repaint();
}
//--
void __fastcall jShape::SetTriangle(jTriangleType Value)
{
FTriangle = Value;
Repaint();
}
//--
void __fastcall jShape::SetRatio(int Value)
{
if(Value < 0) Value = -Value;
if(Value > 100) Value = 100;
FRatio = Value;
Repaint();
}
//--
void __fastcall jShape::Paint()
{
Canvas->Brush->Color = Parent->Brush->Color;
Canvas->Brush->Style = bsSolid;
Canvas->FillRect(Rect(0,0, Width, Height));
 
Canvas->Brush->Color = BrushColor;
Canvas->Brush->Style = BrushStyle;
 
Canvas->Pen->Color = PenColor;
Canvas->Pen->Style = PenStyle;
 
switch(Shape)
    {
    case ztRectangle :
    Canvas->Rectangle(0, 0, Width-1, Height-1);
    break;
 
    case ztSquare :
    DrawSquare();
    break;
 
    case ztRoundRect :
    //...
    break;
 
    case ztRoundSquare :
    //...
    break;
 
    case ztEllipse :
    Canvas->Ellipse(0,0, Width-1, Height-1);
    break;
 
    case ztCircle :
    DrawCircle();
    break;
 
    case ztLosange :
    DrawLosange();
    break;
 
    case ztTriangle :
    DrawTriangle();
    break;
    }
}
//--
void __fastcall jShape::DrawLosange()
{
int we = Width / 2;
int he = Height / 2;
 
Canvas->MoveTo(we,0);
Canvas->LineTo(Width-1, he);
Canvas->LineTo(we, Height-1);
Canvas->LineTo(0, he);
Canvas->LineTo(we,0);
Canvas->FloodFill(we,he, Canvas->Pixels[we][he], fsSurface);
}
//---------------------------------------------------------------------------
void __fastcall jShape::DrawSquare()
{
int we = Width / 2;
int he = Height / 2;
int size = we;
if(we > he) size = he;
Canvas->Rectangle(we-size, he-size, we+size, he+size);
}
//---------------------------------------------------------------------------
void __fastcall jShape::DrawCircle()
{
int we = Width / 2;
int he = Height / 2;
int size = we;
if(we > he) size = he;
Canvas->Ellipse(we-size, he-size, we+size, he+size);
}
//---------------------------------------------------------------------------
void __fastcall jShape::DrawTriangle()
{
TPoint S1;
TPoint S2;
TPoint S3;
TPoint FP;
int we = Width-1;
int he = Height-1;
switch(Triangle)
    {
    case ztLeft :
    S1 = Point(0, he);
    S2 = Point(0, 0);
    S3 = Point(we, (he * FRatio) / 100);
    break;
    case ztTop :
    S1 = Point(0, 0);
    S2 = Point(we, 0);
    S3 = Point(we - ((we * FRatio) / 100), he);
    break;
    case ztRight :
    S1 = Point(we, 0);
    S2 = Point(we, he);
    S3 = Point(0, he-((he * FRatio) / 100));
    break;
    case ztBottom :
    S1 = Point(we,he);
    S2 = Point(0, he);
    S3 = Point((we * FRatio) / 100, 0);
    break;
    }
FP = Point((S1.x + S2.x + S3.x) / 3,(S1.y + S2.y + S3.y) / 3) ;
Canvas->MoveTo(S1.x, S1.y);
Canvas->LineTo(S2.x, S2.y);
Canvas->LineTo(S3.x, S3.y);
Canvas->LineTo(S1.x, S1.y);
Canvas->FloodFill(FP.x,FP.y, Canvas->Pixels[FP.x][FP.y], fsSurface);
}
//--

Dans cet exemple, la base du triangle est alignée sur l'un des 4 cotés de l'objet :

enum jTriangleType { ztLeft=0, ztTop, ztRight, ztBottom}; // jTriangleType Triangle

Le sommet (opposé à la base) est donc situé sur le coté opposé à la base en le positionnant selon la formule : si AB est un segment et M un point sur le segment, on a AM = AB * Ratio / 100)

J'ai fait en sorte que l'ensemble (Triangle et Ratio) soit tel qu'une fois dessiné, le triangle puisse sembler en rotation.

A plus !

[Mattetfamilly]

Perso je me suis servi de TShape pour masquer une signature sur un document...

A une époque dans ma boite l'utilisation d'un fichier image d'une signature était assez tabou... Aujourd'hui ça l'est encore mais moins.

Chacun de nos appareils est testé et fait l'objet d'un pv délivré au nom du client.
Ce pv est édité avec QuickReport et via des fonctions propre au QuickReport, nous pouvons les consulter après stockage dans un format toujours propre au QuickReport.
Mais donc en consultation, nous avions choisi que l'utilisateur ne puisse pas voir à l'écran la signature du document (ni de la copier de fait par une impression d'écran...) mais qu'il puisse imprimé le document signé... Le composant TShape est apparu comme une bonne solution pour masquer la signature...