Imprimer à partir de votre applicationPrint from your app

API importantesImportant APIs

Découvrez comment imprimer des documents à partir d’une application Windows universelle.Learn how to print documents from a Universal Windows app. Cette rubrique montre également comment imprimer des pages spécifiques.This topic also shows how to print specific pages. Pour plus d’informations sur les modifications avancées de l’interface utilisateur d’aperçu avant impression, consultez Personnaliser l’interface utilisateur d’aperçu avant impression.For more advanced changes to the print preview UI, see Customize the print preview UI.

Conseil

 La plupart des exemples de cette rubrique sont basés sur l' exemple d’impression plateforme Windows universelle (UWP), qui fait partie des exemples d’application plateforme Windows universelle (UWP) référentiel sur GitHub. Most of the examples in this topic are based on the Universal Windows Platform (UWP) print sample, which is part of the Universal Windows Platform (UWP) app samples repo on GitHub.

S’inscrire pour l’impressionRegister for printing

Pour ajouter la fonctionnalité d’impression à votre application, vous devez commencer par vous inscrire au contrat d’impression.The first step to add printing to your app is to register for the Print contract. Votre application doit le faire sur chaque écran à partir duquel vous souhaitez que votre utilisateur puisse imprimer.Your app must do this on every screen from which you want your user to be able to print. Seul l’écran qui est affiché à l’utilisateur peut être inscrit à des fins d’impression.Only the screen that is displayed to the user can be registered for printing. Si un écran de votre application est inscrit à des fins d’impression, son inscription doit être annulée au moment de sa fermeture.If one screen of your app has registered for printing, it must unregister for printing when it exits. S’il est remplacé par un autre écran, l’écran suivant doit s’inscrire à un nouveau contrat d’impression lorsqu’il s’ouvre.If it is replaced by another screen, the next screen must register for a new Print contract when it opens.

Conseil

 Si vous devez prendre en charge l’impression à partir de plusieurs pages de votre application, vous pouvez placer ce code d’impression dans une classe d’assistance commune et faire réutiliser les pages de votre application. If you need to support printing from more than one page in your app, you can put this print code in a common helper class and have your app pages reuse it. Pour obtenir un exemple de procédure à suivre, voir la classe PrintHelper dans l’exemple d’impression UWP.For an example of how to do this, see the PrintHelper class in the UWP print sample.

Tout d’abord, déclarez PrintManager et PrintDocument.First, declare the PrintManager and PrintDocument. Le type PrintManager se trouve dans l’espace de noms Windows.Graphics.Printing avec des types prenant en charge d’autres fonctionnalités d’impression Windows.The PrintManager type is in the Windows.Graphics.Printing namespace along with types to support other Windows printing functionality. Le type PrintDocument se trouve dans l’espace de noms Windows.UI.Xaml.Printing avec d’autres types autorisant la préparation du contenu XAML à des fins d’impression.The PrintDocument type is in the Windows.UI.Xaml.Printing namespace along with other types that support preparing XAML content for printing. Vous pouvez faciliter l’écriture de votre code d’impression en ajoutant les instructions using ou Imports suivantes dans votre page.You can make it easier to write your printing code by adding the following using or Imports statements to your page.

using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;

La classe PrintDocument permet de gérer une grande partie de l’interaction entre l’application et la classe PrintManager, mais elle expose quelques rappels qui lui sont propres.The PrintDocument class is used to handle much of the interaction between the app and the PrintManager, but it exposes several callbacks of its own. Lors de l’inscription, créez des instances des classes PrintManager et PrintDocument, et inscrivez des gestionnaires pour leurs événements d’impression.During registration, create instances of PrintManager and PrintDocument and register handlers for their printing events.

Dans l’exemple d’impression UWP, l’inscription est effectuée à l’aide de la méthode RegisterForPrinting.In the UWP print sample, registration is performed by the RegisterForPrinting method.

public virtual void RegisterForPrinting()
{
   printDocument = new PrintDocument();
   printDocumentSource = printDocument.DocumentSource;
   printDocument.Paginate += CreatePrintPreviewPages;
   printDocument.GetPreviewPage += GetPrintPreviewPage;
   printDocument.AddPages += AddPrintPages;

   PrintManager printMan = PrintManager.GetForCurrentView();
   printMan.PrintTaskRequested += PrintTaskRequested;
}

Lorsque l’utilisateur accède à une page qui prend en charge l’impression, il lance l’inscription dans la OnNavigatedTo méthode.When the user goes to a page that supports printing, it initiates the registration within the OnNavigatedTo method.

protected override void OnNavigatedTo(NavigationEventArgs e)
{
   // Initialize common helper class and register for printing
   printHelper = new PrintHelper(this);
   printHelper.RegisterForPrinting();

   // Initialize print content for this scenario
   printHelper.PreparePrintContent(new PageToPrint());

   // Tell the user how to print
   MainPage.Current.NotifyUser("Print contract registered with customization, use the Print button to print.", NotifyType.StatusMessage);
}

Dans l’exemple, les gestionnaires d’événements sont désinscrits dans la UnregisterForPrinting méthode.In the sample, the event handlers are unregistered in the UnregisterForPrinting method.

public virtual void UnregisterForPrinting()
{
    if (printDocument == null)
    {
        return;
    }

    printDocument.Paginate -= CreatePrintPreviewPages;
    printDocument.GetPreviewPage -= GetPrintPreviewPage;
    printDocument.AddPages -= AddPrintPages;

    PrintManager printMan = PrintManager.GetForCurrentView();
    printMan.PrintTaskRequested -= PrintTaskRequested;
}

Lorsque l’utilisateur quitte une page qui prend en charge l’impression, les gestionnaires d’événements sont désinscrits dans la OnNavigatedFrom méthode.When the user leaves a page that supports printing, the event handlers are unregistered within the OnNavigatedFrom method.

Notes

Si vous disposez d’une application à plusieurs pages et que vous ne déconnectez pas l’impression, une exception est levée lorsque l’utilisateur quitte la page, puis y retourne.If you have a multiple-page app and don't disconnect printing, an exception is thrown when the user leaves the page and then returns to it.

protected override void OnNavigatedFrom(NavigationEventArgs e)
{
   if (printHelper != null)
   {
         printHelper.UnregisterForPrinting();
   }
}

Créer un bouton d’impressionCreate a print button

Ajoutez un bouton d’impression à l’emplacement de votre choix dans l’écran de votre application.Add a print button to your app's screen where you'd like it to appear. Assurez-vous qu’il n’interfère pas avec le contenu que vous voulez imprimer.Make sure that it doesn't interfere with the content that you want to print.

<Button x:Name="InvokePrintingButton" Content="Print" Click="OnPrintButtonClick"/>

Ensuite, ajoutez un gestionnaire d’événements au code de votre application pour gérer l’événement Click.Next, add an event handler to your app's code to handle the click event. Utilisez la méthode ShowPrintUIAsync pour démarrer l’impression à partir de votre application.Use the ShowPrintUIAsync method to start printing from your app. ShowPrintUIAsync est une méthode asynchrone qui affiche la fenêtre d’impression appropriée.ShowPrintUIAsync is an asynchronous method that displays the appropriate printing window. Nous vous recommandons d’abord d’appeler la méthode IsSupported pour vérifier que l’application est exécutée sur un appareil qui prend en charge l’impression (et gère le cas où elle ne l’est pas).We recommend calling the IsSupported method first in order to check that the app is being run on a device that supports printing (and handle the case in which it is not). Si l’impression ne peut pas être effectuée à ce moment pour toute autre raison, ShowPrintUIAsync lève une exception.If printing can't be performed at that time for any other reason, ShowPrintUIAsync will throw an exception. Nous vous recommandons d’intercepter ces exceptions et d’informer l’utilisateur quand l’impression ne peut pas être effectuée.We recommend catching these exceptions and letting the user know when printing can't proceed.

Dans cet exemple, une fenêtre d’impression s’affiche dans le gestionnaire d’événements pour un clic sur un bouton.In this example, a print window is displayed in the event handler for a button click. Si la méthode lève une exception (parce que l’impression ne peut pas être effectuée à ce moment précis), un contrôle ContentDialog informe l’utilisateur de la situation.If the method throws an exception (because printing can't be performed at that time), a ContentDialog control informs the user of the situation.

async private void OnPrintButtonClick(object sender, RoutedEventArgs e)
{
    if (Windows.Graphics.Printing.PrintManager.IsSupported())
    {
        try
        {
            // Show print UI
            await Windows.Graphics.Printing.PrintManager.ShowPrintUIAsync();

        }
        catch
        {
            // Printing cannot proceed at this time
            ContentDialog noPrintingDialog = new ContentDialog()
            {
                Title = "Printing error",
                Content = "\nSorry, printing can' t proceed at this time.", PrimaryButtonText = "OK"
            };
            await noPrintingDialog.ShowAsync();
        }
    }
    else
    {
        // Printing is not supported on this device
        ContentDialog noPrintingDialog = new ContentDialog()
        {
            Title = "Printing not supported",
            Content = "\nSorry, printing is not supported on this device.",PrimaryButtonText = "OK"
        };
        await noPrintingDialog.ShowAsync();
    }
}

Mettre en forme le contenu de votre applicationFormat your app's content

Lors de l’appel de ShowPrintUIAsync, l’événement PrintTaskRequested est déclenché.When ShowPrintUIAsync is called, the PrintTaskRequested event is raised. Le gestionnaire d’événements PrintTaskRequested présenté dans cette étape crée une classe PrintTask en appelant la méthode PrintTaskRequest.CreatePrintTask et transmet le titre de la page d’impression et le nom d’un délégué PrintTaskSourceRequestedHandler.The PrintTaskRequested event handler shown in this step creates a PrintTask by calling the PrintTaskRequest.CreatePrintTask method and passes the title for the print page and the name of a PrintTaskSourceRequestedHandler delegate. Notez que dans cet exemple, le délégué PrintTaskSourceRequestedHandler est défini inline.Notice that in this example, the PrintTaskSourceRequestedHandler is defined inline. Le délégué PrintTaskSourceRequestedHandler, qui fournit le contenu mis en forme pour l’impression, est décrit plus tard.The PrintTaskSourceRequestedHandler provides the formatted content for printing and is described later.

Dans cet exemple, un gestionnaire d’achèvement est également défini pour déceler les erreurs.In this example, a completion handler is also defined to catch errors. La gestion des événements d’achèvement est recommandée ; de cette façon, votre application peut informer l’utilisateur en cas d’erreur et fournir des solutions possibles.It's a good idea to handle completion events because then your app can let the user know if an error occurred and provide possible solutions. De même, votre application peut utiliser l’événement d’achèvement pour indiquer à l’utilisateur les prochaines étapes à suivre une fois le travail d’impression terminé.Likewise, your app could use the completion event to indicate subsequent steps for the user to take after the print job is successful.

protected virtual void PrintTaskRequested(PrintManager sender, PrintTaskRequestedEventArgs e)
{
   PrintTask printTask = null;
   printTask = e.Request.CreatePrintTask("C# Printing SDK Sample", sourceRequested =>
   {
         // Print Task event handler is invoked when the print job is completed.
         printTask.Completed += async (s, args) =>
         {
            // Notify the user when the print operation fails.
            if (args.Completion == PrintTaskCompletion.Failed)
            {
               await scenarioPage.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
               {
                     MainPage.Current.NotifyUser("Failed to print.", NotifyType.ErrorMessage);
               });
            }
         };

         sourceRequested.SetSource(printDocumentSource);
   });
}

Une fois la tâche d’impression créée, PrintManager demande une collection de pages d’impression à afficher dans l’interface utilisateur de l’aperçu avant impression en déclenchant l’événement de pagination .After the print task is created, the PrintManager requests a collection of print pages to show in the print preview UI by raising the Paginate event. Cela correspond à la méthode Paginate de l’interface IPrintPreviewPageCollection.This corresponds with the Paginate method of the IPrintPreviewPageCollection interface. Le gestionnaire d’événements que vous avez créé lors de l’inscription est appelé à ce moment.The event handler you created during registration will be called at this time.

Important

 Si l’utilisateur modifie les paramètres d’impression, le gestionnaire d’événements de pagination sera rappelé pour vous permettre de redistribuer le contenu. If the user changes print settings, the paginate event handler will be called again to allow you to reflow the content. Pour une expérience utilisateur optimale, nous vous recommandons de vérifier les paramètres avant de redisposer le contenu et d’éviter de réinitialiser le contenu paginé si ce n’est pas nécessaire.For the best user experience, we recommend checking the settings before you reflow the content and avoid reinitializing the paginated content when it's not necessary.

Dans le gestionnaire d’événements Paginate (la méthode CreatePrintPreviewPages dans l’exemple d’impression UWP), créez les pages à afficher dans l’interface utilisateur d’aperçu avant impression et à envoyer à l’imprimante.In the Paginate event handler (the CreatePrintPreviewPages method in the UWP print sample), create the pages to show in the print preview UI and to send to the printer. Le code dont vous vous servez pour préparer le contenu de votre application à imprimer est propre à votre application et au contenu que vous imprimez.The code you use to prepare your app's content for printing is specific to your app and the content you print. Reportez-vous au code source de l’exemple d’impression UWP pour voir comment il met en forme le contenu à des fins d’impression.Refer to the UWP print sample source code to see how it formats its content for printing.

protected virtual void CreatePrintPreviewPages(object sender, PaginateEventArgs e)
{
   // Clear the cache of preview pages
   printPreviewPages.Clear();

   // Clear the print canvas of preview pages
   PrintCanvas.Children.Clear();

   // This variable keeps track of the last RichTextBlockOverflow element that was added to a page which will be printed
   RichTextBlockOverflow lastRTBOOnPage;

   // Get the PrintTaskOptions
   PrintTaskOptions printingOptions = ((PrintTaskOptions)e.PrintTaskOptions);

   // Get the page description to deterimine how big the page is
   PrintPageDescription pageDescription = printingOptions.GetPageDescription(0);

   // We know there is at least one page to be printed. passing null as the first parameter to
   // AddOnePrintPreviewPage tells the function to add the first page.
   lastRTBOOnPage = AddOnePrintPreviewPage(null, pageDescription);

   // We know there are more pages to be added as long as the last RichTextBoxOverflow added to a print preview
   // page has extra content
   while (lastRTBOOnPage.HasOverflowContent && lastRTBOOnPage.Visibility == Windows.UI.Xaml.Visibility.Visible)
   {
         lastRTBOOnPage = AddOnePrintPreviewPage(lastRTBOOnPage, pageDescription);
   }

   if (PreviewPagesCreated != null)
   {
         PreviewPagesCreated.Invoke(printPreviewPages, null);
   }

   PrintDocument printDoc = (PrintDocument)sender;

   // Report the number of preview pages created
   printDoc.SetPreviewPageCount(printPreviewPages.Count, PreviewPageCountType.Intermediate);
}

Quand une page particulière doit être affichée dans la fenêtre d’aperçu avant impression, la classe PrintManager déclenche l’événement GetPreviewPage.When a particular page is to be shown in the print preview window, the PrintManager raises the GetPreviewPage event. Cela correspond à la méthode MakePage de l’interface IPrintPreviewPageCollection.This corresponds with the MakePage method of the IPrintPreviewPageCollection interface. Le gestionnaire d’événements que vous avez créé lors de l’inscription est appelé à ce moment.The event handler you created during registration will be called at this time.

Dans le gestionnaire d’événements GetPreviewPage (la méthode GetPrintPreviewPage dans l’exemple d’impression UWP), définissez la page appropriée sur le document à imprimer.In the GetPreviewPage event handler (the GetPrintPreviewPage method in the UWP print sample), set the appropriate page on the print document.

protected virtual void GetPrintPreviewPage(object sender, GetPreviewPageEventArgs e)
{
   PrintDocument printDoc = (PrintDocument)sender;
   printDoc.SetPreviewPage(e.PageNumber, printPreviewPages[e.PageNumber - 1]);
}

Enfin, quand l’utilisateur clique sur le bouton d’impression, la classe PrintManager demande la collection finale de pages à envoyer à l’imprimante en appelant la méthode MakeDocument de l’interface IDocumentPageSource.Finally, once the user clicks the print button, the PrintManager requests the final collection of pages to send to the printer by calling the MakeDocument method of the IDocumentPageSource interface. En XAML, cela déclenche l’événement AddPages .In XAML, this raises the AddPages event. Le gestionnaire d’événements que vous avez créé lors de l’inscription est appelé à ce moment.The event handler you created during registration will be called at this time.

Dans le gestionnaire d’événements AddPages (la méthode AddPrintPages dans l’exemple d’impression UWP), ajoutez des pages de la collection de pages à l’objet PrintDocument à envoyer à l’imprimante.In the AddPages event handler (the AddPrintPages method in the UWP print sample), add pages from the page collection to the PrintDocument object to be sent to the printer. Si un utilisateur spécifie des pages ou une plage de pages en particulier à imprimer, vous utilisez ces informations à cet endroit pour ajouter uniquement les pages qui seront effectivement envoyées à l’imprimante.If a user specifies particular pages or a range of pages to print, you use that information here to add only the pages that will actually be sent to the printer.

protected virtual void AddPrintPages(object sender, AddPagesEventArgs e)
{
   // Loop over all of the preview pages and add each one to  add each page to be printied
   for (int i = 0; i < printPreviewPages.Count; i++)
   {
         // We should have all pages ready at this point...
         printDocument.AddPage(printPreviewPages[i]);
   }

   PrintDocument printDoc = (PrintDocument)sender;

   // Indicate that all of the print pages have been provided
   printDoc.AddPagesComplete();
}

Préparer les options d’impressionPrepare print options

Préparez ensuite les options d’impression.Next prepare print options. À titre d’exemple, cette section décrit comment définir l’option d’étendue de pages pour permettre l’impression de pages spécifiques.As an example, this section will describe how to set the page range option to allow printing of specific pages. Pour d’autres d’options avancées, consultezPersonnaliser l’interface utilisateur d’aperçu avant impression.For more advanced options, see Customize the print preview UI.

Cette étape crée une nouvelle option d’impression, définit une liste de valeurs prises en charge par l’option, puis ajoute l’option à l’interface utilisateur d’aperçu avant impression.This step creates a new print option, defines a list of values that the option supports, and then adds the option to the print preview UI. L’option d’étendue de pages comprend les paramètres suivants :The page range option has these settings:

Nom d'optionOption name ActionAction
Print all (Imprimer tout)Print all Imprime toutes les pages du document.Print all pages in the document.
Print Selection (Imprimer la sélection)Print Selection Imprime uniquement le contenu sélectionné par l’utilisateur.Print only the content the user selected.
Print Range (Étendue)Print Range Affiche un contrôle d’édition dans lequel l’utilisateur peut entrer les pages à imprimer.Display an edit control into which the user can enter the pages to print.

Tout d’abord, modifiez le gestionnaire d’événements PrintTaskRequested pour ajouter le code permettant d’obtenir un objet PrintTaskOptionDetails .First, modify the PrintTaskRequested event handler to add the code to get a PrintTaskOptionDetails object.

PrintTaskOptionDetails printDetailedOptions = PrintTaskOptionDetails.GetFromPrintTaskOptions(printTask.Options);

Effacez la liste des options affichées dans l’interface utilisateur d’aperçu avant impression, puis ajoutez les options que vous voulez afficher quand l’utilisateur souhaite imprimer à partir de l’application.Clear the list of options that are shown in the print preview UI and add the options that you want to display when the user wants to print from the app.

Notes

 Les options apparaissent dans l’interface utilisateur d’aperçu avant impression dans l’ordre dans lequel elles sont ajoutées, la première option figurant en haut de la fenêtre. The options appear in the print preview UI in the same order they are appended, with the first option shown at the top of the window.

IList<string> displayedOptions = printDetailedOptions.DisplayedOptions;

displayedOptions.Clear();
displayedOptions.Add(Windows.Graphics.Printing.StandardPrintTaskOptions.Copies);
displayedOptions.Add(Windows.Graphics.Printing.StandardPrintTaskOptions.Orientation);
displayedOptions.Add(Windows.Graphics.Printing.StandardPrintTaskOptions.ColorMode);

Créez l’option d’impression et initialisez la liste de valeurs de l’option.Create the new print option and initialize the list of option values.

// Create a new list option
PrintCustomItemListOptionDetails pageFormat = printDetailedOptions.CreateItemListOption("PageRange", "Page Range");
pageFormat.AddItem("PrintAll", "Print all");
pageFormat.AddItem("PrintSelection", "Print Selection");
pageFormat.AddItem("PrintRange", "Print Range");

Ajoutez votre option d’impression personnalisée, puis attribuez le gestionnaire d’événements.Add your custom print option and assign the event handler. L’option personnalisée est ajoutée en dernière position, en bas de la liste des options.The custom option is appended last so that it appears at the bottom of the list of options. Vous pouvez cependant la placer n’importe où dans la liste, de sorte que vous n’avez pas à vous soucier d’ajouter les options d’impression personnalisées en dernier.But you can put it anywhere in the list, custom print options don't need to be added last.

// Add the custom option to the option list
displayedOptions.Add("PageRange");

// Create new edit option
PrintCustomTextOptionDetails pageRangeEdit = printDetailedOptions.CreateTextOption("PageRangeEdit", "Range");

// Register the handler for the option change event
printDetailedOptions.OptionChanged += printDetailedOptions_OptionChanged;

La méthode CreateTextOption crée la zone de texte Range (Étendue).The CreateTextOption method creates the Range text box. Il s’agit de l’emplacement où l’utilisateur spécifie les pages qu’il souhaite imprimer quand il sélectionne l’option Print Range (Étendue).This is where the user enters the specific pages they want to print when they select the Print Range option.

Gérer les modifications apportées aux options d’impressionHandle print option changes

Le gestionnaire d’événements OptionChanged a un rôle double.The OptionChanged event handler does two things. Premièrement, il affiche et masque le champ d’édition de texte pour l’étendue de pages en fonction de l’option d’étendue de pages sélectionnée par l’utilisateur.First, it shows and hides the text edit field for the page range depending on the page range option that the user selected. Deuxièmement, il teste le texte entré dans la zone de texte d’étendue de pages pour vérifier qu’il représente une étendue de pages valide pour le document.Second, it tests the text entered into the page range text box to make sure that it represents a valid page range for the document.

Cet exemple montre comment les événements de modification d’option d’impression sont gérés dans l' exemple d’impression UWP.This example shows how print option change events are handled in the UWP print sample.

async void printDetailedOptions_OptionChanged(PrintTaskOptionDetails sender, PrintTaskOptionChangedEventArgs args)
{
   if (args.OptionId == null)
   {
         return;
   }

   string optionId = args.OptionId.ToString();

   // Handle change in Page Range Option
   if (optionId == "PageRange")
   {
         IPrintOptionDetails pageRange = sender.Options[optionId];
         string pageRangeValue = pageRange.Value.ToString();

         selectionMode = false;

         switch (pageRangeValue)
         {
            case "PrintRange":
               // Add PageRangeEdit custom option to the option list
               sender.DisplayedOptions.Add("PageRangeEdit");
               pageRangeEditVisible = true;
               await scenarioPage.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
               {
                     ShowContent(null);
               });
               break;
            case "PrintSelection":
               await scenarioPage.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
               {
                     Scenario4PageRange page = (Scenario4PageRange)scenarioPage;
                     PageToPrint pageContent = (PageToPrint)page.PrintFrame.Content;
                     ShowContent(pageContent.TextContentBlock.SelectedText);
               });
               RemovePageRangeEdit(sender);
               break;
            default:
               await scenarioPage.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
               {
                     ShowContent(null);
               });
               RemovePageRangeEdit(sender);
               break;
         }

         Refresh();
   }
   else if (optionId == "PageRangeEdit")
   {
         IPrintOptionDetails pageRange = sender.Options[optionId];
         // Expected range format (p1,p2...)*, (p3-p9)* ...
         if (!Regex.IsMatch(pageRange.Value.ToString(), @"^\s*\d+\s*(\-\s*\d+\s*)?(\,\s*\d+\s*(\-\s*\d+\s*)?)*$"))
         {
            pageRange.ErrorText = "Invalid Page Range (eg: 1-3, 5)";
         }
         else
         {
            pageRange.ErrorText = string.Empty;
            try
            {
               GetPagesInRange(pageRange.Value.ToString());
               Refresh();
            }
            catch (InvalidPageException ipex)
            {
               pageRange.ErrorText = ipex.Message;
            }
         }
   }
}

Conseil

 GetPagesInRangePour plus d’informations sur l’analyse de la plage de pages que l’utilisateur entre dans la zone de texte plage, consultez la méthode dans l' exemple d’impression UWP . See the GetPagesInRange method in the UWP print sample for details on how to parse the page range the user enters in the Range text box.

Afficher un aperçu des pages sélectionnéesPreview selected pages

La façon dont vous mettez en forme le contenu de votre application à des fins d’impression dépend de la nature de votre application et de son contenu.How you format your app's content for printing depends on the nature of your app and its content. Classe d’assistance à l’impression dans utilisée dans l' exemple d’impression UWP pour mettre en forme le contenu à imprimer.A print helper class in used in the UWP print sample to format the content for printing.

Lorsque vous imprimez un sous-ensemble de pages, il existe plusieurs façons d’afficher le contenu dans l’aperçu avant impression.When printing a subset of pages, there are several ways to show the content in the print preview. Quelle que soit la méthode que vous choisissez pour afficher l’étendue de pages dans l’aperçu avant impression, la sortie imprimée doit contenir uniquement les pages sélectionnées.Regardless of the method you chose to show the page range in the print preview, the printed output must contain only the selected pages.

  • Affichez toutes les pages dans l’aperçu avant impression, qu’une étendue de pages soit spécifiée ou non, sans informer l’utilisateur des pages qui seront réellement imprimées.Show all the pages in the print preview whether a page range is specified or not, leaving the user to know which pages will actually be printed.
  • Affichez uniquement les pages sélectionnées par l’utilisateur par le biais de l’étendue de pages dans l’aperçu avant impression en mettant à jour l’écran chaque fois que l’utilisateur modifie l’étendue de pages.Show only the pages selected by the user's page range in the print preview, updating the display whenever the user changes the page range.
  • Affichez toutes les pages dans l’aperçu avant impression, mais en grisant les pages qui ne figurent pas dans l’étendue sélectionnée par l’utilisateur.Show all the pages in print preview, but grey out the pages that are not in page range selected by the user.