Discussion :

[Invité]

Bonjour,

Si comme j'en crois la documentation, tous les styles d'une Form peuvent être gérés à partir d'un fichier.style, quelqu'un comprendrait-il la chronologie des "actes" à accomplir ?
http://docwiki.embarcadero.com/RADSt...vec_les_styles

Je ne veux pas savoir comment fait le Collègue et les 950 bidouilles utilisées ou utilisables mais quelque chose de simple, de "standard" comme dans Qt. Bref, je veux comprendre le mécanisme des styles en Delphi. J'ai bien réussi, venant de Lazarus, à comprendre ceux de Qt qui entre parenthèses sont vraiment fonctionnels... Et plus, je voudrais le faire aussi directement que possible, "à la main" genre notepad++. J'espère que je mettrais moins de temps à assimiler.

1. Je crée ma Form : fMain
2. Est-ce que je peux à ce moment-là générer un fMain.style, le lier à la Form et surpasser celui par défaut ? Eventuellement quels rapports avec fMain.fmx ?
3. Je pose une StringGrid
4. Comment incorpore-t-on son style dans fMain.style ? Cela se fait peut-être automatiquement... Comme je n'ai pas -semble-t-il- passé l'étape 2, je n'en sais rien.

Question subsidiaire : quand on bricole "mal" un fichier .lfm, .dfm et je suppose .fmx, on obtient un message d'erreur au moment d'ouvrir la Form dans l'éditeur. En est-il de même pour un .style ? J'aurais bien aimé en rencontrer des messages d'erreur. Ils m'auraient servi de guide. Mais pas vu.


J'ai des codes de styles pour XE6 notamment pour une StringGrid. J'ai les méthodes d'appel. Mais au bout d'une heure, je n'arrive pas à relier les morceaux... à priori soit parce que le fMain.style n'est pas compatible, soit parce qu'il n'est pas "connecté", soit parce qu'il n'est pas prioritaire par rapport au style par défaut.

Je ne sais pas si c'est la traduction française qui est approximative, si c'est ma compréhension de la langue française qui est mauvaise, ou si je ne pense pas comme les créateurs des styles Delphi... Mais ma logique n'est pour l'instant pas adaptable à la compréhension des explications fournies.

Merci pour votre aide.

[SergioMaster]

Bonjour,

je ne sais pas si je vais répondre a ta satisfaction , les styles continuent à me donner le tournis , surtout si on ajoute des composants TMS sur la forme .
De base , sur ta forme tu poses un TStyleBook et tu lies ta forme à ce dernier via la propriété de la forme : StyleBook
déjà à partir de là tu peux 'jouer' avec les différents styles proposés par Embarcadero (répertoire <installation XE>\redist\styles\fmx)
après (et je pense que c'est ton point 2) tu peux ajouter/modifier le style de certains composants pour te les personnaliser et ensuite sauvegarder le tout dans un nouveau fichier (<- ça, ça reste théorique , je n'ai pas vérifié)
tu peux également mettre plusieurs TStylebook sur une même fiche (histoire de perdre un peu plus de cheveux)

Courage et Cheveux (pour ne pas crier "chauve qui peut")
Serge

[Paul TOTH]

Bonjour,

Alors les Styles FMX c'est quelque chose d'assez particulier, et ça n'a notamment rien à voir avec les feuilles de Styles HTML pour ceux qui connaissent.

première démonstration de ce que sont les styles :

sur une fiche, placez un panel Panel1 contenant un Edit et un Button

placez un second panel Panel2

maintenant si sur Panel1 je définis la propriété StyleName à "paneltest" et que sur Panel2 je définie la propriété StyleLookup à "paneltest" également, la magie des styles s'opère et Panel2 affiche alors un Edit et un Button !

Si on lance l'application les deux Edit permettent de saisir du texte et les deux boutons sont cliquables...par contre si je définis un événement OnClick sur Button1, le bouton affiché dans Panel2 ne déclenche pas le code.

mais avec cet exemple on constate que le style "paneltest" a été déclaré par la propriété StyleName et que StyleLookup a été capable de le retrouver pour créer dans Panel2 les mêmes composants que ceux présents dans le style "paneltest", car il est bien question d'instancier des objets ! un Style est très proche d'un DFM/FMX, la grosse différence c'est qu'il ne fera pas référence aux événements de la fiche (OnClick etc...).

lien entre composant et style

alors ok, un Style c'est donc une arborescence d'objet comme dans un FMX qu'on vient coller dans le composant parent....mais comme se fait le lien entre les propriétés de mon objet et les éléments de son style ?

Et bien là il n'y a pas de secret, un composant donné s'attend à trouver des éléments précis dans le style, ainsi un Button aura un élément "background" et un élément "text", la méthode ApplyStyle du composant va rechercher dans les objets du style des éléments dont la propriété StyleName est égale à ces valeurs pour leur fournir les valeurs définies au niveau de l'objet Button via des Interfaces bien définies.

exemple:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
procedure TCustomButton.ApplyStyle;
var
  StyleObject: TFmxObject;
begin
  inherited;
  StyleObject := FindStyleResource('background');
  if (StyleObject <> nil) and Supports(StyleObject, ITintedObject) then
  begin
    FTintObject := (StyleObject as ITintedObject);
    FTintObject.TintColor := FTintColor;
  end;
...

Si maintenant on regarde le Style d'un bouton (clic droit sur le bouton - Modifier le style personnalisé) on constate que le style par défaut utilise des éléments qui ne sont pas présents dans la palette de composants standard comme un TButtonStyleObject ou un TButtonStyleTextObject ... c'est là à mon avis que ça devient compliqué...d'autant que les boutons Windows, MacOS, iOS et Android n'utilisent pas les mêmes styles, donc pas forcément les mêmes objets, seuls les StyleName sont respectés pour garder le lien Objet/Style.

J'ai par exemple réalisé un bouton FMX qui peut afficher un Bitmap...pour ce faire je dérive de TButton et je surcharge (entre autre) deux méthodes clé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
 
// GetStyleObject permet de retrouver le style de l'objet
function TBitmapButton.GetStyleObject:TFmxObject;
var
  image: TImage;
begin
// si aucun style personnalisé n'est défini
  if (StyleLookup = '') then
  begin
 
    // on récupère le style par défaut de TButton (selon la plateforme)
    Result := inherited GetStyleObject;
 
    // et on lui ajoute une image non cliquable (c'est le bouton qui clique, pas l'image) qui occupe tout l'espace client
    image := TImage.Create(Result);
    image.Parent := Result;
    image.Align := TAlignLayout.Contents;
    image.HitTest := False;
    image.StyleName := 'image';
 
  // sinon ça ne nous regarde pas !
  end else
    Result := inherited GetStyleObject;
end;
 
// Lors de l'applyStyle on va définir l'image de fond
procedure TBitmapButton.ApplyStyle;
var
  image: TFmxObject;
begin
  inherited;
 // recherche de l'image dans le Style
  image := FindStyleResource('image');
 // sans passer par une Interface on impose un TImage
  if Assigned(image) and (image is TImage) then
  begin
  // on y colle le bitmap défini dans les propriétés de l'objet TBitmapButton
    TImage(image).Bitmap.Assign(FBitmap);
  end;
end;

Voila un bref aperçu de la mécanique interne des Styles FMX, notez aussi que d'une version Delphi à une autre, les Styles FMX ont pu être modifiés et les composants peuvent ne plus rechercher les mêmes éléments dans le style ! Je pense spécialement à TCalendar qui ne possède aucun style dans XE2 et qui est complètement stylé dans XE7.

[Invité]

Merci pour vos réponses à tous deux.

Serge, à priori c'est la gestion des fichier.style qui semble être "ma" solution. Et Paul, j'aime beaucoup factoriser et réutiliser mon code... et donc je voudrais non pas définir un style dans une Form mais un style facilemement répliquable (et modifiable) mais totalement indépendant d'une Form à l'autre... d'où la possibilité d'utiliser un fichier de description des styles. Voilà pourquoi, je m'intéresse au fichier.style. Alors en effet cela ressemble à l'utilisation d'un fichier CSS. Et si j'ai compris l'exemple qui m'a interpellé, cela y ressemble au moins un peu.

Ma problématique est celle-ci.
Je construis une StringGrind dans ma Form

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
 
procedure TForm1.FormCreate(Sender: TObject);
var
aCol, aRow : integer;
aColMax, aRowMax : integer;
rTmp : Real;
begin
  Randomize;
  aColMax := 10;
  aRowMax := 20;
 
  with SG do begin
    for aCol := 0 to aColMax -1 do begin
      AddObject(TStringColumn.Create(self));
      Columns[aCol].Header := IntToStr(aCol);
    end;
 
    RowCount := aRowMax;
    for aRow := 0 to aRowMax -1 do begin
      Cells[0, aRow] := IntToStr(aRow);
      for aCol := 1 to aColMax -1 do begin
        rTmp := Random(200000)/1000;
        if Random(2)mod 2 = 0 then rTmp := -rTmp;
        Cells[aCol, aRow] :=  FloatToStr(rTmp);
      end;
    end;
  end;
end;

Je veux modifier le style des cellules contenant des décimaux négatifs.

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
procedure TForm1.SGPainting(Sender: TObject; Canvas: TCanvas;
  const ARect: TRectF);
var
  I, J: Integer;
  T: TTextCell;
begin
  // my Column 0 is text, all other columns are money in this example
  for I := 1 to SG.ColumnCount - 1 do
    for J := 0 to SG.Columns[I].ChildrenCount- 1 do
    begin
      T := TTextCell(SG.Columns[I].Children[J]);
      // set the Cell text alignment to right align
    //  T.TextAlign := TTextAlign.Trailing;
 
      // test the Cell string for a negative value
      //if (T.Text[1] = '-') then begin
        // remove the leading minus sign
        //T.Text := Copy(T.Text, 2, Length(T.Text) - 1);
        // set the font to red using the style
        T.StyleLookup := 'textcellnegativestyle';
     // end else begin
     //  T.StyleLookup := 'textcellstyle';
     // end;
    end;
end;

Je dispose d'un fichier fMain.style qui "normalement" devrait me permettre de régler mon problème quelque soit la Form utilisée en supposant que j'en dispose de plusieurs évidemment. Je suis donc parti de l'exemple malheureusement incomplet que j'ai voulu adapter. Je l'ai choisi parce qu'il semble répondre à mes critères : le style dans un fichier extérieur, aussi facile, à priori, à ré-exploiter qu'à corriger. Le problème c'est que n'est pas expliqué comment le fichier d'origine est réellement créé et comment il est associé à la Form (par code, par remplissage dans l'inspecteur d'objet,...). Peut-être mon approche est-elle totalement erronée. Ce qui m'a laissé supposer le contraire, c'est qu'on place "usuellement" un objet sur la Form pour gérer le style ... ou qu'il est créé et "placé" automatiquement. Donc de prime abord, le style est d'abord lié à la Form... D'où une approche peut-être simpliste de ma part. Je dois avouer que l'exemple de Paul m'inquiète plus conceptuellement qu'il ne me rassure. Ce développement "virtuel" ne semble pas à ma portée... mais je tente.

Première démonstration de ce que sont les styles
Avec la réplication du style du panel1 sur le panel 2 : OK sauf que
Le panel2 ne prend pas la dimension de Panel1 et que l'équivalent de Button1 et Edit1 n'existe pas dans Panel2 dans l'arbre structure... C'est très curieux. En effet les 2 boutons peuvent être cliqué mais pas dans l'IDE. Je fais quoi avec le bouton1 de Panel2 ?
le fmain fmx ne contient rien de spécial

Code :

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

1
2
3
4
5
6
7
8
9
10
11
object Form1: TForm1
  Left = 0
  Top = 0
  Caption = 'Form1'
  ClientHeight = 480
  ClientWidth = 640
  FormFactor.Width = 320
  FormFactor.Height = 480
  FormFactor.Devices = [Desktop]
  DesignerMasterStyle = 0
end

Le Project4.res n'est pas lisible évidemment... et mon Win32/debug ne contient que le .dcu et l'.exe. Hum... Simple mais peu instructif. Cela doit être la magie invoquée par Paul... et les tours de magie, cela reste secret, en "machinerie interne".

Pour le deuxième exemple, je suis déjà à la ramasse. Je comprends que les styles soient différents d'un OS à l'autre. En Qt, j'adapte les polices et même leur taille à l'OS par exemple. Mais comment je différencie les styles d'un OS à l'autre ? Cela je suis preneur. Le système est cohérent et source de simplicité, normalement. Seulement la mécanique ?

Je suppose que je rapatrie les fichiers des styles par défaut dans le répertoire de mon projet. Ensuite supposons que dans les Grids, les nombres négatifs passent en rouge en utilisant les styles, je crée une copie du style par défaut Windows retenu, une autre par défaut mac OS, les renomme, puis les surcharge. Mais comment j'informe la Grid que le bon fichier est le fichier renommé&surchargé.style ? Je pensais simplement que la Form1 était lié au dit "form1.style" (mon fichier renommé&surchargé.style) par un StyleBook ou par un code... et qu'ensuite on affectait à l'objet (ici la Grid) son style soit directement par son StyleLookup, soit par code comme dans l'exemple auquel je me suis référé. J'ai essayé mais sans succès.

Si Paul ou Serge qui ont des lieues d'avance sur ma démarche ont la patience de me dire ce qui cloche dans ma "sorcellerie", j'essaye de corriger la base (ie le lien au fichier.style) et je place le source sur le site pour amélioration. Cela me semble la moindre des choses.

[Paul TOTH]

bon alors, en premier lieu, je pense que tu cherches à utiliser les Styles Delphi à la manière des class HTML...mais ce n'est pas le but

tu ne peux pas forcer un attribut par la feuille de style, c'est le Composant qui vient piocher dans le style les éléments qui l'intéresse.

par exemple sur la TStringGrid on trouve un élément portant le StyleName "focus" qui permet de définir l'aspect de la cellule qui a le focus, mais ce style s'applique uniquement parce que le composant TStringGrid le recherche

Code :

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

1
2
3
4
5
6
7
8
 
// extrait de TCustomGrid.ApplyStyle
  T := FindStyleResource('focus');
  if Assigned(T) and (T is TControl) then
  begin
    FFocus := TControl(T);
    FFocus.Visible := False;
  end;

on trouve ensuite dans la méthode UpdateFocusRect() le code qui va venir placer ce FFocus à la bonne place dans la fiche.

Code :

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

1
2
3
4
5
6
7
8
 
          if FocusVisible then
          begin
            FFocus.SetBounds(P.X, P.Y, W, H);
            FFocus.Opacity := 0.4;
            FFocus.Visible := True;
            FFocus.BringToFront;
          end;

on remarque au passage que l'opacité est en dur dans le code, il ne sera donc jamais possible de la définir dans le style.

Donc pour en revenir à ton problème, comment faire en sorte qu'un nombre négatif soit affiché en rouge ?

il y a deux méthodes qui interviennent au niveau du style pour ce point:

Code :

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

1
2
3
4
5
6
7
8
9
 
procedure TColumn.BeforeDrawing(const Canvas: TCanvas);
begin
  if Grid <> nil then
  begin
    if Supports(CellControl, IDrawableCell, FDrawable) then
      FDrawable.BeforeDrawing(Canvas)
  end;
end;

Code :

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

1
2
3
4
5
6
7
8
9
 
procedure TColumn.DefaultDrawCell(const Canvas: TCanvas; const Bounds: TRectF; const Row: Integer;
  const Value: TValue; const State: TGridDrawStates);
...
begin
  if FDrawable <> nil then
    FDrawable.DrawCell(Canvas, Bounds, Row, Value, State)
  else
  begin

Si CellControl supporte l'interface IDrawableCell, c'est lui qui pourra définir l'aspect de la cellule.

d'où vient ce CellControl ? Il peut être défini dans l'évènement OnCreateCustomEditor, à défaut de quoi il est créé directement dans le code

Code :

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

1
2
3
4
5
6
7
8
9
 
function TColumn.CreateCellControl: TStyledControl;
begin
  Result := TTextCell.Create(Self);
  TTextCell(Result).OnTyping := TextTypingProc;
  TTextCell(Result).OnChange := TextChangeProc;
  TTextCell(Result).OnChangeTracking := TextTypingProc;
  TTextCell(Result).OnExit := DoTextExit;
end;

ce composant peut lui-même être stylé, mais même là il n'est pas question de définir la couleur du texte en fonction de sa valeur mais simplement de définir le style général du composant !

Comme les éléments de Style sont des objets, s'il n'existe aucun objet proposant de changer la couleur du texte si le contenu est un nombre négatif, rien ne permettra de le faire.

Or donc pour avoir une grille qui affiche les nombres négatifs en rouge il faut :
1) dériver TStringGrid pour intercepter la création du "CellControl"
2) créer un composant CellControl qui tienne compte de la valeur de texte pour utiliser l'élément de style "negatif" le cas échéant ou le style "defaultText" le reste du temps (ce sont des exemples).

A partir de là, il sera possible de définir un style personnalisé en modifiant les attributs de l'objet ayant le StyleName "negatif" dans le fichier .style

Alors on peut trouver ça lourd, mais en même temps CSS ne propose pas de solution non plus, il faut venir greffer du Javascript pour gérer les nombres négatifs

Là il est possible non seulement de modifier la feuille de style, mais également d'enrichir les composants stylés

[Invité]

Bonjour Paul et merci pour votre réponse.

Je comprends et malheureusement je n'en tire pas de bonnes conclusions mais je vais quand même continuer à étudier la question : ras le bol de tous ces aller-retours Delphi <-> Autre chose sans avoir un avis personnel étayé (sachant évidemment que je garde Qt).

Mes conclusions actuelles et évidemment non définitives au bout de quelques heures de travail et de recherches sur la question :

• le code fonctionnel (ie le traitement métier des données) et celui des styles (ie la présentation des données) ne sont pas séparés : on est totalement à l'opposé d'une véritable architecture 3 tiers. Il y en a partout ! ma perception est qu'on a un cadre rigide mais sans les avantages qu'il devrait apporter !
• le choix retenu par Embarcadero est compliqué d'accès et d'utilisation. Enfin pour moi... mais quand on parcourt le web, pas que pour moi. Ce qui n'arrange pas mes affaires.
• le code n'est pas facilement réutilisable d'un projet à l'autre. Enfin il semble compte-tenu des "acrobaties" nécessaires et de l'imbrication que vous mettez en évidence entre les 2 couches.
• il faut que je trouve un autre moyen dans la limite de l'espace que me laisse la techno FMX... parce que je ne vois pas quel est son apport dans mes applis mais par contre, je perçois toute la complexité qu'elle m'impose. Dériver des composants, je ne faisais que cela en Lazarus... Mais j'obtenais le résultat voulu dans le cadre très "large" que me permet le langage. Là, j'ai un véritable problème. Si je dérive un composant sans aucun degré de liberté dans le cheminement de ma pensée, de mon savoir-faire pour respecter le cadre ultra-rigide de la pratique des styles que me semble totalement -bof je ne qualifie pas-, j'étouffe.

Il est totalement exclu que j'utilise le code que vous me proposez pour colorier en rouge un nombre négatif. La question est de savoir : "Est-ce la seule approche possible ?" Je n'ai qu'un QI standard... et je suis natif de la Terre (un seul cerveau utilisé à quelques %) ! Bref, la normalité... Alors avec un peu d'optimisme (en supposant que j'arrive à comprendre) quand je vais vouloir justifier des TMemo dans une cellule de ma Grid ou, comme j'arrive en Qt -après là-aussi de longs efforts de compréhension- en quelques lignes (en code "natif" en utilisant les widgets de base), à incorporer du HTML dans le "TMemo" -enfin il n'y en a pas besoin- de la cellule de ma Grid et par exemple à en changer la police suivant l'OS (par style), même en prenant une Grid TMS, ce genre de péripétie doit pouvoir être facilement gérée. Euh... c'était une phrase à la FMX et... une "simple" comparativement... Comment je vais gérer la dérivation de ma TMS Grid si je ne dispose pas du code source ?

Votre code est certainement fonctionnel mais je ne veux pas faire "cela"... Le type de code que je cherche à produire est celui qui je l'espère fonctionne dans l'exemple que j'ai relevé en XE6 : affecter le style à l'objet, cela me semble correct :

Code :

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

T.StyleLookup := 'textcellnegativestyle';

Si cela ne fonctionne pas, alors il y a peu d'espoir pour moi un jour de produire quelque chose en FMX.

Mais il y a toujours ce souci que me tenaille. L'approche que vous me proposez est adaptée à mon avis à de l'Androïd et de l'iOS. Un seul style pour l'appli, une "page", peu de modifications, peu d'objets graphiques, tous élémentaires... Et je développe principalement pour les Desktops. C'est pour cela -on en avait parlé- que je disais qu'Androïd Studio me semblait adapté à sa fonction et je crois me rappeler que vous m'aviez précisé qu'il n'était pas adapté à un codage "un peu" sophistiqué. Je sens FMX comme cela pour l'instant. Mais si le code XE6 "voulait" fonctionner, je changerais aussitôt d'avis parce que d'une manière simple, il élargirait le champ des possibles.

Encore merci pour votre aide. Je retourne essayer de progresser un peu.

[Paul TOTH]

Rebonjour,

Alors je ne te propose pas d'utiliser ce que j'explique au dessus, je montre simplement comment cela fonctionne


http://www.raize.com/Articles/FmxStr...dCellFonts.asp

ceci dit, d'après mes tests, CellControl n'est utilisé qu'en mode édition...il faut passer par OnDrawColumnCell pour personnaliser la cellule...hors édition

ce qui n'est pas simple, vu que la couleur du texte est dans un membre FDrawLayout privé...

voici ce que ça donne (par copie du code interne de TColumn.DefaultDrawCell):

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
 
 
procedure TForm1.SGDrawColumnCell(Sender: TObject; const Canvas: TCanvas;
  const Column: TColumn; const Bounds: TRectF; const Row: Integer;
  const Value: TValue; const State: TGridDrawStates);
const
  HorzTextMargin = 2;
  VertTextMargin = 1;
var
  S: string;
  R: TRectF;
  DrawLayout: TTextLayout;
begin
  R := Bounds;
  R.Inflate(-HorzTextMargin, -VertTextMargin);
 
  S := Value.AsString;
 
  DrawLayout := TTextLayoutManager.DefaultTextLayout.Create(Canvas);
  DrawLayout.BeginUpdate;
  try
    DrawLayout.MaxSize := PointF(Width, SG.RowHeight);
    DrawLayout.WordWrap := False;
    DrawLayout.Opacity := SG.AbsoluteOpacity;
    DrawLayout.HorizontalAlign := SG.TextSettings.HorzAlign;
    DrawLayout.VerticalAlign := SG.TextSettings.VertAlign;
    DrawLayout.Font.Assign(SG.TextSettings.Font);
    if (S <> '') and (S[1] = '-') then
      DrawLayout.Color := TAlphaColorRec.Red
    else
      DrawLayout.Color := SG.TextSettings.FontColor;
    DrawLayout.Trimming := TTextTrimming.Character;
    DrawLayout.TopLeft := R.TopLeft;
    DrawLayout.Text := S;
    DrawLayout.MaxSize := PointF(R.Width, R.Height);
  finally
    DrawLayout.EndUpdate;
  end;
  DrawLayout.RenderLayout(Canvas);
  DrawLayout.Free;
end;

Par contre en créant un type FinancialCell et en lui ajoutant l'interface IDrawableCell on peut gérer cela au niveau de ce composant; c'est ce que font TProgressCell, TPopupCell et TImageCell...mais pas TTextCell

[Invité]

Des progrès... J'ai réussi à faire fonctionner l'exemple en question. Là, cette programmation ressemble à quelque chose (pour moi) et sépare suffisamment les styles de la couche métier. J'ai dû jouer du copier/coller avec NotePad++. Mais je ne sais pas encore si elle est généralisable. D'une part, le copier/coller est pénible dans le fichier.style, et d'autre part si j'ai bien lu, certains composants sont limités en matière de "stylisation" ou en sont dénués.

Un site à mémoriser précieusement : http://monkeystyler.com/guide/TStyleManager

On y apprend comment appeler son fichier.style. On peut le définir Form par Form.

Code :

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

TStyleManager.SetStyleFromFile('c:\mystyle.style');

Curieusement, l'unit FMX.Styles (pour utiliser TStyleManager) n'est pas placée par défaut dans les uses de la Form même si un TSyleBook est déjà placé dessus??? Et donc, il faut le faire à la main.

Ceci dit, tout semble bien fonctionner pendant un certain temps avant que ne s'affiche Exception EInvalidPointer dans le module Project2.exe en 0000777D. Opération de pointeur incorrecte. Pourquoi ? Trop tôt pour le dire.

On y découvre des approximations graphiques que je ne sais pas corriger pour l'instant. Mais pour moi, c'est quand même une satisfaction. Cela indique déjà que j'ai un peu progressé ! Pour vérifier, basiquement, j'ai pris un TEdit, changé dans son style associé, uniquement sa couleur de foreground et mis en "bold" puis enregistré dans mon fichier.style. Son TStyleLockup est bien pris en compte par le programme... Et voici ce que j'obtiens en saisie. J'ai tapé séquentiellement la séquence "abcdefghij" sans toucher à rien :

Il faut regarder le curseur. Normalement, à chaque fois le curseur devrait être en bout de ligne. Mais plus je saisis, plus il se décale. Image 3, le curseur devrait être placé après le f et, image 4 après le j. Mais cela, c'est peu important pour l'instant. Si c'est un bug, cela doit être corrigeable.

Je suis plus inquiet pour l'exception. Cela peut indiquer que mon code et/ou ma pratique sont inadaptés.
On continue donc....

[SergioMaster]

Bonjour,

je vois que tu avances
un autre site à mémoriser , si tu ne l'a déjà découvert, c'est celui-ci http://www.tindex.net/FireMonkey/Styles.html

[Invité]

Bonjour Serge,

Merci, excellent site qui me permet un nouveau progrès : je viens de comprendre qu'on peut travailler avec plusieurs StyleBook sur une même Form et les chaîner ! En clair cela veut dire que tu peux utiliser un style général (exemple C:\Program Files\Embarcadero\Studio\15.0\Redist\styles\Fmx\Transparent.Style) comme on fait usuellement et l'updater avec un autre TStyleBook qui charge ton propre fichier qui ne contient QUE tes modifications ou tes ajouts. Cela va réduire grandement l'usage de notepad++. C'est la partie relative au Mac et au "retina ou non" qui m'en a donné l'idée,

Set the HiResStyleBook property of the StyleBook2 component to StyleBook1.
Set the StyleBook property of the form to StyleBook2.

du lien vers lequel marcocantu réoriente ses lecteurs après avoir schématiquement précisé cette possibilité. Après une petite vérification sur mon programme de base, je vois bien le style en question -encore un truc pour tablette (ie pas mon style, c'est hideux)- et mes modifications. Par contre, j'ai toujours ce message d'erreur de pointeur... et mon Delphi se déstabilise. J'ai de nombreux messages d'erreurs au lancement même si finalement l'IDE s'ouvre. Comme c'est une version trial, je ne sais pas si je peux la réinstaller... Je ne tente pas le coup tant que j'arrive à la lancer.

Quelqu'un sait-il s'il est possible de placer des commentaires dans les fichiers.style ? "Ils" auraient pu retenir un format standard (xml ou autre). Là, il n'y a que les décalages comme points de repères.

C'est qui ce "marcocantu" ?... Ce n'est pas le premier article que je lis de lui. Je crois que tu m'en avais déjà parlé, mais je ne me souviens plus. S'il n'est pas chez Embarcadero, il ferait bien de le recruter... et s'il l'est, de lui confier la documentation et sa publication

Serge, je fignole et je reproduis de A à Z le projet à partir d'un projet vierge... et je te l'envoie pour test (probablement demain*) : est-ce que cette erreur de pointeur est due à mon environnement ou est-elle intrinsèquement liée au projet ? A priori, si j'en crois ma doc, mon code est compatible XE6-XE7.

J'espère que mon XE7 va tenir toute la journée... Je commence à y reprendre beaucoup de plaisir.
Bonne fin de WE.

*J'ai également un petit truc sympa à régler sous Qt 5 : détecter sou Nux quel est l'environnement graphique de l'utilisateur (Gnome, KDE...). J'alterne Delphi et Qt : cela maintient relax et permet aux idées de "maturer" en arrière plan.

[SergioMaster]

Re,

C'est qui ce "marcocantu" ?... Ce n'est pas le premier article que je lis de lui. Je crois que tu m'en avais déjà parlé, mais je ne me souviens plus. S'il n'est pas chez Embarcadero, il ferait bien de le recruter... et s'il l'est, de lui confier la documentation et sa publication

Je te rassure Marco a été recruté il y a de cela 2 ou 3 ans , c'est le monsieur Europe , mais bien avant cela auteur de nombreux livres sur Delphi (le Paul Toth italien) je te renvoie sur son site http://www.marcocantu.com/ ou son blog http://blog.marcocantu.com/ et bien d'autres interventions depuis son recrutement (webinars) plus facilement compréhensibles (je parle de son expression orale) que celles de David I.

[Paul TOTH]

Quelqu'un sait-il s'il est possible de placer des commentaires dans les fichiers.style ? "Ils" auraient pu retenir un format standard (xml ou autre). Là, il n'y a que les décalages comme points de repères.

non un fichier Style n'est rien d'autre qu'un DFM/FMX, on vient le tripatouiller à la main faute d'un éditeur efficace, mais ce n'est pas le but au départ...si on compare à Android par exemple, il est souvent plus simple de modifier le layout XML à la main, alors qu'il est assez rare d'aller dans le DFM de Delphi.

[Invité]

Bonjour,

je butte sur un problème idiot. Si je chaine mes 2 TStylebook en ayant choisi un style général C:\Program Files\Embarcadero\Studio\15.0\Redist\styles\Fmx\Transparent.Style proposé par Embaracadero, cela fonctionne. Mais si je veux utiliser le style standard de la Form (= no style), si je chaine mon propre fichier contenant uniquement mes modifications alors le fond de la Form, fond qui n'est défini nulle part, devient noir.... Donc, je ne peux pas utiliser le chaînage dans ces conditions à moins de posséder un fichier.style qui correspond à "no style" en réalité (i.e. l'apparence par défaut)...