Implémenter l'impression dans vos applications revient à configurer 4 objets ; ces objets sont :
- L'objet PrintDocument
- L'objet PrintDialog
- L'objet PrintPreviewDialog
- L'objet PageSetupDialog
Voyons à présent chacun de ces objets et comment les combiner pour obtenir une fonctionnalité d'impression.
Vous pouvez récupérer le projet accompagnant cet article ici.
L'objet PrintDocument.
L'objet PrintDocument représente le document à imprimer ; pour lancer l'impression du document, il suffit d'appeler la méthode Print de l'objet PrintDocument ; cette méthode permet de lancer l'impression de notre document sur l'imprimante par défaut.
void PrintButton_Click(object sender, EventArgs e) {
docToPrint.Print();
}
Cependant, avant d'imprimer le document, il faut définir ce que l'on va imprimer. Pour cela, nous allons définir le contenu à imprimer dans l'événement PrintPage de l'objet PrintDocument.
Par exemple, pour imprimer le texte « Implémentation de l'impression », il nous faut le spécifier dans l'objet graphic récupéré à partir de l'événement PrintPage, comme ceci :
void docToPrint_PrintPage(object sender, PrintPageEventArgs e) {
e.Graphics.DrawString(
"Implémentation de l'impression",
new
Font("Arial", 10), Brushes.Black, new
PointF());
}
Voici le code complet du formulaire PrintDocumentForm permettant de mettre en œuvre ce mécanisme :
public
class
PrintDocumentForm : Form {
#region Variables & Properties
PrintDocument docToPrint;
Button PrintButton;
Panel panel;
#endregion
#region Création de notre formulaire
public PrintDocumentForm() {
this.Load += new
EventHandler(PrintDocumentForm_Load);
docToPrint = new
PrintDocument();
docToPrint.PrintPage += new
PrintPageEventHandler(docToPrint_PrintPage);
PrintButton = new
Button();
PrintButton.Text = "Print";
PrintButton.Click += new
EventHandler(PrintButton_Click);
panel = new
Panel();
}
void PrintDocumentForm_Load(object sender, EventArgs e) {
this.Controls.Add(panel);
panel.Controls.Add(PrintButton);
}
#endregion
#region Gestion de l'impression
///
<summary>
/// La méthode Print() permet de déclencher
/// l'impression du document
///
</summary>
///
<param name="sender"></param>
///
<param name="e"></param>
void PrintButton_Click(object sender, EventArgs e) {
docToPrint.Print();
}
///
<summary>
/// L'événement PrintPage() permet de spécifier le
/// document à imprimer en travaillant avec l'objet
/// Graphics.
///
</summary>
///
<param name="sender"></param>
///
<param name="e"></param>
void docToPrint_PrintPage(object sender, PrintPageEventArgs e) {
e.Graphics.DrawString(
"Implémentation de l'impression",
new
Font("Arial", 10), Brushes.Black, new
PointF());
}
#endregion
}
Et voici le résultat en utilisant comme imprimante par défaut une imprimante XPS
Une des limites de notre méthode d'impression est le fait de ne pas pouvoir choisir notre boite de dialogue ; c'est l'objectif du composant PrintDialog
L'objet PrintDialog
Le composant Printdialog est une boite de dialogue modale donnant la possibilité à nos utilisateurs de sélectionner une imprimante.
Pour utiliser ce composant, il nous suffit d'appeler la méthode ShowDialog et de tester la valeur de retour DialogResult correspondant à l'action de l'utilisateur. Si l'utilisateur a cliqué sur OK, nous lançons l'impression, sinon nous ne faisons rien.
Pour cela, modifions le code la méthode PrintButton_Click afin de refléter tout ceci.
void PrintButton_Click(object sender, EventArgs e) {
if (dialogToShow.ShowDialog() == DialogResult.OK)
docToPrint.Print();
}
(Regardez le listing complet du formulaire PrintDialogForm pour l'exemple complet).
Et voici le résultat.
Maintenant que nous sommes capables de sélectionner l'imprimante à utiliser, voyons comment prévisualiser notre document avec de l'imprimer.
L'objet PrintPreview
L'objet PrintPreview est une boite de dialogue donnant la possibilité de prévisualiser un document tel qu'il sera à l'impression
Pour l'utiliser l'objet PrintPreview, affectez sa propriété Document au PrintDocument à prévisualiser, puis appelez la méthode ShowDialog()
void PreviewButton_Click(object sender, EventArgs e) {
previewToShow.Document = docToPrint;
previewToShow.ShowDialog();
}
(Regardez le listing complet de l'exemple PrintPreviewForm pour l'exemple complet)
Et voici le résultat
L'avantage de prévisualiser avant d'imprimer est que l'on se rend compte d'incohérence avant de gaspiller du papier (pensons à la nature J).
Ici, nous remarquons par exemple que les marges ne sont pas correctes ; il serait donc souhaitable de donner à l'utilisateur la possibilité d'ajuster ce genre de propriété ; l'objet PageSetupDialog en est responsable.
L'objet PageSetupDialog
Cet objet permet à l'utilisateur de modifier les paramètres d'impression liés au document.
Voici un exemple de code (le code complet se trouve dans le listing PageSetupForm) :
void SetupButton_Click(object sender, EventArgs e) {
docSetup.Document = docToPrint;
docSetup.PageSettings = new
PageSettings();
docSetup.PrinterSettings = new
PrinterSettings();
if (docSetup.ShowDialog() == DialogResult.OK) {
docToPrint.PrinterSettings = docSetup.PrinterSettings;
}
}
Et le résultat
Taches supplémentaires :
Vous pouvez déclencher des événements avant ou après l'impression en implémentant les événements BeginPrint et EndPrint de l'objet PrintDocument.
Par exemple, le code suivant affiche une MessageBox en fin d'impression pour notifier l'utilisateur :
void docToPrint_EndPrint(object sender, PrintEventArgs e) {
MessageBox.Show("Impression terminée !");
}
Vous pouvez également gérer l'impression sur plusieurs pages, en jouant avec les méthodes MeasureString(), DrawString(), SubString() et la propriété HasMorePage comme illustré ci-dessous (formulaire CompleteForm).
void PrintButton_Click(object sender, EventArgs e) {
if (dialogToShow.ShowDialog() == DialogResult.OK) {
//On initialise ici le texte à imprimer car
//la Methode Print_Page est appelée autant de
//fois que nécessaire jusque ca que la propriété
//PrintPageEventArgs.e.HasPage soit égale à false
txtToPrint = richTextBox.Text;
docToPrint.Print();
}
}
void docToPrint_PrintPage(object sender, PrintPageEventArgs e) {
var numberOfCharacters = 0;
var numberOfLines = 0;
//Police à utiliser
var fontToUse = richTextBox.Font;
//Rectangle définissant la zone d'impression
var rectangleToUse = e.MarginBounds;
var sizeToUse = rectangleToUse.Size;
//ne pas mettre ceci ici txtToPrint = richTextBox.Text;
//car on rentre dans une boucle infinie si le document
//contient plusieurs pages.
//On récupère le nombre de ligne grâce à la méthode
//MeasureString
e.Graphics.MeasureString(txtToPrint, fontToUse, sizeToUse,
StringFormat.GenericTypographic, out numberOfCharacters, out numberOfLines);
//On imprime une page...
e.Graphics.DrawString(txtToPrint, fontToUse, Brushes.Black, rectangleToUse,
StringFormat.GenericTypographic);
//...puis on supprime ce qui vient d'être imprimé.
txtToPrint = txtToPrint.Substring(numberOfCharacters);
// On vérifie si il reste du contenu à imprimer ; si oui
//la méthode Print_Page sera relancée.
e.HasMorePages = (txtToPrint.Length > 0);
}
Ca y'est, dorénavant vous avez toutes les bases nécessaires pour implémenter l'impression dans vos applications.