Comment personnaliser les paramètres d’impression (applications UWP pour périphériques)

Dans Windows 8.1, les applications pour appareils UWP permettent aux fabricants d’imprimantes de personnaliser le volet qui affiche les paramètres d’impression avancés. Cette rubrique présente la fenêtre contextuelle des paramètres d’impression avancés, et montre comment la version C# de l’exemple des paramètres d’impression et des notifications d’impression remplace la fenêtre contextuelle par défaut par une fenêtre contextuelle personnalisée. Pour en savoir plus sur les applications d’appareils UWP en général, veuillez consulter la rubrique Découverte des applications d’appareils UWP.

La version C# de l’exemple Paramètres d’impression et notifications d’impression utilise la page Preferences.xaml pour démontrer l’interface utilisateur d’un volet personnalisé pour les paramètres d’impression avancés. Une classe d’assistance d’impression est utilisée pour créer un contexte de périphérique (IPrinterExtensionContext) et effectuer les requêtes de périphérique. Le fichier PrinterHelperClass.cs se trouve dans le projet DeviceAppForPrintersLibrary et utilise des API définies dans le projet PrinterExtensionLibrary. La bibliothèque d’extension d’imprimante offre un moyen pratique d’accéder aux interfaces d’extension d’imprimante du pilote d’impression v4. Pour plus d’informations, veuillez consulter l’aperçu de la bibliothèque d’extension d’imprimante.

Paramètres d’impression avancés

L’expérience des paramètres d’impression avancés est la fonctionnalité qu’une imprimante offre lorsqu’un utilisateur souhaite sélectionner des paramètres d’impression qui ne sont pas proposés dans la fenêtre d’impression. Elle est accessible via le lien Plus de paramètres dans la fenêtre d’impression. Ce n’est pas une expérience en plein écran, mais elle s’affiche dans un volet, qui est un contrôle pour afficher une interface utilisateur contextuelle légère, qui se ferme lorsque l’utilisateur clique ou tape en dehors de celle-ci.

Cette expérience peut être utilisée pour mettre en avant des caractéristiques différenciées pour votre imprimante, telles que la capacité d’appliquer des filigranes à une page de document, d’offrir des options d’impression sécurisée ou des options d’amélioration d’image.

Lorsqu’une application UWP pour périphérique n’est pas installée pour une imprimante, Windows fournit une expérience de paramètres d’impression par défaut. Si Windows détecte qu’une application UWP pour périphérique est installée pour votre imprimante, et que l’application a opté pour l’extension windows.printTaskSettings, votre application remplace l’expérience par défaut fournie par Windows.

Pour invoquer le volet des paramètres d’impression avancés :

1. Ouvrez une application UWP qui prend en charge l’impression

2. Accédez aux icônes en balayant du côté droit de l’écran (ou en utilisant la touche Windows + C)

3. Sélectionnez l’icône Appareils

4. Sélectionnez Imprimer

5. Sélectionnez une imprimante

6. La fenêtre Imprimer s’ouvre

7. Cliquez sur le lien Plus de paramètres dans la fenêtre Imprimer

8. Le volet des paramètres d’impression avancés s’ouvre

   • La fenêtre contextuelle par défaut apparaît lorsque aucune UWP pour périphérique pour l’imprimante n’est installée

   • Une fenêtre contextuelle personnalisée apparaît lorsque une UWP pour périphérique pour l’imprimante est installée

Prérequis

Avant de commencer :

1. Assurez-vous que votre imprimante est installée avec un pilote d’impression v4. Pour plus d’informations, veuillez consulter la section Développement de pilotes d’impression v4.

2. Préparez votre PC de développement. Veuillez consulter la section Bien démarrer pour obtenir des informations sur le téléchargement des outils et la création d’un compte développeur.

3. Associez votre application au magasin. Consultez la section Créer une application UWP pour périphérique pour obtenir des informations à ce sujet.

4. Créez des métadonnées de périphérique pour votre imprimante qui l’associent à votre application. Veuillez consulter la section Créer des métadonnées de périphérique pour plus d’informations à ce sujet.

5. Construisez l’interface utilisateur pour la page principale de votre application. Toutes les applications UWP pour périphériques peuvent être lancées à partir de Start, où elles seront affichées en plein écran. Utilisez l’expérience Start pour mettre en valeur votre produit ou services d’une manière qui correspond à la marque spécifique et aux caractéristiques de vos appareils. Il n’y a pas de restrictions spéciales sur le type de contrôles UI qu’elle peut utiliser. Pour bien démarrer avec la conception de l’expérience plein écran, consultez les principes de conception de Microsoft Store.

6. Si vous développez votre application avec C# ou JavaScript, ajoutez les projets PrinterExtensionLibrary et DeviceAppForPrintersLibrary à votre solution d’application UWP pour périphérique . Vous pouvez trouver chacun de ces projets dans l’exemple Paramètres d’impression et notifications d’impression.

Étape 1 : Enregistrer l’extension

Pour que Windows reconnaisse que l’application peut fournir un volet personnalisé pour les paramètres d’impression avancés, elle doit enregistrer l’extension de tâche d’impression. Cette extension est déclarée dans un élément Extension, avec un attribut Category défini sur une valeur de windows.printTaskSettings. Dans les exemples C# et C++, l’attribut Executable est défini sur $targetnametoken$.exe et l’attribut EntryPoint est défini sur DeviceAppForPrinters.App.

Vous pouvez ajouter l’extension des paramètres de la tâche d’impression sur l’onglet Déclarations de l’éditeur de manifeste dans Microsoft Visual Studio. Vous pouvez également modifier manuellement le manifeste du package d’application XML, en utilisant l’éditeur XML (Texte). Faites un clic droit sur le fichier Package.appxmanifest dans L’Explorateur de solutions pour accéder aux options de modification.

Cet exemple montre l’extension des paramètres de la tâche d’impression dans l’élément Extension, tel qu’il apparaît dans le fichier de manifeste du package d’application, Package.appxmanifest.

<?xml version="1.0" encoding="utf-8"?>
<Package xmlns="http://schemas.microsoft.com/appx/2010/manifest">
  <Identity Name="Microsoft.SDKSamples.DeviceAppForPrinters.CS" Publisher="CN=Microsoft Corporation, O=Microsoft Corporation, L=Redmond, S=Washington, C=US" Version="1.0.0.0" />
  <Properties>
    <DisplayName>Device App For Printers C# sample</DisplayName>
    <PublisherDisplayName>Microsoft Corporation</PublisherDisplayName>
    <Logo>Assets\storeLogo-sdk.png</Logo>
  </Properties>
  <Prerequisites>
    <OSMinVersion>6.3.0</OSMinVersion>
    <OSMaxVersionTested>6.3.0</OSMaxVersionTested>
  </Prerequisites>
  <Resources>
    <Resource Language="x-generate" />
  </Resources>
  <Applications>
    <Application Id="DeviceAppForPrinters" Executable="$targetnametoken$.exe" EntryPoint="DeviceAppForPrinters.App">
      <VisualElements DisplayName="Device App For Printers C# sample" Logo="Assets\squareTile-sdk.png" SmallLogo="Assets\smallTile-sdk.png" Description="DeviceAppForPrinters C# sample" ForegroundText="light" BackgroundColor="#00b2f0" ToastCapable="true">
<DefaultTile ShowName="allLogos" ShortName="App4PrinterCS" WideLogo="Assets\tile-sdk.png" />
<SplashScreen Image="Assets\splash-sdk.png" BackgroundColor="#00b2f0" />
      </VisualElements>
      <Extensions>
<Extension Category="windows.backgroundTasks" EntryPoint="BackgroundTask.PrintBackgroundTask">
  <BackgroundTasks>
    <Task Type="systemEvent" />
  </BackgroundTasks>
</Extension>
<Extension Category="windows.printTaskSettings" Executable="$targetnametoken$.exe" EntryPoint="DeviceAppForPrinters.App" />
      </Extensions>
    </Application>
  </Applications>
</Package>

Étape 2 : Développez l’interface utilisateur

Avant de construire votre application, vous devriez travailler avec vos designers et votre équipe marketing pour concevoir l’expérience utilisateur. L’expérience utilisateur devrait projeter les aspects de branding de votre entreprise et vous aider à établir une connexion avec vos utilisateurs.

Recommandations en matière de conception

Il est important de consulter les directives pour les fenêtres contextuelles des applications UWP avant de concevoir votre fenêtre contextuelle personnalisée. Les directives aident à garantir que votre fenêtre contextuelle offre une expérience intuitive qui est cohérente avec d’autres applications UWP.

Pour la page principale de votre application, gardez à l’esprit que Windows 8.1 peut afficher plusieurs applications dans différentes tailles sur un seul écran. Consultez les directives suivantes pour en savoir plus sur la manière dont votre application peut s’adapter de manière transparente entre les tailles d’écran, les tailles de fenêtre et les orientations.

• Directives pour les tailles de fenêtre et l’adaptation à l’écran

• Directives pour le redimensionnement des fenêtres pour des mises en page hautes et étroites

Dimensions de la fenêtre contextuelle

La fenêtre contextuelle qui affiche les paramètres d’impression avancés mesure 646 pixels de large et au moins 768 pixels de haut (la hauteur réelle dépend de la résolution de l’écran de l’utilisateur). Le bouton Retour dans la zone de titre de la fenêtre contextuelle est fourni par Windows. Le texte « Titre de l’application » est le titre de l’application provenant du fichier de manifeste de l’application. La zone de titre mesure 80 pixels de haut, laissant 688 pixels pour la zone visible du volet personnalisé.

Définition de la couleur du titre de l’application et de l’icône

Le titre, la couleur de fond, la couleur du texte et le petit logo sur la fenêtre contextuelle personnalisée proviennent de l’élément VisualElements dans le fichier de manifeste du package d’application.

Cet exemple montre le titre et l’icône, tels que définis dans l’élément VisualElements, dans le fichier de manifeste du package d’application (Package.appxmanifest).

      <VisualElements DisplayName="Device App For Printers C# sample" Logo="Assets\squareTile-sdk.png" SmallLogo="Assets\smallTile-sdk.png" Description="DeviceAppForPrinters C# sample" ForegroundText="light" BackgroundColor="#00b2f0" ToastCapable="true">
        <DefaultTile ShowName="allLogos" ShortName="App4PrinterCS" WideLogo="Assets\tile-sdk.png" />
        <SplashScreen Image="Assets\splash-sdk.png" BackgroundColor="#00b2f0" />
      </VisualElements>

Bonnes pratiques

• Gardez le même aspect visuel et la même convivialité. Harmonisez votre fenêtre contextuelle personnalisée avec le design de votre expérience de démarrage (la page principale de votre application), en incluant des éléments tels que les polices, les couleurs et les contrôles. L’application devrait sembler familière aux utilisateurs, peu importe d’où ils la lancent.

• Simplifiez les interactions. Évitez les interactions longues ou complexes. Dans la plupart des cas, des actions comme configurer une imprimante, visualiser le statut, commander de l’encre et dépanner sont mieux réalisées à l’intérieur de l’expérience de démarrage.

• Minimisez la navigation. Évitez d’obliger vos utilisateurs à naviguer constamment entre plusieurs pages dans votre fenêtre contextuelle personnalisée. Utilisez plutôt le défilement vertical ou des contrôles intégrés, tels que l’affichage progressif d’options, les listes déroulantes et les messages d’erreur inline.

• N’utilisez pas de fenêtres contextuelles à masquage rapide. L’expérience d’impression utilise déjà une fenêtre contextuelle à masquage rapide. Inclure un autre élément à masquage rapide dans votre fenêtre contextuelle personnalisée peut désorienter vos utilisateurs.

• Désactivez les liens qui éloignent les utilisateurs de l’interface d’impression. Lorsqu’un utilisateur imprime un contenu, vous devriez prendre des mesures pour s’assurer qu’il reste dans le contexte d’impression. Par exemple, si votre application contient des liens menant vers d’autres zones de votre application (comme vers une page d’accueil ou vers une page pour acheter de l’encre), vous devriez les désactiver pour que l’utilisateur ne quitte pas accidentellement l’expérience des paramètres d’impression avancés.

Étape 3 : Gérer l’activation

Si votre application a déclaré l’extension des paramètres de tâche d’impression, elle doit implémenter une méthode OnActivated pour gérer l’événement d’activation de l’application. L’activation de l’application est le moment où votre application peut choisir quelle page sera lancée au démarrage de l’application. Pour les applications ayant déclaré l’extension des paramètres de tâche d’impression, Windows transmet le contexte de l’extension de tâche d’impression dans les arguments de l’événement Activated : Windows.ApplicationModel.Activation.IActivatedEventArgs.

Une application UWP pour périphérique peut déterminer que l’activation est destinée aux paramètres d’impression avancés (qu’un utilisateur a juste tapé sur Plus d’options dans la boîte de dialogue des paramètres d’impression) lorsque la propriété kind de l’argument de l’événement est égale à Windows.ApplicationModel.Activation.ActivationKind.printTaskSettings.

Cet exemple montre le gestionnaire d’événements d’activation dans la méthode OnActivated, tel qu’il apparaît dans le fichier Constants.cs. Les arguments de l’événement sont ensuite convertis en Windows.ApplicationModel.Activation.PrintTaskSettingsActivatedEventArgs. Bien que l’exemple inclue ce code dans le fichier Constants.cs, il fait en réalité partie de la classe App qui est également définie dans le fichier App.xaml.cs.

partial class App : Application
{
    protected override void OnActivated(IActivatedEventArgs args)
    {
        if (args.Kind == ActivationKind.PrintTaskSettings)
        {
            Frame rootFrame = new Frame();
            if (null == Window.Current.Content)
            {
                rootFrame.Navigate(typeof(MainPage));
                Window.Current.Content = rootFrame;
            }
            Window.Current.Activate();

            MainPage mainPage = (MainPage)rootFrame.Content;

            // Load advanced printer preferences scenario
            mainPage.LoadAdvancedPrintSettingsContext((PrintTaskSettingsActivatedEventArgs)args);
        }
    }
}

Étape 4 : Affichage des paramètres

Lorsque la méthode LoadAdvancedPrintSettingsContext est appelée, le contexte de configuration de la tâche d’impression est attribué à des variables de la classe MainPage. Cela permettra à la fenêtre contextuelle à masquage rapide personnalisée d’accéder aux paramètres d’impression lorsqu’elle est lancée.

Les arguments d’événement qui sont passés à la méthode LoadAdvancedPrintSettingsContext, exposent des propriétés pour accéder et contrôler l’imprimante :

• La propriété args.configuration fournit un objet de type Windows.Devices.Printers.Extensions.PrintTaskConfiguration. Cet objet donne accès au contexte d’extension de tâche d’impression et permet également d’ajouter un gestionnaire d’événements pour mettre à jour le billet d’impression.
• La propriété args.configuration.printerExtensionContext fournit un objet de type Windows.Devices.Printers.Extensions.PrinterExtensionContext. Cet objet est un pointeur vers les interfaces de la bibliothèque d’extension d’imprimante pour le schéma d’impression, le billet d’impression et les informations de la file d’attente d’impression. Il sera null si aucune interface n’est exposée. Pour plus d’informations, veuillez consulter Aperçu de la bibliothèque d’extension d’imprimante.

Cet exemple montre la méthode LoadAdvancedPrintSettingsContext, telle qu’elle apparaît dans le fichier Constants.cs.

public PrintTaskConfiguration Config;
public Object Context;

public void LoadAdvancedPrintSettingsContext(PrintTaskSettingsActivatedEventArgs args)
{
    Config = args.Configuration;
    Context = Config.PrinterExtensionContext;
    LoadScenario(typeof(DeviceAppForPrinters.Preferences));
}

Sur la page de la fenêtre contextuelle à masquage rapide personnalisée, Preferences.xaml.cs, une classe nommée rootPage fait office de pointeur vers la classe MainPage afin que le contexte d’extension de la tâche d’impression et le contexte du périphérique d’impression puissent être accessibles depuis la fenêtre contextuelle.

Cet exemple montre le pointeur dans une partie de la classe Preferences, du fichier Preferences.xaml.cs. Téléchargez l’exemple Paramètres d’impression et notifications d’impression pour voir le code complet.

public sealed partial class Preferences : SDKTemplate.Common.LayoutAwarePage
{
    // A pointer back to the main page.  
    MainPage rootPage = MainPage.Current;

    // To listen for save requests.
    PrintTaskConfiguration configuration;

    // To create the printer device context.
    Object printerExtensionContext;
    PrintHelperClass printHelper;

    // The features in this sample were chosen because they're available on a wide range of printer drivers.
    private string[] features = { "PageOrientation", "PageOutputColor", "PageMediaSize", "PageMediaType" };
    private string[] selections = { null, null, null, null };

    // . . .
    // . . .
    // . . .

Lorsque le constructeur de la page Preferences.xaml.cs est appelé, des objets sont créés pour le contexte d’extension de la tâche d’impression (un objet PrintTaskConfiguration nommé configuration) et le contexte du périphérique d’impression (un objet PrintHelperClass nommé printHelper).

Après la création de ces objets, le contexte du périphérique d’impression est utilisé dans la méthode DisplaySettings pour charger des TextBlocks et des ComboBoxes. Notez que contrairement à JavaScript, les changements de sélection ne sont pas déclenchés sur le même fil que le reste de l’application. Vous devez maintenir un cache local des sélections des utilisateurs pour les utiliser plus tard.

Cet exemple montre le constructeur de la page de la fenêtre contextuelle à masquage rapide personnalisée, DisplaySettings, et d’autres méthodes d’assistance dans le fichier Preferences.xaml.cs.

public Preferences()
{
    this.InitializeComponent();

    configuration = rootPage.Config;
    printerExtensionContext = rootPage.Context;
    printHelper = new PrintHelperClass(printerExtensionContext);

    // Disable scenario navigation by hiding the scenario list UI elements
    ((UIElement)rootPage.FindName("Scenarios")).Visibility = Windows.UI.Xaml.Visibility.Collapsed;
    ((UIElement)rootPage.FindName("ScenarioListLabel")).Visibility = Windows.UI.Xaml.Visibility.Collapsed;
    ((UIElement)rootPage.FindName("DescriptionText")).Visibility = Windows.UI.Xaml.Visibility.Collapsed;

    DisplaySettings();
}


private void DisplaySettings(bool constraints=false)
{
    PrintOptions.Visibility = Windows.UI.Xaml.Visibility.Visible;
    WaitPanel.Visibility = Windows.UI.Xaml.Visibility.Collapsed;

    // Fill in the drop-down select controls for some common printing features.
    TextBlock[] featureLabels = { PageOrientationLabel, PageOutputColorLabel, PageMediaSizeLabel, PageMediaTypeLabel };
    ComboBox[] featureBoxes = { PageOrientationBox, PageOutputColorBox, PageMediaSizeBox, PageMediaTypeBox };

    for (int i = 0; i < features.Length; i++)
    {
        // Only display a feature if it exists
        featureLabels[i].Visibility = Windows.UI.Xaml.Visibility.Collapsed;
        featureBoxes[i].Visibility = Windows.UI.Xaml.Visibility.Collapsed;

        string feature = features[i];

        // Check whether the currently selected printer's capabilities include this feature.
        if (!printHelper.FeatureExists(feature))
        {
            continue;
        }

        // Fill in the labels so that they display the display name of each feature.
        featureLabels[i].Text = printHelper.GetFeatureDisplayName(feature);
        string[] index = printHelper.GetOptionInfo(feature, "Index");
        string[] displayName = printHelper.GetOptionInfo(feature, "DisplayName");
        string selectedOption = printHelper.GetSelectedOptionIndex(feature);

        // Unless specified, do not get constraints
        bool[] constrainedList = constraints ? printHelper.GetOptionConstraints(feature) : new bool[index.Length];

        // Populate the combo box with the options for the current feature.
        PopulateBox(featureBoxes[i], index, displayName, selectedOption, constrainedList);
        selections[i] = selectedOption;

        // Every time the selection for a feature changes, we update our local cached set of selections.
        featureBoxes[i].SelectionChanged += OnFeatureOptionsChanged;

        // Show existing features
        featureLabels[i].Visibility = Windows.UI.Xaml.Visibility.Visible;
        featureBoxes[i].Visibility = Windows.UI.Xaml.Visibility.Visible;
    }
}

void PopulateBox(ComboBox box, string[] index, string[] displayName, string selectedOption, bool[] constrainedList)
{
    // Clear the combobox of any options from previous UI refresh before repopulating it.
    box.SelectionChanged -= OnFeatureOptionsChanged;
    box.Items.Clear();
    // There should be only one displayName for each possible option.
    if (index.Length == displayName.Length)
    {
        for (int i = 0; i < index.Length; i++)
        {
            // Create a new DisplayItem so the user will see the friendly displayName instead of the index.
            ComboBoxItem newItem = new ComboBoxItem();
            newItem.Content = displayName[i];
            newItem.DataContext = index[i];
            newItem.Foreground = constrainedList[i] ? new SolidColorBrush(Colors.Red) : new SolidColorBrush(Colors.Black);
            box.Items.Add(newItem);

            // Display current selected option as selected in the combo box.
            if (selectedOption == index[i])
            {
                box.SelectedIndex = i;
                box.Foreground = newItem.Foreground;
            }
        }
    }
}

private void OnFeatureOptionsChanged(object sender, SelectionChangedEventArgs args)
{
    ComboBox comboBox = sender as ComboBox;

    for (int i = 0; i < features.Length; i++)
    {
        if (features[i] + "Box" == comboBox.Name)
        {
            selections[i] = (comboBox.SelectedItem as ComboBoxItem).DataContext as string;
        }
    }
}

Étape 5 : Sauvegarde des paramètres

Lorsque l’utilisateur a terminé de définir les paramètres d’impression avancés, l’application pour périphérique du Microsoft Store doit sauvegarder les modifications avant que l’utilisateur ne revienne à la fenêtre Imprimer. Pour cela, l’application doit écouter lorsque l’utilisateur appuie sur le bouton Retour (depuis la page de la fenêtre contextuelle à masquage rapide personnalisée). Lorsque cela se produit, l’événement SaveRequested de l’extension de la tâche d’impression (l’objet configuration) est déclenché.

Cet exemple montre l’écouteur d’événement pour SaveRequested, ajouté dans le gestionnaire d’événements OnNavigatedTo de la fenêtre contextuelle à masquage rapide, dans le fichier Preferences.xaml.cs. Lorsque l’événement SaveRequested est déclenché, la méthode OnSaveRequested sera invoquée (cette méthode se trouve également dans le fichier Preferences.xaml.cs).

protected override void OnNavigatedTo(NavigationEventArgs e)
{
    if (null == configuration)
    {
        rootPage.NotifyUser("Configuration arguments cannot be null", NotifyType.ErrorMessage);
        return;
    }

    // Add an event listener for saverequested (the back button of the flyout is pressed).
    configuration.SaveRequested += OnSaveRequested;
}

Dans la méthode OnSaveRequested, l’application utilise d’abord l’objet printHelper pour définir les options actuellement sélectionnées pour chaque fonctionnalité sur le contexte de l’extension de l’imprimante. Ensuite, elle appelle la méthode Save sur l’objet request qui est passé en argument à la méthode OnSaveRequested. La méthode Save, de la classe Windows.Devices.Printers.Extensions.PrintTaskConfigurationSaveRequest, utilise le contexte de l’extension de l’imprimante pour valider le billet d’impression et sauvegarder la configuration de la tâche d’impression.

Cet exemple montre la méthode OnSaveRequested dans le fichier Preferences.xaml.cs. Étant donné que l’événement SaveRequested n’est pas soulevé sur le fil d’interface utilisateur, il doit utiliser un Windows.UI.Core.CoreDispatcher pour poster des messages au fil d’interface utilisateur afin d’afficher les messages appropriés lors de la validation et de l’enregistrement du billet.

async private void OnSaveRequested(object sender, PrintTaskConfigurationSaveRequestedEventArgs args)
{
    if (null == printHelper || null == printerExtensionContext || null == args)
    {
        await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
        {
            rootPage.NotifyUser("onSaveRequested: args, printHelper, and context cannot be null", NotifyType.ErrorMessage);
        });
        return;
    }

    // Get the request object, which has the save method that allows saving updated print settings.
    PrintTaskConfigurationSaveRequest request = args.Request;

    if (null == request)
    {
        await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
        {
            rootPage.NotifyUser("onSaveRequested: request cannot be null", NotifyType.ErrorMessage);
        });
        return;
    }

    PrintTaskConfigurationSaveRequestedDeferral deferral = request.GetDeferral();

    // Two separate messages are dispatched to:
    // 1) put up a popup panel,
    // 2) set the each options to the print ticket and attempt to save it,
    // 3) tear down the popup panel if the print ticket could not be saved.
    await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
    {
        PrintOptions.Visibility = Windows.UI.Xaml.Visibility.Collapsed;
        WaitPanel.Visibility = Windows.UI.Xaml.Visibility.Visible;
    });

    // Go through all the feature select elements, look up the selected
    // option name, and update the context
    // for each feature
    for (var i = 0; i < features.Length; i++)
    {
        // Set the feature's selected option in the context's print ticket.
        // The printerExtensionContext object is updated with each iteration of this loop
        printHelper.SetFeatureOption(features[i], selections[i]);
    }

    bool ticketSaved;
    try
    {
        // This save request will throw an exception if ticket validation fails.
        // When the exception is thrown, the app flyout will remain.
        // If you want the flyout to remain regardless of outcome, you can call
        // request.Cancel(). This should be used sparingly, however, as it could
        // disrupt the entire the print flow and will force the user to
        // light dismiss to restart the entire experience.
        request.Save(printerExtensionContext);

        if (configuration != null)
        {
            configuration.SaveRequested -= OnSaveRequested;
        }
        ticketSaved = true;
    }
    catch (Exception exp)
    {
        // Check if the HResult from the exception is from an invalid ticket, otherwise rethrow the exception
        if (exp.HResult.Equals(unchecked((int)0x8007000D))) // E_INVALID_DATA
        {
            ticketSaved = false;
        }
        else
        {
            throw;
        }
    }

    // If ticket isn't saved, refresh UI and notify user
    if (!ticketSaved)
    {
        await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
        {
            rootPage.NotifyUser("Failed to save the print ticket", NotifyType.ErrorMessage);
            DisplaySettings(true);
        });
    }
    deferral.Complete();
}

Sauvegarde des options nécessitant une saisie utilisateur

L’exemple Paramètres d’impression et notifications d’impression montre comment définir des fonctionnalités définies, ce qui couvre la plupart des options d’impression. Cependant, certaines options nécessitent une interface utilisateur personnalisée pour obtenir une valeur spécifiée par l’utilisateur. Par exemple, si une application utilisait les paramètres d’impression avancés pour spécifier une taille de page personnalisée, elle prendrait ces mesures pour sauvegarder la valeur spécifiée par l’utilisateur :

1. Récupérer le billet d’impression lors de l’activation de l’application. L’activation de l’application pour les paramètres d’impression est décrite plus tôt dans Étape 3 : Gérer l’activation.

2. Vérifier si l’option de taille de page est spécifiée. Dans une application C# ou JS, la classe d’assistance d’impression peut vérifier cette option. Dans une application C++, appelez QueryInterface sur IPrintSchemaOption pour récupérer IPrintSchemaPageMediaSizeOption.

   Cet exemple montre une méthode dans une classe d’assistance d’impression qui vérifie si l’option de taille de page est spécifiée.

   public bool ShouldShowCustomUI(string index)
   {
       if (null != index)
       {
           string feature = "PageMediaSize";
           int i = int.Parse(index);
           IPrintSchemaOption selectedOption = GetCachedFeatureOptions(feature)[i];
           if (selectedOption.Name.Equals("CustomMediaSize", StringComparison.CurrentCulture)
               || selectedOption.Name.Equals("PSCustomMediaSize", StringComparison.CurrentCulture))
           {
               return true;
           }
       }
       return false;
   }
   

3. Dans la fenêtre contextuelle à masquage rapide personnalisée, affichez une interface utilisateur personnalisée qui demande à l’utilisateur la hauteur et la largeur de la page, et récupérez la hauteur et la largeur spécifiées par l’utilisateur à partir de IPrintSchemaPageMediaSizeOption.

   Cet exemple montre une méthode pour une fenêtre contextuelle à masquage rapide personnalisée qui demande à l’utilisateur la hauteur et la largeur de la page.

   private void ShowCustomPageMediaSizeUI(string index, bool keepValue)
   {
       //Hide custom media size UI unless needed
       if (IsCustomSizeSelected(index))
       {
          if (keepValue && (!customWidth.Equals("")) && (!customHeight.Equals("")))
          {
                       CustomWidthBox.Text = customWidth;
                       CustomHeightBox.Text = customHeight;
          }
          else
          {
             // Use a helper function from the WinRT helper component
             CustomWidthBox.Text = printHelper.GetCustomWidth(index);
             CustomHeightBox.Text = printHelper.GetCustomHeight(index);
          }
          CustomUIPanel.Visibility = Windows.UI.Xaml.Visibility.Visible;
          CustomWidthBox.KeyDown += OnCustomValueEntered;
          CustomHeightBox.KeyDown += OnCustomValueEntered;
       }
       else
       {
          CustomUIPanel.Visibility = Windows.UI.Xaml.Visibility.Collapsed;
          CustomWidthBox.KeyDown -= OnCustomValueEntered;
          CustomHeightBox.KeyDown -= OnCustomValueEntered;
       }
   }
   

4. Mettez à jour l’objet IPrintSchemaPageMediaSizeOption avec les valeurs spécifiées par l’utilisateur et validez que la hauteur et la largeur correspondent aux valeurs spécifiées par l’utilisateur.

   Cet exemple est une méthode d’assistance pour mettre à jour l’objet IPrintSchemaPageMediaSizeOption dans une classe d’assistance d’imprimante. Le gestionnaire OnSaveRequested dans la fenêtre contextuelle à masquage rapide personnalisée appellerait cette fonction s’il détermine qu’une option de taille de page personnalisée a été demandée.

   public void SetCustomMediaSizeDimensions(string width, string height)
   {
     if ((null == width) && (null == height) && (null == Capabilities))
     {
                   return;
     }
     try
     {
                   CheckSizeValidity(width, height);
     }
     catch (FormatException e)
     {
                   throw new ArgumentException(e.Message);
     }
     catch (OverflowException e)
     {
                   throw new ArgumentException(e.Message);
     }
   
     // The context is retrieved during app activation.
     IPrintSchemaTicket ticket = context.Ticket;
   
     //
     // Input XML as Stream
     //
     XElement ticketRootXElement = null;
     using (Stream ticketReadStream = ticket.GetReadStream())
     {
        ticketRootXElement = XElement.Load(ticketReadStream);
     }
   
     XNamespace psfNs = PrintSchemaConstants.FrameworkNamespaceUri;
     XNamespace pskNs = PrintSchemaConstants.KeywordsNamespaceUri;
     string pskPrefix = ticketRootXElement.GetPrefixOfNamespace(pskNs);
   
     // Modify the MediaSizeHeight and MediaSizeWidth
     IEnumerable<XElement> parameterInitCollection =
       from c in ticketRootXElement.Elements(psfNs + "ParameterInit")
   
     select c;
   
     foreach (XElement parameterInit in parameterInitCollection)
     {
       if (0 == String.Compare((string)parameterInit.Attribute("name"), pskPrefix + ":PageMediaSizePSWidth"))
       {
         IEnumerable<XElement> valueCollection = from c in parameterInit.Elements(psfNs + "Value")
         select c;
         valueCollection.ElementAt(0).Value = width;
       }
   
        else if (0 == String.Compare((string)parameterInit.Attribute("name"), pskPrefix + ":PageMediaSizePSHeight"))
       {
         IEnumerable<XElement> valueCollection = from c in parameterInit.Elements(psfNs + "Value")
         select c;
         valueCollection.ElementAt(0).Value = height;
        }
     }
   
     //
     // Write XLinq changes back to DOM
     //
      using (Stream ticketWriteStream = ticket.GetWriteStream())
      {
        ticketRootXElement.Save(ticketWriteStream);
      }
   }
   

Test

Avant de pouvoir tester votre application UWP pour périphérique, elle doit être liée à votre imprimante à l’aide de métadonnées de périphérique.

• Vous avez besoin d’une copie du package de métadonnées de périphérique pour votre imprimante, pour y ajouter les informations de l’application de périphérique. Si vous n’avez pas de métadonnées de périphérique, vous pouvez les construire en utilisant l’Assistant de création de métadonnées de périphérique comme décrit dans le sujet Créer des métadonnées de périphérique pour votre application UWP pour périphérique.

  Remarque

  Pour utiliser l’Assistant de création de métadonnées de périphérique, vous devez installer Microsoft Visual Studio Professional, Microsoft Visual Studio Ultimate, ou le SDK autonome pour Windows 8.1, avant de compléter la procédure de cette rubrique. L’installation de Microsoft Visual Studio Express pour Windows installe une version du SDK qui n’inclut pas l’assistant.

Les étapes suivantes construisent votre application et installent les métadonnées de périphérique.

1. Activez la signature de test.

   1. Lancez l’Assistant de création de métadonnées de périphérique depuis %ProgramFiles(x86)%\Windows Kits\8.1\bin\x86, en double-cliquant sur DeviceMetadataWizard.exe

   2. Depuis le menu Outils, sélectionnez Activer la signature de test.

2. Redémarrez l’ordinateur

3. Construisez la solution en ouvrant le fichier de solution (.sln). Appuyez sur F7 ou allez dans Construire->Construire la solution depuis le menu supérieur après que l’exemple ait été chargé.

4. Déconnectez et désinstallez l’imprimante. Cette étape est nécessaire pour que Windows lise les métadonnées de périphérique mises à jour la prochaine fois que le périphérique est détecté.

5. Éditez et sauvegardez les métadonnées de périphérique. Pour lier l’application de périphérique à votre périphérique, vous devez associer l’application de périphérique à votre périphérique

   Remarque

   Si vous n’avez pas encore créé vos métadonnées de périphérique, consultez Créer des métadonnées de périphérique pour votre application UWP pour périphérique.

   1. Si l’Assistant de création de métadonnées de périphérique n’est pas encore ouvert, lancez-le depuis %ProgramFiles(x86)%\Windows Kits\8.1\bin\x86, en double-cliquant sur DeviceMetadataWizard.exe.

   2. Cliquez sur Éditer les métadonnées de périphérique. Cela vous permettra d’éditer votre package de métadonnées de périphérique existant.

   3. Dans la boîte de dialogue Ouvrir, localisez le package de métadonnées de périphérique associé à votre application UWP pour périphérique. (Il a une extension de fichier devicemetadata-ms).

   4. Sur la page Spécifier les informations de l’application UWP pour périphérique, saisissez les informations de l’application Microsoft Store dans la boîte Application UWP pour périphérique. Cliquez sur Importer le fichier manifeste de l’application UWP pour entrer automatiquement le Nom du package, le Nom de l’éditeur, et l’ID de l’application UWP.

   5. Si votre application s’inscrit pour des notifications d’imprimante, remplissez la boîte Gestionnaires de notifications. Dans ID de l’événement, saisissez le nom du gestionnaire d’événements d’impression. Dans Actif de l’événement, saisissez le nom du fichier où ce code réside.

   6. Lorsque vous avez terminé, cliquez sur Suivant jusqu’à ce que vous arriviez à la page Terminer.

   7. Sur la page Revoir le package de métadonnées de périphérique, assurez-vous que tous les paramètres sont corrects et sélectionnez la case à cocher Copier le package de métadonnées de périphérique dans le magasin de métadonnées sur l’ordinateur local. Ensuite, cliquez sur Enregistrer.

6. Reconnectez votre imprimante pour que Windows lise les métadonnées de périphérique mises à jour lorsque le périphérique est connecté.

Dépannage

Problème : Les paramètres d’impression avancés affichent la fenêtre contextuelle à masquage rapide par défaut au lieu de la fenêtre contextuelle à masquage rapide personnalisée

Si la fenêtre contextuelle à masquage rapide des paramètres d’impression avancés affiche la fenêtre contextuelle à masquage rapide par défaut au lieu de la fenêtre contextuelle à masquage rapide personnalisée que votre application implémente...

• Cause possible : Le test de signature n’est pas activé. Consultez la section Débogage de ce sujet pour savoir comment l’activer.

• Cause possible : L’application ne recherche pas le bon nom de famille de package. Vérifiez le nom de famille de package dans votre code. Ouvrez package.appxmanifest dans Visual Studio et assurez-vous que le nom de famille de package que vous recherchez correspond à celui de l’onglet Packaging, dans le champ Nom de famille de package.

• Cause possible : Les métadonnées de périphérique ne sont pas associées au nom de famille de package. Utilisez l’Assistant de création de métadonnées de périphérique pour ouvrir les métadonnées de périphérique et vérifier le nom de famille de package. Lancez l’assistant depuis %ProgramFiles(x86)%\Windows Kits\8.1\bin\x86, en double-cliquant sur DeviceMetadataWizard.exe.

Problème : L’application est lancée dans la fenêtre contextuelle à masquage rapide puis est immédiatement rejetée

Si votre fenêtre contextuelle à masquage rapide personnalisée pour les paramètres d’impression avancés disparaît immédiatement après son lancement...

• Cause possible : Dans Windows 8, il existe un problème connu selon lequel dans une fenêtre contextuelle à masquage rapide, les applications UWP seront rejetées sous le débogueur. Désactivez le débogage une fois que vous savez que l’activation fonctionne. Si vous devez déboguer l’enregistrement du billet d’impression, attachez le débogueur après l’activation.

Rubriques connexes

Développement de pilotes d’impression v4

Interfaces d’extension d’imprimante (pilote d’impression v4)

Communications bidirectionnelles

Bien démarrer avec les applications UWP

Créer une application UWP pour périphérique (guide pas à pas)

Créer des métadonnées de périphérique pour une application UWP pour périphérique (guide étape par étape)