Udostępnij przez

Jak dostosować ustawienia drukowania (aplikacje urządzeń platformy UWP)

Important

Metadane urządzenia są przestarzałe i zostaną usunięte w przyszłej wersji systemu Windows. Aby uzyskać informacje o zastąpieniu tej funkcji, zobacz Driver Package Container Metadata (Metadane kontenera pakietów sterowników).

W systemie Windows 8.1 aplikacje urządzeń platformy UNIWERSALNEJ systemu Windows umożliwiają producentom drukarek dostosowanie wysuwane wyświetlające zaawansowane ustawienia drukowania. W tym temacie przedstawiono okno wysuwane zaawansowanych ustawień drukowania i pokazano, jak przykład C# ustawień drukowania i powiadomień drukowania zastępuje domyślne okno wysuwane oknem niestandardowym. Aby dowiedzieć się więcej o aplikacjach urządzeń platformy uniwersalnej systemu Windows, zobacz Poznaj aplikacje urządzeń UWP.

Przykładowa wersja języka C# ustawień drukowania i powiadomień drukowania używa strony Preferences.xaml w celu zademonstrowania interfejsu użytkownika niestandardowego wysuwanego dla zaawansowanych ustawień drukowania. Klasa pomocnika wydruku służy do tworzenia kontekstu urządzenia (IPrinterExtensionContext) i wykonywania zapytań dotyczących urządzenia. The PrinterHelperClass.cs file is in the DeviceAppForPrintersLibrary project and uses APIs defined in the PrinterExtensionLibrary project. Biblioteka rozszerzeń drukarki zapewnia wygodny sposób uzyskiwania dostępu do interfejsów rozszerzeń drukarki sterownika wydruku w wersji 4. Aby uzyskać więcej informacji, zobacz Omówienie biblioteki rozszerzeń drukarki.

Note

Przykłady kodu pokazane w tym temacie są oparte na wersji języka C# ustawień drukowania i przykładowych powiadomień drukowania . Ten przykład jest również dostępny w językach JavaScript i C++. Należy pamiętać, że ponieważ język C++ może uzyskać bezpośredni dostęp do interfejsu COM, wersja języka C++ przykładu nie zawiera projektów biblioteki kodu. Pobierz przykłady, aby wyświetlić najnowsze wersje kodu.

Zaawansowane ustawienia drukowania

Zaawansowane środowisko ustawień drukowania to funkcja oferowana przez drukarkę, gdy użytkownik chce wybrać ustawienia drukowania, które nie są oferowane w oknie Drukowanie. It is accessible through the More settings link in the Print window. Nie jest to środowisko pełnoekranowe, ale wyświetlane w oknie wysuwanym, który jest kontrolką służącą do wyświetlania lekkiego, kontekstowego interfejsu użytkownika, który jest odrzucany po kliknięciu lub naciśnięciu użytkownika poza nim.

To środowisko może służyć do wyróżniania zróżnicowanych funkcji drukarki, takich jak możliwość stosowania znaków wodnych do strony dokumentu, oferowania bezpiecznych opcji drukowania lub opcji ulepszania obrazu.

Jeśli aplikacja urządzenia platformy UNIWERSALNEJ systemu Windows nie jest zainstalowana dla drukarki, system Windows udostępnia domyślne ustawienia drukowania. Jeśli system Windows wykryje, że aplikacja urządzenia platformy uniwersalnej systemu Windows jest zainstalowana dla drukarki i że aplikacja zdecydowała się na windows.printTaskSettings rozszerzenie, aplikacja zastępuje domyślne środowisko udostępniane przez system Windows.

Aby wywołać okno wysuwane dla zaawansowanych ustawień drukowania:

  1. Otwieranie aplikacji platformy UNIWERSALNEJ systemu Windows obsługującej drukowanie

  2. Dostęp do paneli, przesuwając palcem po prawej stronie ekranu (lub przy użyciu logo systemu Windows + C)

  3. Tap the Devices charm

  4. Tap Print

  5. Naciśnij drukarkę

  6. The Print window opens

  7. Click the More settings link on the Print window

  8. Zostanie otwarte okno wysuwane zaawansowane ustawienia drukowania

    • 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

przykłady domyślnych i niestandardowych wysuwanych dla zaawansowanych ustawień drukowania.

Prerequisites

Przed rozpoczęciem pracy:

  1. Upewnij się, że drukarka jest zainstalowana przy użyciu sterownika wydruku w wersji 4. Aby uzyskać więcej informacji, zobacz Tworzenie sterowników wydruku wersji 4.

  2. Skonfiguruj komputer deweloperów. See Getting started for info about downloading the tools and creating a developer account.

  3. Skojarz aplikację ze sklepem. Aby uzyskać informacje na ten temat, zobacz Tworzenie aplikacji urządzenia uniwersalnego systemu Windows.

  4. Utwórz metadane urządzenia dla drukarki, która skojarzy ją z aplikacją. Aby uzyskać więcej informacji, zobacz Tworzenie metadanych urządzenia .

  5. Skompiluj interfejs użytkownika dla strony głównej aplikacji. Wszystkie aplikacje urządzeń platformy UWP można uruchamiać z poziomu ekranu startowego, w którym będą wyświetlane w trybie pełnoekranowym. Użyj środowiska Start, aby wyróżnić produkt lub usługi w sposób zgodny z określonymi znakami i funkcjami urządzeń. Nie ma specjalnych ograniczeń dotyczących typu kontrolek interfejsu użytkownika, których może używać. Aby rozpocząć projektowanie środowiska pełnoekranowego, zobacz Zasady projektowania sklepu 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. Każdy z tych projektów można znaleźć w przykładzie Ustawienia drukowania i powiadomienia drukowania .

Note

Ponieważ język C++ może uzyskiwać bezpośredni dostęp do modelu COM, aplikacje języka C++ nie wymagają oddzielnej biblioteki do pracy z kontekstem urządzenia drukarki opartej na modelu COM.

Krok 1. Rejestrowanie rozszerzenia

Aby system Windows rozpoznał, że aplikacja może dostarczyć niestandardowe okno wysuwane dla zaawansowanych ustawień drukowania, musi zarejestrować rozszerzenie ustawień zadania drukowania. To rozszerzenie jest zadeklarowane w elemecie Extension z atrybutem Category ustawionym na wartość windows.printTaskSettings. W przykładach języka C# i C++ atrybut Executable jest ustawiony na $targetnametoken$.exe , a atrybut EntryPoint jest ustawiony na DeviceAppForPrinters.App.

You can add the print task settings extension on the Declarations tab of the Manifest Designer in Microsoft Visual Studio. Możesz również ręcznie edytować plik XML manifestu pakietu aplikacji przy użyciu edytora XML (text). 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>

Krok 2. Kompilowanie interfejsu użytkownika

Przed utworzeniem aplikacji należy współpracować z projektantami i zespołem marketingowym w celu zaprojektowania środowiska użytkownika. Doświadczenie użytkownika powinno odzwierciedlać aspekty brandingowe Twojej firmy i pomagać w budowaniu relacji z użytkownikami.

Design guidelines

Przed projektowaniem niestandardowego wysuwanego menu, należy zapoznać się z wytycznymi dotyczącymi aplikacji UWP. Wytyczne pomagają zapewnić, że menu wysuwane oferuje intuicyjne doświadczenie użytkownika zgodne z innymi aplikacjami platformy UWP.

Na stronie głównej aplikacji należy pamiętać, że system Windows 8.1 może wyświetlać wiele aplikacji w różnych rozmiarach na jednym monitorze. Zapoznaj się z poniższymi wskazówkami, aby dowiedzieć się więcej na temat sposobu, w jaki aplikacja może swobodnie przepływać między rozmiarami ekranu, rozmiarami okien i orientacjami.

Flyout dimensions

Okno wysuwane wyświetlające zaawansowane ustawienia drukowania ma szerokość 646 pikseli i co najmniej 768 pikseli (rzeczywista wysokość zależy od rozdzielczości ekranu użytkownika). Przycisk Wstecz w obszarze tytułu wysuwanego jest dostarczany przez system Windows. Tekst "Tytuł aplikacji" to tytuł aplikacji z manifestu aplikacji. Obszar tytułu ma 80 pikseli wysokości, pozostawiając 688 pikseli dla widocznego obszaru wysuwanego niestandardowego.

wymiary wysuwane dla zaawansowanych ustawień drukarki.

Note

Jeśli niestandardowe okno wysuwane ma więcej niż 688 pikseli wysokości, użytkownik może przesuwać lub przewijać, aby wyświetlić części wysuwane, które znajdują się powyżej lub poniżej widocznego obszaru.

Definiowanie koloru i ikony tytułu aplikacji

Tytuł, kolor tła, kolor tekstu i małe logo na niestandardowym wysuwaniu są pobierane z VisualElements elementu w pliku manifestu pakietu aplikacji.

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

  • Zachowaj ten sam wygląd i działanie. Dopasuj niestandardowe okno wysuwane do projektu środowiska startowego (strona główna aplikacji), w tym elementy, takie jak czcionki, kolory i kontrolki. Aplikacja powinna czuć się znajoma dla osób niezależnie od tego, skąd ją wywołują.

  • Zachowaj proste interakcje. Unikaj czasochłonnych lub złożonych interakcji. W większości przypadków akcje, takie jak konfigurowanie drukarki, wyświetlanie stanu, zamawianie pisma odręcznego i rozwiązywanie problemów, najlepiej wykonywać w środowisku uruchamiania.

  • Zachowaj nawigację do minimum. Unikaj przechodzenia użytkowników między wieloma stronami w niestandardowym wysuwaniu. Zamiast tego należy używać kontrolek przewijania w pionie lub wbudowanych, takich jak kontrolki progresywnego ujawniania, listy rozwijane i wbudowane komunikaty o błędach.

  • Nie używaj lekkich wysuwanych rzutów. Środowisko drukowania używa już lekkiego wysuwanego odrzucania. Dołączenie innego elementu odrzucania światła w niestandardowym wysuwaniu może mylić użytkowników.

  • Wyłącz łącza, które prowadzą użytkowników z dala od środowiska drukowania. Gdy użytkownik drukuje zawartość, należy wykonać kroki, aby upewnić się, że pozostają w kontekście wydruku. Jeśli na przykład aplikacja zawiera linki prowadzące do innych obszarów aplikacji (takich jak strona główna lub strona zakupu pisma odkowego), należy je wyłączyć, aby użytkownik nie pozostawiał przypadkowo zaawansowanych ustawień drukowania.

Krok 3. Obsługa aktywacji

Jeśli aplikacja zadeklarowała rozszerzenie ustawień zadania drukowania, musi zaimplementować metodę OnActivated do obsługi zdarzenia aktywacji aplikacji. Aktywacja aplikacji jest wtedy, gdy aplikacja może wybrać, która strona zostanie uruchomiona podczas uruchamiania aplikacji. W przypadku aplikacji, które zadeklarowały rozszerzenie ustawień zadania drukowania, system Windows przekazuje kontekst rozszerzenia zadania drukowania w argumentach zdarzeń Aktywowane: 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.

Note

W niektórych przypadkach, jeśli użytkownik odrzuci aplikację natychmiast po jej uruchomieniu, może zostać zgłoszony wyjątek w procedurze obsługi aktywacji. Aby tego uniknąć, upewnij się, że procedura obsługi aktywacji jest wydajnie zakończona i nie wykonuje przetwarzania intensywnie korzystającego z zasobów.

This example shows the activation event handler in the OnActivated method, as it appears in the Constants.cs file. Argumenty zdarzeń są następnie rzutowane jako 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);
        }
    }
}

Krok 4. Wyświetlanie ustawień

Po wywołaniu LoadAdvancedPrintSettingsContext metody kontekst konfiguracji zadania drukowania jest przypisywany do zmiennych klasy MainPage. Dzięki temu niestandardowe okno wysuwane będzie uzyskiwać dostęp do ustawień drukowania po jej uruchomieniu.

Argumenty zdarzeń, które są przekazywane do LoadAdvancedPrintSettingsContext metody, uwidaczniają właściwości na potrzeby uzyskiwania dostępu do drukarki i kontrolowania jej:

  • The args.configuration property provides an object of type Windows.Devices.Printers.Extensions.PrintTaskConfiguration. Ten obiekt zapewnia dostęp do kontekstu rozszerzenia zadania drukowania, a także umożliwia dodanie programu obsługi zdarzeń w celu zaktualizowania biletu wydruku.
  • The args.configuration.printerExtensionContext property provides an object of type Windows.Devices.Printers.Extensions.PrinterExtensionContext. Ten obiekt jest wskaźnikiem do interfejsów PrinterExtensionLibrary dla informacji o schemacie wydruku, PrintTicket i wydruku kolejki. Jeśli interfejsy nie zostaną ujawnione, będzie mieć wartość null. Aby uzyskać więcej informacji, zobacz Omówienie biblioteki rozszerzeń drukarki.

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. Pobierz przykładowe ustawienia drukowania i powiadomienia drukowania, aby zobaczyć pełny kod.

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

Po utworzeniu tych obiektów kontekst urządzenia drukarki jest używany w metodzie DisplaySettings do ładowania obiektów TextBlocks i ComboBoxes. Należy pamiętać, że w przeciwieństwie do języka JavaScript zmiany w zaznaczeniu nie są wyzwalane w tym samym wątku co pozostała część aplikacji. Musisz zachować lokalną pamięć podręczną wybranych użytkowników do użycia w przyszłości.

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

Krok 5. Zapisywanie ustawień

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). W takim przypadku SaveRequested jest wyzwalane zdarzenie kontekstu rozszerzenia zadania drukowania ( configuration obiektu).

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

W metodzie OnSaveRequested aplikacja najpierw używa printHelper obiektu , aby ustawić aktualnie wybrane opcje dla każdej funkcji w kontekście rozszerzenia drukarki. Następnie wywołuje metodę Save w request obiekcie przekazywanym jako argument do OnSaveRequested metody . Metoda Save z klasy Windows.Devices.Printers.Extensions.PrintTaskConfigurationSaveRequest używa kontekstu rozszerzenia drukarki, aby zweryfikować bilet wydruku i zapisać konfigurację zadania drukowania.

Important

Jeśli bilet wydruku jest nieprawidłowy w jakikolwiek sposób, metoda zgłasza wyjątek, Save który musi obsłużyć aplikacja. Jeśli aplikacja nie obsługuje wyjątku, przepływ zostanie zatrzymany, zmuszając użytkownika do zwolnienia wysuwania i ponownego uruchomienia przepływu wydruku.

This example shows the OnSaveRequested method in the Preferences.xaml.cs file. SaveRequested Ponieważ zdarzenie nie jest wywoływane w wątku interfejsu użytkownika, należy użyć modułu Windows.UI.Core.CoreDispatcher do publikowania komunikatów w wątku interfejsu użytkownika w celu wyświetlenia odpowiednich komunikatów podczas walidacji i zapisywania biletu.

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

Zapisywanie opcji wymagających danych wejściowych użytkownika

W przykładzie Ustawienia drukowania i powiadomienia drukowania pokazano, jak ustawić zdefiniowane funkcje, które obejmują większość opcji drukowania. Jednak niektóre opcje wymagają niestandardowego interfejsu użytkownika, aby uzyskać wartość określoną przez użytkownika. Jeśli na przykład aplikacja użyła zaawansowanych ustawień drukowania w celu określenia niestandardowego rozmiaru strony, należy wykonać następujące kroki, aby zapisać wartość określoną przez użytkownika:

  1. Pobierz bilet wydruku podczas aktywacji aplikacji. Aktywacja aplikacji dla ustawień drukowania została opisana wcześniej w kroku 3: Obsługa aktywacji.

  2. Sprawdź, czy określono opcję rozmiaru strony. W aplikacji C# lub JS klasa pomocnika wydruku może sprawdzić tę opcję. W aplikacji języka C++ wywołaj metodę QueryInterface na stronie IPrintSchemaOption, aby pobrać element IPrintSchemaPageMediaSizeOption.

    W tym przykładzie przedstawiono metodę w klasie pomocnika wydruku, która sprawdza, czy określono opcję rozmiaru strony.

    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. W oknie wysuwanym niestandardowym wyświetl niestandardowy interfejs użytkownika, który prosi użytkownika o wysokość i szerokość strony oraz pobierz wysokość i szerokość określonego przez użytkownika z IPrintSchemaPageMediaSizeOption.

    W tym przykładzie pokazano metodę niestandardowego wysuwania, która prosi użytkownika o wysokość i szerokość strony.

    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. IPrintSchemaPageMediaSizeOption Zaktualizuj obiekt przy użyciu wartości określonych przez użytkownika i sprawdź, czy wysokość i szerokość są zgodne z wartościami określonymi przez użytkownika.

    Ten przykład to metoda pomocnika służąca do aktualizowania IPrintSchemaPageMediaSizeOption obiektu w klasie pomocnika drukarki. Procedura OnSaveRequested obsługi w niestandardowym wysuwaniu wywoła tę funkcję, jeśli określi, że zażądano niestandardowego rozmiaru strony.

    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

Aby można było przetestować aplikację urządzenia platformy UWP, należy ją połączyć z drukarką przy użyciu metadanych urządzenia.

  • Aby dodać do niego informacje o aplikacji urządzenia, potrzebna jest kopia pakietu metadanych urządzenia dla drukarki. Jeśli nie masz metadanych urządzenia, możesz je skompilować przy użyciu Kreatora tworzenia metadanych urządzenia zgodnie z opisem w temacie Tworzenie metadanych urządzenia dla aplikacji urządzenia platformy UWP.

    Note

    Aby użyć Kreatora tworzenia metadanych urządzenia, przed wykonaniem kroków opisanych w tym temacie należy zainstalować program Microsoft Visual Studio Professional, Microsoft Visual Studio Ultimate lub autonomiczny zestaw SDK dla systemu Windows 8.1. Zainstalowanie programu Microsoft Visual Studio Express dla systemu Windows powoduje zainstalowanie wersji zestawu SDK, która nie zawiera kreatora.

W poniższych krokach skompiluj aplikację i zainstaluj metadane urządzenia.

  1. Włącz podpisywanie testowe.

    1. Uruchom Kreatora tworzenia metadanych urządzenia z %ProgramFiles(x86)%\Windows Kits\8.1\bin\x86, klikając dwukrotnie DeviceMetadataWizard.exe

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

  2. Uruchom ponownie komputer

  3. Skompiluj rozwiązanie, otwierając plik rozwiązania (.sln). Naciśnij F7 lub przejdź do Buduj-Kompiluj rozwiązanie> z górnego menu po załadowaniu przykładu.

  4. Odłącz i odinstaluj drukarkę. Ten krok jest wymagany, aby system Windows odczytał zaktualizowane metadane urządzenia przy następnym wykryciu urządzenia.

  5. Edytowanie i zapisywanie metadanych urządzenia. Aby połączyć aplikację urządzenia z urządzeniem, musisz skojarzyć aplikację urządzenia z urządzeniem

    Note

    Jeśli metadane urządzenia nie zostały jeszcze utworzone, zobacz Tworzenie metadanych urządzenia dla aplikacji urządzenia platformy UWP.

    1. Jeśli Kreator tworzenia metadanych urządzenia nie jest jeszcze otwarty, uruchom go od %ProgramFiles(x86)%\Windows Kits\8.1\bin\x86, klikając dwukrotnie DeviceMetadataWizard.exe.

    2. Kliknij pozycję Edytuj metadane urządzenia. Umożliwi to edytowanie istniejącego pakietu metadanych urządzenia.

    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. Na stronie Określanie informacji o aplikacji urządzenia UWP wprowadź informacje o aplikacji ze Sklepu Microsoft w polu tekstowym Aplikacja urządzenia platformy UWP. Kliknij pozycję Importuj plik manifestu aplikacji platformy UWP , aby automatycznie wprowadzić nazwę pakietu, nazwę wydawcy i identyfikator aplikacji platformy 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. Na stronie Przeglądanie pakietu metadanych urządzenia upewnij się, że wszystkie ustawienia są poprawne, a następnie zaznacz pole wyboru Kopiuj pakiet metadanych urządzenia do magazynu metadanych na komputerze lokalnym . Then click Save.

  6. Połącz ponownie drukarkę, aby system Windows odczytał zaktualizowane metadane urządzenia po nawiązaniu połączenia z urządzeniem.

Troubleshooting

Problem: Zaawansowane ustawienia drukowania pokazują domyślne menu wysuwane zamiast niestandardowego wysuwanego

Jeśli zaawansowane ustawienia drukowania wysuwane wyświetla domyślne okno wysuwane zamiast niestandardowego wysuwanego implementowania aplikacji...

  • Possible cause: Test signing is not turned on. Aby uzyskać informacje na temat włączania go, zobacz sekcję Debugowanie w tym temacie.

  • Possible cause: The app is not querying for the right Package Family Name. Sprawdź nazwę rodziny pakietów w kodzie. 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. Użyj Kreatora tworzenia metadanych urządzenia , aby otworzyć metadane urządzenia i sprawdzić nazwę rodziny pakietów. Start the wizard from %ProgramFiles(x86)%\Windows Kits\8.1\bin\x86, by double-clicking DeviceMetadataWizard.exe.

Problem: Aplikacja jest uruchamiana w wysuwanym oknie wysuwanym, a następnie jest natychmiast odrzucana

Jeśli niestandardowe okno wysuwane dla zaawansowanych ustawień drukowania zniknie natychmiast po jego uruchomieniu...

  • Possible cause: In Windows 8, there is a known issue that within a flyout, UWP apps will be dismissed under the debugger. Wyłącz debugowanie, gdy wiesz, że aktywacja działa. Jeśli musisz debugować zapisywanie biletu wydruku, dołącz debuger po aktywacji.
  • Last updated on