Discussion :

[naute]

Bonjour .

Dans le cadre de la migration d'un petit soft de Windows/Delphi vers GNU-Linux/Lazarus, et comme une partie du graphisme va être à réécrire, je me pose la question du choix de la surface de dessin :

• TImage
• TPaintBox
• TPanel

Ma question est simple : quels sont les critères à prendre en considération pour effectuer un choix pertinent?

La réponse est peut-être plus compliquée .

Merci de vos avis,
amicalement,
naute.

[jurassic pork]

hello,
un autre candidat le TBGRAGraphicControl qui fait partie de la bibliothèque BGRABITMAP voir ici ce que dit BeanzMaster
Gilles Vasseur a écrit dans son tuto : Apprendre à dessiner des rectangles - BGRABitmap avec Lazarus :

Alors, qu'apporte la bibliothèque BGRABitmap ?

La première lacune de la LCL, et elle est de taille, est de ne pas incorporer d'anticrénelage afin de rendre le dessin plus lisse, sans effet d'escalier pour les lignes obliques.
La seconde différence importante entre la bibliothèque LCL et celle fournie par BGRABitmap est la transparence que propose la dernière.

Ami calmant, J.P

[Jipété]

Salut,

j'ai fait la manip suivante ; poser un TImage, un TPanel et un TPaintBox sur une fiche, et dans cette partie de unit1.pas,

Code :

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

1
2
3
4
5
6
7
8
type
 
  { TForm1 }
 
  TForm1 = class(TForm)
    Image1: TImage;
    PaintBox1: TPaintBox;
    Panel1: TPanel;

j'ai fait Ctrl-clic sur chacun des trois types, à tour de rôle, ce qui m'a donné ;

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
  TImage = class(TCustomImage)
  //Ctrl-clic envoie là :
    TCustomImage = class(TGraphicControl)
    public
      property Canvas: TCanvas read GetCanvas;
 
 
  TPaintBox = class(TGraphicControl)
  //Ctrl-clic envoie là :
    TGraphicControl = class(TControl)
    public
      property Canvas: TCanvas read FCanvas;
 
 
  TPanel = class(TCustomPanel)
    TCustomPanel = class(TCustomControl)
      TCustomControl = class(TWinControl)
      public
        property Canvas: TCanvas read FCanvas write FCanvas;

Et dans les 3 cas un Ctrl-clic sur TCanvas envoie toujours là :

Code :

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

1
2
Graphics
   TCanvas = class(TFPCustomCanvas)

Conclusion : sous des noms ronflants proposant des propriétés diverses et variées, la mécanique cachée dessous est toujours la même.

Perso j'utilise le TPanel comme un container pour d'autres objets, le TImage pour afficher des... images, ben oui, et le TPaintBox pour dessiner, aventure dans laquelle je ne me suis pas encore lancé.

[Paul TOTH]

Bonjour .

Dans le cadre de la migration d'un petit soft de Windows/Delphi vers GNU-Linux/Lazarus, et comme une partie du graphisme va être à réécrire, je me pose la question du choix de la surface de dessin :

• TImage
• TPaintBox
• TPanel

Ma question est simple : Quels sont les critères à prendre en considération pour effectuer un choix pertinent?

La réponse est peut-être plus compliquée .

Merci de vos avis,
amicalement,
naute.

si possible, le mieux est de se baser sur TCanvas pour tout, peu importe a qui il appartient (y compris TPrinter)

sinon TPanel est un objet Windows qui possède son propre Handle et son propre Canvas
TPaintBox est une zone rectangulaire à l'intérieur de son parent (un TPanel par exemple), c'est une sorte de clipping sur son parent
TImage c'est pas loin d'être un TPaintBox sauf qu'il dessine une image, donc le dessin est persistant.

En effet, un canvas est à l'écran ce que le crayon est au papier, un moyen pour dessiner. Si on ne veux pas refaire le dessin à chaque "OnPaint" il faut stocker le résultat dans une image qu'on recalculera si nécessaire (redimensionnement par exemple). Par contre les images prennent de la mémoire, donc c'est une question de balance entre consommation CPU (complexité du dessin) et consommation mémoire (taille de l'image).

[naute]

Bonjour à tous .

@ jurassic pork

L'anti-crénelage est, certes, un atout esthétique, mais est-ce qu'il ne risque pas de perturber un remplissage effectué avec un FloodFill() dans la zone où il opère?

Je ne sais pas comment il travaille, mais apparemment, il encadre la ligne avec un dégradé (transparent?) pour faire une transition douce entre la couleur de cette ligne et celle du fond. Quand je rempli avec une autre couleur, est-ce que la nouvelle couleur est prise en compte dans l'affichage de la transition? Parce que sinon, ça risque de ne pas être très joli.

@ jipété

Je ne savais pas que plusieurs TCanvas différents avaient pu être implémentés . Quel aurait été l’intérêt? En plus, sauf erreur, mais là je m'aventure un peu, tous les composants visuels s'auto-dessinent, si je puis dire, sur leur propre Canvas, même si celui-ci n'est pas accessible à l'utilisateur. Je suppose qu'il s'agit toujours du même TCanvas. Ou non? Ou je n'ai pas bien compris ce que tu voulais dire .

@ Paul TOTH

Dans la mesure où je n'affiche pas, à proprement parler, une image (provenant d'un fichier par exemple) mais où je dessine (à l'aide de procédures du genre LineTo()), j'ai l'impression, d'après ce que tu me dis, que TImage et TPaintBox seront d'un usage identique dans mon cas.

Reste l'intérêt (ou non) du TPanel. Mon graphisme est simple : Il s'agit à la base d'une grille de 4 colonnes sur 366 rangées. Comme elle ne tient pas dans l'écran, je dois la faire défiler dans le sens vertical. Ce défilement induit des instabilités dans l'affichage, atténués par DoubleBuffered=True; mais pas supprimées. Est-ce qu'utiliser un TPanel résoudrait le problème?

De toute manière, comme tu le dis, le travail se fera sur un TCanvas

Merci pour vos interventions,
amicalement,
naute.

[Roland Chastain]

Bonjour ! Une petite précision.

un autre candidat le TBGRAGraphicControl qui fait partie de la bibliothèque BGRABITMAP

Pour être très exact, TBGRAGraphicControl fait partie de l'ensemble de composants BGRAControls, qui s'appuie effectivement sur BGRABitmap mais qui en est différent. Cette précision n'a peut-être pas grande importance, mais j'ai remarqué que la confusion est souvent faite, comme si on était forcé d'installer BGRAControls pour utiliser BGRABitmap, ce qui n'est pas le cas.

[naute]

Bonjour Roland .

comme si on était forcé d'installer BGRAControls pour utiliser BGRABitmap)

Si j'opte pour l'utilisation des composants BGRA* pour faire seulement du dessin, puis-je installer uniquement BGRAControls ou BGRABitmap est-il également requis? Et qu'en est-il du composant BGRAControlSFX?
De plus, est-ce que les composant BGRA* sont implémentés de la même manière, du moins en ce qui concerne leur utilisation, sous Windows et sous GNU-Linux, parce que, par exemple, il s'avère que la procédure FloodFill() de Lazarus est implémentée sous Windows mais pas sous GNU-Linux, voir le constat de Beanz Master.

Amicalement,
naute.

[Jipété]

Yop !

@ jipété

Je ne savais pas que plusieurs TCanvas différents avaient pu être implémentés . Quel aurait été l’intérêt? En plus, sauf erreur, mais là je m'aventure un peu, tous les composants visuels s'auto-dessinent, si je puis dire, sur leur propre Canvas, même si celui-ci n'est pas accessible à l'utilisateur. Je suppose qu'il s'agit toujours du même TCanvas. Ou non ? Ou je n'ai pas bien compris ce que tu voulais dire .

Je pense aussi.
J'ai dû mal m'exprimer : le canvas de chacun des 3 objets que tu suggères dérive de

Code :

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

1
2
Graphics
   TCanvas = class(TFPCustomCanvas)

En gros et dit autrement, c'est toujours le même canvas que tu vas trifouiller, quelque soit l'objet ancêtre qui le propose, mais 1 canvas par objet (je vois l'ambiguïté, là) : si tu as 10 TImage's chacun aura son canvas, et si tu as 4 TPainBox là aussi chacun aura son canvas, ces 14 canvas sont tous différents, autonomes, mais descendent tous du TFPCustomCanvas, donc les outils qui peuvent s'appliquer à l'un (brush, pen, etc.) pourront s'appliquer aux autres, indépendamment les uns des autres bien sûr (sinon ça serait un brave boxon ! )

sur leur propre Canvas, même si celui-ci n'est pas accessible à l'utilisateur.

Comment ça, pas accessible ?
Image1.Canvas existe, tout comme PaintBox1.Canvas et Panel1.Canvas. Kess tu veux de plus ?

[Roland Chastain]

Si j'opte pour l'utilisation des composants BGRA* pour faire seulement du dessin, puis-je installer uniquement BGRAControls ou BGRABitmap est-il également requis? Et qu'en est-il du composant BGRAControlSFX?

Pour dessiner, vous avez besoin de la bibliothèque BGRABitmap qui ne nécessite aucune installation. Les composants BGRA Controls sont basés sur BGRABitmap. Quant à BGRA Controls FX, c'est (si j'en crois cette discussion) un ensemble de composants basés sur BGRABitmap et OpenGL.

La bibliothèque BGRABitmap est multiplateforme. Quant aux composants BGRA Controls, je ne sais pas : je ne les utilise pas.

L'utilisation de BGRABitmap ne se justifie que si vous voulez dessiner avec anti-crénelage et transparence, ou utiliser je ne sais quelle autre technique de dessin sophistiquée. Tout dépend de ce que vous voulez faire exactement.

[naute]

En gros et dit autrement, c'est toujours le même canvas que tu vas trifouiller, quelque soit l'objet ancêtre qui le propose, mais 1 canvas par objet

Nous sommes donc bien d'accord.

Comment ça, pas accessible ?
Image1.Canvas existe, tout comme PaintBox1.Canvas et Panel1.Canvas. Kess tu veux de plus ?

Je me site. Je sais, ça fait un peu narcissique mais bon :

tous les composants visuels s’auto-dessinent, si je puis dire, sur leur propre Canvas, même si celui-ci n'est pas accessible à l'utilisateur.

Je parle des composants visuels en général. Prend(s) l'exemple d'un TButton qu'on va appeler Button1 (comme c'est original), sa propriété Button1.Canvas, qui existe forcément, n'est pas publiée, pas plus qu'un évènement genre Button1.OnDrawItem qui permettrait de le redessiner. Tu n'y a donc pas accès, ou du moins, je ne vois pas comment y accéder.

Edit : Je me site. Énorme! Je préfère ne pas le corriger : C'est trop gros .

[naute]

Pour dessiner, vous avez besoin de la bibliothèque BGRABitmap qui ne nécessite aucune installation.

Il faut quand même bien que j'installe le paquet, non? J'ai bien essayé, pour voir, de mettre BGRABitmap dans la clause uses, mais ça n'a rien donné, ce qui, je suppose, n'étonnera personne.

Les composants BGRA Controls sont basés sur BGRABitmap.
Quant à BGRA Controls FX, c'est (.../...) un ensemble de composants basés sur BGRABitmap et OpenGL.
La bibliothèque BGRABitmap est multiplateforme.

D'accord.

Quant aux composants BGRA Controls, je ne sais pas : je ne les utilise pas.

Donc à tester en ce qui me concerne.

L'utilisation de BGRABitmap ne se justifie que si vous voulez dessiner avec anti-crénelage et transparence, ou utiliser je ne sais quelle autre technique de dessin sophistiquée. Tout dépend de ce que vous voulez faire exactement.

Il est vrai que pour l'application en question, l'intérêt de cette bibliothèque n'est pas évident. Mais ça peut être utile de la connaître pour d'autres aventures .

Merci pour ces précisions,
amicalement,
naute.

[BeanzMaster]

Pour dessiner, vous avez besoin de la bibliothèque BGRABitmap qui ne nécessite aucune installation

Il faut quand même bien que j'installe le paquet, non? J'ai bien essayé, pour voir, de mettre BGRABitmap dans la clause uses, mais ça n'a rien donné, ce qui, je suppose, n'étonnera personne.

Toutes les bibliothèques NE nécessitent PAS d'installation. Les paquets sont juste là pour faire le lien avec celles-ci, pour retrouver et passer le chemin ou elles sont installées au compilateur. Et pour l'intégrations des composants avec l'EDI si ces dites bibliothèques en contiennent.

Dans la cas de BGRA, si tu copies les fichiers dans 'Lazarus\components\BGRABitmap :
1) Soit tu compile le paquet fournis avec. Qui est un paquet qui s'utilise à l'exécution et tu le rajoutes dans les dépendances de ton projet ce qui est le plus simple si tu utilises cette bibliothèque dans plusieurs projets.
2) Soit tu choisis de ne pas utilisé le paquet et là tu es obligé dans les options de ton projet "Options du compilateur --> Chemins --> autres fichiers unités" d'ajouter les dossiers ou tu as copié les fichiers de la bibliothèque en question (le mieux ici étant de les mettre dans un sous-dossier de ton projet)

Il est vrai que pour l'application en question, l'intérêt de cette bibliothèque n'est pas évident. Mais ça peut être utile de la connaître pour d'autres aventures .

Par rapport à ton projet de planning (je suppose que c'est ça) BGRABitmap t'évitera de tomber sur des OS comme avec floodfill. L'anti-crénelage est un atout esthétique, mais tu n'es pas obligé de l'utiliser. BGRABitmap te donnera également accès à d'autres possibilités comme les effets typographiques, le remplissage avec des dégradés ect.... De plus l'affichage sera plus rapide (quoique la procedure pour dessiner des lignes de BGRABitmap est plus lente que celle implanté nativement dans TCanvas)

Comme l'a suggéré Paul Toth tu peux directement utiliser l'Objet TCanvas, l'anavatage est que de là tu pourras l'envoyer directement sur le composant que tu souhaites TPanel, TPaintPox ou encore TPrinter pour l'impression.

A+

[naute]

@ Beanz Master

Je crois que je vais installer le paquet. Avec le Gestionnaire de paquets en ligne que tu m'a fais connaître dans un autre fil, c'est hyper simple, et BGRABitmap commence réellement à m'intéresser .

Un petit retour : Il semble qu'en dessinant sur un TPanel, je n'ai plus d'instabilité dans l'affichage lors du défilement, et cela même sans DoubleBuffered. À confirmer bien sûr avec le planning finalisé, mais on n'y est pas encore.

Merci à tous
amicalement,
naute.

Je passe en résolu mais si vous avez d'autres commentaires, il sont les bienvenus .

[jurassic pork]

hello,

À confirmer bien sûr avec le planning finalisé, mais on n'y est pas encore.

Merci à tous
amicalement,
naute.

Je passe en résolu mais si vous avez d'autres commentaires, il sont les bienvenus .

Juste par curiosité : Si ton application est du genre planning, pourquoi ne pas utiliser un composant du type TStringGrid (ou TDrawGrid) ou TsWorksheetGrid ( du paquet fpspreadsheet) ?

Ami calmant, J.P

[Paul TOTH]

Nous sommes donc bien d'accord.

pas moi les canvas sont potentiellement tous différents, le Canvas d'une imprimante n'est pas le même que la canvas d'un Bitmap qui n'est pas le même que le canvas qui dessine à l'écran, mais ils proposent tous les mêmes méthodes.

Je parle des composants visuels en général. Prend(s) l'exemple d'un TButton qu'on va appeler Button1 (comme c'est original), sa propriété Button1.Canvas, qui existe forcément, n'est pas publiée, pas plus qu'un évènement genre Button1.OnDrawItem qui permettrait de le redessiner. Tu n'y a donc pas accès, ou du moins, je ne vois pas comment y accéder.

Edit : Je me site. Énorme! Je préfère ne pas le corriger : C'est trop gros .

alors je ne connais pas Lazarus/Linux mais l'idée de la VCL est d'encapsuler les composants natifs, si je ne m'abuse avec Lazarus/Linux on choisie un framework (Gnome, KDE...) et ce sont les éléments de ce framework qui sont utilisés, comme sous Windows ce sont les BUTTON de Windows qu'on utilise...il reste possible de personnaliser et de dessiner sur ce composant système, mais au départ c'est pas Lazarus qui le dessine (contrairement à Firemonkey de Delphi qui par défaut dessine effectivement tout lui même)

[naute]

@ jurassic pork

C'est certainement possible, mais je ne sais pas comment redessiner une grille. Or là, sur un TCanvas, ça va à peu près. Donc...voilà. Pour te donner un exemple, tu peux, si tu veux, aller voir la capture d'un exemple de mon planning. Est-ce qu'on peut faire ça en modifiant un TCustomGrid (ou autre)?

pas moi les canvas sont potentiellement tous différents, le Canvas d'une imprimante n'est pas le même que la canvas d'un Bitmap qui n'est pas le même que le canvas qui dessine à l'écran, mais ils proposent tous les mêmes méthodes.

J'ignorai (comme plein d'autres choses, d'ailleurs). Mais effectivement, le fait qu'ils aient les mêmes méthodes, propriétés... du moins apparemment, me faisait penser qu'il s'agissait d'une seule et unique entité.

alors je ne connais pas Lazarus/Linux mais l'idée de la VCL est d'encapsuler les composants natifs, si je ne m'abuse avec Lazarus/Linux on choisie un framework (Gnome, KDE...) et ce sont les éléments de ce framework qui sont utilisés, comme sous Windows ce sont les BUTTON de Windows qu'on utilise...il reste possible de personnaliser et de dessiner sur ce composant système, mais au départ c'est pas Lazarus qui le dessine (contrairement à Firemonkey de Delphi qui par défaut dessine effectivement tout lui même)

Là, de toute manière, j'ai dit une grosse bêtise. TCanvas dérive de TPersistent et non pas de TComponant. Donc, à priori (?), TButton ne peut pas avoir de Canvas. Je dois reconnaître que tout ça n'est pas bien clair pour moi. Mais bon : ça n'empêche pas d'avancer . Au contraire, d'ailleurs. Moins on en sait, plus on a de chances d'apprendre .

Amicalement,
naute.

[Jipété]

Bonjour,

pas moi les canvas sont potentiellement tous différents,

Paul, va falloir que tu nous expliques, parce que j'ai fait la manip suivante : un TImage, un TPaintBox, un TPanel posés sur une fiche, et l'ajout de "Printers" dans le uses,


puis ces 4 lignes dans le FormCreate, et pour chacune un Ctrl-clic sur "Canvas" et ça donne, dans l'ordre, ça :

Code :

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

1
2
3
4
    property Canvas: TCanvas read GetCanvas;
    property Canvas;
    property Canvas: TCanvas read FCanvas write FCanvas;
    property Canvas: TCanvas read GetCanvas;

Ctrl-clic sur TCanvas des lignes 1, 3 et 4 envoie vers TCanvas = class(TFPCustomCanvas).
Quant à la 2^e ligne, il faut passer par une étape intermédiaire, TGraphicControl = class(TControl) où l'on trouve property Canvas: TCanvas read FCanvas; qui renvoie également sur la class(TFPCustomCanvas), sise dans graphics.pp.

Donc pour moi tous ces canvas spécialisés descendent d'un ancêtre commun situé dans la class(TFPCustomCanvas), jusqu'à preuve du contraire.
Ou je n'ai rien compris, ou on utilise les mêmes mots pour parler de choses différentes ?

[Paul TOTH]

Bonjour,


Paul, va falloir que tu nous expliques, parce que j'ai fait la manip suivante : un TImage, un TPaintBox, un TPanel posés sur une fiche, et l'ajout de "Printers" dans le uses,

ben c'est la base de la POO

toutes les variables pointent sur le type TCanvas, mais ce n'est pas cette déclaration qui est importante, c'est la façon dont ils sont créés (ici pour Windows)

TPanel -> TCustomControl.Create : FCanvas := TControlCanvas.Create;
TImage -> TGraphicControl.Create: FCanvas := TControlCanvas.Create;
TPaintBox -> TGraphicControl.Create: FCanvas := TControlCanvas.Create;

pour le coup c'est la même classe, par contre il faut regarder les nuances au niveau de TControlCanvas.CreateHandle qui fait la distinction entre TWinControl et TGraphicControl

pour TPrinter c'est un peu plus sioux mais on finit sur TPrinterCanvas normalement

[BeanzMaster]

pas moi les canvas sont potentiellement tous différents, le Canvas d'une imprimante n'est pas le même que la canvas d'un Bitmap qui n'est pas le même que le canvas qui dessine à l'écran, mais ils proposent tous les mêmes méthodes.

Bonjour,
Paul, va falloir que tu nous expliques, parce que j'ai fait la manip suivante : un TImage, un TPaintBox, un TPanel posés sur une fiche, et l'ajout de "Printers" dans le uses,

Ce que Paul veux dire, je penses que c'est par rapport à la surface de dessin. Un TPanel, TPaintBox peux avoir une aire de dessin différente par rapport à un TPrinter (une feuille A4 par exemple). Il faudra donc ajuster les dimensions, les postions en fonction de chaque entité dessinée. Une solution présente dans BGRABitmap est l'utilisation d'un Canvas vectoriel

alors je ne connais pas Lazarus/Linux mais l'idée de la VCL est d'encapsuler les composants natifs, si je ne m'abuse avec Lazarus/Linux on choisie un framework (Gnome, KDE...) et ce sont les éléments de ce framework qui sont utilisés, comme sous Windows ce sont les BUTTON de Windows qu'on utilise...il reste possible de personnaliser et de dessiner sur ce composant système, mais au départ c'est pas Lazarus qui le dessine (contrairement à Firemonkey de Delphi qui par défaut dessine effectivement tout lui même)

C'est exactement ça. Néanmoins, sous Lazarus il existe un paquet disponible nativement à installer "CustomDrawn" mais c'est loin d'être FireMonkey et les composants disponibles sont loin d'être finis et stables. C'est d'ailleurs pourquoi ils ne sont pas installés par défaut.

[jurassic pork]

hello,

C'est certainement possible, mais je ne sais pas comment redessiner une grille. Or là, sur un TCanvas, ça va à peu près. Donc...voilà. Pour te donner un exemple, tu peux, si tu veux, aller voir la capture d'un exemple de mon planning. Est-ce qu'on peut faire ça en modifiant un TCustomGrid (ou autre)?

Voici ce que l'on peut faire par exemple en utilisant un TStringGrid :


La première colonne des dates est remplie normalement par un :

Code :

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

1
2
3
4
5
6
7
8
9
10
var maDate: TDateTime;
begin
  madate:= StrToDateTime('01/01/2018 00:00');
  StringGrid1.RowHeights[0] := 50;
  For x:= 1 To 365 do
    begin
    StringGrid1.Cells[0,x] :=  FormatDateTime('dddd d mmmm yyyy',madate);
    madate := incDay(maDate,1);
    end;
end;

Les colonnes 1,2 et 3 sont remplies grâce à l'événement OnDrawCell du TStringGrid avec un code du genre :

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
procedure TForm1.StringGrid1DrawCell(Sender: TObject; aCol, aRow: Integer;
  aRect: TRect; aState: TGridDrawState);
var MyRect : TRect;
 function RectDeb(myRect: Trect): TRect;
   begin
       myRect.Left := myRect.Right - myRect.Width div 3;
       RectDeb := myRect;
   end;
 function RectFin(myRect: Trect): TRect;
   begin
       myRect.Width := myRect.Width div 3;
       RectFin := myRect;
   end;
 
begin
  if (aRow > 0 ) And (aCol > 0) then         //Use DrawCell to paint rectangle
    begin//
      if Reserv[aCol,aRow].nom <> '' then
        begin
          if aCol = 1 then
            TStringGrid(Sender).canvas.Brush.Color :=  frGite1
          else if  aCol = 2 then
            TStringGrid(Sender).canvas.Brush.Color :=  frGite2
          else   TStringGrid(Sender).canvas.Brush.Color :=  frGite3;
          if Reserv[aCol,aRow].jourdeb = aRow then
            TStringGrid(Sender).canvas.FillRect(RectDeb(Arect));
          if Reserv[aCol,ARow].jourfin = aRow then
            TStringGrid(Sender).canvas.FillRect(RectFin(Arect));
          if (Reserv[aCol,aRow].jourdeb <> aRow) And
             ( Reserv[aCol,ARow].jourfin <> aRow) Then
              TStringGrid(Sender).canvas.FillRect(ARect);
          TStringGrid(Sender).canvas.FillRect(myRect);   //Paint Cell
          if Reserv[aCol,ARow].jouraffiche = aRow then
             TStringGrid(Sender).Canvas.TextOut(aRect.Left + 40, aRect.Top + 2,
               Reserv[aCol,aRow].nom);
         end;
    end;
end;

Pour pouvoir remplir quelques jours j'ai créé sans trop réfléchir un tableau reserv :

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
    typereserv = record
    nom : String;
    jourdeb : integer;
    jourfin : integer;
    jouraffiche : integer;
  end;
const
   CoulFonte = clBlack;
   NbJours = 366;              // Nombre de jours à afficher sur le planning
   FrGite1 = $00DDDDFF;        // Couleurs des fonds gîtes libres
   FrGite2 = $00FFDDDD;
   FrGite3 = $00C8C8C8;
 
var
  Form1: TForm1;
  reserv: Array[1..3,1..366] of typereserv;

initialisé dans le FormCreate avec quelques valeurs :

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
  reserv[1,8].jourdeb := 8;
  reserv[1,8].nom := 'LOCATAIRE TATA';
  reserv[1,9].nom := 'LOCATAIRE TATA';
  reserv[1,10].nom := 'LOCATAIRE TATA';
  reserv[1,11].nom := 'LOCATAIRE TATA';
  reserv[1,11].jourAffiche := 11;
  reserv[1,12].nom := 'LOCATAIRE TATA';
  reserv[1,13].nom := 'LOCATAIRE TATA';
  reserv[1,13].jourfin := 13;
  reserv[2,10].jourdeb := 10;
  reserv[2,10].nom := 'LOCATAIRE TITI';
  reserv[2,11].nom := 'LOCATAIRE TITI';
  reserv[2,11].jourAffiche := 11;
  reserv[2,12].nom := 'LOCATAIRE TITI';
  reserv[2,12].jourfin := 12;
  reserv[3,15].jourdeb := 15;
  reserv[3,15].nom := 'LOCATAIRE TOTO';
  reserv[3,16].nom := 'LOCATAIRE TOTO';
  reserv[3,17].nom := 'LOCATAIRE TOTO';
  reserv[3,18].nom := 'LOCATAIRE TOTO';
  reserv[3,19].nom := 'LOCATAIRE TOTO';
  reserv[3,19].jourAffiche := 19;
  reserv[3,20].nom := 'LOCATAIRE TOTO';
  reserv[3,21].nom := 'LOCATAIRE TOTO';
  reserv[3,22].nom := 'LOCATAIRE TOTO';
  reserv[3,22].jourfin := 22;
  reserv[3,22].jourdeb := 22;
  reserv[3,23].nom := 'LOCATAIRE TUTU';
  reserv[3,23].jourAffiche := 23;
  reserv[3,24].nom := 'LOCATAIRE TUTU';
  reserv[3,24].jourfin := 24;

Je suppose que tu utilises une base de données pour gérer les locataires ?

Quelque chose m'intrigue : Comment Affiches-tu le nom d'un locataire quand il n'a pris q'une nuitée ?

Ami calmant, J.P