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

[SergioMaster]

Bonjour,

Tu vas créer tes colonnes ? Il semble qu'avec FMX on soit obliger de le faire.

Oui je tentais cet exploit et Non, on n'est pas obligé de créer les colonnes on peut très bien lier la grille, l'EDI se chargeant de la création des colonnes en fonction du type de données.
Ce qui est gênant dans cette démarche :
- les Livebindings non modifiables (encore que, j'ai une idée à creuser)
- plusieurs mésaventures (d'expérience) arrive dès que l'on change le design

Les nuits portant conseil, je me suis réveillé ce matin avec une petite idée : "et si on ne prenait pas la chose par le bon bout ?"

Je m'explique, plutôt que de dériver une grille (travail énorme) si l'on créait de nouveaux types de colonnes. Ça je sais que c'est relativement facile, j'ai dû déjà voir un ou deux articles lors de mes recherches. Le travail ensuite serait de faire en sorte que ces colonnes soient prises par défaut par le concepteur (en fonction d'une indication dans les déclarations des colonnes ?)

Bref j'ai 2 ou 3 idées peut-être saugrenues que je vais explorer aujourd'hui

Nota : Pour le TMSFMXLiveGrid et les colonnes cachées, je n'ai plus le truc en mémoire mais il me semble que j'avais trouvé la manière de le faire je vais revoir dans mes programmes mais il me semble que le "mot clé" n'est plus Visible mais quelque chose comme HideColumn(n)/ShowColumn(n)

[SergioMaster]

- les Livebindings non modifiables (encore que, j'ai une idée à creuser)
cette idée, s'est révélé fausse. Je pensais qu'en allant dans le DFM remplacer un TLinkGridToDatasource en TGridLink cela me permettrait ensuite de modifier les liens c'est raté

- Créer un nouveau type de colonne oui mais les sources de ce premier lien sont à revoir ça ne passe pas la compilation par contre j'ai trouvé un lien hyper intéressant affaire à suivre

- Modifier le type de colonne à l'exécution ? Ça, ce n'était pas saugrenu sauf que ce n'est pas sur le composant grille qu'il faut "jouer" mais sur les liens

Code :

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

1
2
3
4
5
6
7
8
 
procedure TForm38.Button1Click(Sender: TObject);
begin
// la colonne 1 est au design de type IntegerColumn donc alignée à droite 
// je la change en StringColumn 
LinkGridToDataSourcePrototypeBindSource1.Columns[1].ColumnStyle:='StringColumn';
// la colonne (les données) est alignée à gauche
end;

- Avoir des colonnes à la meilleure largeur

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
procedure TForm38.LinkGridToDataSourcePrototypeBindSource1AssigningValue(
  Sender: TObject; AssignValueRec: TBindingAssignValueRec; var Value: TValue;
  var Handled: Boolean);
var AObject : TObject;
    w : single;
    ATLayout : TTextLayout;
begin
AObject:=AssignValueRec.OutObj;
if AObject.ClassNameIs('TGridDataObject')
 then begin
   // la colonne 0 fait au départ 62 de large
 if AObject.ClassNameIs('TGridDataObject')
 then begin
   if TGridDataObject(AObject).Column=0 then
     begin
      ATLayout:=TTextLayoutManager.DefaultTextLayout.Create;
      ATLayout.BeginUpdate;
      ATLayout.Font:=Grid1.TextSettings.Font;
      ATLayout.Text:=UpperCase(Value.AsString); // uppercase pour être sûr 
      ATLayout.EndUpdate;
      w:=ATLayout.TextWidth;
      w:=Max(Round(w),LinkGridToDataSourcePrototypeBindSource1.Columns[0].width);
      LinkGridToDataSourcePrototypeBindSource1.Columns[0].width:=round(w);
     end;
 end;
 
 end;

Le principe est posé, resterait à prendre en compte la taille de l'entête de colonne.
Deux pistes :
- le faire dans le calcul de w
- le faire quand l'objet (AssignValueRec.OutObj) est de type TGrid car j'ai pu remarquer que c'était le premier élément qui montre le bout de son nez pointe dans onAssigningValue (à voir)


Conclusion après ce premier tour ce n'est pas la grille qu'il faut "toucher" mais les liaisons de celle-ci voilà qui complique le problème d'une part parce qu'il peut y avoir deux types de lien (le rapide TLinkGridToDataSource ou le manuel TGridLink) et d'autre part je ne vois pas comment intégrer ces "recherches" à un composant grille au design

[Invité]

Bonjour Serge,

j'ai réussi partiellement à dériver une TGrid mais un problème résolu en ouvre immédiatement un autre.

Parallèlement, je teste la TeeGrid. Elle fonctionne aussi bien en LiveBinding qu'avec un vrai DataSource. Donc avant de m'enthousiasmer et d'acheter la version avec les codes sources, je teste la version Rio sous FMX...

Je ne manquerai pas de faire un CR à la fin de mon essai.
Bonne journée. Cordialement. Gilles

[SergioMaster]

Bonjour Gilles,

Parallèlement, je teste la TeeGrid. Elle fonctionne aussi bien en LiveBinding qu'avec un vrai DataSource. Donc avant de m'enthousiasmer et d'acheter la version avec les codes sources, je teste la version Rio sous FMX.

Je ne connaissais pas, je vais donc aussi tester de mon côté

Merci pour ce lien

Serge

[Invité]

Bonjour,

en attendant les réponses aux questions que j'ai posées à l'éditeur de TeeGrid (qui se font un peu attendre), j'ai bien avancé mon travail sur la TGrid native de FMX en m'inspirant du travail de Serge, de lectures trouvées sur le Web... et en utilisant mes codes Lazarus. Maintenant, j'aimerais installer ma TlzGrid comme composant dans la palette de Delphi (pour FireMonkey). Quelqu'un possède-t-il une méthode exhaustive étape par étape pour faire cela ?

Merci d'avance. Gilles

[SergioMaster]

Bonjour,

je pense que ce PDF (article non encore corrigé donc non publié) devrait répondre a tes questions

Sinon, en gros, il faut une procédure Register

Code :

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

1
2
3
4
5
procedure Register; 
 begin 
  GroupDescendentsWith(lzGrid, FMX.Controls.TControl);  
 RegisterComponents('Gilles', [TLzGrid]); 
end;

un code [ComponentPlatforms(pidWin32 or pidWin64 or pidAndroid)] juste au-dessus de ta déclaration de classe permettra de réduire aux seuls OS supportés (ici windows+android)

[Invité]

Bonjour,

Un immense merci à Serge. J'ai enfin pu intégrer ma TlzGridFMX dans l'IDE. J'essaierai de trouver un autre nom mais pour l'instant, cela simplifie mon portage de code de la lzDbGrid Lazarus à la lzGrid FMX.


Quelques questions encore :

• il y a-t-il un format spécial pour incorporer l'image associée aux composants : bmp ?, png ?, ico ? et taille ? J'ai essayé les 2 derniers format en vain.
• comment met-on à jour le composant ? Une simple reconstruction de lzAddition.bpl semble être insuffisante. Faut-il le recompiler pour chaque OS puis le désinstaller et le réinstaller ? En Lazarus, parfois c'est nécessaire mais généralement pas.

J'ai rencontré quelques problèmes inattendus. Je les ai notés ainsi d'ailleurs que la liste des ressources documentaires utilisées. Je transmettrai le tout à Serge au fil de l'évolution du composant. Il n'y a rien de confidentiel... au contraire.
Cordialement. Gilles

[SergioMaster]

Re,
Pour ce qui est de TeeGrid, je suis déçu ou je fais mal les manipulations je n'arrive pas à faire le liaisons LiveBindings, il faut passer par un Tdatasource
Pour ce qui est de "l'image" du composant il faut le mettre en ressource (je pense en parler dans la suite du tutoriel "composant_b")
lire ce post, https://www.developpez.net/forums/d1.../#post10907267

comment met-on à jour le composant ? Une simple reconstruction de lzAddition.bpl semble être insuffisante.

lors de tous mes essais (très nombreux) je réinstallais (clic droit sur le paquet) sauf planton cela suffisait.

Faut-il le recompiler pour chaque OS

ben je n'ai testé que pour Androïd, et Patrick me l'a testé pour Mac je n'ai pas souvenance de l'avoir compilé pour ces OS, cela étant c'est parce que c'est le source qui est utilisé à la compilation et non le BPL/DCU comme un package "distribué" sans les sources. J'avoue ne pas pouvoir indiquer de démarche dans ce cas

[Invité]

Bonjour,

j'insiste lourdement sur le Bitmap associé au composant dans la palette de l'IDE.
J'ai essayé avec Bccr32 (à l'ancienne), et évidemment [Ressources et Images] du menu [Projet], plusieurs format de bmp, de tailles... en vain (et même des png, ico...).

J'ai essayé l'article suivant. J'ai essayé également dans cet article plusieurs formats et tailles de BMP.
Le résultat :


Je joins le source correspondant à l'article. J'ai également vérifié à partir d'une application VCL : idem. Ce n'est certainement qu'un détail mais il n'y a pas de raison pour que cela ne fonctionne pas. J'ai aussi essayé sur plusieurs appareils (Mac Mini, PC Windows... donc des cartes graphiques différentes) et les versions 10.3, 10.3.1, Enterprise et Community... Pareil : je sèche lamentablement !

Quelle est la solution ?
Merci. Gilles

[SergioMaster]

Bonjour Gilles,

une image valant mieux que tout

et je n'ai fait qu'installer ton composant, en vérifiant les ressources (projet/ressources et images) avant

P.S. Oui tu peux jubiler, j'ai aussi mis IBDac (version de démo) qui m'a permis de tester qu'il était possible d'utiliser Firebird 3 sur Android (pour l'instant je n'ai testé que la partie client-> serveur)

[Invité]

Bonjour Serge,

et je n'ai fait qu'installer ton composant, en vérifiant les ressources (projet/ressources et images) avant

En vérifiant donc pas en changeant... Alors qu'est-ce que c'est que ce binz sur mes appareils ? Et surtout d'où cela vient-il ? Les images des composants TMS ou Unidac apparaissent normalement.

P.S. Oui tu peux jubiler, j'ai aussi mis IBDac (version de démo) qui m'a permis de tester qu'il était possible d'utiliser Firebird 3 sur Android (pour l'instant je n'ai testé que la partie client-> serveur)

Non, je ne jubile pas. Les composants de Devart sont simplement plus facilement "déployables" que les natifs d'Embarcadero ce qui sur du multiOS est quand même extrêmement appréciable. Mais concernant IBDAC, il me semble qu'il faut quand même (encore) joindre une bibliothèque cliente pour chaque OS. Alors qu'en mariaDB ot PostgreSQL, je ne joins rien : c'est "direct" presque magique

Bonne journée. Gilles

[SergioMaster]

En vérifiant donc pas en changeant... Alors qu'est-ce que c'est que ce binz sur mes appareils ? Et surtout d'où cela vient-il ?

J'oublierai la partie sur les composants tiers
Je ne peux dès lors qu'indiquer des pistes puisque chez moi cela s'est passé sans problème :
- une histoire de résolution d'écran (encore que ce ne soit pas le terme exact) ? Le fameux "multiresbitmap" qui resurgi, là je patauge encore un peu dans la semoule (c'est peu dire)
Ce qui me fait penser à ça ? Je reprends les termes de Remy Lebeau du lien que tu as prédemment cité

La véritable amélioration réside dans le fait que les nouvelles versions de l'EDI prennent en charge des tailles non standard pour les images de palette (16x16, 24x24, 32x32)

concernant IBDAC, il me semble qu'il faut quand même (encore) joindre une bibliothèque cliente pour chaque OS

je confirme (j'ai rajouté libfbclient.so.3.0.4 et libib_util.so dans ./assets/.internal pour le déploiement) mais bon, cela aurait été aussi le cas pour Firedac sauf que, avec Firedac (driver IB en changeant la bibliothèque du vendeur) la bibliothèque ne fonctionne pas alors qu'avec IBDAC cela fonctionne

[SergioMaster]

Plutôt qu'un [Edit] de ma dernière discussion.
La réponse se trouve peut-être dans cet article
il semblerait que l'on puisse indiquer en sus du nom du composant sa taille et son type (bmp ou png)

Bitmap et PNG

Les icônes de composant peuvent être à la fois au format bitmap et au format PNG. Les nouvelles icônes sont toutes alpha transparentes et anti-aliasées. Ils peuvent être soit une image PNG, ou un bitmap 32bpp (non-premultiplied-alpha).

Si le bitmap est 32bpp, l'EDI suppose qu'il s'agit d'une icône de nouveau style et qu'elle possède un canal alpha valide. (Lors des tests, nous avons vu quelques icônes qui étaient des bitmaps de 32 bpp, mais avec un canal alpha 100% transparent. Si vous expédiez des icônes de cette manière, votre icône apparaîtra totalement transparente.) Si le bitmap est d'un autre format, comme 24bpp, il suppose qu’il s’agit d’une ancienne icône de couleur assortie. Cela offre une compatibilité totale avec les versions antérieures, de sorte que les icônes de composants de style ancien fonctionnent toujours.

Si vous souhaitez utiliser un fichier PNG au lieu d'un fichier bitmap, les noms des ressources sont les mêmes, mais ils portent le suffixe '_PNG' et sont stockés en tant que ressource RCDATA, pas en tant que ressource BITMAP. Ainsi, l'icône 32x32 de TLabel, en tant que script de ressource utilisant une image PNG, serait:

RCDATA TLabel32_PNG 'tlabel32.png'

Rétrocompatibilité

Si vous utilisez des bitmaps 32bpp, les IDE antérieurs à 10.2.2 ne pourront pas afficher les icônes correctement. Il y a deux façons de gérer cela:

Créez différents ensembles de ressources pour les packages de composants destinés à un environnement de développement intégré récent. Nous recommandons cela à partir de la version 10.3 - c’est-à-dire que votre package de composants pour 10.3, qui serait un projet et un package différents de ceux de 10.2.x, pourrait stocker des ressources différentes.
Laissez les anciens bitmaps existants et ajoutez de nouvelles ressources PNG. Les PNG sont chargés de préférence en bitmaps. Par conséquent, si vous avez une icône bitmap (ancienne ou nouvelle!) Et une nouvelle icône PNG, 10.2.2 chargera le fichier PNG. Les anciens IDE ne connaissent pas la ressource PNG, vous pouvez donc avoir deux ensembles d'icônes dans le même package.

Cela dit je n'ai fait que survoler l'article, pas tester