Impression - programmer en java, programme java, cours

Impression
Chapitres traités Impression de composant de l'interface
utilisateur
Durant cette étude, nous allons voir comment imprimer facilement une image (qui peut être en réalité que du texte) sur une seule feuille
de papier, comment gérer une impression sur plusieurs pages et comment tirer profit de l'élégance du modèle graphique Java2D pour
générer facilement une boîte de dialogue affichant un aperçu de l'impression.
La plate-forme Java permet également d'imprimer des composants de l'interface utilisateur. Il suffit généralement de faire appel à la méthode
print() du composant à imprimer.
Afin de bien maîtriser l'ensemble des informations contenues dans cette étude, reportez-vous à l'étude qui porte sur le Graphisme 2D.
§
Imprimer des images
Dans ce chapitre, nous allons aborder ce qui est probablement la situation d'impression la plus courante : une image 2D. Bien entendu, l'image peut contenir du texte de
différentes polices, voire n'être constituée que de texte. Pour créer une impression, il convient de prendre en compte au moins deux éléments :
1. Vous devez fournir un objet qui implémente l'interface java.awt.print.Printable. Cette interface possède une seule méthode : print().
2. Vous devez créer un travail d'impression.
Interface Printable
int print(Graphics surface,PageFormat page,int numéro)
Cette méthode est appelée chaque fois que le gestionnaire d'impression a besoin d'une page formatée pour l'impression. Votre code dessine le texte et
l'image qui doivent être imprimés dans le contexte graphique. Le format de la page indique les dimensions du papier et les marges d'impression. Le numéro
de page indique quelle page vous devez afficher.
Travail d'impression - PrinterJob
Pour créer un travail d'impression, utilisez la classe java.awt.print.PrinterJob :
1. Tout d'abord, appelez la méthode statique getPrinterJob() pour obtenir un objet de travail d'impression.
2. Utilisez ensuite la méthode setPrintable() pour obtenir l'objet qui imlémente l'interface Printable qui doit afficher le contenu de la page.
Printable canevas = ... ;
PrinterJob travail =PrinterJob.getPrinterJob();
travail.setPrintable(canevas);
Attention : Il existe une classe PrintJob qui gère les impressions avec le style du JDK1.1. Cette classe est maintenant obsolète. Ne la confondez pas avec la classe
PrinterJob.
Avant de commencer un nouveau travail d'impression, n'oubliez pas d'appeler la méthode printDialog() pour afficher une boîte de dialogue d'impression. Cette boîte
de dialogue permet à l'utilisateur de sélectionner l'imprimante, la plage des pages à imprimer et divers paramètres d'impression.
Collecter les paramètres d'impression - PrintRequestAttributSet - et lancer l'impression
Il est possible de collecter les paramètres d'impression dans un objet d'une classe qui implémente l'interface javax.print.attribute.PrintRequestAttributSet dans la méthode
printDialog(). Java fournit une classe javax.print.attribute.HashPrintRequestAttributSet dans ce but.
...
HashPrintRequestAttributSet attributs =new HashPrintRequestAttributSet();
travail.printDialog(attributs);
La méthode printDialog() renvoie true si l'utilisateur a cliqué sur OK et false s'il a annulé la boîte de dialogue. Si l'utilisateur a accepté, appelez la méthode print() de la
classe PrinterJob pour lancer la procédure d'impression. La méthode print() peut, si un problème survient, déclencher une exception PrinterException.
if (travail.printDialog(attributs)) {
try {
travail.print();

}
catch (PrinterException exception) { ... }
Au cours de l'impression, la méthode print() de la classe PrinterJob effectue des appels répétés à la méthode print() de l'objet implémentant l'interface Printable
associé à la tâche.
Etant donné que le travail d'impression ne sait pas combien de pages vous souhaitez imprimer, il se contente d'appeler plusieurs fois la méthode print().
Tant que la méthode print() renvoie la valeur Printable.PAGE_EXISTS, le travail d'impression continue de produire des pages. Lorsque la méthode print()
renvoie Printable.NO_SUCH_PAGE, le travail d'impression s'arrête.
Attention ! Le nombre de pages que le travail d'impression passe à la méthode print() commence par 0.
§
Par conséquent, le travail d'impression ne sait pas précisément combien de pages il faut imprimer, avant que l'impression totale ne soit terminée. C'est
pour cette raison que la boîte de dialogue d'impression affiche une plage d'impression correspondant aux pages 1 à 1. Vous verrez dans le prochain
chapitre comment éviter cet inconvénient en fournissant un objet java.awt.print.Book au travail d'impression.
Processus d'impression (avancement par bandes)
Pendant le processus d'impression, le travail d'impression appelle plusieurs fois la méthode print() de l'objet Printable. Ce travail d'impression a l'autorisation d'effectuer
plusieurs appels pour la même page. Par conséquent, il ne faut pas compter les pages dans la méthode print(), mais plutôt se fonder sur le paramètre de nombre de pages.
Il existe une bonne raison pour que le travail d'impression puisse appeler plusieurs fois la méthode print() pour la même page. Certaines imprimantes, en particulier
les imprimantes matricielles et à jet d'encre, utilisent un effet de bandes. Elles impriment une bande à la fois, avancent la feuille de papier, puis impriment la bande
suivante. Cela fournit au travail d'impression une technique pour gérer la taille du fichier d'impression.
Si le travail d'impression demande à l'objet Printable d'imprimer une bande, il définit une zone de clipping dans le contexte graphique correspondant à la bande
sélectionnée, puis appelle la méthode print(). Ses opérations d'affichage seront alors restreintes au rectangle de la bande, et seuls les éléments graphiques qui se
trouvent dans cet bande seront affichés.
Votre méthode print() n'a pas forcément besoin d'être au courant de ce procédé, à une seule exception près : elle ne doit pas interférer avec le rectangle de clipping.
Attention : L'objet Graphics que votre méthode print() récupère est également restreint à la zone imprimable, c'est-à-dire que les marges y sont imprimées. Si vous
remplacez la zone de clipping, il se peut que vous imprimiez en dehors des marges. En particulier dans un contexte graphique d'impression, vous devez respecter la
zone de clipping. Appelez donc clip() et non setClip(), pour réduire la zone de clipping. Si vous êtes amenés à réduire la zone de clipping, vérifiez que vous appelez
bien getClip() au début de votre méthode print() et que vous restaurez cette zone de clipping.
Pour en savoir plus sur le cliping, revoir les cours sur le Graphisme 2D.
§
Le paramètre PageFormat de la méthode print()
Le paramètre PageFormat de la méthode print() contient des informations sur la page imprimée. Ainsi, les méthodes getWidth() et getHeight() renvoient la taille du papier,
mesurée en points.
Un point correspond à 1/72
ème
de pouce, un pouce valant 25,4 millimètres. Par exemple une feuille de papier A4 contient 595 par 842 points. La bibliothèque
d'impression se sert de points pour deux raisons.
1. Les tailles de papier et les marges sont mesurées en points.
2. L'unité par défaut pour tous les contextes graphiques d'impression est aussi le point.
Les méthodes getWidth() et getHeight() de la classe PageFormat fournissent la taille complète du papier. Vous ne pouvez pas imprimer à n'importe quel endroit d'une
page. La plupart du temps, les utilisateurs sélectionnent des marges, et même s'ils ne le font pas, les imprimantes ont besoin d'un faible espace pour entraîner la
feuille sur laquelle elles impriment ; cet espace n'est par conséquent pas imprimable.
Les méthodes getImageableWidth() et getImageableHeight() fournissent les dimensions de la zone réellement imprimable. Cependant les marges doivent être
symétriques : il vous faut également connaître le coin supérieur gauche de la zone graphique, qui peut être obtenu grâce aux méthodes suivantes : getImageableX()
et getImageableY().

Astuce : le contexte graphique que vous recevez dans la méthode print() est clippé pour exclure les marges. Mais l'origine du système de coordonnées reste
néanmoins le coin supérieur gauche de la feuille de papier. Il est donc intéressant d'effectuer une translation sur le système de coordonnées pour commencer au coin
supérieur gauche de la zone graphique. Commencez simplement votre méthode print() par :
int print(Graphics surface, PageFormat page, int numéro) {
surface.translate(page.getImageableX(), page.getImageableY());
...
}
Si vous souhaitez que vos utilisateurs puissent choisir les paramètres des marges ou qu'ils puissent changer d'orientation (portrait ou paysage) sans définir d'autres
attributs d'impression, vous pouvez appeler la méthode pageDialog() de la classe PrinterJob :
PageFormat page = travail.pageDialog(attributs);
L'un des onglets de la boîte de dialogue d'impression contient la boîte de dialogue de configuration de la page. Vous souhaiterez peut-être donner aux
utilisateurs le choix de définir un format de page avant l'impression, en particulier si votre programme présente un affichage en WYSIWYG des pages à
imprimer. La méthode pageDialog() renvoie un objet PageFormat contenant les réglages de l'utilisateur.
Utiliser des boîtes de dialogue d'impression natives
Avant la version SDK 1.4, le système d'impression utilisait des boîtes de dialogue de configuration d'impression et de mise en page natives de la plate-forme hôte. Pour
afficher une boîte de dialogue native, appelez la méthode printDialog() sans aucun paramètre. Il n'existe aucune méthode permettant de rassembler les paramètres
utilisateur dans un ensemble d'attributs
L'un des avantages potentiels qui existent à utiliser une boîte de dialogue d'impression native réside dans le fait que certains pilotes d'imprimante possèdent des
fonctions spéciales qui ne sont pas accessibles par le biais d'une boîte de dialogue inter-plates-formes.
Pour afficher une boîte de dialogue de mise en page d'impression native, vous passez un objet par défaut de type PageFormat à la méthode pageDialog(). La méthode
clone l'objet, le modifie en fonction des choix de l'utilisateur dans la boîte de dialogue, puis renvoie l'objet cloné.
PageFormat défaut = travail.defaultPage();
PageFormat page = travail.pageDialog(défaut);

Exemple de mise en oeuvre
Je vous propose de mettre en oeuvre une petite application qui permet d'afficher un ensemble de formes sur un écran et sur une page imprimée :

codage correspondant
package impression;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.geom.*;
import java.awt.print.*;
import javax.print.attribute.*;
import javax.swing.*;
public class Imprimante extends JFrame {
private PanneauImpression canevas = new PanneauImpression();
private PrintRequestAttributeSet attributs = new HashPrintRequestAttributeSet();
private JToolBar barre = new JToolBar();
public Imprimante() {
super("Impression");
add(canevas);
add(barre, BorderLayout.NORTH);
barre.add(new AbstractAction("Imprimer") {
public void actionPerformed(ActionEvent e) {
try {
PrinterJob travail = PrinterJob.getPrinterJob();
travail.setPrintable(canevas);
if (travail.printDialog(attributs)) {
travail.print(attributs);
}
}
catch (PrinterException ex) {
JOptionPane.showMessageDialog(Imprimante.this, ex);
}
}
});
barre.add(new AbstractAction("Mise en page") {
public void actionPerformed(ActionEvent e) {
PrinterJob travail = PrinterJob.getPrinterJob();
travail.pageDialog(attributs);
}
});
setSize(330, 300);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setVisible(true);
}
public static void main(String[] args) { new Imprimante(); }
private class PanneauImpression extends JComponent implements Printable {
@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);
dessinePage((Graphics2D) g);
}
@Override
public int print(Graphics g, PageFormat page, int numéro)
throws PrinterException {