Partage via

Documents multipages

  • Article

Cet article décrit le protocole d'impression Windows et explique comment imprimer des documents qui contiennent plusieurs pages. L'article couvre les rubriques suivantes :

Protocole d’impression

Pour imprimer un document multipage, le framework et l'affichage interagissent de la façon suivante. Tout d’abord, l’infrastructure affiche la boîte de dialogue Imprimer , crée un contexte d’appareil pour l’imprimante et appelle la fonction membre StartDoc de l’objet CDC . Ensuite, pour chaque page du document, l’infrastructure appelle la fonction membre StartPage de l’objet CDC , indique à l’objet d’affichage d’imprimer la page et appelle la fonction membre EndPage . Si le mode imprimante doit être modifié avant de démarrer une page particulière, l’affichage appelle ResetDC, qui met à jour la structure DEVMODE contenant les nouvelles informations du mode imprimante. Lorsque l’intégralité du document a été imprimée, l’infrastructure appelle la fonction membre EndDoc .

Substitution des fonctions de classe View

La classe CView définit plusieurs fonctions membres appelées par l’infrastructure lors de l’impression. Lorsque vous remplacez ces fonctions dans votre classe d'affichage, vous fournissez les connexions entre la logique d'impression du framework et la logique d'impression de votre classe d'affichage. Le tableau suivant répertorie ces fonctions membres.

Les fonctions substituables de CView pour l'impression

Nom Motif de remplacement
OnPreparePrinting Pour insérer des valeurs dans la boîte de dialogue Imprimer, notamment la longueur du document
OnBeginPrinting Pour allouer les polices ou d'autres ressources GDI
OnPrepareDC Pour paramétrer les attributs du contexte de périphérique pour une page spécifique, ou calculer la pagination de délai d'impression
OnPrint Pour imprimer une page de données
OnEndPrinting Pour libérer des ressources GDI

Vous pouvez effectuer un traitement d'impression dans d'autres fonctions également, mais ces fonctions sont celles qui pilotent le processus d'impression.

L'illustration suivante montre les étapes impliquées dans le processus d'impression et indique où chaque CView des fonctions membres de l'impression est appelé. Le reste de cet article explique la plupart de ces étapes plus en détail. Des parties supplémentaires du processus d’impression sont décrites dans l’article Allocation de ressources GDI.

Printing loop process.
La boucle d'impression

Pagination

L’infrastructure stocke une grande partie des informations relatives à un travail d’impression dans une structure CPrintInfo . Plusieurs valeurs dans CPrintInfo se rapportent à la pagination ; ces valeurs sont accessibles comme indiqué dans le tableau suivant.

Les informations de numéro de page stockées dans CPrintInfo

Variable membre ou

nom(s) de la fonction		 Numéro de page référencée
GetMinPage/SetMinPage Première page du document
GetMaxPage/SetMaxPage Dernière page du document
GetFromPage Première page à imprimer
GetToPage Dernière page à imprimer
m_nCurPage Page actuellement imprimée

Les numéros de page commence à 1, c'est-à-dire, la première page est numérotée à 1, et non à 0. Pour plus d’informations sur ces membres et d’autres membres de CPrintInfo, consultez la référence MFC.

Au début du processus d’impression, l’infrastructure appelle la fonction membre OnPreparePrinting de la vue, en passant un pointeur vers une CPrintInfo structure. L’Assistant Application fournit une implémentation de OnPreparePrinting ce qui appelle DoPreparePrinting, une autre fonction membre de CView. DoPreparePrinting est la fonction qui affiche la boîte de dialogue Imprimer et crée un contexte de périphérique d'imprimante.

À ce stade, l'application ne connaît pas le nombre de pages contenues dans le document. Elle utilise les valeurs par défaut 1 et 0xFFFF pour les numéros des première et dernière pages du document. Si vous savez combien de pages votre document contient, remplacez OnPreparePrinting et appelez [SetMaxPage]--brokenlink--(reference/cprintinfo-class.md#setmaxpage) pour la CPrintInfo structure avant de l’envoyer DoPreparePrinting. Cela vous permet de spécifier la longueur du document.

DoPreparePrinting affiche alors la boîte de dialogue Imprimer. Lorsque la valeur est renvoyée, la structure CPrintInfo contient les valeurs spécifiées par l'utilisateur. Si l'utilisateur ne souhaite imprimer qu'une seule plage de pages sélectionnées, il ou elle peut spécifier des numéros de page de début et de fin dans la boîte de dialogue Imprimer. L’infrastructure récupère ces valeurs à l’aide des fonctions et GetToPage des GetFromPage fonctions de CPrintInfo. Si l'utilisateur ne spécifie pas d'étendue de pages, le framework appelle GetMinPage et GetMaxPage et utilise les valeurs retournées pour imprimer le document.

Pour chaque page d’un document à imprimer, l’infrastructure appelle deux fonctions membres dans votre classe d’affichage, OnPrepareDC et OnPrint, et transmet chaque fonction deux paramètres : un pointeur vers un objet CDC et un pointeur vers une CPrintInfo structure. Chaque fois que l’infrastructure appelle OnPrepareDC et qu’elle transmet une valeur différente dans le membre m_nCurPage de la CPrintInfoOnPrintstructure. De cette manière, le framework indique à l'affichage quelle page doit être imprimée.

La fonction membre OnPrepareDC est également utilisée pour l’affichage de l’écran. Elle ajuste le contexte de périphérique avant que l'ajout n'ait lieu. OnPrepareDC sert un rôle semblable à l'impression, mais il existe des différences : d'abord, l'objet CDC représente le contexte de l'imprimante au lieu d'un contexte de périphérique, et ensuite, un objet CPrintInfo est transmis en tant que second paramètre. (Ce paramètre est NULL lorsqu’il OnPrepareDC est appelé pour l’affichage de l’écran.) Remplacez OnPrepareDC la modification du contexte de l’appareil en fonction de la page imprimée. Par exemple, vous pouvez déplacer l'origine de la fenêtre d'affichage et la zone de découpage pour garantir que la partie pertinente du document est imprimée.

La fonction membre OnPrint effectue l’impression réelle de la page. L’article How Default Printing Is Done montre comment l’infrastructure appelle OnDraw avec un contexte d’appareil d’imprimante pour effectuer l’impression. Plus précisément, le framework appelle OnPrint avec une structure CPrintInfo et un contexte de périphérique, et OnPrint passe le contexte de périphérique à OnDraw. Remplacez OnPrint pour exécuter un rendu qui doit être effectué uniquement lors de l'impression et pas pour l'affichage à l'écran. Par exemple, pour imprimer des en-têtes ou des pieds de page (consultez l’article En-têtes et pieds de page pour plus d’informations). Ensuite, appelez OnDraw de la substitution de OnPrint pour effectuer les opérations communes au rendu à l'écran et à l'impression.

Le fait que OnDraw le rendu pour l’affichage d’écran et l’impression signifie que votre application est WYSIWYG : « Ce que vous voyez est ce que vous obtenez ». Toutefois, supposons que vous n’écrivez pas d’application WYSIWYG. Par exemple, prenez le cas d'un éditeur de texte qui utilise une police en gras pour l'impression mais affiche des codes de contrôle pour indiquer le texte en gras sur l'écran. Dans ce type de situation, vous utilisez OnDraw strictement pour l'écran. Lorsque vous remplacez OnPrint, remplacez l'appel à OnDraw par un appel à une fonction de dessin distincte. La fonction dessine le document de la manière dont il apparaît sur le papier, à l'aide des attributs que vous n'affichez pas sur l'écran.

Pages d’imprimante et pages de document

Lorsque vous faites référence à des numéros de page, il est parfois nécessaire de distinguer le concept de page dans le cadre de l'imprimante et le concept de page dans le cadre d'un document. Du point de vue de l'imprimante, une page est une feuille de papier. Toutefois, une feuille de papier n'est pas nécessairement une page du document. Par exemple, si vous imprimez un bulletin d’informations, où les feuilles doivent être pliées, une feuille de papier peut contenir les première et dernière pages du document, côte à côte. De même, si vous imprimez une feuille de calcul, le document ne comprend pas les pages du tout. En revanche, une feuille de papier peut contenir des lignes allant de 1 à 20 et des colonnes de 6 à 10.

Tous les numéros de page de la structure CPrintInfo font référence aux pages d’imprimante. Le framework appelle OnPrepareDC et OnPrint une fois pour chaque feuille de papier qui transite par l'imprimante. Lorsque vous remplacez la fonction OnPreparePrinting pour spécifier la longueur du document, vous devez utiliser des pages d’imprimante. Si une correspondance un-à-un est possible (autrement dit, une page d'impression est égale à une page de document), alors le processus est simplifié. Si, en revanche, les pages de documents et d'impression ne correspondent pas directement, vous devez les convertir entre elles. Par exemple, envisagez d'imprimer une feuille de calcul. En remplaçant OnPreparePrinting, vous devez calculer le nombre de feuilles de papier nécessaires pour imprimer la feuille de calcul entière, puis utiliser cette valeur en appelant la fonction membre SetMaxPage de CPrintInfo. De même, en cas de OnPrepareDCsubstitution, vous devez traduire m_nCurPage dans la plage de lignes et de colonnes qui apparaîtront sur cette feuille particulière, puis ajuster l’origine de la fenêtre d’affichage en conséquence.

Pagination au moment de l’impression

Dans certains cas, il est possible que votre classe d'affichage ne connaisse pas à l'avance la longueur du document avant qu'il soit réellement imprimé. Par exemple, supposons que votre application n'est pas WYSIWYG, donc la longueur d'un document à l'écran ne correspond pas à sa longueur une fois imprimée.

Cela provoque un problème lorsque vous remplacez OnPreparePrinting pour votre classe d’affichage : vous ne pouvez pas passer une valeur à la SetMaxPage fonction de la structure CPrintInfo , car vous ne connaissez pas la longueur d’un document. Si l'utilisateur ne spécifie pas un numéro de page pour arrêter d'utiliser la boîte de dialogue Imprimer, le framework ne saura pas quand arrêter la boucle d'impression. La seule façon de déterminer l'arrêt de la boucle d'impression est d'imprimer le document et de voir à quel moment il se termine. La classe d'affichage doit vérifier la fin du document lorsqu'il est imprimé, puis d'avertir le framework lorsque la fin est atteinte.

L’infrastructure s’appuie sur la fonction OnPrepareDC de votre classe d’affichage pour lui indiquer quand arrêter. Après chaque appel, OnPrepareDCl’infrastructure case activée un membre de la CPrintInfo structure appelée m_bContinuePrinting. Sa valeur par défaut est TRUE. Tant qu’il reste ainsi, l’infrastructure continue la boucle d’impression. S’il est défini sur FALSE, l’infrastructure s’arrête. Pour effectuer la pagination au moment de l’impression, remplacez-la OnPrepareDC par case activée si la fin du document a été atteinte et définissez m_bContinuePrinting sur FALSE lorsqu’il est atteint.

L’implémentation par défaut des OnPrepareDC jeux m_bContinuePrinting sur FALSE si la page active est supérieure à 1. Cela signifie que si la longueur du document n'est pas spécifiée, le framework suppose que le document ne comporte qu'une seule page. La conséquence de ce fait est que vous devez être prudent lorsque vous appelez la version de la classe de base de OnPrepareDC. Ne supposez pas que m_bContinuePrinting sera TRUE après avoir appelé la version de la classe de base.

Que voulez-vous en savoir plus sur

Voir aussi

Impression
CView, classe
CDC, classe