Discussion :

[SergioMaster]

Bonjour,

Cela fait suite, en quelque sorte, à la discussion sur la répartition circulaire de valeurs. Comment coder une sorte de tambour* de valeurs, en 3D Alweber nous a sorti son bandit manchot, mais sans 3D, comment procéder ?

*en anglais on écrirait plutôt spinner mais les recherches que j'ai pu faire avec ce mot clé traitent plus de gauges circulaires (type TAniIndicator) que de mon objectif
Elles m'ont cependant permis de redécouvrir Tarc et de trouver un petit code sympa (à améliorer) pour une sorte d'AniIndicator

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
unit UHorlogeArc;
 
interface
 
uses
  System.SysUtils, System.Types, System.UITypes, System.Classes, System.Variants,
  FMX.Types, FMX.Controls, FMX.Forms, FMX.Graphics, FMX.Dialogs, FMX.StdCtrls,
  FMX.Controls.Presentation, FMX.Edit, FMX.Objects;
 
type
  TForm3 = class(TForm)
    Timer1: TTimer;
    Arc1: TArc;
    Edit1: TEdit;
    btnarc: TButton;
    procedure btnarcClick(Sender: TObject);
    procedure Timer1Timer(Sender: TObject);
  private
    { Déclarations privées }
      Increment: Integer;
      PotentialEnergy: array[0..15] of Single;
      ReverseMotion : Boolean;
      RotationSpeed : Single;
      procedure SetArray(var aData: array of Single; const aSource: array of Single);
  public
    { Déclarations publiques }
  end;
 
var
  Form3: TForm3;
 
implementation
 
{$R *.fmx}
 
procedure TForm3.SetArray(var aData: array of Single; const aSource: array of Single);
var
  I: Integer;
begin
  for I := Low(aSource) to High(aSource) do
    begin
    aData[I] := aSource[I];
    end;
end;
 
procedure TForm3.btnarcClick(Sender: TObject);
begin
  SetArray(PotentialEnergy, [23, 40, 39, 31, 23, 18, 15, 13, 11, 9, 7, 6, 5, 4, 4]);
  Increment := -1;
  ReverseMotion := False;
  arc1.StartAngle := 0;
  arc1.EndAngle := 20;
  RotationSpeed := strtoint(edit1.text); // Degrees per 0.1 second
  timer1.Enabled := True;
end;
 
procedure TForm3.Timer1Timer(Sender: TObject);
begin
  if not ReverseMotion then
    begin
    Inc(Increment);
    arc1.EndAngle := arc1.EndAngle + PotentialEnergy[Increment];
    arc1.StartAngle := arc1.StartAngle + RotationSpeed;
    end
  else
    begin
    Inc(Increment);
    arc1.StartAngle := arc1.StartAngle + PotentialEnergy[Increment] + RotationSpeed;
    arc1.EndAngle := arc1.EndAngle - PotentialEnergy[Increment];
    end;
 
 if (Increment > 10)then
    begin
    ReverseMotion  := not ReverseMotion;
    Increment := -1;
    end;
end;
 
end.

[SergioMaster]

Bonjour,

cela ressemble une fois de plus à un monologue mais bon.

Ce matin j'ai tester la collection TQueue pour ce qui est de faire défiler vers le bas un ensemble de valeur dans un Tmemo

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
 
  private
    { Déclarations privées }
    Liste : TQueue<String>;
    procedure fillmemo;
  public
    { Déclarations publiques }
  end;
 
var
  Form1: TForm1;
 
implementation
 
{$R *.fmx}
 
procedure TForm1.btDownClick(Sender: TObject);
var c : string;
begin
 c:=Liste.Peek;
 Liste.Dequeue;
 liste.Enqueue(c);
 fillMemo;
end;
 
procedure TForm1.BtnUpClick(Sender: TObject);
begin
// ????
end;
 
procedure TForm1.fillmemo;
var c : string;
begin
memo1.BeginUpdate;
memo1.lines.clear;
for c in Liste do
   memo1.Lines.Add(c);
memo1.EndUpdate;
end;
 
procedure TForm1.FormCreate(Sender: TObject);
var i : integer;
    c : string;
begin
Liste:=TQueue<String>.Create;
for i := 0 to 11 do
    Liste.Enqueue(i.ToString);
FillMemo;
end;

Cela ressemble à peu près à ce que je recherche, du moins le mouvement vers le bas mais je ne vois pas comme faire pour "remonter" (BtnUp)

Le TQueue n'est peut-être pas la bonne solution. D'autre suggestions ?

[blonde]

Je veux bien m'essayer à l'exercice, mais je n'ai pas compris ce que tu veux faire au final.
Es-ce que tu pourrais ré-expliquer ?

[SergioMaster]

Re,

c'est vrai que l'ajout de ma découverte sur l'animation au sujet de base peut brouiller les cartes

Alors ce que je cherche à obtenir c'est une sorte de cylindre de valeurs (cela existe chez TMS mais c'est pour pouvoir parler de composant)
par exemple


cela dit, entre temps (malgré ta réponse rapide, merci) j'ai utilisé à la place d'un TQueue, et une idée de TStack, un TList<String> qui convient parfaitement, je ne connaissais pas ce TList.Move !

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
  private
    { Déclarations privées }
    Liste : Tlist<String>;
    procedure fillmemo;
  public
    { Déclarations publiques }
  end;
 
var
  Form1: TForm1;
 
implementation
 
{$R *.fmx}
 
procedure TForm1.btDownClick(Sender: TObject);
begin
 Liste.Move(0,Liste.Count-1);
 fillMemo;
end;
 
procedure TForm1.BtnUpClick(Sender: TObject);
begin
 Liste.Move(Liste.Count-1,0);
 fillMemo;
end;
 
procedure TForm1.fillmemo;
var c : string;
begin
memo1.BeginUpdate;
memo1.lines.clear;
for c in Liste do
   memo1.Lines.Add(c);
memo1.EndUpdate;
end;
 
procedure TForm1.FormCreate(Sender: TObject);
var i : integer;
    c : string;
begin
Liste:=TList<String>.Create;
for i := 0 to 24 do
    Liste.Add(i.ToString);
FillMemo;
end;

Maintenant que je sais comment "nourrir" la liste, je m'attaquerai (futur week-end) à une version composant à partir de ce test. (un effet loupe en plus ça pourrait être sympathique, mais je digresse comme d'habitude)

[pprem]

cela ressemble une fois de plus à un monologue mais bon.

Tente sur Twitch, y a toujours 2 ou 3 personnes pour participer quand on fait des bêtises.

[Paul TOTH]

je suis à peu près certain que le sujet a déjà été traité...mais je ne retrouve que ça

[SergioMaster]

Tente sur Twitch

Oui, effectivement ce serait alors un monologue avec interventions écrites, qui sait, dans un an et demi et la fibre je te ferai peut-être de la concurence

je suis à peu près certain que le sujet a déjà été traité

D6 ! ça a quand même évolué.
Je n'en étais pas pour l'instant aux images, juste aux strings, mais pourquoi pas avec des images , histoire de faire comme la demo déjà citée de AlWeber.
Encore un Todo de plus

[ShaiLeTroll]

Après si tu veux une liste circulaire inspirée d'un Ring Buffer, pour éviter le Move qui doit décaler les tous les pointeurs dans le tableau
Tu peux le faire avec une double liste chainée dont le dernier item pointe sur le premier (et réciproquement)

Lorsque tu augmentes, tu n'as qu'a mémoriser l'élément suivant,
la liste ne bouge jamais, c'est juste le curseur de lecture qui change

[ShaiLeTroll]

Double Liste Chaine pour le fun

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
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
unit HorlogeRoll_MainForm;
 
interface
 
uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls;
 
 
type
  TRingList<T> = class(TObject)
  private
    type
      PRingItem = ^TRingItem;
      TRingItem = record
        Value: T;
        Prior: PRingItem;
        Next: PRingItem;
      end;
  protected
    FLast: PRingItem;
    FCurr: PRingItem;
 
    function ValueToString(const Value: T): string; virtual; abstract;
  public
    destructor Destroy(); override;
 
    procedure Add(const Value: T);
    procedure Up();
    procedure Down();
    procedure ToStrings(AStrings: TStrings);
  end;
 
  TByteRingList = class(TRingList<Byte>)
  protected
    function ValueToString(const Value: Byte): string; override;
  public
    constructor Create(AStart, AEnd: Byte);
  end;
 
  THours = class(TByteRingList)
  public
    constructor Create();
  end;
 
  TMinutes = class(TByteRingList)
  public
    constructor Create();
  end;
 
type
  TForm1 = class(TForm)
    lbHours: TListBox;
    btnHourUp: TButton;
    btnHourDown: TButton;
    btnMinuteDown: TButton;
    lbMinutes: TListBox;
    btnMinuteUp: TButton;
    procedure FormCreate(Sender: TObject);
    procedure btnHourUpClick(Sender: TObject);
    procedure btnHourDownClick(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
    procedure btnMinuteUpClick(Sender: TObject);
    procedure btnMinuteDownClick(Sender: TObject);
  private
    { Déclarations privées }
    FHours: THours;
    FMinutes: TMinutes;
  public
    { Déclarations publiques }
  end;
 
var
  Form1: TForm1;
 
implementation
 
{$R *.dfm}
 
procedure TForm1.btnHourDownClick(Sender: TObject);
begin
  FHours.Down();
  lbHours.Items.Clear();
  FHours.ToStrings(lbHours.Items);
end;
 
procedure TForm1.btnHourUpClick(Sender: TObject);
begin
  FHours.Up();
  lbHours.Items.Clear();
  FHours.ToStrings(lbHours.Items);
end;
 
procedure TForm1.btnMinuteDownClick(Sender: TObject);
begin
  FMinutes.Down();
  lbMinutes.Items.Clear();
  FMinutes.ToStrings(lbMinutes.Items);
end;
 
procedure TForm1.btnMinuteUpClick(Sender: TObject);
begin
  FMinutes.Up();
  lbMinutes.Items.Clear();
  FMinutes.ToStrings(lbMinutes.Items);
end;
 
procedure TForm1.FormCreate(Sender: TObject);
begin
  FHours := THours.Create();
  lbHours.Items.Clear();
  FHours.ToStrings(lbHours.Items);
 
  FMinutes := TMinutes.Create();
  lbMinutes.Items.Clear();
  FMinutes.ToStrings(lbMinutes.Items);
end;
 
procedure TForm1.FormDestroy(Sender: TObject);
begin
  FreeAndNil(FHours);
  FreeAndNil(FMinutes);
end;
 
{ TRingList }
 
procedure TRingList<T>.Add(const Value: T);
var
  Curr: PRingItem;
begin
  if Assigned(FLast) and Assigned(FCurr) then
  begin
    New(Curr);
    Curr.Value := Value;
    Curr.Prior := FLast;
    Curr.Next := FCurr;
 
    FCurr.Prior := Curr;
    FLast.Next := Curr;
 
    FLast := Curr;
  end
  else
  begin
    New(FCurr);
    FCurr.Value := Value;
    FCurr.Prior := FCurr;
    FCurr.Next := FCurr;
    FLast := FCurr;
  end;
end;
 
destructor TRingList<T>.Destroy();
var
  Curr, Next: PRingItem;
begin
  FLast := nil;
 
  if Assigned(FCurr) then
  begin
    Curr := FCurr;
    Next := Curr.Next;
    if Assigned(Next) then
    begin
      Curr.Next := nil;
 
      while Assigned(Next) do
      begin
        Curr := Next;
        Next := Curr.Next;
        Dispose(Curr);
      end;
    end
    else
       Dispose(Curr);
  end;
 
  inherited Destroy();
end;
 
procedure TRingList<T>.Down();
begin
  FCurr := FCurr.Prior;
end;
 
procedure TRingList<T>.ToStrings(AStrings: TStrings);
var
  Curr: PRingItem;
begin
  if Assigned(FCurr) then
  begin
    Curr := FCurr;
 
    repeat
      AStrings.Add(ValueToString(Curr.Value));
      Curr := Curr.Next;
    until Curr = FCurr;
  end;
end;
 
procedure TRingList<T>.Up();
begin
  FCurr := FCurr.Next;
end;
 
 
{ TByteRingList }
 
constructor TByteRingList.Create(AStart, AEnd: Byte);
var
  I: Integer;
begin
  inherited Create();
 
  for I := AStart to AEnd do
    Add(I);
end;
 
function TByteRingList.ValueToString(const Value: Byte): string;
begin
  Result := Value.ToString();
end;
 
{ THours }
 
constructor THours.Create();
begin
  inherited Create(0, 23);
end;
 
{ TMinutes }
 
constructor TMinutes.Create();
begin
  inherited Create(0, 59);
end;
 
 
end.

Code dfm :

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
 
object Form1: TForm1
  Left = 0
  Top = 0
  Caption = 'Form1'
  ClientHeight = 548
  ClientWidth = 635
  Color = clBtnFace
  Font.Charset = DEFAULT_CHARSET
  Font.Color = clWindowText
  Font.Height = -11
  Font.Name = 'Tahoma'
  Font.Style = []
  OldCreateOrder = False
  OnCreate = FormCreate
  OnDestroy = FormDestroy
  PixelsPerInch = 96
  TextHeight = 13
  object lbHours: TListBox
    Left = 8
    Top = 39
    Width = 75
    Height = 323
    ItemHeight = 13
    TabOrder = 0
  end
  object btnHourUp: TButton
    Left = 8
    Top = 8
    Width = 75
    Height = 25
    Caption = 'Up'
    TabOrder = 1
    OnClick = btnHourUpClick
  end
  object btnHourDown: TButton
    Left = 8
    Top = 368
    Width = 75
    Height = 25
    Caption = 'Down'
    TabOrder = 2
    OnClick = btnHourDownClick
  end
  object btnMinuteDown: TButton
    Left = 89
    Top = 368
    Width = 75
    Height = 25
    Caption = 'Down'
    TabOrder = 3
    OnClick = btnMinuteDownClick
  end
  object lbMinutes: TListBox
    Left = 89
    Top = 39
    Width = 75
    Height = 323
    ItemHeight = 13
    TabOrder = 4
  end
  object btnMinuteUp: TButton
    Left = 89
    Top = 8
    Width = 75
    Height = 25
    Caption = 'Up'
    TabOrder = 5
    OnClick = btnMinuteUpClick
  end
end

[SergioMaster]

Bonjour,

D'un memo je suis passé à un TListbox et j'ai rajouté les diverses possibilités de défilement (boutons, mouvements, flêches)
https://serge-girard.developpez.com/...bour_edit.webm
Celui des flêches me pose un souci, la sélection affichée.

Todos :
- en faire un composant (bien sûr avec possibilité de liaison) comme mon pseudo thermometre.
- augmenter le nombre d'items de la liste

@ShaiLeTroll Bonne idée la double liste chainée, le terme "ring buffer" je n'y aurai jamais pensé. Cependant j'ai du mal avec le concept cela me demande un peu d'étude de ton code à tête fraiche

[Paul TOTH]

Dans la mesure ou tu n'utilises que des nombres, je serais forcément parti soit sur une liste virtuelle soit sur un canvas et le nième élément c'est IntToStr((n + Start) mod Total), il ne reste plus qu'à faire bouger Start pour faire défiler la liste virtuelle.

[SergioMaster]

Dans la mesure où tu n'utilises que des nombres

Pour l'instant, rien ne m'empêche (si ce n'est ma flemme à l'instant T) de changer pour des objets et mettre une image à la place des chaînes.
c'est un TList<String> que j'ai utilisé pas des nombres

[SergioMaster]

si tu veux une liste circulaire inspirée d'un Ring Buffer

En fait, aujourd'hui en regardant les nouveautés getit je suis "tombé" sur https://getitnow.embarcadero.com/circular-buffer/
Il va falloir que j'essaye ça