Discussion :

[Invité]

Bonjour,

je possède les Grids TMS mais je les trouve mal adaptées à ce dont j'ai besoin (i.e. trop lourdes car mal documentées au niveau de mes besoins) .

En Lazarus, j'obtiens ceci à partir de la dbGrid native :
Pièce jointe 468641

J'ai besoin :

1. de pouvoir 'stretcher' la colonne de mon choix (pas forcément la dernière comme ici), les tailles des autres colonnes étant automatiquement ajustées (sauf [pt 4] les ftMemo qui bénéficient d'un traitement particulier).
2. d'indiquer graphiquement le tri engagé et son sens, sachant que je définis les colonnes triables dans mon composant
3. de laisser la possibilité de chercher dans certaines colonnes (également définies dans le composant) en intégrant un TEdit dans l'entête
4. et même si cela ne figure pas sur le dessin, d'intègrer également la possibilité d'adapter la taille des cellules au multiligne à partir d'un vieux code que j'avais élaboré il y a quelques années.

Sergio ayant montré la voie pour fabriquer des composants (VCL ne m'intéresse pas), j'aimerais réaliser l'identique sous Delphi FMX et malheureusement compte tenu de la structure adoptée par les TGrids, je ne vois pas comment aborder le problème.
En Lazarus, l'interface ressemble à cela :

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
unit lzDbGrid;
 
{$mode objfpc}{$H+}
 
interface
 
uses
  Classes, SysUtils, LResources, Graphics,
  Grids, DBGrids, DB {TBookMark, TField}, Math {Max}, LCLProc {FreeThenNil},
  Controls {Controls},
  LCLintf {CellToRect},
  StdCtrls {TEdit},
  Forms {Application.xxx},
  uni;
 
type
  { TGridHelper }
  TGridHelper = class helper for TDBGrid
    function GetIndexOfColumnByName(const aName: string;
      bVisible: boolean = False): integer;
    function GetAutoColumnWidth(aIndex: integer): integer;
  end;
 
  TlzCustomDbGrid = class(TCustomDbGrid);
 
  { TDbGrid }
  TlzDbGrid = class(TDbGrid)
  private
    { Private declarations }
    FImageSort: TBitmap;
    FImageSortAsc: TBitmap;
    FImageSortDesc: TBitmap;
    FImageSearch: TBitmap;
    FBmp: TBitmap;
    FImageRefresh: TBitmap;
    FSelectedFont: TFont;
    FStretchColumnFieldname: string;
    FColumnToStretchIndex: integer;
    FColumnToStretchWidth: integer;
    FSortedColumnsFieldName: string;
    slSortedColumns: TStringList;
    FSearchedColumnsFieldName: string;
    slSearchedColumns: TStringList;
    bRect: TRect;
    edSEARCH: TEdit;
    //Events
    FOnTitleClick: TDBGridClickEvent;
    //Methods Events
    procedure SelfOnTitleClick(Sender: TColumn);
    //Methods
    procedure SetImageSort(Value: TBitmap);
    procedure SetImageSortAsc(Value: TBitmap);
    procedure SetImageSortDesc(Value: TBitmap);
    procedure SetImageSearch(Value: TBitmap);
    procedure SetImageRefresh(Value: TBitmap);
    procedure SetSelectedFont(const Value: TFont);
    procedure SetStretchColumnFieldname(Value: string);
    procedure edSEARCHcharge(aRect: TRect);
    procedure edSEARCHChange(Sender: TObject);
    function CellToRect(): TRect;
    procedure SetSortedColumnsFieldName(Value: string);
    procedure SetSearchedColumnsFieldName(Value: string);
    procedure Split(const Delimiter: char; Input: string; const Strings: TStrings);
 
  protected
    { Protected declarations }
    procedure DrawCell(aCol, aRow: integer; aRect: TRect; aState: TGridDrawState);
      override;
    procedure DoPrepareCanvas(aCol, aRow: integer; aState: TGridDrawState); override;
    procedure HeaderSized(IsColumn: boolean; index: integer); override;
    procedure Resize; override;
    procedure Loaded; override;
    procedure MouseDown(Button: TMouseButton; Shift: TShiftState;
      X, Y: integer); override;
    function DoMouseWheelDown(Shift: TShiftState; MousePos: TPoint): boolean; override;
    function DoMouseWheelUp(Shift: TShiftState; MousePos: TPoint): boolean; override;
    procedure KeyDown(var Key: word; Shift: TShiftState); override;
    procedure MouseMove(Shift: TShiftState; X, Y: integer); override;
    procedure SetColumnToStretchWidth;
 
  public
    { Public declarations }
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
  published
    { Published declarations }
    property SelectedColor;
    property ImageSort: TBitmap read FImageSort write SetImageSort;
    property ImageSortAsc: TBitmap read FImageSortAsc write SetImageSortAsc;
    property ImageSortDesc: TBitmap read FImageSortDesc write SetImageSortDesc;
    property ImageSearch: TBitmap read FImageSearch write SetImageSearch;
    property ImageRefresh: TBitmap read FImageRefresh write SetImageRefresh;
    property StretchColumnFieldname: string
      read FStretchColumnFieldname write SetStretchColumnFieldname;
    property SelectedFont: TFont read FSelectedFont write SetSelectedFont;
    property SortedColumnsFieldname: string
      read FSortedColumnsFieldname write SetSortedColumnsFieldname;
    property SearchedColumnsFieldname: string
      read FSearchedColumnsFieldname write SetSearchedColumnsFieldname;
    //Events
    property OnTitleClick: TDBGridClickEvent read FOnTitleClick write FOnTitleClick;
    //Methods
    procedure Paint; override;
  end;

Cela me paraît relativement simple parce que la notion de cells est directement implémentée dans la TDBGrid. Mais avec la TGrid de Delphi, il en est tout autrement.

Quelqu'un pourrait-il m'orienter vers le début d'une approche FMX ?

Merci. Cordialement. Gilles

[SergioMaster]

Bonjour Gilles,

Sergio ayant montré la voie pour fabriquer des composants

la voie était plutôt un tout petit sentier de montagne cela dit j'ai bien avancé depuis même s'il y a encore deux petites choses qui me grattent je vais finir par le boucler ce GR

Pour ce qui est de la grille FMX je ne sais s'il y a besoin de dériver quoique ce soit mon tutoriel sur les grilles couvre une partie des points que tu soulèves (surtout dans le coin du mécano chap VII) ou du moins indique des pistes à suivre

point 1 géré par les expressions IV-B-2-h ou par simple code sur l'évènement onResize
point 2 cela passera certainement par l'ajout de l'unité THeader , abordé dans le chapitre VII-B-1. Dessin d'un triangle dans une cellule
point 3 encore l'unité THeader ou peut-être l'ajout d'un TSearchBox ?
point 4 je pense qu'en traitant la hauteur de la ligne de la même façon que la largeur cela doit être jouable

[SergioMaster]

Bonjour,

point 1, voici comment je ferais avec 2 propriétés

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
unit Unit31;
 
interface
 
uses
  System.SysUtils, System.Types, System.UITypes, System.Classes, System.Variants,
  FMX.Types, FMX.Controls, FMX.Forms, FMX.Graphics, FMX.Dialogs, FMX.Objects,
  System.Rtti, FMX.Grid.Style, FMX.Grid, FMX.Controls.Presentation,
  FMX.ScrollBox, FMX.Edit, FMX.EditBox, FMX.SpinBox, FMX.StdCtrls,
  FMX.Header, FMX.SearchBox, FMX.Memo;
 
type
  THGrid = Class(TCustomGrid);
 
  TForm31 = class(TForm)
    Grid1: TGrid;
    Column1: TColumn;
    Column2: TColumn;
    Column3: TColumn;
    Column4: TColumn;
    Label1: TLabel;
    Button1: TButton;
    NumColonneVar: TSpinBox;
    StyleBook1: TStyleBook;
    procedure FormCreate(Sender: TObject);
    procedure Button1Click(Sender: TObject);
    procedure NumColonneVarChange(Sender: TObject);
  private
    FVColSize: Single;
    FVcolIndex: Integer;
    procedure SetVColSize(const Value: Single);
    procedure SetVcolIndex(const Value: Integer);
    { Déclarations privées }
  public
    { Déclarations publiques }
    property VColIndex : Integer read FVcolIndex write SetVcolIndex default -1;
    property VColSize : Single read FVColSize write SetVColSize;
  end;
 
var
  Form31: TForm31;
 
implementation
 
{$R *.fmx}
 
procedure TForm31.Button1Click(Sender: TObject);
// taille Header
var AHeader : THeader;
    I : Integer;
begin
AHeader:=THeader(Grid1.FindStyleResource('Header'));
AHeader.Height:=AHeader.Height*2;
end;
 
procedure TForm31.FormCreate(Sender: TObject);
begin
NumColonneVar.Max:=Grid1.ColumnCount;
NumColonneVar.Min:=0;
FVcolIndex:=-1;
FVColSize:=0;
end;
 
procedure TForm31.NumColonneVarChange(Sender: TObject);
begin
VColIndex:=Trunc(NumColonneVar.Value)-1;
end;
 
procedure TForm31.SetVcolIndex(const Value: Integer);
// Largeur colonne
var i : word;
    w,ScWidth : Single;
begin
if Value<>FVcolIndex then
 begin
  ScWidth:=TScrollBar(Grid1.FindStyleResource('VScrollBar')).Width;
  if FVColIndex>=0 then Grid1.Columns[FVcolIndex].Width:=FVColSize
                   else FVColSize:=0;
  w:=Grid1.width-(scWidth*2);   // GridStyle.BackGround.VScrollBar.Width pourquoi*2 certainement une valeur de retina?
  for i := 0 to Grid1.ColumnCount-1 do
   if i<>Value then w:=w-Grid1.Columns[i].width;
  if Value>=0 then begin
                    FVColSize:=Grid1.Columns[Value].Width;
                    Grid1.Columns[Value].width:=w;
                   end
              else FVColSize:=0;
  FVcolIndex:=Value;
 end;
end;
 
procedure TForm31.SetVColSize(const Value: Single);
begin
  FVColSize := Value;
end;
 
end.

Pour les Headers, j'avoue avoir quelques difficultés. Pour l'instant je n'y accède pas (sauf bien sûr le texte et la hauteur en jouant sur le style)

[Invité]

Bonjour Serge,

j'avais étudié déjà un peu ton code... mais je reste toujours aussi perplexe. Je ne vais retenir qu'un seul élément.
J'ai besoin d'accéder au dataset "relié" à la Grid pour le parcourir et déterminer la largeur max. du contenu d'une colonne donnée. Mais ici, je vais faire plus simple : je voudrais comme en Lazarus rendre une colonne invisible (sans créer dans l'IDE les colonnes de la Grid). Les Champs du DataSet possèdent cette propriété.

En lazarus with datasource.dataset do. En Delphi, le datasource c'est le LinkGridToData (semble -t-il) de la propriété LiveBindings de la Grid. Or déjà, un simple code "with Grid1.Livebindings." ne passe pas !Pièce jointe 468952

Alors, je ne pensais pas avoir autant de problème sur quelque chose d'aussi simple.
D'abord je n'arrive pas partant de la Grid (i.e. "with Grid1 do...") à accéder par programmation à son DataSet : Grid1.LiveBindings semble être inconnu. [Voir ci-dessus]
Donc je passe directement par le "LiveBinder", code en bas à droite. Il passe mais il est inactif. Je suis allé directement dans l'inspecteur d'objet, ai placé la propriété Visible du champ du DataSet à False. Il semble inopérant [Voir ci-dessus], alors qu'en Lazarus, il l'est !
Pièce jointe 468955

Finalement, il m'a fallu construire une à une les colonnes du DbGrid dans celui-ci, puis les lier au DataSet pour ensuite aller dans son éditeur de colonnes et mettre la propriété Visible à False et obtenir le résultat cherché :
Pièce jointe 468953

Donc je résume ma perplexité :

• l'approche LiveBinding en combinaison Editeur/Programmation m'est pour le moment impossible.
• la cosntruction physique des colonnes dans l'éditeur du DBGrid semble obligatoire alors qu'en lazarus ce n'est pas le cas.

Il est vrai que je suis un détracteur forcené du LiveBindings que je trouve compliqué, dont j'arrive mal à définir les capacités et les limites. Je privilégie en Lazarus (et autrefois en Delphi) l'approche composant. Ici mon composant serait hérité d'un TGrid. Je ne sais pas comment s'appelleront les composants de son "LiveBinder". Pourquoi LinkGridToDataSourceBindSourceDB12 arrive-t-il comme nom (!?) et également comme contenu d'une propriété du TGrid. En réalité la propriété LiveBindings est un modèle bizarre qui pour l'instant ne me semble pas facilement programmable et encore moins exploitable 'économiquement' (voire même, à mon niveau, techniquement).

Cordialement. Gilles.

[Invité]

Bonjour Serge,

nos codes se sont croisés. Ce qui me gène beaucoup dans ton approche de ce matin, c'est que je n'arrive pas à me rendre compte si le code est "autonome".

Je pose un THGrid sur la Form31. A partir de là, en programmation classique (Lazarus, Delphi 7), je définis ses propriétés et j'utilise ses méthodes publiques à partir de la Form alors que le composant lui-même utilise ses méthodes internes et évènements internes pour "répondre" aux diverses sollicitations.

Code :

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

1
2
3
4
With THGrid1 do 
begin
 StrechedColumns := 'xxCOLa; xxCOLb';
end;

En interne par exemple :

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
 
unit lzDbGrid; 
[...]
type
 
 
  { TGridHelper }
  TGridHelper = class helper for TDBGrid
    function GetIndexOfColumnByName(const aName: string;
      bVisible: boolean = False): integer;
    function GetAutoColumnWidth(aIndex: integer): integer;
  end;
 
  TlzCustomDbGrid = class(TCustomDbGrid);
 
  { TDbGrid }
  TlzDbGrid = class(TDbGrid)    
   private  
   [...]
   end;
 
function TGridHelper.GetAutoColumnWidth(aIndex: integer): integer;
var
  B: TBookmark;
  F: TField;
  bmp: TBitmap;
begin
  Result := -1;
  if not columns[aIndex].Visible then
    Exit;
  bmp := TBitmap.Create;
  try
    bmp.Canvas.Font.Assign(TitleFont);
    with DataSource.DataSet do
    begin
      B := Bookmark;
      F := FieldByName(Columns[aIndex].FieldName);
      Result := bmp.Canvas.TextWidth(F.DisplayLabel + ' ');
    end;
 
    bmp.Canvas.Font.Assign(Font);
    with DataSource.DataSet do
    begin
      DisableControls;
      try
        First;
        while not EOF do
        begin
          if F.Visible then
            Result := Max(Result, bmp.Canvas.TextWidth(F.AsString + '   '));
          Next;
        end;
      finally
        Bookmark := B;
        EnableControls;
      end;
    end;
  finally
    bmp.Free;
  end;
end;

Tu remarqueras ici l'usage du "with DataSource.DataSet do". Je n'utilise pas les columns de la Grid parce qu'en réalité elles ne contiennent rien physiquement. Contrairement à la TStringGrid, la TGrid est un simple outil d'affichage interactif. Une colonne affiche les données contenues dans le DataSet. Alors autant s'adresser directement au Dataset. C'est ma perception actuelle (issue évidemment de mes vieilles habitudes). Mais je n'ai rien rencontré qui m'incite à changer de modélisation. D'ailleurs cela explique ma réticence à utiliser les Grids de TMS qui sont obligées de faire d'incroyables acrobaties pour obtenir les résultats désirés.

Bref, perplexe je reste. C'est pas que je ne veuille pas évoluer mais je dois obtenir le même résultat, d'une manière que je comprenne, autrement que par une usine à gaz. Dans une application Desktop, les fenêtres dont les approches sont identiques, sont nombreuses (par exemple une vue de table). Il faut que le code soit reproductible d'une fenêtre à l'autre sans adaptations excessives.

Je crée mon LiveBindings et basta... La requête du DataSet change. Les champs dans l'éditeur de colonnes (avec les entêtes) aussi... en 2 ou 3 clicks de souris. Je modifie quelques propriétés de la dbGrid en précisant uniquement le nom des champs du DataSet : l'index par défaut, le nom des colonnes 'strechées', triées, et le nom de celles où il est possible de faire une recherche. Éventuellement le nom de la fenêtre permettant la modification... C'est tout. Rapide, efficace, économe, standardisé. Voila ce que je cherche à reproduire avec FMX depuis le début. L'avantage du composant : sa modification s'applique automatiquement à toutes les fenêtres sur lesquelles il est posé.

Pour le mobile, il y a moins de fenêtres, chacune étant en général "individualisées". Mais il est bien écrit que FireMonkey permet le développement Desktop... Est-ce qu'il faut lire "en utilisant une approche mobile" ? Là aussi je reste perplexe et ne demande qu'à être convaincu du contraire.
Cordialement. Gilles

[SergioMaster]

Bonjour,

Mais il est bien écrit que FireMonkey permet le développement Desktop...

Je ne fais presque que du dev. desktop et n'ayant toujours pas d'apple, du windows donc tu peux en tirer la conclusion que Oui

Est-ce qu'il faut lire "en utilisant une approche mobile" ?

Pas du tout, l'approche mobile se fait à partir d'un écran desktop avec les limitations intrinsèque à la cible (taille écran)

Je pense avoir trouvé comment accéder aux différents headers
syntaxe balbutiante :

Code :

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

1
2
3
4
5
6
7
8
H : THeader;
IH : THeaderItem;
Grid.FindStyleResource<THeader>('header',H); // récupère les Headers;
for i:=0 to H.ItemsCount -1 do 
begin
  IH:=THeaderItem(H[i]);
  // manips sur IH
end;

De là à pouvoir accéder au canvas j'ai un doute mais qui sait c'est juste un début de piste

par contre mes essais de création d'un composant grid se heurtent à un problème, j'ai acquis comme principe de passer d'abord par un création au runtime avant d'utiliser l'unité comme composant.

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
unit UnitGrid;
 
interface
uses
    System.Classes,
    FMX.Grid.Style, FMX.Grid,FMX.Header,FMX.StdCtrls, FMX.SearchBox;
 
type
  TMyGrid = Class (TCustomGrid)
  private
    FStrechColSize: Single;
    FStrechColIndex: Integer;
    FHeaderHeight: Single;
    procedure SetStrechColIndex(const Value: Integer);
    procedure SetStrechColSize(const Value: Single);
    procedure SetHeaderHeight(const Value: Single);
  protected
    function GetDefaultStyleLookupName: string; override;
    procedure DoEndUpdate; override;
  public
    constructor Create(AOwner: TComponent); override;
    property HeaderHeight : Single read FHeaderHeight write SetHeaderHeight;
    property StrechColIndex : Integer read FStrechColIndex write SetStrechColIndex default -1;
    property StrechColSize : Single read FStrechColSize write SetStrechColSize;
  published
    property Anchors;
    property Align;
    property CanFocus;
    property CanParentFocus;
    property ClipChildren;
    property ClipParent;
    property ControlType;
    property Cursor;
    property DisableFocusEffect;
    property DragMode;
    property EnableDragHighlight;
    property Enabled;
    property Height;
    property HelpContext;
    property HelpKeyword;
    property HelpType;
    property HitTest;
    property Locked;
    property Padding;
    property Opacity;
    property Margins;
    property PopupMenu;
    property Position;
    property ReadOnly;
    property RotationAngle;
    property RotationCenter;
    property Scale;
    property Size;
    property StyleLookup;
    property TextSettings;
    property StyledSettings;
    property TabOrder;
    property TabStop;
    property TouchTargetExpansion;
    property Visible;
    property Width;
    property RowHeight;
    property RowCount;
    property Options;
    property Images;
 
    property DefaultDrawing;
    property OnHeaderClick;
    property OnColumnMoved;
    property OnDrawColumnHeader;
    property OnSelectCell;
    property OnSelChanged;
    property OnDrawColumnBackground;
    property OnDrawColumnCell;
    property OnGetValue;
    property OnSetValue;
    property OnCreateCustomEditor;
    property OnEditingDone;
    property OnResize;
    property OnResized;
    property OnCellClick;
    property OnCellDblClick;
    property OnDragEnter;
    property OnDragLeave;
    property OnDragOver;
    property OnDragDrop;
    property OnDragEnd;
end;
 
implementation
 
{ TMyGrid }
 
constructor TMyGrid.Create(AOwner: TComponent);
begin
   inherited;
   AddObject(TColumn.Create(Self)); // tentative d'ajout d'une colonne pour y mettre un curseur 
 end;
 
procedure TMyGrid.DoEndUpdate;
begin
  Model.ClearCache;
  inherited;
end;
 
function TMyGrid.GetDefaultStyleLookupName: string;
begin
  Result := 'gridstyle';  
end;
 
procedure TMyGrid.SetHeaderHeight(const Value: Single);
var AHeader:Theader;
begin
 if Value<>FHeaderHeight then
  begin
    FHeaderHeight := Value;
    AHeader:=THeader(findStyleResource('Header'));
    if Assigned(AHeader) then  AHeader.height:=40;
  end;
end;
 
procedure TMyGrid.SetStrechColIndex(const Value: Integer);
// Largeur colonne
var i : word;
    w,ScWidth : Single;
begin
if Value<>FStrechColIndex then
 begin
  ScWidth:=TScrollBar(FindStyleResource('vScrollBar')).Width;
  if FStrechColIndex>=0 then Columns[FStrechColIndex].Width:=FStrechColSize
                   else FStrechColSize:=0;
  w:=width-(scWidth*2);   // GridStyle.BackGround.VScrollBar.Width pourquoi*2 certainement une valeur de retina à trouver
  for i := 0 to ColumnCount-1 do
   if i<>Value then w:=w-Columns[i].width;
  if Value>=0 then begin
                    FStrechColSize:=Columns[Value].Width;
                    Columns[Value].width:=w;
                   end
              else FStrechColSize:=0;
  FStrechColIndex:=Value;
 end;
end;
 
procedure TMyGrid.SetStrechColSize(const Value: Single);
begin
  FStrechColSize := Value;
end;
 
end.

Impossible d'afficher la grille cela attendra Jeudi maintenant !

[Invité]

Bonsoir Serge,

Code :

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

1
2
3
4
5
6
 
constructor TMyGrid.Create(AOwner: TComponent);
begin
   inherited;
   AddObject(TColumn.Create(Self)); // tentative d'ajout d'une colonne pour y mettre un curseur 
 end;

Tu vas créer tes colonnes ? Il semble qu'avec FMX on soit obliger de le faire. Mais ce sera alors une procédure manuelle : il faudra définir et enregistrer les TColumn une par une... exactement comme je suis obligé de le faire actuellement avec le LiveBindings. Car dans le CREATE, je ne vois pas bien comment les créer automatiquement à partir du LiveBindings pointant sur le DataSet ... On arrive au problème de la Poule et de l'Oeuf... à moins que l'on puisse s'en "passer"

J'ai étudié un peu plus en avant en passant par les TGrid et TMSLiveGrid. Je n'y arrive vraiment pas !
Pièce jointe 469341
Comme toi, je vais laisser passer une journée... au moins

Merci pour ton aide. Cordialement. Gilles