 |
|
|
| |
| TUTORIEL TECHNOS .NET |
|
|
|
| WinForms : gérer les options d'impression |
| Reprise de notre éditeur de texte, avec l'ajout de deux fonctionnalités liées à l'impression : la mise en page du document, et son aperçu avant impression.
(16/01/2006) |
  |
Notre première approche de
C# (lire l'article du 28/11/05) nous avait amené à implémenter
une impression simple, lancée depuis le menu de notre éditeur
de texte bien-aimé. La fonctionnalité était telle que le document
était imprimé avec les réglages par défaut de l'imprimante,
sans intervention possible du rédacteur. C'est ce que nous allons
modifier dans cet article.
C'est ici
que l'on constate combien la modularité de .NET paye : dans
les faits, construire un aperçu du document à imprimer n'est
pas très éloigné du code nécessaire pour imprimer ce même document.
Dans le cas d'une impression, c'est la classe PrintDocument
qui nous préoccupait, et si l'on veut simplement afficher une
prévisualisation, le code sera quasiment le même, modulo
quelques classes clefs.
Pour commencer, l'ajout d'options dans le menu fichier, pour
la mise en page et l'aperçu, ne varient guère par rapport aux
épisodes précédents :
miFile.MenuItems.Add(new
MenuItem("Imprimer", new EventHandler(this.Imprimer_Clicked)));
miFile.MenuItems.Add(new MenuItem("Mise en page",
new EventHandler(this.MiseEnPage_Clicked)));
miFile.MenuItems.Add(new MenuItem("Aperçu avant
impression", new EventHandler(this.ApercuImpression_Clicked)));
Les évènements sont ensuite très comparables :
private void Imprimer_Clicked(object
sender, EventArgs e) {
try {
sreader = new StringReader(txt.Text);
try {
printFont =
new Font("Arial", 10);
pd.PrintPage
+= new PrintPageEventHandler(this.pd_PrintPage);
pd.Print();
}
finally {
sreader.Close();
}
}
catch(Exception ex) {
MessageBox.Show(ex.Message);
}
}
Il s'agit ci-dessus de la méthode qui déclenche l'impression
du document, vue dans notre article précédent. Elle fait appel
à une autre méthode, pd_PrintPage(),
non reproduite ici, pour monter le graphisme même de la page.
protected void MiseEnPage_Clicked(object
sender, System.EventArgs e) {
try {
pd.PrintPage += new PrintPageEventHandler(this.pd_PrintPage);
PageSetupDialog setup = new PageSetupDialog();
PageSettings settings = pd.DefaultPageSettings;
setup.PageSettings = settings;
if (setup.ShowDialog() == DialogResult.OK)
pd.DefaultPageSettings =
setup.PageSettings;
}
catch(Exception excp) {
MessageBox.Show(excp.Message);
}
}
Cheminement tout à fait logique, tout en faisant également appel
à pd_PrintPage() : on instancie
la classe PageSetupDialog()
dans setup, en même temps que
l'on créé un objet PageSettings,
settings, qui contient les réglages
par défaut. Ceux-ci sont appliqués à la propriété PageSettings
de setup.
On ouvre alors la boîte de dialogue, et une fois celle-ci validée,
les potentiels nouveaux réglages sont appliqués à la propriété
des réglages par défaut de la page, pd.DefaultPageSettings.
Parce que pd est une variable
de classe, on retrouvera ces réglages partout où l'on fera ensuite
appel à elle.
protected void ApercuImpression_Clicked(object
sender, System.EventArgs e) {
try {
sreader = new StringReader(txt.Text);
PrintPreviewDialog ppd = new PrintPreviewDialog();
pd.PrintPage += new PrintPageEventHandler(this.pd_PrintPage);
ppd.Document = pd;
ppd.ShowDialog();
}
catch(Exception exp) {
MessageBox.Show(exp.Message);
}
}
L'aperçu diverge peu. La grosse diffférence de code est
que l'on n'applique pas de réglages à la page : il n'y a pas
de transfert d'informations, on ne fait que prendre ce qui existe.
Ainsi, les changements de mise en page se répercuteront sur
l'aperçu, en bonne logique, grâce à pd.
L'ensemble de l'aperçu est géré par PrintPreviewDialog.
On voit donc que les principales classes utilisées sont PrintDocument
(instancié en début de programme sous le nom pd)
pour l'impression, PageSetupDialog
pour la mise en page, et PrintPreviewDialog
pour l'aperçu. Le contenu est ensuite ici placé de la même manière
au sein des variables d'objet - même s'il y a des techniques
plus spécifiques pour chaque objet. C'est tout l'intérêt
de la modularité de .Net, et du nommage explicite des
objets.
 |
Forum |
|
|
Réagissez
dans les forums
de JDN Développeurs
|
Il faut noter l'importance d'avoir l'objet pd,
l'instance principale de PrintDocument,
comme variable de classe : c'est le seul moyen de faire
transiter les informations entre les différents modules .NET.
Sans cela, à chaque action sur ces modules, l'appel d'un nouveau
module ne verrait s'afficher qu'une table rase. |
|
|
|
|
|
|
|
| Quand achetez-vous le plus en ligne ? |
|
|
|
|
|
|
|
|
| |
|
