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
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
| using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing.Printing;
using System.Drawing;
using System.Windows.Forms;
namespace FactuLite
{
//////////////////////////////////////////////////////////////////////////////////////////////////
// CLASSE QUI PERMET D'IMPRIMER UN TEXTE AU FORMAT RTF //
//////////////////////////////////////////////////////////////////////////////////////////////////
//-----------------------------------------------------------------------------------------------
// Microsoft fourni une méthode d'impression basée sur l'API USER32.DLL (SendMessage), mais cette
// méthode ne permet pas de calculer la hauteur que prend le texte.
// Cette méthode-ci se base sur l'utilisation d'un RichTextBox invisible qu'on utilise pour
// récupérer les caractéristiques de la fonte et du style caractère par caractère, ce qui permet
// de gérer toutes les fonctionnalités.
// Le traitement est accéléré du fait que le Richtextbox est invisible. Si on utilise un visible,
// le rendre invisible avant le traitement et le rendre visible de suite après, le changement
// d'état n'est pas visible (pas de clignotement)
// Pas besoin de Idisposable : rien à détruire, on n'utilise que des pointeurs vers des valeurs
// reçues en paramètre
//-----------------------------------------------------------------------------------------------
/// <summary>Classe permettant d'imprimer un RichTextBox</summary>
public class ImprimerRTF
{
//////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////
// ATTRIBUTS //
//////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////
PrintPageEventArgs pea; // contexte d'environnement d'impression de page
Font fonte; // fonte de substitution
int limGauche; // limite gauche du texte
int limDroite; // limite droite du texte
int PosY; // ordonnée de la prochaine ligne
RichTextBox rtb; // RichTextBox ouvert sur une forme mais invisible
// qui va servir à manipuler le texte rtf
Graphics gfx; // Zone graphique d'affichage
private Brush Noir = Brushes.Black; // couleur noire
//////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////
// PROPRIETES //
//////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////
// CONSTRUCTEURS //
//////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////
//--------------------------------------------------------------------------------------------
/// <summary>Constructeur d'un objet d'impression de RichTextBox</summary>
/// <param name="e">Contexte d'environnement d'impression de page</param>
/// <param name="rtb">RichTextBox invisible ouvert sur une forme</param>
/// <param name="fonte">fonte de substitution, ou null si aucune</param>
/// <param name="posY">Ordonnée de la première ligne de texte</param>
/// <param name="limiteGauche">Limite gauche du texte par rapport à la marge gauche</param>
/// <param name="limiteDroite">Limite droite du texte par rapport à la marge gauche</param>
//--------------------------------------------------------------------------------------------
public ImprimerRTF(PrintPageEventArgs e, RichTextBox rtb, Font fonte, int posY, int limiteGauche, int limiteDroite)
{
this.pea = e; // affecter les paramètres reçus
this.rtb = rtb;
this.fonte = fonte;
this.PosY = posY;
this.limGauche = limiteGauche;
this.limDroite = limiteDroite;
gfx = e.Graphics;
}
//--------------------------------------------------------------------------------------------
/// <summary>Constructeur d'un objet d'impression de RichTextBox</summary>
/// <param name="e">Contexte d'environnement d'impression</param>
/// <param name="rtb">RichTextBox invisible ouvert sur une forme</param>
/// <param name="fonte">Fonte de substitution</param>
/// <param name="posY">Ordonnée de début d'impression</param>
//--------------------------------------------------------------------------------------------
public ImprimerRTF(PrintPageEventArgs e, RichTextBox rtb, Font fonte, int posY)
: this(e, rtb, fonte, posY, 0, e.MarginBounds.Right - e.MarginBounds.Left) { }
//--------------------------------------------------------------------------------------------
/// <summary>Constructeur d'un objet d'impression de RichTextBox</summary>
/// <param name="e">Contexte d'environnement d'impression</param>
/// <param name="rtb">RichTextBox invisible ouvert sur une forme</param>
//--------------------------------------------------------------------------------------------
public ImprimerRTF(PrintPageEventArgs e, RichTextBox rtb)
: this(e,rtb,null,0) {}
//////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////
// METHODES //
//////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////
// EXECUTER L'IMPRESSION OU LE CALCUL DU TEXTE RTF //
//////////////////////////////////////////////////////////////////////////////////////////////
//--------------------------------------------------------------------------------------------
// Cette méthode permet d'imprimer un texte RTF (print = true), ou de calculer sa hauteur (false)
//
// REMARQUES :
// -----------
// La manipulation des sélections ne fonctionne que si le RichTextBox a le focus.
// Il doit donc physiquement être présent sur une form ouvert, même invisible.
// Ca explique qu'on ne puisse pas créer ce RitchTextBox ici, car il serait créé mais pas ouvert
//
// Si le RichTextBox est invisible, la vitesse de traitement des sélections est supérieure
//
// Lorsqu'on mesure la largeur d'un texte avec MesureString, les espaces en fin de mot ne sont
// pas pris en compte. Par contre, ceux en début de mot bien, ce qui explique la méthode utiisée
// Toujours dans MesureString, la taille d'un espace est ajoutée automatiquement pour que la
// taille tienne compte d'un espace inter-mot.
//
// Si on tente d'imprimer mot par mot (plus simple que de faire des groupes), l'espace entre
// les différents mots ne dispose pas de la fonte. Ainsi, il est impossible d'imprimer un
// espace souligné si on procède de cette façon.
//--------------------------------------------------------------------------------------------
private int Executer(string TextRtf, bool print)
{
Font fontSel = null; // fonte du groupe de mot sélectionné
float PosX = (float)limGauche; // abcisse actuelle d'impression du prochain groupe de mots
int debutMot; // Position du début du mot suivant dans le texte à imprimer
int longMot; // Nombre de caractères du mot actuel
bool retour; // indique qu'on demande un passage à la ligne
int LongTotaleText; // longueur totale du texte à imprimer en caractères
char car; // caractère lu
bool carTrouv; // caractère trouvé autre que séparateur
int longGroupe; // nombre de caractères dans le groupe
int debutGroupe = 0; // position du début du groupe dans le texte total
bool finGroupe; // signale qu'on a délimité un groupe
Font fonteLue; // fonte du mot qu'on tente d'intégrer au groupe
string texte; // texte à imprimer
int TailleMax = 0; // interligne de la plus grande fonte de la ligne
float LargGroupe = 0; // espace pris en largeur par l'impression du groupe
try
{
rtb.Rtf = TextRtf; // affecter le texte au richtextbox invisible
}
catch (Exception) // si échec (texte non formaté rtf)
{
rtb.Text = TextRtf; // alors, texte ordinaire
}
if (rtb.Text == "") // si aucun texte réel
return PosY; // retourner position actuelle
rtb.Focus(); // focus sur le rtb utilisé comme cible
LongTotaleText = rtb.Text.Length; // longueur totale à examiner
debutMot = 0; // position du début du premier caractère du prochain mot
// trouver tous les groupes
do // pour chaque goupe dans le texte
{
longGroupe = 0; // longueur du groupe de mots
finGroupe = false; // fin du groupe non trouvée
retour = false; // par défaut, séparateur n'est pas retour à la ligne
// trouver un groupe
do // pour chaque mot du groupe
{
longMot = 0; // longueur du mot
carTrouv = false; // pas encore de caractère valide trouvé
// trouver un mot
for (int i = debutMot; i < LongTotaleText; i++) // pour chaque caractère de la zone texte restante
{
car = rtb.Text[i]; // récupérer le caractère suivant
if (car == ' ' && carTrouv) // si c'est un espace suivant un caractère valide
break; // fin du mot
if (car == '\n') // un retour à la ligne est d'office accepté
{
retour = true; // signaler retour à la ligne
break; // fin du mot
}
longMot++; // un caractère traité, séparateur non inclu
if (car != ' ') // si caractère autre que séparateur (indispensable plusieurs espaces se suivent en début de mot)
carTrouv = true; // un caractère valide trouvé
}
if (longMot > 0) // si le mot trouvé est autre chose qu'un séparateur
{
rtb.Select(debutMot, longMot); // sélectionner le mot
fonteLue = rtb.SelectionFont; // récupérer la fonte concernée
if (fonte != null) // si fonte de substitution demandée
fonteLue = new Font(fonte, fonteLue.Style); // substituer la fonte, garder les styles
if (longGroupe == 0) // si c'est le premier mot du groupe
{
debutGroupe = debutMot; // le groupe commence avec ce mot
longGroupe = longMot; // la longeur du groupe = longueur du mot
debutMot += longMot + 1; // position du début du mot suivant, en ajoutant le séparateur
fontSel = fonteLue; // la fonte du groupe sera celle du premier mot
}
else // si ce n'est pas le premier mot du groupe
{
if (fonteLue.Equals(fontSel)) // si la fonte du mot est bien celle du groupe
{
rtb.Select(debutGroupe, longGroupe + longMot); // sélectionner tout le groupe de mots
LargGroupe = gfx.MeasureString(rtb.SelectedText, fontSel).Width; // récupére largeur du texte du groupe
if (LargGroupe + PosX <= limDroite) // si le groupe de mots tient sur la ligne
{
longGroupe += longMot + 1; // ajouter la longueur du mot et séparateur au groupe
debutMot += longMot + 1; // position du mot suivant
}
else // si avec ce mot, le groupe sort de la page
{
retour = true; // indiquer saut de ligne
}
}
else // si la fonte est différente pour ce mot que pour les autres
{
finGroupe = true; // on ne tient pas compte de ce mot dans le groupe
}
}
}
else // si le mot trouvé est un séparateur seul
{
debutMot++; // le mot suivant démarre un caractère plus loin
}
} while (!retour && !finGroupe && debutMot < LongTotaleText); // tant que pas fin de groupe ou retour à la ligne ou fin de la zone texte : mot suivant du groupe
// imprimer un groupe complet
rtb.Select(debutGroupe, longGroupe); // sélectionner tout le groupe
LargGroupe = gfx.MeasureString(rtb.SelectedText, fontSel).Width; // récupére largeur du texte du groupe
texte = rtb.SelectedText; // récupérer le texte à imprimer
if (print) // si impression réelle demandée
gfx.DrawString(texte, fontSel, Noir, PosX, PosY); // imprimer le texte en bonne position
TailleMax = Math.Max(fontSel.Height, TailleMax); // conserver la plus grande taille de fonte de la ligne
if (retour || debutMot >= LongTotaleText) // si séparateur = passage à la ligne ou traitement terminé
{
PosY += TailleMax; // passer à la ligne
PosX = limGauche; // début de ligne
TailleMax = 0; // nouvelle ligne = nouvelle taille
}
else // si pas de passage à la ligne
{
PosX += LargGroupe; // position suivante sur la même ligne
}
} while (debutMot < LongTotaleText); // tant que pas examiné tout le texte, groupe suivant
return PosY;
}
//////////////////////////////////////////////////////////////////////////////////////////////
// IMPRIMER LE TEXTE RTF //
//////////////////////////////////////////////////////////////////////////////////////////////
//--------------------------------------------------------------------------------------------
/// <summary>Imprime le texte à la position actuelle</summary>
/// <param name="TextRtf">Texte au format RTF à imprimer</param>
/// <returns>Retourne la position de la prochaine ligne à imprimer</returns>
//--------------------------------------------------------------------------------------------
public int Imprimer(string TextRtf)
{
return Executer(TextRtf, true); // lancer impression réelle
}
//////////////////////////////////////////////////////////////////////////////////////////////
// SURCHARGE : IMPRIMER LE TEXTE RTF //
//////////////////////////////////////////////////////////////////////////////////////////////
//--------------------------------------------------------------------------------------------
/// <summary>Imprime le texte à la position donnée</summary>
/// <param name="TextRtf">Texte au format RTF à imprimer</param>
/// <param name="posY">Ordonnée de la première ligne</param>
/// <returns>Retourne la position de la prochaine ligne à imprimer</returns>
//--------------------------------------------------------------------------------------------
public int Imprimer(string TextRtf, int posY)
{
this.PosY = posY; // affecter l'ordonnée de début d'impression
return Executer(TextRtf,true); // I
}
//////////////////////////////////////////////////////////////////////////////////////////////
// SURCHARGE : IMPRIMER LE TEXTE RTF //
//////////////////////////////////////////////////////////////////////////////////////////////
//--------------------------------------------------------------------------------------------
/// <summary>Imprime le texte à la position donnée et en remplaçant la fonte par celle donnée</summary>
/// <param name="TextRtf">Texte au format RTF à imprimer</param>
/// <param name="posY">Ordonnée de la première ligne</param>
/// <param name="fonte">Fonte de substitution de celle originale (les styles sont conservés)</param>
/// <param name="limiteDroite">Limite gauche d'impression par rapport à la marge gauche</param>
/// <param name="limiteGauche">Limite droite d'impression par rapport à la marge gauche</param>
/// <returns>Retourne la position de la prochaine ligne à imprimer</returns>
//--------------------------------------------------------------------------------------------
public int Imprimer(string TextRtf, int posY, Font fonte , int limiteGauche, int limiteDroite)
{
this.fonte = fonte; // affecter les paramètres
this.limDroite = limiteDroite;
this.limGauche = limiteGauche;
return Imprimer(TextRtf,posY); // appel d'une surcharge plus simple
}
//////////////////////////////////////////////////////////////////////////////////////////////
// RETOURNE LA HAUTEUR D'IMPRESSION DU TEXTE RTF //
//////////////////////////////////////////////////////////////////////////////////////////////
//--------------------------------------------------------------------------------------------
/// <summary>Retourne la hauteur d'impression du texte RTF</summary>
/// <param name="TextRtf">Texte au format RTF à mesurer</param>
/// <returns>Retourne la hauteur du texte à l'impression</returns>
//--------------------------------------------------------------------------------------------
public int GetHauteurTextRtf(string TextRtf)
{
int result;
int PosActu = PosY; // mémoriser position actuelle
PosY = 0; // pour être certain d'avoir la place
result = Executer(TextRtf, false); // récupérer hauteur effective
PosY = PosActu; // remettre position à sa valeur originale
return result; // retourner hauteur
}
//////////////////////////////////////////////////////////////////////////////////////////////
// RETOURNE LA HAUTEUR D'IMPRESSION DU TEXTE RTF : SURCHARGE //
//////////////////////////////////////////////////////////////////////////////////////////////
//--------------------------------------------------------------------------------------------
/// <summary>Calcule la hauteur d'un texte avec les paramètres spécifiés, et modifie les dits paramètres</summary>
/// <param name="TextRtf">Texte au for</param>
/// <param name="fonte">Fonte d'impression</param>
/// <param name="limiteGauche">Limite gauche de la zone d'impression par rapport à la marge gauche</param>
/// <param name="limiteDroite">Limite droite de la zone d'impression par rapport à la marge gauche</param>
/// <returns></returns>
//--------------------------------------------------------------------------------------------
public int GetHauteurTextRtf(string TextRtf, Font fonte, int limiteGauche, int limiteDroite)
{
this.fonte = fonte; // affecter les paramètres
this.limDroite = limiteDroite;
this.limGauche = limiteGauche;
return GetHauteurTextRtf(TextRtf); // appel de la surcharge simplifiée
}
}// classe
}// espace de nommage |
impression en couleur
Répondre avec citation
Partager