Discussion :

[Zacheus]

Bonjour,

j'ai pris comme modèle une réalisation en Lazarus, réalisée en 2 coups de cuillère à pot, et même sans cuillère.

Donc, 2 boutons ou images en haut à gauche et en haut à droite à 10 et 10 des bords, 2 labels alignés au centre, et une barre de progression en bas centrée horizontalement tout comme le label qui est placé en-dessous.

En Firemonkey, il m'a semblé, documentation trop succincte à l'appui, que le point de départ était un GridPanelLayout, client de la Form. J'ai configuré initialement 2 lignes et 2 colonnes à 50%. Mais quand il a fallu placer les boutons à 10 des bords, j'ai été obligé d'utiliser 2 layouts pour que Margin fonctionne. En réalité, c'est le Margin du layout qui fonctionne parce que le Margin du bouton n'a aucune incidence dans le GridPanelLayout. Puis j'ai placé les 2 boutons dans leur layout respectif. Mais alors, les ancres des boutons ne les placent plus automatiquement dans le Designer : il faut les placer à la main. Par contre, en exécution, ils les maintiennent en position. Je trouve cela mal foutu au point que je me demande si je suis dans les clous ?



Mais c'est après que cela me pose vraiment problème : je pensais qu'avec le RowSpan et le Colspan, il était possible de placer le GridLayout1 au point central des 2 lignes et des 2 colonnes. Mais il semble que le fait que le layout1 et le layout2 existent (donc utilisent la Row 0) empêche de placer GridLayout1 au centre. Il faudrait donc ajouter une troisième ligne et le GridLayout1 occuperait le centre de la ligne 1 (RowSpan = 2). C'est cela le principe ? Là encore, je doute parce que créer une ligne supplémentaire augmente la rigidité notamment en terme de superposition de l'assemblage.

En supposant que l'image (en place de Button2) en haut à droite déborde (puisse déborder sur la ligne centrale, la Row1 du GridPanelLayout1, ligne semble-t-il nécessaire) comme je le fais en Lazarus, cela devient un véritable casse-tête. On peut superposer des layouts ? Visiblement pas dans des cellules de GridPanelLayout.

Y a quelqu'un qui a un tuto assez sophistiqué sur la question : les principes, les limites, des exemples que l'on peut assembler.
Merci. Zac.

[Barbibulle]

Je n'y connais rien à FMX mais peut être trouvera tu ce tuto intéressant
http://www.ledevdujeudi.com/layouts/

Je ne sais pas quel version de Delphi tu utilises mais ca pourrait aider ceux qui connaissent FMX de la connaitre (ca m'a l'air d'évoluer assez rapidement cette histoire)

[Zacheus]

Tu vas me trouver contrariant, mais je développe Desktop. J'ai déjà bien assez de mal. Finalement j'ai remplacé les Gridlayout par des GridPanelLayout et le résultat montre que je dois faire des progrès... Petit à petit en agrandissant puis diminuant la hauteur de la Form, le laNOM et le laVERSION se superposent pour finir par sortir de la Form
Original

ADD : J'ai réussi à peu près avec les GridPanelLayout mais le fonctionnement est bizarre surtout quand on réduit plusieurs fois la fenêtre à sa hauteur minimale avant de l’agrandir à nouveau : la Row centrale se désagrège petit à petit. Evidemment, on peut contrôler la hauteur minimale de la fenêtre. par contre pour la superposition, cela a l'air de fonctionner automatiquement. Reste le problème des Margin. Ci Joint le coude source "minimal" en XE7-FMX

A bientôt. Zac.

[Thierry Laborde]

Bonjour,

Tout d'abord il ne faut pas confondre la propriété Margins avec la propriété Padding. Les Margins permettent de définir les marges par rapport aux contrôles enfants. Donc il est normal que cela n'ai pas d'impact sur le bouton. Il serait préférable d'utiliser le Padding qui permet de définir la marge par rapport au Parent.
Toutes les explications sont ici :

http://docwiki.embarcadero.com/Libra...ontrol.Padding

Ensuite pour moi le GridPanelLayout n'a aucuns interêt dans ce cas là. Des layouts simples avec les bons Align et Anchors suffisent largement.
Quelques liens interessant (En plus de celui de Barbibule bien sûr) :

http://docwiki.embarcadero.com/RADSt...ons_FireMonkey
http://docwiki.embarcadero.com/Libra...s.TAlignLayout
http://docwiki.embarcadero.com/RADSt...lle_et_de_flux
http://docwiki.embarcadero.com/RADSt...les_FireMonkey

Comme l'a demandé Barbibule, sur quelle version de Delphi êtes vous ?

[ALWEBER]

N'ayant pas le pied marin je n'utilise pas les ancres mais plutot des alignements

Ci-après le contenu du fichier fmx. Tu noteras le déplacement du GridLayout1

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
 
object fFirst: TfFirst
  Left = 0
  Top = 0
  Caption = 'Form2'
  ClientHeight = 349
  ClientWidth = 585
  FormFactor.Width = 320
  FormFactor.Height = 480
  FormFactor.Devices = [Desktop]
  DesignerMasterStyle = 0
  object GridPanelLayout1: TGridPanelLayout
    Align = Client
    Size.Width = 585.000000000000000000
    Size.Height = 349.000000000000000000
    Size.PlatformDefault = False
    TabOrder = 0
    ColumnCollection = <
      item
        Value = 50.000000000000000000
      end
      item
        Value = 50.000000000000000000
      end>
    ControlCollection = <
      item
        Column = 0
        Control = Layout1
        Row = 0
      end
      item
        Column = 1
        Control = Layout2
        Row = 0
      end>
    RowCollection = <
      item
        Value = 33.333333333333340000
      end
      item
        Value = 66.666666666666670000
      end>
    object Layout1: TLayout
      Align = Top
      Size.Width = 292.500000000000000000
      Size.Height = 50.000000000000000000
      Size.PlatformDefault = False
      TabOrder = 1
      object Button1: TButton
        Align = Left
        Size.Width = 80.000000000000000000
        Size.Height = 50.000000000000000000
        Size.PlatformDefault = False
        TabOrder = 1
        Text = 'Button1'
      end
    end
    object Layout2: TLayout
      Align = Top
      Position.X = 292.500000000000000000
      Size.Width = 292.500000000000000000
      Size.Height = 50.000000000000000000
      Size.PlatformDefault = False
      TabOrder = 0
      object Button3: TButton
        Align = Right
        Position.X = 212.500000000000000000
        Size.Width = 80.000000000000000000
        Size.Height = 50.000000000000000000
        Size.PlatformDefault = False
        TabOrder = 1
        Text = 'Button1'
      end
    end
  end
  object GridLayout1: TGridLayout
    Align = Center
    ItemHeight = 100.000000000000000000
    ItemWidth = 160.000000000000000000
    Orientation = Horizontal
    Size.Width = 160.000000000000000000
    Size.Height = 100.000000000000000000
    Size.PlatformDefault = False
    TabOrder = 2
    object Panel1: TPanel
      Align = Client
      Size.Width = 160.000000000000000000
      Size.Height = 100.000000000000000000
      Size.PlatformDefault = False
      TabOrder = 0
    end
  end
end

[Zacheus]

Merci pour les liens, je vais essayer de rassembler tout cela. La version que j'utilise est XE7.

Je crois qu'a terme, utiliser directement le dfm est une bonne solution à condition de maîtriser et de comprendre le code. Enfin c'est ce que je fais usuellement en Lazarus (par paresse mais également par soucis de ne pas perdre un temps précieux). Mais les ancrages y sont fort simples conceptuellement. Evidemment la notion de scale & co n'y est pas intégrée -ou si elle est disponible, je ne l'ai jamais utilisée. Mais je n'en ai encore jamais eu besoin- d'où certainement un concept plus simple mais d'un ratio simplicité/efficacité redoutable.

Le tout est de savoir ce dont je dispose en Delphi et comment organiser les différents éléments. Pour l'instant, j'en ai pris plein la vue. Mais je suis incapable d'en faire le synthèse et de mettre en oeuvre. C'est du bricolage, une utilisation en fonction de mes acquis en Lazarus : Je veux cela. J'utilise quoi ? Il est vrai qu'avec un peu d'habitude cela doit paraître naturel. J'étudie et je jais appel au forum et éventuellement je peux partager mes nouvelles modestes connaissances sachant que je ne sais pas utiliser votre outil rédactionnel.

Merci. Zac.

[ALWEBER]

Ci Joint le coude source "minimal" en XE7-FMX
A bientôt. Zac.

Ci joint ta version retravaillée sur la base de mon précédent message

[Zacheus]

Merci Alweber,

Bien compris le GridLayout en align center indépendant du GridPanelLayout.

Par contre, si tu veux garder la taille de tes boutons à leur valeur par défaut, je ne vois pas d'autre solution que l'emploi d'un (sous) Layout. Ce qui me gène, c'est qu'aucun des éléments ne permet de réaliser à la fois mes demandes. L'un d'entre eux accepte les marges, l'autre accepte de respecter la taille du contenu... mais pas l'un.

Ma première approche a été de chercher l'enveloppe qui permet de placer en haut à droite avec une margin ou un padding de 8 x 8 en conservant la taille du bouton et pas l'inverse (le bouton qui prend la taille de l'enveloppe).

Et c'est à ce niveau que je suis totalement dérouté. Je vais prendre les contenants un par un, et noter dans une grille leur capacité en m'appuyant sur les liens proposés, histoire de fixer cette approche et de pouvoir l'exploiter ultérieurement.

Je ne sais pas si tu disposes de Lazarus. J'ai mis 3 minutes pour faire le même travail sans un seul container (layout) pour un fonctionnement identique. Tu comprendras ma déroute. Mais je ne suis pas là pour critiquer Delphi mais simplement pour préciser mes pré-requis qui sont un peu décalés Ce qui me manque, c'est les fonctionnalités exactes de chaque container pour piocher à bon escient. C'est vrai que si on n'est pas regardant sur la taille des boutons, on peut faire plus simple. J'étudierai cela demain matin. J'ai déjà une solution en croisant ton approche avec la mienne. Il faut que je rationalise tout cela dans ma tête et même si la solution est plus compliquée, c'est plus rassurant pour moi de savoir qu'il m'est possible de faire ce que je veux plutôt que de contraindre mon UI à ce que fait de manière plus simple Delphi. Comme mon approche pour la gestion des Form : un peu plus compliquée parce que sans repère mais exactement ce dont j'avais besoin. Il est bon de savoir que l'on peut sortir des sentiers battus, être original... et se faire plaisir. Donc pour l'instant, c'est un peu compliqué mais pas d’écueil infranchissable en XE7 et plein de promesses et déjà de réalités d'ailleurs.

Encore merci pour votre aide. Zac.

Le lfm

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
object Form1: TForm1
  Left = 238
  Height = 211
  Top = 150
  Width = 454
  Caption = 'Form1'
  ClientHeight = 211
  ClientWidth = 454
  LCLVersion = '1.4.2.0'
  object Button1: TButton
    AnchorSideLeft.Control = Owner
    AnchorSideTop.Control = Owner
    Left = 8
    Height = 25
    Top = 8
    Width = 75
    BorderSpacing.Left = 8
    BorderSpacing.Top = 8
    Caption = 'Button1'
    TabOrder = 0
  end
  object Label1: TLabel
    AnchorSideLeft.Control = Label4
    AnchorSideLeft.Side = asrCenter
    AnchorSideTop.Control = Label4
    AnchorSideTop.Side = asrBottom
    AnchorSideBottom.Control = Label4
    Left = 174
    Height = 45
    Top = 56
    Width = 106
    Anchors = [akLeft, akBottom]
    BorderSpacing.Bottom = 4
    Caption = 'laNOM'
    Font.Height = -32
    Font.Style = [fsBold]
    ParentColor = False
    ParentFont = False
  end
  object Label2: TLabel
    AnchorSideLeft.Control = Label1
    AnchorSideLeft.Side = asrCenter
    AnchorSideTop.Control = Label1
    AnchorSideTop.Side = asrBottom
    Left = 197
    Height = 15
    Top = 109
    Width = 60
    BorderSpacing.Left = 8
    BorderSpacing.Top = 8
    Caption = 'laVERSION'
    Font.Style = [fsBold]
    ParentColor = False
    ParentFont = False
  end
  object Label3: TLabel
    AnchorSideLeft.Control = Owner
    AnchorSideLeft.Side = asrCenter
    AnchorSideBottom.Control = Owner
    AnchorSideBottom.Side = asrBottom
    Left = 210
    Height = 15
    Top = 188
    Width = 34
    Anchors = [akLeft, akBottom]
    BorderSpacing.Bottom = 8
    Caption = 'Label3'
    ParentColor = False
  end
  object ProgressBar1: TProgressBar
    AnchorSideLeft.Control = Label3
    AnchorSideLeft.Side = asrCenter
    AnchorSideBottom.Control = Label3
    Left = 127
    Height = 20
    Top = 160
    Width = 200
    Anchors = [akLeft, akBottom]
    BorderSpacing.Bottom = 8
    TabOrder = 1
  end
  object Button2: TButton
    AnchorSideTop.Control = Owner
    AnchorSideRight.Control = Owner
    AnchorSideRight.Side = asrBottom
    Left = 371
    Height = 25
    Top = 8
    Width = 75
    Anchors = [akTop, akRight]
    BorderSpacing.Top = 8
    BorderSpacing.Right = 8
    Caption = 'Button2'
    TabOrder = 2
  end
  object Label4: TLabel
    AnchorSideLeft.Control = Owner
    AnchorSideLeft.Side = asrCenter
    AnchorSideTop.Control = Owner
    AnchorSideTop.Side = asrCenter
    Left = 227
    Height = 1
    Top = 105
    Width = 1
    ParentColor = False
    OnClick = Label4Click
  end
end

[Zacheus]

Bonjour,

j'en suis revenu à mon problème élémentaire pour mieux comprendre : Placer 2 boutons de 80x24 (et pas une autre taille) en haut de la Form, l'un à gauche, l'autre à droite à 10 pixels des bords. A force d'examiner le système Delphi, j'en suis arrivé à une méthode minimaliste.

Em mode Conception (csDesigning) : palette + souris. En Lazarus on définit ce comportement des composants par (csDesigning in ComponentState)
Je crée une Form dont je modifie le padding-> Padding : 10, 10, 10, 10
Je pose 2 boutons, n'importe où sur la Form : TButton1 et TButton2.

• Premier Tbutton
  • -> Align = Left. Le bouton se place à gauche sur toute la hauteur en conservant sa largeur, à 10 px de la Form.
  • -> Je désactive Align = Left None.
  • -> Je corrige la Hauteur = 460 24
• Deuxième Tbutton
  • -> Align = Right. Le bouton se place à droite sur toute la hauteur en conservant sa largeur, à 10 px de la Form.
  • -> Je désactive Align = Right None. Oui mais la sélection de None modifie les ancres et active automatiquement akLeft et akTop, Je désactive akLeft et active à la place akRight
  • -> Je corrige la Hauteur = 460 24

Voila j'obtiens visuellement, ce à quoi ressemble ma Form en mode csDesigning.

Et l'ensemble fonctionne correctement en mode run [not (csDesigning in ComponentState)]. Mon observation des layouts est la même. J'y vois une approche très singulière et très mal décrite.

J'ai retenu :

1. Pour que le padding d'un contenant fonctionne sur un contenu en mode csDesigning, il faut que la propriété align du contenu soit activée (<>None)... sinon dans mon exemple, le placement des TButton à 10 des bords doit être réalisé à la main.
2. Les modes align manquent totalement de souplesse : Un left aligne bien l'objet à gauche mais sur toute la hauteur de son contenant,... C'est très mal foutu et se moque totalement des spécifications des Ancres dans ce mode csDesigning. En align := left, on a beau débrancher akBottom qui est sélectionné automatiquement par le choix d'Align = Left, il est quand même impossible de remettre la hauteur du bouton à 24ou de la modifier à la souris. Pour le faire, toujours en mode csDesigning, vous devez-vous remettre en Align := None puis corriger la hauteur du Tbutton.
   [3]Et en mode run [not (csDesigning in ComponentState)], comme en Lazarus, ce sont les ancres qui comptent même si Align = None.

Je maintiens ce que j'écrivais. Peut-être plus puissant que Lazarus (à cause des scales) mais sinon, l'ergonomie d'utilisation pour le programmeur n'est pas à la hauteur de la puissance ! Un coup à prendre quoi.

Ceci résout pour moi la question posée.
Zac

PS :


Le FMX

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
object Form1: TForm1
  Left = 0
  Top = 0
  Caption = 'Form1'
  ClientHeight = 358
  ClientWidth = 786
  Padding.Left = 10.000000000000000000
  Padding.Top = 10.000000000000000000
  Padding.Right = 10.000000000000000000
  Padding.Bottom = 10.000000000000000000
  FormFactor.Width = 320
  FormFactor.Height = 480
  FormFactor.Devices = [Desktop]
  OnCreate = FormCreate
  DesignerMasterStyle = 0
  object Button1: TButton
    Position.X = 10.000000000000000000
    Position.Y = 10.000000000000000000
    Size.Width = 80.000000000000000000
    Size.Height = 24.000000000000000000
    Size.PlatformDefault = False
    TabOrder = 1
    Text = 'Button1'
  end
  object Button2: TButton
    Anchors = [akTop, akRight]
    Position.X = 696.000000000000000000
    Position.Y = 10.000000000000000000
    Size.Width = 80.000000000000000000
    Size.Height = 24.000000000000000000
    Size.PlatformDefault = False
    TabOrder = 2
    Text = 'Button2'
  end
  object Layout1: TLayout
    Align = VertCenter
    Position.X = 10.000000000000000000
    Position.Y = 129.000000000000000000
    Size.Width = 766.000000000000000000
    Size.Height = 50.000000000000000000
    Size.PlatformDefault = False
    TabOrder = 3
    object laNOM: TLabel
      Align = Top
      StyledSettings = [Family, FontColor]
      Size.Width = 766.000000000000000000
      Size.Height = 25.000000000000000000
      Size.PlatformDefault = False
      TextSettings.Font.Size = 24.000000000000000000
      TextSettings.Font.Style = [fsBold]
      TextSettings.HorzAlign = Center
      Text = 'laNOM'
    end
    object laVERSION: TLabel
      Align = Bottom
      StyledSettings = [Family, Size, FontColor]
      Position.Y = 33.000000000000000000
      Size.Width = 766.000000000000000000
      Size.Height = 17.000000000000000000
      Size.PlatformDefault = False
      TextSettings.Font.Style = [fsBold]
      TextSettings.HorzAlign = Center
      Text = 'laVERSION'
    end
  end
  object Layout2: TLayout
    Align = Bottom
    Position.X = 10.000000000000000000
    Position.Y = 298.000000000000000000
    Size.Width = 766.000000000000000000
    Size.Height = 50.000000000000000000
    Size.PlatformDefault = False
    TabOrder = 4
    object Label1: TLabel
      Align = Bottom
      Position.Y = 32.000000000000000000
      Size.Width = 766.000000000000000000
      Size.Height = 18.000000000000000000
      Size.PlatformDefault = False
      TextSettings.HorzAlign = Center
      Text = 'laINFO'
    end
    object GridPanelLayout1: TGridPanelLayout
      Align = Top
      Size.Width = 766.000000000000000000
      Size.Height = 25.000000000000000000
      Size.PlatformDefault = False
      TabOrder = 1
      ColumnCollection = <
        item
          Value = 50.000000000000000000
        end
        item
          Value = 50.000000000000000000
        end>
      ControlCollection = <
        item
          Column = 0
          ColumnSpan = 2
          Control = ProgressBar1
          Row = 0
        end>
      RowCollection = <
        item
          Value = 100.000000000000000000
        end>
      object ProgressBar1: TProgressBar
        Align = HorzCenter
        Orientation = Horizontal
        Position.X = 283.000000000000000000
        Size.Width = 200.000000000000000000
        Size.Height = 25.000000000000000000
        Size.PlatformDefault = False
      end
    end
  end
end

[Aooka]

Salut,


Tu place un TLayout, et deux TButton sur ta TForm.

Trois variables vont donc se déclarer :

Code :

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

1
2
3
Button1: TButton;
Button2: TButton;
Layout1: TLayout;

Ensuite dans ton OnShow par exemple : (d'ailleurs je me demande si c'est mieux de le mettre dans le OnShow ou dans le OnCreate ?)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
begin
  Layout1.Width := Self.Width;
  Layout1.Height := Button1.Height;
  Layout1.Align := TAlignLayout.Top;
 
  Button1.Parent := Layout1;
  Button2.Parent := Layout1;
 
  Button1.Align := TAlignLayout.Left;
  Button2.Align := TAlignLayout.Right;
end;

Pour le rendu tu aura ton TButton1 à gauche et le TButton2 .. Oui à droite !


Sur ce,
Bonne fin de journée,

[Zacheus]

Oui, mais je n'ai pas du tout envie de coder les positionnements ! C'est renier même l'existence du Designer. On peut aussi se passer de l'Inspecteur d'Objets, écrire tout le programme avec NotePad++ et compiler en ligne de commande !
Ce n'est pas du tout mon approche... et pas du tout ce que je cherche. J'ai goûté à Lazarus à ce niveau et il ne me vient même pas à l'esprit de faire autrement tellement c'est efficace et simple. Alors je veux bien faire des concessions parce qu'avec Delphi je n'ai pas encore goûté au mobile et je suppose que le système utilisé par Lazarus ne conviendrait pas et que, de ce fait, il a bien fallu adapter les ancrages à la mobilité. Ceci dit, le système Delphi est performant, c'est l'approche qu'il faut découvrir : elle est un peu délicate pour un novice.

Mais là, tu me proposes de revenir à une approche globale que j'exècre. On mélange tout, l'IHM, les requêtes, les patch sur les composants, tout cela dans le code du projet, n'importe où, quand on en a besoin... Dans ces cas-là, je passe à Qt ou n'importe quel langage bas-niveau. Je crois qu'en Pascal, il y a une place pour chaque chose. J'adore cette structure, cette clarté, cette logique (voire cette rigidité), cette lisibilité, cette approche quoi ! Un langage où on ne met pas les variables en plein milieu du code , un langage qui permet de factoriser intensément le code... Bon si je me lance, on n'a pas fini. Comme je l'ai déjà écrit, je n'aime pas mélanger les genres. Tu imagines quand on va peaufiner mon IHM... On sera obligé de lire tout mon code ?

Bref, ta proposition, c'est malin et fonctionnel, mais pour toutes les raisons évoquées, je n'en veux pas. Merci quand même. Zac.

[der§en]

La solution fournis par Martin Lestas est parfaitement réalisable avec le désigner.

Pour résoudre ton problème, il il plusieurs solutions simple possibles avec le désigner de FMX, as toi de choisir le bon en fonction des évolutions envisagés...

[Zacheus]

Bonjour Dergen,

oui elle est réalisable, j'en conviens aisément et cela aurait pu être mon premier réflexe si Lazarus ne m'avait pas habitué à ne pas mélanger les genres à ce niveau... car dans la mesure du possible je ne veux utiliser que le fmx, comme je pratique avec le lfm parce que je pense que c'est possible et conçu pour... avec rien dans le .pas. Et c'est effectivement possible pour ce que j'en ai découvert grâce à l'aide apportée par ce forum. On se sent un peu perdu des fois par rapport à la quantité d'infos disponibles et surtout il est difficile de hiérarchiser les méthodes à faire prévaloir.

La mise en cause vers l'approche que je cherchais était là :

Ensuite pour moi le GridPanelLayout n'a aucuns interêt dans ce cas là. Des layouts simples avec les bons Align et Anchors suffisent largement.
Quelques liens interessant [...]

Effectivement, j'ai remis un GridpanelLayout (au centre) pour me faire plaisir mais Alweber a montré qu'on pouvait faire plus simple Et le "largement" est fondé : les Tbutton ne sont même pas dans des layouts dans ma dernière version.

Je ne dis pas qu'un jour, il ne faudra pas ajouter quelques lignes dans le .pas comme des fois en Lazarus pour éviter des références (des ancrages) circulaires. Mais pas pour des problèmes simples comme celui que j'ai évoqué en exemple.

C'est un peu curieux, comme les gens ne veulent pas utiliser la capacité des outils mis à la disposition. Je veux prendre mon temps et utiliser Firemonkey non pas comme j'utilise Lazarus, mais comme il est conçu. Bien sûr qu'il existera toujours quelqu'un pour expliquer que le DataSource est indispensable. On peut se passer du LiveBindings et pourquoi pas des styles en FMX et évidemment à la place aligner des lignes de codes dans les *.pas. Ce n'est pas mon approche même si je dois redécouvrir les bases de ce produit. Si c'est pour programmer comme avec Delphi 7 (et pas Delphi XE7), j'ai fait un achat inutile. Alors OK, cela va secouer -secoue déjà- mes habitudes et je concède que c'est un peu pénible. Je découvre le LiveBindings "fin" d'un côté, pour l'instant une vraie prise de tête, mais la mise en œuvre des layouts l'était tout autant hier. Et parallèlement, je n'ai pas pu résister à brancher un Androïd en recréation de cette partie un peu pénible pour l'instant, histoire de voir les scales : Ouahhhhhh ! Rien que les prémices justifient de faire quelques efforts d'adaptation et sous doute plus.

Cordialement. Zac.