Cómo personalizar la configuración de impresión (aplicaciones de dispositivos para UWP)

En Windows 8.1, las aplicaciones de dispositivos para UWP permiten a los fabricantes de impresoras personalizar el control flotante que muestra la configuración avanzada de impresión. En este tema se presenta el panel de configuración avanzada de impresión y se muestra cómo la versión en C# del ejemplo de configuración de impresión y notificaciones de impresión reemplaza el panel predeterminado por uno personalizado. Para obtener más información sobre las aplicaciones de dispositivos para UWP en general, consulta Meet UWP device apps (Conocer aplicaciones de dispositivos para UWP).

La versión de C# del ejemplo Configuración de impresión e notificaciones de impresión usa la página Preferences.xaml para mostrar la interfaz de usuario de un control flotante personalizado para la configuración avanzada de impresión. Se usa una clase auxiliar de impresión para crear un contexto de dispositivo (IPrinterExtensionContext) y realizar las consultas del dispositivo. The PrinterHelperClass.cs file is in the DeviceAppForPrintersLibrary project and uses APIs defined in the PrinterExtensionLibrary project. La biblioteca de extensiones de impresora proporciona una manera cómoda de acceder a las interfaces de extensión de impresora del controlador de impresión v4. Para obtener más información, consulte la introducción a la biblioteca de extensiones de impresora.

Configuración avanzada de impresión

La experiencia avanzada de configuración de impresión es la funcionalidad que ofrece una impresora cuando un usuario quiere seleccionar la configuración de impresión que no se ofrece en la ventana Imprimir. It is accessible through the More settings link in the Print window. No es una experiencia de pantalla completa, pero se muestra dentro de un control flotante, que es un control para mostrar una interfaz de usuario contextual ligera que se descarta cuando un usuario hace clic o pulsa fuera de él.

Esta experiencia se puede usar para resaltar características diferenciadas para su impresora, como la capacidad de aplicar marcas de agua a una página de documentos, ofrecer opciones de impresión seguras o opciones de mejora de imágenes.

Cuando una aplicación de dispositivo para UWP no está instalada para una impresora, Windows proporciona una experiencia de configuración de impresión predeterminada. Si Windows detecta que una aplicación de dispositivo para UWP está instalada para la impresora y que la aplicación ha optado por la windows.printTaskSettings extensión, la aplicación reemplaza la experiencia predeterminada proporcionada por Windows.

Para invocar el control flotante para la configuración avanzada de impresión:

1. Abrir una aplicación para UWP que admita la impresión

2. Acceda a los accesos deslizando el dedo en el lado derecho de la pantalla (o mediante la tecla del logotipo de Windows + C)

3. Tap the Devices charm

4. Tap Print

5. Pulse una impresora.

6. The Print window opens

7. Click the More settings link on the Print window

8. Se abre el control flotante de configuración de impresión avanzada.

   • 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

Antes de comenzar:

1. Asegúrese de que la impresora está instalada mediante un controlador de impresión v4. Para obtener más información, consulte Desarrollo de controladores de impresión v4.

2. Configure tu PC de desarrollo. See Getting started for info about downloading the tools and creating a developer account.

3. Asocie la aplicación a la tienda. Consulta Crear una aplicación de dispositivo para UWP para obtener información sobre eso.

4. Cree metadatos de dispositivo para la impresora que la asocie a la aplicación. Consulte Creación de metadatos de dispositivo para obtener más información sobre eso.

5. Compile la interfaz de usuario para la página principal de la aplicación. Todas las aplicaciones de dispositivos para UWP se pueden iniciar desde Inicio, donde se mostrarán en pantalla completa. Utiliza la experiencia de inicio para resaltar tus productos o servicios de una manera que coincida con la imagen de marca y las características específicas de tus dispositivos. No hay restricciones especiales en el tipo de controles de interfaz de usuario que puede usar. Para empezar a trabajar con el diseño de la experiencia de pantalla completa, consulta los principios de diseño de 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. Puede encontrar cada uno de estos proyectos en el ejemplo Configuración de impresión e notificaciones de impresión .

Paso 1: Registrar la extensión

Para que Windows reconozca que la aplicación puede proporcionar un control flotante personalizado para la configuración avanzada de impresión, debe registrar la extensión de configuración de tareas de impresión. Esta extensión se declara en un Extension elemento, con un Category atributo establecido en un valor de windows.printTaskSettings. En los ejemplos de C# y C++, el Executable atributo se establece $targetnametoken$.exe en y el EntryPoint atributo se establece en DeviceAppForPrinters.App.

You can add the print task settings extension on the Declarations tab of the Manifest Designer in Microsoft Visual Studio. También puede editar manualmente el xml del manifiesto del paquete de la aplicación mediante el Editor XML (texto). 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>

Paso 2: Compilar la interfaz de usuario

Antes de compilar la aplicación, debe trabajar con los diseñadores y el equipo de marketing para diseñar la experiencia del usuario. La experiencia del usuario debe proyectar los aspectos de personalización de marca de su empresa y ayudarle a crear una conexión con los usuarios.

Design guidelines

Es importante revisar las directrices de control flotante de la aplicación para UWP antes de diseñar el control flotante personalizado. Las directrices ayudan a garantizar que el control flotante proporciona una experiencia intuitiva que es coherente con otras aplicaciones para UWP.

Para la página principal de la aplicación, tenga en cuenta que Windows 8.1 puede mostrar varias aplicaciones en varios tamaños en un solo monitor. Consulta las instrucciones siguientes para obtener más información sobre cómo la aplicación puede volver a conectarse correctamente entre tamaños de pantalla, tamaños de ventana y orientaciones.

• Directrices para tamaños de ventana y escalado a pantallas

• Directrices para cambiar el tamaño de las ventanas a diseños altos y estrechos

Flyout dimensions

El control flotante que muestra la configuración avanzada de impresión es de 646 píxeles de ancho y al menos 768 píxeles de alto (el alto real depende de la resolución de la pantalla del usuario). Windows proporciona el botón Atrás en el área de título del control flotante. El texto "Título de la aplicación" es el título de la aplicación del manifiesto de la aplicación. El área de título es de 80 píxeles de alto, dejando 688 píxeles para el área visible del control flotante personalizado.

Definición del color y el icono del título de la aplicación

Título, color de fondo, color de texto y el logotipo pequeño del control flotante personalizado se toma del VisualElements elemento del archivo de manifiesto del paquete de la aplicación.

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

• Mantén la misma apariencia. Alinee el control flotante personalizado con el diseño de la experiencia de inicio (la página principal de la aplicación), incluidos elementos como fuentes, colores y controles. La aplicación debe sentirse familiar para los usuarios, independientemente de dónde lo invoquen.

• Mantenga las interacciones sencillas. Evite interacciones complejas o lentas. En la mayoría de los casos, las acciones como configurar una impresora, ver el estado, ordenar la entrada de lápiz y solucionar problemas se realizan mejor dentro de la experiencia inicio.

• Mantenga la navegación a un mínimo. Evite hacer que los usuarios naveguen hacia atrás y hacia delante entre varias páginas en el control flotante personalizado. En su lugar, use controles de desplazamiento vertical o insertados, como controles de divulgación progresiva, listas desplegables y mensajes de error insertados.

• No use controles flotantes de cierre de luz. La experiencia de impresión ya usa un control flotante de cierre de luz. Incluir otro elemento de cierre de luz en el control flotante personalizado puede confundir a los usuarios.

• Deshabilite los vínculos que llevan a los usuarios fuera de la experiencia de impresión. Cuando un usuario está imprimiendo contenido, debe tomar medidas para asegurarse de que permanecen en el contexto de impresión. Por ejemplo, si la aplicación tiene vínculos que conducen a otras áreas de la aplicación (por ejemplo, a una página principal o a una página para comprar entrada de lápiz), debe deshabilitarlos para que el usuario no deje accidentalmente la experiencia avanzada de configuración de impresión.

Paso 3: Controlar la activación

Si la aplicación ha declarado la extensión de configuración de tareas de impresión, debe implementar un OnActivated método para controlar el evento de activación de la aplicación. La activación de la aplicación es cuando la aplicación puede elegir qué página se iniciará a medida que se inicia la aplicación. En el caso de las aplicaciones que han declarado la extensión de configuración de tareas de impresión, Windows pasa el contexto de extensión de tarea de impresión en los argumentos del evento Activado: 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. A continuación, los argumentos del evento se convierten como 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);
        }
    }
}

Paso 4: Mostrar la configuración

Cuando se llama al LoadAdvancedPrintSettingsContext método , el contexto de configuración de la tarea de impresión se asigna a las variables de la clase MainPage. Esto permitirá que el control flotante personalizado acceda a la configuración de impresión cuando se inicie.

Los argumentos de evento que se pasan al LoadAdvancedPrintSettingsContext método exponen las propiedades para acceder y controlar la impresora:

• The args.configuration property provides an object of type Windows.Devices.Printers.Extensions.PrintTaskConfiguration. Este objeto proporciona acceso al contexto de extensión de tarea de impresión y también permite agregar un controlador de eventos para actualizar el vale de impresión.
• The args.configuration.printerExtensionContext property provides an object of type Windows.Devices.Printers.Extensions.PrinterExtensionContext. Este objeto es un puntero a las interfaces PrinterExtensionLibrary para la información sobre el esquema de impresión, PrintTicket y la cola de impresión. Será NULL si no se expone ninguna interfaz. Para obtener más información, consulta Información general sobre la biblioteca de extensiones de impresora.

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. Descargue la configuración de impresión y el ejemplo de notificaciones de impresión para ver el código completo.

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).

Una vez creados esos objetos, el contexto del dispositivo de impresora se usa en el DisplaySettings método para cargar TextBlocks y ComboBoxes. Tenga en cuenta que, a diferencia de JavaScript, los cambios en la selección no se activan en el mismo subproceso que el resto de la aplicación. Tiene que mantener una caché local de selecciones de usuario para usarlas más adelante.

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

Paso 5: Guardar la configuración

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). Cuando esto sucede, se desencadena el SaveRequested evento del contexto de extensión de tarea de impresión (el configuration objeto).

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

En el OnSaveRequested método , la aplicación usa primero el printHelper objeto para establecer las opciones seleccionadas actualmente para cada característica en el contexto de la extensión de impresora. A continuación, llama al Save método en el request objeto que se pasa como argumento al OnSaveRequested método . El Save método, de la clase Windows.Devices.Printers.Extensions.PrintTaskConfigurationSaveRequest, usa el contexto de la extensión de impresora para validar el vale de impresión y guardar la configuración de la tarea de impresión.

This example shows the OnSaveRequested method in the Preferences.xaml.cs file. Dado que el SaveRequested evento no se genera en el subproceso de la interfaz de usuario, debe usar windows.UI.Core.CoreDispatcher para publicar mensajes en el subproceso de la interfaz de usuario para mostrar los mensajes adecuados al validar y guardar el vale.

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

Guardar opciones que requieren la entrada del usuario

En el ejemplo Configuración de impresión e notificaciones de impresión se muestra cómo establecer características definidas, que abarcan la mayoría de las opciones de impresión. Sin embargo, algunas opciones requieren una interfaz de usuario personalizada para obtener un valor especificado por el usuario. Por ejemplo, si una aplicación usa la configuración de impresión avanzada para especificar un tamaño de página personalizado, realizaría estos pasos para guardar el valor especificado por el usuario:

1. Recupere el vale de impresión durante la activación de la aplicación. La activación de la aplicación para la configuración de impresión se describe anteriormente en Paso 3: Controlar la activación.

2. Compruebe si se especifica la opción de tamaño de página. En una aplicación de C# o JS, la clase auxiliar de impresión puede comprobar esta opción. En una aplicación de C++, llame a QueryInterface en IPrintSchemaOption para recuperar IPrintSchemaPageMediaSizeOption.

   En este ejemplo se muestra un método en una clase auxiliar de impresión que comprueba si se especifica la opción de tamaño de página.

   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. En el control flotante personalizado, muestra una interfaz de usuario personalizada que solicita al usuario el alto y el ancho de la página, y recupera el alto y ancho especificados por el usuario de IPrintSchemaPageMediaSizeOption.

   En este ejemplo se muestra un método para un control flotante personalizado que solicita al usuario el alto y el ancho de la página.

   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. Actualice el IPrintSchemaPageMediaSizeOption objeto con los valores especificados por el usuario y compruebe que el alto y el ancho coinciden con los valores especificados por el usuario.

   Este ejemplo es un método auxiliar para actualizar el IPrintSchemaPageMediaSizeOption objeto en una clase auxiliar de impresora. El OnSaveRequested controlador del control flotante personalizado llamaría a esta función si determina que se solicitó una opción de tamaño de página personalizada.

   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

Para poder probar la aplicación de dispositivo para UWP, debe estar vinculada a la impresora mediante metadatos del dispositivo.

• Necesita una copia del paquete de metadatos del dispositivo para la impresora, para agregarle la información de la aplicación del dispositivo. Si no tiene metadatos de dispositivo, puede compilarlos mediante el Asistente para creación de metadatos de dispositivo, tal como se describe en el tema Crear metadatos de dispositivo para la aplicación de dispositivo para UWP.

  Note

  Para usar el Asistente para creación de metadatos de dispositivo, debe instalar Microsoft Visual Studio Professional, Microsoft Visual Studio Ultimate o el SDK independiente para Windows 8.1, antes de completar los pasos de este tema. La instalación de Microsoft Visual Studio Express para Windows instala una versión del SDK que no incluye el asistente.

Los pasos siguientes compilan la aplicación e instalan los metadatos del dispositivo.

1. Habilite la firma de prueba.

   1. Inicie el Asistente para creación de metadatos de dispositivo desde %ProgramFiles(x86)%\Windows Kits\8.1\bin\x86 haciendo doble clic enDeviceMetadataWizard.exe

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

2. Reiniciar el equipo

3. Compile la solución abriendo el archivo de solución (.sln). Pulse F7 o vaya a Crear->Crear solución en el menú superior después de cargar el ejemplo.

4. Desconecte y desinstale la impresora. Este paso es necesario para que Windows lea los metadatos del dispositivo actualizado la próxima vez que se detecte el dispositivo.

5. Edite y guarde los metadatos del dispositivo. Para vincular la aplicación de dispositivo al dispositivo, debe asociar la aplicación de dispositivo al dispositivo.

   Note

   Si aún no has creado los metadatos del dispositivo, consulta Crear metadatos de dispositivo para tu aplicación de dispositivo para UWP.

   1. Si el Asistente para creación de metadatos de dispositivo aún no está abierto, inícielo desde %ProgramFiles(x86)%\Windows Kits\8.1\bin\x86, haciendo doble clic enDeviceMetadataWizard.exe.

   2. Haga clic en Editar metadatos del dispositivo. Esto le permitirá editar el paquete de metadatos del dispositivo existente.

   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. En la página Especificar información de la aplicación de dispositivo para UWP , escriba la información de la aplicación de Microsoft Store en el cuadro aplicación de dispositivo para UWP . Haz clic en Importar archivo de manifiesto de aplicación para UWP para escribir automáticamente el nombre del paquete, el nombre del publicador y el identificador de la aplicación para 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. En la página Revisar el paquete de metadatos del dispositivo , asegúrese de que toda la configuración es correcta y active la casilla Copiar el paquete de metadatos del dispositivo en el almacén de metadatos del equipo local . Then click Save.

6. Vuelva a conectar la impresora para que Windows lea los metadatos del dispositivo actualizados cuando el dispositivo esté conectado.

Troubleshooting

Problema: La configuración avanzada de impresión muestra el control flotante predeterminado en lugar del control flotante personalizado

Si el control flotante de configuración de impresión avanzada muestra el control flotante predeterminado en lugar del control flotante personalizado que implementa la aplicación...

• Possible cause: Test signing is not turned on. Consulte la sección Depuración de este tema para obtener información sobre cómo activarla.

• Possible cause: The app is not querying for the right Package Family Name. Compruebe el nombre de familia del paquete en el código. 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. Use el Asistente para creación de metadatos de dispositivo para abrir los metadatos del dispositivo y comprobar el nombre de familia del paquete. Start the wizard from %ProgramFiles(x86)%\Windows Kits\8.1\bin\x86, by double-clicking DeviceMetadataWizard.exe.

Problema: la aplicación se inicia en el control flotante y, a continuación, se descarta inmediatamente.

Si el control flotante personalizado para la configuración avanzada de impresión desaparece inmediatamente después de iniciarse...

• Possible cause: In Windows 8, there is a known issue that within a flyout, UWP apps will be dismissed under the debugger. Desactive la depuración una vez que sepa que la activación funciona. Si necesita depurar guardar el vale de impresión, adjunte el depurador después de la activación.

Related topics

• desarrollo de controladores de impresión v4
• Interfaces de extensión de impresora (controlador de impresión v4)
• Bidirectional Communications
• Introducción a las aplicaciones para UWP
• Creación de una aplicación de dispositivo para UWP (guía paso a paso)
• Creación de metadatos de dispositivo para una aplicación de dispositivo para UWP (guía paso a paso)