Comment personnaliser les paramètres d’impression (applications d’appareil UWP)

Dans Windows 8.1, les applications d’appareil UWP permettent aux fabricants d’imprimantes de personnaliser le menu volant qui affiche les paramètres d’impression avancés. Cette rubrique présente le menu volant des paramètres d’impression avancés et montre comment la version C# des paramètres d’impression et de l’exemple de notifications d’impression remplace le menu volant par défaut par un menu volant personnalisé. Pour en savoir plus sur les applications d’appareil UWP en général, consultez Meet UWP device apps.

La version C# des paramètres d’impression et de l’exemple de notifications d’impression utilise la page Preferences.xaml pour illustrer l’interface utilisateur d’un menu volant personnalisé pour les paramètres d’impression avancés. Une classe d’assistance d’impression est utilisée pour créer un contexte d’appareil (IPrinterExtensionContext) et effectuer les requêtes d’appareil. The PrinterHelperClass.cs file is in the DeviceAppForPrintersLibrary project and uses APIs defined in the PrinterExtensionLibrary project. La bibliothèque d’extensions d’imprimante offre un moyen pratique d’accéder aux interfaces d’extension d’imprimante du pilote d’impression v4. Pour plus d’informations, consultez la vue d’ensemble de la bibliothèque d’extensions d’imprimante.

Paramètres d’impression avancés

L’expérience avancée des paramètres d’impression est la fonctionnalité qu’offre une imprimante lorsqu’un utilisateur souhaite sélectionner les paramètres d’impression qui ne sont pas proposés dans la fenêtre Imprimer. It is accessible through the More settings link in the Print window. Il ne s’agit pas d’une expérience en plein écran, mais s’affiche dans un menu volant, qui est un contrôle permettant d’afficher une interface utilisateur légère et contextuelle qui est ignorée lorsqu’un utilisateur clique ou appuie en dehors de celui-ci.

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

Lorsqu’une application d’appareil UWP 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 d’appareil UWP est installée pour votre imprimante et que l’application a choisi l’extension windows.printTaskSettings , votre application remplace l’expérience par défaut fournie par Windows.

Pour appeler le menu volant pour les paramètres d’impression avancés :

1. Ouvrir une application UWP prenant en charge l’impression

2. Accédez aux icônes en balayant sur le côté droit de l’écran (ou à l’aide de la touche de logo Windows + C)

3. Tap the Devices charm

4. Tap Print

5. Appuyez sur une imprimante

6. The Print window opens

7. Click the More settings link on the Print window

8. Le menu volant paramètres d’impression avancés s’ouvre

   • The default flyout appears when no UWP device app for the printer is installed

   • A custom flyout appears when a UWP device app for the printer is installed

Prerequisites

Avant de commencer :

1. Vérifiez que votre imprimante est installée à l’aide d’un pilote d’impression v4. Pour plus d’informations, consultez Développement de pilotes d’impression v4.

2. Configurez votre PC de développement. See Getting started for info about downloading the tools and creating a developer account.

3. Associez votre application au Windows Store. Pour plus d’informations sur cela, consultez Créer une application d’appareil UWP .

4. Créez des métadonnées d’appareil pour votre imprimante qui l’associe à votre application. Pour en savoir plus, consultez Créer des métadonnées d’appareil .

5. Générez l’interface utilisateur pour la page principale de votre application. Toutes les applications d’appareil UWP peuvent être lancées à partir de l’écran de démarrage, où elles s’affichent en plein écran. Utilisez l’expérience de démarrage pour mettre en évidence vos produits ou services d’une manière qui correspond à la personnalisation et aux fonctionnalités spécifiques de vos appareils. Il n’existe aucune restriction spéciale sur le type de contrôles d’interface utilisateur qu’il peut utiliser. Pour commencer à concevoir l’expérience en plein écran, consultez les principes de conception du Microsoft Store.

6. If you're writing your app with C# or JavaScript, add the PrinterExtensionLibrary and DeviceAppForPrintersLibrary projects to your UWP device app solution. Vous trouverez chacun de ces projets dans les paramètres d’impression et l’exemple de notifications d’impression .

Étape 1 : Inscrire l’extension

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

You can add the print task settings extension on the Declarations tab of the Manifest Designer in Microsoft Visual Studio. Vous pouvez également modifier manuellement le xml du manifeste du package d’application à l’aide de l’éditeur XML (texte). Right-click the Package.appxmanifest file in Solution Explorer for editing options.

This example shows the print task settings extension in the Extension element, as it appears in the app package manifest file, 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 : Générer l’interface utilisateur

Avant de créer votre application, vous devez travailler avec vos concepteurs et votre équipe marketing pour concevoir l’expérience utilisateur. L’expérience utilisateur doit projeter les aspects de personnalisation de votre entreprise et vous aider à créer une connexion avec vos utilisateurs.

Design guidelines

Il est important de passer en revue les instructions de menu volant de l’application UWP avant de concevoir votre menu volant personnalisé. Les instructions permettent de s’assurer que votre menu volant offre une expérience intuitive 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 de différentes tailles sur un seul moniteur. Consultez les instructions suivantes pour en savoir plus sur la façon dont votre application peut reflower correctement entre les tailles d’écran, les tailles de fenêtre et les orientations.

• Recommandations en matière de tailles de fenêtre et de mise à l’échelle vers les écrans

• Recommandations en matière de redimensionnement des fenêtres sur des dispositions hautes et étroites

Flyout dimensions

Le menu volant qui affiche les paramètres d’impression avancés est de 646 pixels de large et d’au moins 768 pixels (la hauteur réelle dépend de la résolution de l’écran de l’utilisateur). Le bouton Précédent dans la zone de titre du menu volant est fourni par Windows. Le texte « Titre de l’application » est le titre de l’application à partir du manifeste de l’application. La zone de titre est de 80 pixels de haut, ce qui laisse 688 pixels pour la zone visible du menu volant personnalisé.

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

Le titre, la couleur d’arrière-plan, la couleur du texte et le petit logo du menu volant personnalisé sont extraits de l’élément VisualElements du fichier manifeste du package d’application.

This example shows the title and icon, as defined in the VisualElements element, in the app package manifest file (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>

Best practices

• Gardez la même apparence. Alignez votre menu volant personnalisé avec la conception de votre expérience de démarrage (la page principale de votre application), y compris les éléments tels que les polices, les couleurs et les contrôles. L’application doit se sentir familière aux personnes quel que soit l’endroit à partir duquel elles l’appellent.

• Gardez les interactions simples. Évitez les interactions fastidieuses ou complexes. Dans la plupart des cas, les actions telles que la configuration d’une imprimante, l’affichage de l’état, l’ordre des entrées manuscrites et la résolution des problèmes sont optimales dans l’expérience de démarrage.

• Conservez la navigation au minimum. Évitez de faire naviguer vos utilisateurs entre plusieurs pages dans votre menu volant personnalisé. Utilisez plutôt des contrôles de défilement vertical ou inline, tels que des contrôles de divulgation progressive, des listes déroulantes et des messages d’erreur inline.

• N’utilisez pas de menu volants d’abandon clair. L’expérience d’impression utilise déjà un menu volant d’abandon clair. L’inclusion d’un autre élément d’abandon clair dans votre menu volant personnalisé peut confondre vos utilisateurs.

• Désactivez les liens qui éloignent les utilisateurs de l’expérience d’impression. Lorsqu’un utilisateur imprime du contenu, vous devez prendre des mesures pour vous assurer qu’il reste dans le contexte d’impression. Par exemple, si votre application comporte des liens qui mènent à d’autres zones de votre application (par exemple, vers une page d’accueil ou une page pour l’achat d’encre), vous devez les désactiver afin que l’utilisateur ne quitte pas l’expérience avancée des paramètres d’impression accidentellement.

É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 OnActivated méthode pour gérer l’événement Activation de l’application. L’activation de l’application est lorsque votre application peut choisir la page qui démarre à mesure que l’application démarre. Pour les applications qui ont déclaré l’extension des paramètres de tâche d’impression, Windows transmet le contexte d’extension de tâche d’impression dans les arguments d’événement activés : Windows.ApplicationModel.Activation.IActivatedEventArgs.

A UWP device app can determine that the activation is intended for advanced print settings (that someone just tapped More options on the print settings dialog) when the event argument's kind property is equal to Windows.ApplicationModel.Activation.ActivationKind.printTaskSettings.

This example shows the activation event handler in the OnActivated method, as it appears in the Constants.cs file. Les arguments d’événement sont ensuite castés en tant que Windows.ApplicationModel.Activation.PrintTaskSettingsActivatedEventArgs. Although the sample includes this code in the Constants.cs file, it's actually part of the App class that is also defined in the App.xaml.cs file.

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 : Afficher les paramètres

Lorsque la LoadAdvancedPrintSettingsContext méthode est appelée, le contexte de configuration de tâche d’impression est affecté aux variables de la classe MainPage. Cela permet au menu volant personnalisé d’accéder aux paramètres d’impression lors du lancement.

Les arguments d’événement passés à la LoadAdvancedPrintSettingsContext méthode, exposent les propriétés d’accès et de contrôle de l’imprimante :

• The args.configuration property provides an object of type Windows.Devices.Printers.Extensions.PrintTaskConfiguration. Cet objet fournit un accès au contexte d’extension de tâche d’impression et vous permet également d’ajouter un gestionnaire d’événements pour mettre à jour le ticket d’impression.
• The args.configuration.printerExtensionContext property provides an object of type Windows.Devices.Printers.Extensions.PrinterExtensionContext. Cet objet est un pointeur vers les interfaces PrinterExtensionLibrary pour les informations de schéma d’impression, printTicket et file d’attente d’impression. Elle sera null si aucune interface n’est exposée. Pour plus d’informations, consultez la vue d’ensemble de la bibliothèque d’extensions d’imprimante.

This example shows the LoadAdvancedPrintSettingsContext method, as it appears in the Constants.cs file.

public PrintTaskConfiguration Config;
public Object Context;

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

On the custom flyout page, Preferences.xaml.cs, a class named rootPage acts as a pointer to the MainPage class so that the print task extension context and the printer device context can be accessed from the flyout.

This example shows the pointer in a portion of Preferences class, from the Preferences.xaml.cs file. Téléchargez les paramètres d’impression et l’exemple de notifications d’impression pour afficher 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 };

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

When the page constructor for Preferences.xaml.cs is called, objects are created for the print task extension context (a PrintTaskConfiguration object named configuration) and the printer device context (a PrintHelperClass object named printHelper).

Une fois ces objets créés, le contexte d’appareil d’imprimante est utilisé dans la DisplaySettings méthode pour charger TextBlocks et ComboBoxes. Notez que contrairement à JavaScript, les modifications de la sélection ne sont pas déclenchées sur le même thread que le reste de l’application. Vous devez conserver un cache local des sélections d’utilisateurs à utiliser ultérieurement.

This example shows the custom flyout page constructor, DisplaySettings, and other helper methods in the Preferences.xaml.cs file.

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 : Enregistrer les paramètres

When the user has finished setting advanced print settings, the Microsoft Store device app needs to save the changes before the user goes back to the Print window. To do that, the app needs to listen for when the user taps the Back button (from the custom flyout page). Lorsque cela se produit, l’événement SaveRequested du contexte d’extension de tâche d’impression (l’objet configuration ) est déclenché.

This example shows the event listener for SaveRequested, being added in the OnNavigatedTo event handler of the custom flyout, in the Preferences.xaml.cs file. When the SaveRequested event is triggered, the OnSaveRequested method will be invoked (that method is also in the Preferences.xaml.cs file).

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 OnSaveRequested méthode, l’application utilise d’abord l’objet printHelper pour définir les options actuellement sélectionnées pour chaque fonctionnalité dans le contexte d’extension d’imprimante. Ensuite, il appelle la Save méthode sur l’objet request qui est passé en tant qu’argument à la OnSaveRequested méthode. La Save méthode, à partir de la classe Windows.Devices.Printer.Extensions.PrintTaskConfigurationSaveRequest, utilise le contexte d’extension d’imprimante pour valider le ticket d’impression et enregistrer la configuration de la tâche d’impression.

This example shows the OnSaveRequested method in the Preferences.xaml.cs file. Étant donné que l’événement SaveRequested n’est pas déclenché sur le thread d’interface utilisateur, il doit utiliser un Windows.UI.Core.CoreDispatcher pour publier des messages dans le thread d’interface utilisateur pour afficher les messages appropriés lors de la validation et de l’enregistrement du ticket.

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();
}

Enregistrement des options qui nécessitent une entrée utilisateur

L’exemple de paramètres d’impression et de notifications d’impression montre comment définir des fonctionnalités définies, qui couvrent la plupart des options d’impression. Toutefois, certaines options nécessitent une interface utilisateur personnalisée pour obtenir une valeur spécifiée par l’utilisateur. Par exemple, si une application a utilisé les paramètres d’impression avancés pour spécifier une taille de page personnalisée, procédez comme suit pour enregistrer la valeur spécifiée par l’utilisateur :

1. Récupérez le ticket d’impression pendant l’activation de l’application. L’activation de l’application pour les paramètres d’impression est décrite plus haut à l’étape 3 : Gérer l’activation.

2. Vérifiez 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 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 le menu volant personnalisé, affichez une interface utilisateur personnalisée qui demande à l’utilisateur la hauteur et la largeur de la page, puis récupérez la hauteur et la largeur spécifiées par l’utilisateur à partir de IPrintSchemaPageMediaSizeOption.

   Cet exemple montre une méthode pour un menu volant personnalisé 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 vérifiez 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 OnSaveRequested gestionnaire dans le menu volant personnalisé appelle 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);
      }
   }
   

Testing

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

• Vous avez besoin d’une copie du package de métadonnées d’appareil pour votre imprimante pour y ajouter les informations de l’application d’appareil. Si vous n’avez pas de métadonnées d’appareil, vous pouvez le générer à l’aide de l’Assistant Création de métadonnées d’appareil, comme décrit dans la rubrique Créer des métadonnées d’appareil pour votre application d’appareil UWP.

  Note

  Pour utiliser l’Assistant Création de métadonnées d’appareil, vous devez installer Microsoft Visual Studio Professional, Microsoft Visual Studio Ultimate ou le KIT de développement logiciel (SDK) autonome pour Windows 8.1, avant de suivre les étapes décrites dans cette rubrique. L’installation de Microsoft Visual Studio Express pour Windows installe une version du Kit de développement logiciel (SDK) qui n’inclut pas l’Assistant.

Les étapes suivantes créent votre application et installent les métadonnées de l’appareil.

1. Activez la signature de test.

   1. Démarrez l’Assistant Création de métadonnées d’appareil à partir de %ProgramFiles(x86)%\Windows Kits\8.1\bin\x86, en double-cliquant sur DeviceMetadataWizard.exe

   2. From the Tools menu, select Enable Test Signing.

2. Redémarrer l’ordinateur

3. Générez la solution en ouvrant le fichier de solution (.sln). Appuyez sur F7 ou accédez à Build-Build> Solution à partir du menu supérieur une fois l’exemple chargé.

4. Déconnectez et désinstallez l’imprimante. Cette étape est requise pour que Windows lise les métadonnées de l’appareil mises à jour la prochaine fois que l’appareil est détecté.

5. Modifiez et enregistrez les métadonnées de l’appareil. Pour lier l’application d’appareil à votre appareil, vous devez associer l’application d’appareil à votre appareil

   Note

   Si vous n’avez pas encore créé vos métadonnées d’appareil, consultez Créer des métadonnées d’appareil pour votre application d’appareil UWP.

   1. Si l’Assistant Création de métadonnées d’appareil n’est pas encore ouvert, démarrez-le à partir de %ProgramFiles(x86)%\Windows Kits\8.1\bin\x86, en double-cliquant sur DeviceMetadataWizard.exe.

   2. Cliquez sur Modifier les métadonnées de l’appareil. Cela vous permet de modifier votre package de métadonnées d’appareil existant.

   3. In the Open dialog box, locate the device metadata package associated with your UWP device app. (It has a devicemetadata-ms file extension.)

   4. Dans la page Spécifier les informations de l’application d’appareil UWP , entrez les informations d’application du Microsoft Store dans la zone d’application d’appareil UWP . Cliquez sur Importer le fichier manifeste de l’application UWP pour entrer automatiquement le nom du package, le nom du serveur de publication et l’ID d’application UWP.

   5. If your app is registering for printer notifications, fill out the Notification handlers box. In Event ID, enter the name of the print event handler. In Event Asset, enter the name of the file where that code resides.

   6. When you're done, click Next until you get to the Finish page.

   7. Dans la page Vérifier le package de métadonnées de l’appareil , vérifiez que tous les paramètres sont corrects et activez la case à cocher Copier le package de métadonnées de l’appareil dans le magasin de métadonnées sur l’ordinateur local . Then click Save.

6. Reconnectez votre imprimante afin que Windows lit les métadonnées d’appareil mises à jour lorsque l’appareil est connecté.

Troubleshooting

Problème : les paramètres d’impression avancés affichent le menu volant par défaut au lieu du menu volant personnalisé

Si le menu volant des paramètres d’impression avancés affiche le menu volant par défaut au lieu du menu volant personnalisé que votre application implémente...

• Possible cause: Test signing is not turned on. Pour plus d’informations sur l’activation, consultez la section Débogage de cette rubrique.

• Possible cause: The app is not querying for the right Package Family Name. Vérifiez le nom de la famille de packages dans votre code. Open up package.appxmanifest in Visual Studio and make sure that the package family name you are querying for matches the one in the Packaging tab, in the Package Family Name field.

• Possible cause: The device metadata is not associated with the Package Family Name. Utilisez l’Assistant Création de métadonnées d’appareil pour ouvrir les métadonnées de l’appareil et vérifier le nom de la famille de packages. Start the wizard from %ProgramFiles(x86)%\Windows Kits\8.1\bin\x86, by double-clicking DeviceMetadataWizard.exe.

Problème : l’application est lancée dans le menu volant, puis est immédiatement ignorée

Si votre menu volant personnalisé pour les paramètres d’impression avancés disparaît immédiatement après son lancement...

• Possible cause: In Windows 8, there is a known issue that within a flyout, UWP apps will be dismissed under the debugger. Désactivez le débogage une fois que vous savez que l’activation fonctionne. Si vous devez déboguer l’enregistrement du ticket d’impression, joignez le débogueur après l’activation.

Related topics

• Développement de pilotes d’impression v4
• Interfaces d’extension d’imprimante (pilote d’impression v4)
• Bidirectional Communications
• Prise en main des applications UWP
• Créer une application d’appareil UWP (guide pas à pas)
• Créer des métadonnées d’appareil pour une application d’appareil UWP (guide pas à pas)