Impression avec Qt

Qt fournit un support multiplateforme étendu pour les impressions. En utilisant les systèmes d'impression de chaque plateforme, les applications Qt peuvent utiliser les imprimantes locales ainsi que les imprimantes réseau. Le système d'impression de Qt permet aussi de générer des fichiers PostScript et PDF, proposant ainsi les bases pour des services de génération de rapports.

Classes de gestion de l'impression

Les classes suivantes gèrent la sélection et la configuration des imprimantes, ainsi que l'impression.

Périphériques de dessin et impression

Dans Qt, les imprimantes sont représentées par QPrinter, un périphérique de dessin qui fournit les fonctionnalités spécifiques à l'impression, telles que le support de pages multiples et l'impression recto verso. Cela implique que l'impression passe par l'utilisation d'un QPainter pour dessiner sur une série de pages de la même façon que vous dessineriez sur un widget personnalisé ou une image.

Créer un QPrinter

Bien que les objets QPrinter peuvent être construits et configurés sans l'aide de l'utilisateur, l'impression est souvent effectuée suite à une requête d'un utilisateur ; par exemple, lorsque l'utilisateur sélectionne le menu Fichier|Imprimer... dans une application graphique. Dans ce cas, un objet QPrinter nouvellement construit est fourni à QPrintDialog, permettant à l'utilisateur de spécifier l'imprimante à utiliser, le format des feuilles ainsi que d'autres propriétés d'impression.

     QPrinter printer;
 
     QPrintDialog *dialog = new QPrintDialog(&printer, this);
     dialog->setWindowTitle(tr("Print Document"));
     if (editor->textCursor().hasSelection())
         dialog->addEnabledOption(QAbstractPrintDialog::PrintSelection);
     if (dialog->exec() != QDialog::Accepted)
         return;

Il est aussi possible de définir certaines propriétés par défaut en modifiant le QPrinter avant de le transmettre à la boite de dialogue d'impression. Par exemple, les applications qui génèrent un ensemble de rapports à imprimer peuvent définir le QPrinter afin d'écrire dans un fichier local par défaut plutôt que d'imprimer.

Dessiner sur une page

Une fois que l'objet QPrinter est construit et configuré, un QPainter peut être utilisé pour effectuer des opérations de dessin sur lui. Nous pouvons construire et définir une imprimante de la façon suivante :

     QPrinter printer(QPrinter::HighResolution);
     printer.setOutputFileName("print.ps");
     QPainter painter;
     painter.begin(&printer);
 
     for (int page = 0; page < numberOfPages; ++page) {
 
         // Utilisez l'imprimante pour dessiner sur la page.
 
         if (page != lastPage)
             printer.newPage();
     }
 
     painter.end();

Comme le QPrinter démarre avec une page blanche, nous n'avons besoin d'appeler la fonction newPage() qu'après avoir dessiné sur chaque page, sauf pour la dernière.

Le document est envoyé à l'imprimante ou écrit dans un fichier local lorsque nous appelons la fonction end().

Systèmes de coordonnées

QPrinter fournit des fonctions pour obtenir des informations sur les dimensions du papier (le rectangle de papier) et les dimensions de la zone imprimable (le rectangle de page). Celles-ci sont données dans les coordonnées logiques du périphérique et peuvent être différentes des coordonnées physiques utilisées par le périphérique lui-même. Cela signifie que l'imprimante est capable de rendre des textes et des graphiques à une résolution typiquement plus grande que l'affichage de l'utilisateur.

Bien que nous n'ayons pas besoin de gérer la conversion entre les coordonnées logiques et physiques nous-mêmes, nous avons tout de même besoin d'appliquer des transformations sur les opérations de dessin car les mesures en pixels utilisées pour dessiner à l'écran sont souvent trop petites pour les résolutions supérieures des imprimantes typiques.

Imprimante et systèmes de coordonnées de QPainter

Les fonctions paperRect() et pageRect() fournissent des informations sur la taille du papier utilisé pour l'impression et la zone imprimable sur ce papier. Le rectangle retourné par la fonction pageRect() est habituellement inclus dans le rectangle retourné par la fonction paperRect(). Vous n'avez pas besoin de prendre en compte les positions et les tailles de ces zones lors de l'utilisation de QPainter avec un QPrinter ; l'origine du système de coordonnées du QPainter coïncidera avec le coin supérieur gauche du rectangle de la page et les opérations de dessin seront masquées aux limites de la partie utilisable de la page.

Le système de dessin utilise automatiquement les métriques adéquates pour le périphérique lors du dessin de texte mais, si vous avez besoin de positionner du texte en utilisant les informations obtenues à partir des métriques de fontes, vous devez vous assurer que le périphérique d'impression est spécifié lors de la construction des objets QFontMetrics et QFontMetricsF ou vous assurer que chaque QFont utilisé est construit en utilisant le constructeur acceptant un argument QPaintDevice .

Impression de widgets

Pour imprimer un widget, vous pouvez utiliser la fonction QWidget::render(). Comme déjà mentionné, la résolution des imprimantes est souvent plus grande que la résolution de l'écran, vous devez donc redimensionner le QPainter. Vous pouvez aussi vouloir positionner le widget sur la page. Le code suivant présente une façon de le faire.

         QPainter painter;
         painter.begin(&printer);
         double xscale = printer.pageRect().width()/double(myWidget->width());
         double yscale = printer.pageRect().height()/double(myWidget->height());
         double scale = qMin(xscale, yscale);
         painter.translate(printer.paperRect().x() + printer.pageRect().width()/2,
                            printer.paperRect().y() + printer.pageRect().height()/2);
         painter.scale(scale, scale);
         painter.translate(-width()/2, -height()/2);
 
         myWidget->render(&painter);

Cet exemple centrera le widget sur la page et le redimensionnera pour remplir la page.

Impression de widgets complexes

Certains widgets, tels que QTextEdit et QGraphicsView, affichent du contenu riche qui est normalement géré par des instances d'autres classes, telles que QTextDocument et QGraphicsScene. Cela implique que ce sont ces classes de gestion de contenu qui fournissent les fonctionnalités d'impression, soit à travers une fonction pouvant être utilisée pour effectuer la tâche entière, soit par une fonction qui accepte un objet QPainter existant. Quelques widgets fournissent des fonctions de commodité pour exposer les fonctionnalités d'impression sous-jacentes, évitant d'avoir besoin du gestionnaire de contenu uniquement pour l'appel d'une seule fonction.

Le tableau suivant présente quelles sont les classes et fonctions responsables de l'impression de différents widgets. Pour les widgets qui n'exposent pas de fonctionnalités d'impression directement, les classes de gestion de contenu possédant cette fonctionnalité peuvent être obtenues en appelant une fonction dans l'API du widget correspondant.

QTextEdit requiert un QPrinter plutôt qu'un QPainter car il utilise les informations de dimensions définies pour la page afin d'insérer les sauts de ligne aux endroits appropriés sur le document imprimé.

[ Précédent : Styling ]

Remerciements

Merci à Alexandre Laurent pour la traduction, ainsi qu'à Ilya Diallo, Ali-K?mal Aydin et Claude Leloup pour la relecture !