Discussion :

[yiuche]

Bonjour,
Je demande quelques petits conseil car je n'ai pas trouvé dans la FAQ.
On me demande de créer un curseur dynamique comme ci joint mais je ne sais pas quel outil utiliser.
J'explique ce que ce curseur doit faire :
- lorsque j'affiche la fenêtre, le curseur doit se positionner en récupérant un pourcentage calculé préalablement (c'est une moyenne de plusieurs chiffres).
- je dois pouvoir modifier la valeur du curseur et en simultané on recalcule par une règle de trois la valeur des autres chiffres pour les modifier.
- je dois pouvoir garder la velaur dans une base de données ( je pense que c'est le plus facile..)

Le problème est que je ne sais pas quoi utiliser et si c'est possible de le faire en delphi.
Merci pour vos conseils et remarques...

[Cl@udius]

Salut

L'utilisation d'un TTrackBar ne répond pas à ta demande?
Je pense que l'on peut gérer ta demande sans trop de difficulté avec ce compo.

@+

[yiuche]

C'est ce que j'ai commencé à faire et pour l'instant je me bats avec les paramètres pour essayer de donner le même graphisme que la demande du client...
mais c'est pas gagné !!!

[Cl@udius]

Re,

En définissant ton TrackBar ainsi, on commence à s'en approcher. Faire mieux ? euuh bof !

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
  object TrackBar1: TTrackBar
    Left = 120
    Top = 80
    Width = 150
    Height = 17
    Max = 100
    Position = 50
    SelEnd = 100
    TabOrder = 0
    ThumbLength = 16
    TickStyle = tsNone
  end

@+

[Pedro]

C'est ce que j'ai commencé à faire et pour l'instant je me bats avec les paramètres pour essayer de donner le même graphisme que la demande du client...
mais c'est pas gagné !!!

Salut
Attention, si tu demandes le même "graphisme" alors le TTrackBar ne permet pas de s'afficher comme ça.
Il te faudra récupérer des compos skinnables par exemple.

[LadyWasky]

Je te suggère de le faire toi-même en dérivant à partir de la classe TGraphicControl, et pour les chiffres, on va utiliser une liste de réels par exemple

En tout cas, voici la 1ère partie :

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
unit UnitFloatList;
interface
 
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls, Grids;
 
type
TFloatList = class(TObject)
  private
    FList: TList;
    FSum: Extended;
    FMeanValue: Extended;
    FIsUpdating:boolean;
    FOnStatChanged: TNotifyEvent;
    function GetItems(Item: integer): extended;
    procedure SetItems(Item: integer; Value: extended);
    function GetCount: integer;
    procedure ComputeSum;
    procedure ComputeMeanValue;
    procedure UpDateStats;
    procedure SetOnStatChanged(const Value: TNotifyEvent);
  public
    constructor Create;
    destructor Destroy; override;
    function Add(Value: extended): integer;
    function First: extended;
    function Last: extended;
    procedure Clear;
    procedure Delete(Item: integer);
    procedure BeginUpdate;
    procedure EndupDate;
    property Items[Item: integer]: extended read GetItems
        write SetItems; default;
    property Count: integer read GetCount;
    property Sum:Extended read FSum;
    property MeanValue:Extended read FMeanValue;
    property OnStatChanged:TNotifyEvent read FOnStatChanged write SetOnStatChanged;
  end;
 
implementation
 
function TFloatList.GetItems(Item: integer): extended;
begin
  Result:=PExtended(FList[Item])^;
end;
 
procedure TFloatList.SetItems(Item: integer; Value: extended);
begin
  PExtended(FList[Item])^:=Value;
  UpDateStats;
end;
 
function TFloatList.GetCount: integer;
begin
  Result:=FList.Count;
end;
 
constructor TFloatList.Create;
begin
  inherited Create;
  FList:=TList.Create;
  FIsUpdating:=false;
end;
 
destructor TFloatList.Destroy;
begin
  Clear;
  FList.Free;
  inherited Destroy;
end;
 
function TFloatList.Add(Value: extended): integer;
var
  FloatPtr: PExtended;
begin
  GetMem(FloatPtr, SizeOf(extended));
  FloatPtr^:=Value;
  Result:=FList.Add(FloatPtr);
  UpDateStats;
end;
 
function TFloatList.First: extended;
begin
  Result:=PExtended(FList[0])^
end;
 
function TFloatList.Last: extended;
begin
  Result:=PExtended(FList[FList.Count - 1])^;
end;
 
procedure TFloatList.Clear;
var
  Index: integer;
begin
  for Index:=0 to FList.Count - 1 do
    FreeMem(FList.Items[Index], SizeOf(extended));
  FList.Clear;
end;
 
procedure TFloatList.Delete(Item: integer);
begin
  FreeMem(FList.Items[Item], SizeOf(extended));
  FList.Delete(Item);
  UpDateStats;
end;
 
procedure TFloatList.ComputeMeanValue;
begin
  FMeanValue:=0;
  if Count<>0
  then FMeanValue:=FSum/Count;
end;
 
procedure TFloatList.ComputeSum;
var i:integer;
begin
  FSum:=0;
  for i:=0 to Count-1 do
      FSum:=FSum+Items[i];
end;
 
procedure TFloatList.UpDateStats;
begin
  if FIsUpdating then exit;
  ComputeSum;
  ComputeMeanValue;
  if Assigned(FOnStatChanged) then FOnStatChanged(self);
end;
 
procedure TFloatList.BeginUpdate;
begin
  FIsUpdating:=true;
end;
 
procedure TFloatList.EndupDate;
begin
  FIsUpdating:=False;
  UpDateStats;
end;
 
procedure TFloatList.SetOnStatChanged(const Value: TNotifyEvent);
begin
  FOnStatChanged := Value;
end;
 
end.

C'est une classe qui maintient une liste de réels, la somme et la moyenne est mise à jour à chaque fois qu'un élèment est ajouté/supprimé/modifié.

Je ne me suis pas fait suer à appliquer une règle de trois... tu peux adapter le code si çça te chante pour que celà soit fait ainsi.

Pour l'affichage du 0% et du 100%, je suggère 2 TLabel, donc il ne reste plus que la ligne verte (un LineTo avec Pen.Width=4 fera très bien l'affaire, reste le curseur.... je te charge du bitmap (clFushia pour la transparence)

[LadyWasky]

2ème partie, je n'ai pas testé, mais ça compile :

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
unit WATrackBar;
 
interface
 
uses
  Windows,types,SysUtils, Classes, Controls,Graphics,UnitFloatList;
 
type
  TWATrackBar = class(TGraphicControl)
  private
    { Déclarations privées }
    FFloatList:TFloatList;
    FTracker: TBitmap;
    FColor: TColor;
    FLineWith: integer;
    procedure SetColor(const Value: TColor);
    procedure SetTracker(const Value: TBitmap);
    procedure SetLineWith(const Value: integer);
  protected
    { Déclarations protégées }
    procedure Paint; override;
    procedure DoUpDateStat(Sender:TObject);
  public
    { Déclarations publiques }
    procedure Create(AOwner:TComponent);
    procedure Destroy; override;
  published
    { Déclarations publiées }
    property Tracker:TBitmap read FTracker write SetTracker;
    property Color:TColor read FColor write SetColor;
    property LineWith:integer read FLineWith write SetLineWith;
    property FloatList:TFloatList read FFloatList;
  end;
 
procedure Register;
 
implementation
 
procedure Register;
begin
  RegisterComponents('WA', [TWATrackBar]);
end;
 
{ TWATrackBar }
 
procedure TWATrackBar.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  FLineWidth:=4;
  FTracker:=TBitmap.Create;
  FFloatList:=FFloatList.Create;
  FFloatList.OnStatChanged:=DoUpDateStat;
end;
 
procedure TWATrackBar.Destroy;
begin
  FFloatList.Free;
  FTracker.Free;
  inherited;
end;
 
procedure TWATrackBar.DoUpDateStat(Sender: TObject);
begin
  invalidate;
end;
 
procedure TWATrackBar.Paint;
var x,y:integer;
begin
  inherited;
  Canvas.Pen.Color:=FColor;
  Canvas.Pen.Width:=LineWith;
  Canvas.MoveTo(0,Height div 2);
  Canvas.LineTo(Width,Height div 2);
  x:=Round(FFloatList.MeanValue*(ClientWidth-1)/100)-(Tracker.Width div 2);
  y:=(ClientHeight-Tracker.Height) div 2;
  Canvas.Draw(x,y,FTracker);
end;
 
procedure TWATrackBar.SetColor(const Value: TColor);
begin
  if FColor<>Value then
  begin
    FColor := Value;
    Invalidate;
  end;
end;
 
procedure TWATrackBar.SetLineWith(const Value: integer);
begin
  if FLineWith<>Value then
  begin
    FLineWith := Value;
    Invalidate;
  end;
end;
 
procedure TWATrackBar.SetTracker(const Value: TBitmap);
begin
  FTracker.Assign(Value);
  FTracker.Transparent:=true;
  Invalidate;
end;
 
end.

Utilisation :
Tu dois assigner un Bitmap qui correspond à la forme de ton curseur à la propriété Tracker.

Code :

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

WATrackBar1.Tracker:=MonBitmap;

ou comme ceci :

Code :

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

WATrackBar1.Tracker.LoadFromFile('TonImage.bmp');

Si ton image zappe la transparence qu'il faudrait, c'est parce que dans ton code, tu devrais ajouter ça :

Code :

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

WATrackBar1.Tracker.Transparent:=true;

Faut pas déc... , je n'ai pas pensé à tout


Color, c'est pour la couleur de la ligne (verte dans ton exemple)
LineWidth, pour son épaisseur (= à 4 par défaut)

Tu alimentes la propriété FloatList qui est notre Liste d'entiers de type TFloatList, et via l'évènement OnUpdateStat de celle-ci, qui déclenche la méthode DoUpdateStats, ta trackbar sera mise à jour au niveau de l'affichage, instantanément.
La position de la trackbar est basée sur la moyenne de la liste, en supposant que cette moyenne est une valeur comprise entre 0 et 100

Reste les deux labels, à gauche et à droite, pour afficher 0% et 100%, mais ça, tu sais faire

Je crois que c'est tout, bon dev