Bonjour,

partant de l'exemple cité en titre, je me suis concentré sur le DrawTest et j'ai fait plein d'essais.

Il en résulte cette image, qui permet en plus de comparer Linux à gauche avec Laz 1.4 et XP à droite avec Laz 1.8.2
Nom : compar_drawtest.jpg Affichages : 339 Taille : 180,8 Ko

Ceux qui sont à la pointe de la technologie pourront jouer avec le code ci-après, pour vérifier mes rendus, et c'est très simple :
une fiche de 570 par 620, affecter l'événement OnPaint, y coller ce qui suit :
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
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
procedure TfrmDraw.FormPaint(Sender: TObject); // une fiche 570x620
var
  Bmp: TBitmap;
begin
  Bmp := TBitmap.Create;
  Bmp.Width := 50;
  Bmp.Height := 50;
 
  Canvas.CopyMode := cmSrcCopy; // nécessaire sinon dessins pas redessinés si fiche masquée puis démasquée
 
  //Bmp.Canvas.Pen.Width := 6; // = bordure, donc div 2 tout autour, au final
  //Bmp.Canvas.Pen.Color := clRed; // il semblerait que l'utilisation de .Pen
  // en plus de .Brush impacte le rendu de .Rectangle qui n'a plus besoin des -1
  Bmp.Canvas.Pen.Style:=psClear;
//  Bmp.Canvas.Pen.Style:=psInsideFrame;// pratique en tests pour voir où commencent les objets
  // InsideFrame en haut à gauche et OutsideFrame en bas à droite s'il y a la place
 
  Bmp.Canvas.Brush.Color := clRed;
  //                   L, T,  R,   B  -- R et B par rapport au rectangle et PAS W H
  Bmp.Canvas.Rectangle(0, 0, 149, 149);
  // un .Rectangle commence à L et finit à R : si R < à L alors le rectangle "revient sur ses pas"
 
  Bmp.Canvas.Brush.Color := clYellow;
  Bmp.Canvas.FillRect(Rect(13, 0, 149, 149)); // semble identique à dessous
  //Bmp.Canvas.Rectangle(13, 0, 150, 150); // en effet, pas vu de diff.
 
  Bmp.Canvas.Brush.Color := clBlue;
  Bmp.Canvas.Rectangle(5, 10, 30, 20);
 
  Bmp.Canvas.Brush.Color := clMoneyGreen;
  Bmp.Canvas.Rectangle(25, 15,  3, 25); //rect commence à 25 et finit à  3 donc 21 d'occupation
  Bmp.Canvas.Rectangle(25, 30,  3, 35); //rect commence à 25 et finit à  3 donc 21 d'occupation
  Bmp.Canvas.Rectangle( 3, 40, 25, 45); //rect commence à  3 et finit à 25 donc 21 d'occupation
 
  //Canvas.Draw(10,40, Bmp); Exit;
  // fin construction Bmp -- vérifs :
               //       L,  T, R,  B de la dest /!\ /!\
  Canvas.CopyRect(Rect(10,250,60,300), Bmp.Canvas, Bmp.Canvas.ClipRect);
  // Basic, dessiné sous les deux lignes dessinées + bas par BrushCopy
  //Bmp.SaveToFile('c:\bmptest.bmp');
 
  //////////////////////////////////////////////////////////////
  // Tests BrushCopy  //////////////////////////////////////////
  Canvas.Brush.Color := clSkyBlue; // couleur de bg de Canvas.Brushcopy.Dest
 
  // la zone de texte
  Canvas.TextOut(70, 30, 'CopyBrush simple');// L T, le reste s'adapte
 
  // le carré
  //                      position  taille
  // Dest                    L   T   W   H   Src        origine  dim WxL  Transp Color
  // Transp Color = faux nom --> Zone transparente repérée par la couleur donnée
  // parce que dans le Bmp le bleu est sur le jaune qui est sur le rouge
  // mon gars, arrête de voir des couleurs empilées, elles sont côte à côte dans le Bmp.
  Canvas.BrushCopy(Bounds(  10, 50, 50, 50), Bmp, Bounds( 0,  0, 50, 50), clNone);
  Canvas.BrushCopy(Bounds(  70, 50, 50, 30), Bmp, Bounds( 0,  0, 50, 50), clBlue);
  Canvas.BrushCopy(Bounds( 130, 50, 50, 40), Bmp, Bounds( 0,  0, 50, 50), clRed);
  Canvas.BrushCopy(Bounds( 190, 50, 50, 50), Bmp, Bounds( 0,  0, 50, 50), clYellow);
  Canvas.BrushCopy(Bounds( 250, 50, 50, 50), Bmp, Bounds(10, 10, 30, 20), clYellow);
  Canvas.BrushCopy(Bounds( 310, 50, 50, 50), Bmp, Bounds(10, 20, 30, 20), clNone);// A 5-45
  Canvas.BrushCopy(Bounds( 370, 50, 50, 50), Bmp, Bounds(10, 20, 15, 25), clNone);// B 10-40
  Canvas.BrushCopy(Bounds( 430, 50, 50, 50), Bmp, Bounds(00, 00, 15, 50), clNone);// C
  Canvas.BrushCopy(Bounds( 490, 50, 50, 50), Bmp, Bounds(02, 00, 12, 50), clNone);// D 4-42-4
 
  Canvas.BrushCopy(Bounds( 10, 150, 25, 35), Bmp, Bounds(02, 00, 12, 50), clNone);// E
  Canvas.BrushCopy(Bounds( 70, 150, 25, 35), Bmp, Bounds(00, 00, 50, 50), clNone);//
  Canvas.BrushCopy(Bounds(130, 150, 25, 50), Bmp, Bounds(00, 00, 50, 20), clNone);//
  Canvas.BrushCopy(Bounds(190, 150, 20, 20), Bmp, Bounds(00, 00, 50, 50), clNone);// floue
  Canvas.BrushCopy(Bounds(250, 150, 20, 20), Bmp, Bounds(00, 00, 50, 50), clBlue);// floue
  Canvas.BrushCopy(Bounds(310, 150, 20, 20), Bmp, Bounds(00, 00, 20, 20), clNone);// nette
  Canvas.BrushCopy(Bounds(370, 150, 20, 20), Bmp, Bounds(00, 00, 20, 20), clBlue);// nette
  // la Dest est remplie avec la nouvelle couleur de Brush
  // et la transparence s'applique à la Dest
  // Bounds Src : si on ne prend pas tout, ça génère des zones noires -- pas reproduit
  // A : on commence à 10 et on prend 30 qu'on agrandit à 50 : ça donne  5-45
  // B : on commence à 10 et on prend 15 qu'on agrandit à 50 : ça donne 10-40
  // C : on commence à  0 et on prend 15 qu'on agrandit à 50 : ça donne 10-33-7
  // D: je démarre à 2 (sur 3) et j'en prends 12, soit 1R+10B+1J --> 4-42-4
  // E: le fait de demander W 25 en dest --> on dirait que la source est comprimée
  // à CONFIRMER !!!
 
  {  Makes a stretch draw operation while substituting a color of the source bitmap
  with the color of the brush of the canvas }
  Canvas.Brush.Color := clPurple; // va remplacer la couleur repérée par Transp Color
  Canvas.BrushCopy(Bounds(  70, 250, 50, 50), Bmp, Bounds( 0,  0, 50, 50), clBlue);
  Canvas.Brush.Color := clNone; // = blanc
  Canvas.BrushCopy(Bounds( 130, 250, 50, 50), Bmp, Bounds( 0,  0, 50, 50), clBlue);
 
  // les 2 autres textes de l'exemple d'origine
  //  Canvas.Brush.Color := clYellow;// orig
  Canvas.Brush.Color := clRed; // remonté ici
  Canvas.TextOut(200, 230, 'CopyBrush stretch');// L T
  Canvas.BrushCopy(Bounds(200, 250, 20, 20), Bmp, Bounds(0, 0, 50, 50), clBlue);// orig
  // --> Bmp d'origine stretched en 20x20
  //Canvas.BrushCopy(Bounds(200, 250, 20, 20), Bmp, Bounds(0, 0, 10, 10), clBlue);
 
  //Canvas.Brush.Color := clGreen; // remonté ici
  Canvas.Brush.Color := clYellow;// orig
  Canvas.TextOut(350, 230, 'CopyBrush SrcRect');// L T
  //Canvas.BrushCopy(Bounds(350, 250, 20, 20), Bmp, Bounds(30, 30, 20, 20), clBlue);// orig
  // petite image toute jaune : on commence à 30,30, on prend 20x20 c'est tout jaune
  Canvas.BrushCopy(Bounds(350, 250, 20, 20), Bmp, Bounds(5, 5, 20, 20), clBlue);
  // on commence à 5,5, on prend 20x20 et le clBlue est remplacé par Brush.Color
  // copie 1/1 de la partie choisie
//exit;
 
 
  // CopyMode line 1
 
  Canvas.TextOut(50, 330, 'cmBlackness');
  Canvas.CopyMode := cmBlackness;
  Canvas.Draw(50, 350, Bmp);
 
  Canvas.TextOut(150, 330, 'cmDstInvert');
  Canvas.CopyMode := cmDstInvert;
  Canvas.Draw(150, 350, Bmp);
 
  Canvas.TextOut(250, 330, 'cmMergeCopy');
  Canvas.CopyMode := cmMergeCopy;
  Canvas.Draw(250, 350, Bmp);
 
  Canvas.TextOut(350, 330, 'cmMergePaint');
  Canvas.CopyMode := cmMergePaint;
  Canvas.Draw(350, 350, Bmp);
 
  Canvas.TextOut(450, 330, 'cmNotSrcCopy');
  Canvas.CopyMode := cmNotSrcCopy;
  Canvas.Draw(450, 350, Bmp);
 
  // CopyMode line 2
 
  Canvas.TextOut(50, 430, 'cmNotSrcErase');
  Canvas.CopyMode := cmNotSrcErase;
  Canvas.Draw(50, 450, Bmp);
 
  Canvas.TextOut(150, 430, 'cmPatCopy');
  Canvas.CopyMode := cmPatCopy;
  Canvas.Draw(150, 450, Bmp);
 
  Canvas.TextOut(250, 430, 'cmPatInvert');
  Canvas.CopyMode := cmPatInvert;
  Canvas.Draw(250, 450, Bmp);
 
  Canvas.TextOut(350, 430, 'cmPatPaint');
  Canvas.CopyMode := cmPatPaint;
  Canvas.Draw(350, 450, Bmp);
 
  Canvas.TextOut(450, 430, 'cmSrcAnd');
  Canvas.CopyMode := cmSrcAnd;
  Canvas.Draw(450, 450, Bmp);
 
  // CopyMode line 3
 
  Canvas.TextOut(50, 530, 'cmSrcCopy');
  Canvas.CopyMode := cmSrcCopy;
  Canvas.Draw(50, 550, Bmp);
 
  Canvas.TextOut(150, 530, 'cmSrcErase');
  Canvas.CopyMode := cmSrcErase;
  Canvas.Draw(150, 550, Bmp);
 
  Canvas.TextOut(250, 530, 'cmSrcInvert');
  Canvas.CopyMode := cmSrcInvert;
  Canvas.Draw(250, 550, Bmp);
 
  Canvas.TextOut(350, 530, 'cmSrcPaint');
  Canvas.CopyMode := cmSrcPaint;
  Canvas.Draw(350, 550, Bmp);
 
  Canvas.TextOut(450, 530, 'cmWhiteness');
  Canvas.CopyMode := cmWhiteness;
  Canvas.Draw(450, 550, Bmp);
 
  Bmp.Free;
end;
F9 et ouvrir ses yeux tout en lisant le code et ses commentaires.
Puis "s'approprier" le code et pour ça, une seule manière, modifier un paramètre (une couleur, une dimension), F9 et comparer avec avant.

Ensuite, en se concentrant sur la partie basse, les trois lignes reprennent l'exemple de base sans traficotages et heureusement que j'ai une loupe quand je bidouille ce genre de choses, ça m'a permis de découvrir des rendus à la limite de la visibilité, qui apparaîssent mieux en éclaircissant ou assombrissant les couleurs et, franchement, je ne sais pas trop à quoi ça peut servir ni comment l'utiliser, surtout qu'il y a des différences entre les OS...
Nom : forcer_couleurs.jpg Affichages : 291 Taille : 123,0 Ko

En haut l'original copié/collé depuis le bas de l'image précédente, au milieu la même chose mais éclaircie et en bas assombrie, et on remarque que certaines couleurs quasiment invisibles "montent" (on se croirait dans un labo photo à l'époque des agrandisseurs, si vous avez connu).
Comparez les 3es lignes : ce qui est (donc à la limite du) blanc ou noir dans l'original devient visible.

Note : il n'y a que les 4 premières colonnes, la 5e à droite toute n'apportant rien.

Voilà,