<?xml version="1.0" encoding="utf-8"?>
<!-- Copyright (C) 2013 The Android Open Source Project

     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
     You may obtain a copy of the License at

          http://www.apache.org/licenses/LICENSE-2.0

     Unless required by applicable law or agreed to in writing, software
     distributed under the License is distributed on an "AS IS" BASIS,
     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     See the License for the specific language governing permissions and
     limitations under the License.
-->

<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">

    <!-- Title of the PrintSpooler application. [CHAR LIMIT=50] -->
    <string name="app_label">Print Spooler</string>

    <!-- Label of the print dialog's button for more print options. [CHAR LIMIT=25] -->
    <string name="more_options_button">More options</string>

    <!-- Label of the destination widget. [CHAR LIMIT=20] -->
    <string name="label_destination">Destination</string>

    <!-- Label of the copies count widget. [CHAR LIMIT=20] -->
    <string name="label_copies">Copies</string>

    <!-- Label of the copies count for the print options summary. [CHAR LIMIT=20] -->
    <string name="label_copies_summary">Copies:</string>

    <!-- Label of the paper size widget. [CHAR LIMIT=20] -->
    <string name="label_paper_size">Paper size</string>

    <!-- Label of the paper size for the print options summary. [CHAR LIMIT=20] -->
    <string name="label_paper_size_summary">Paper size:</string>

    <!-- Label of the color mode widget. [CHAR LIMIT=20] -->
    <string name="label_color">Color</string>

    <!-- Label of the printer mode to print on both sides of paper. [CHAR LIMIT=20] -->
    <string name="label_duplex">Two-sided</string>

    <!-- Label of the orientation widget. [CHAR LIMIT=20] -->
    <string name="label_orientation">Orientation</string>

    <!-- Label of the page selection widget. [CHAR LIMIT=20] -->
    <string name="label_pages">Pages</string>

    <!-- Label of the destination widget. [CHAR LIMIT=20] -->
    <string name="destination_default_text">Select a printer</string>

    <!-- Template for the all pages option in the page selection widget. [CHAR LIMIT=20] -->
    <string name="template_all_pages">All <xliff:g id="page_count" example="100">%1$s</xliff:g></string>

    <!-- Template for the page range option in the page selection widget. [CHAR LIMIT=20] -->
    <string name="template_page_range">Range of <xliff:g id="page_count" example="100">%1$s</xliff:g></string>

    <!-- Page range exmple used as a hint of how to specify such. [CHAR LIMIT=20] -->
    <string name="pages_range_example">e.g. 1&#8212;5,8,11&#8212;13</string>

    <!-- Title for the pring preview button .[CHAR LIMIT=30] -->
    <string name="print_preview">Print preview</string>

    <!-- Title for the pring preview button if there is no PDF viewer isntalled. [CHAR LIMIT=50] -->
    <string name="install_for_print_preview">Install PDF viewer for preview</string>

    <!-- Title of the message that the printing application crashed. [CHAR LIMIT=50] -->
    <string name="printing_app_crashed">Printing app crashed</string>

    <!-- Title for the temporary dialog show while an app is generating a print job. [CHAR LIMIT=30] -->
    <string name="generating_print_job">Generating print job</string>

    <!-- Title for the save as PDF option in the printer list. [CHAR LIMIT=30] -->
    <string name="save_as_pdf">Save as PDF</string>

    <!-- Title for the open all printers UI option in the printer list. [CHAR LIMIT=30] -->
    <string name="all_printers">All printers&#8230;</string>

    <!-- Title for the print dialog announced to the user for accessibility. Not shown in the UI. [CHAR LIMIT=none] -->
    <string name="print_dialog">Print dialog</string>

    <!-- Template for the message that shows the current page out of the total number of pages [CHAR LIMIT=none] -->
    <string name="current_page_template"><xliff:g id="current_page">%1$d</xliff:g>
        /<xliff:g id="page_count">%2$d</xliff:g></string>

    <!-- Description of the current page - spoken to the user [CHAR LIMIT=none] -->
    <string name="page_description_template">Page <xliff:g id="current_page" example="1">%1$d</xliff:g>
        of <xliff:g id="page_count" example="100">%2$d</xliff:g></string>

    <!-- Template for the message to announce the print options summary - spoken to the user. [CHAR LIMIT=none] -->
    <string name="summary_template">Summary, copies <xliff:g id="copies" example="1">%1$s</xliff:g>,
        paper size <xliff:g id="paper_size" example="A4">%2$s</xliff:g></string>

    <!-- Description for the handle to expand all print options - spoken to the user. [CHAR LIMIT=none] -->
    <string name="expand_handle">Expand handle</string>

    <!-- Description for the handle to collapse all print options - spoken to the user. [CHAR LIMIT=none] -->
    <string name="collapse_handle">Collapse handle</string>

    <!-- Description for the print button - spoken to the user. [CHAR LIMIT=none] -->
    <string name="print_button">Print</string>

    <!-- Description for the save to PDF button - spoken to the user. [CHAR LIMIT=none] -->
    <string name="savetopdf_button">Save to PDF</string>

    <!-- Message to announce print options are expanded - spoken to the user. [CHAR LIMIT=none] -->
    <string name="print_options_expanded">Print options expanded</string>

    <!-- Message to announce print options are collapsed - spoken to the user. [CHAR LIMIT=none] -->
    <string name="print_options_collapsed">Print options collapsed</string>

    <!-- Select printer activity -->

    <!-- Title for the share action bar menu item. [CHAR LIMIT=20] -->
    <string name="search">Search</string>

    <!-- Title for the select printer activity. [CHAR LIMIT=30] -->
    <string name="all_printers_label">All printers</string>

    <!-- Title of the button to install a print service. [CHAR LIMIT=25] -->
    <string name="add_print_service_label">Add service</string>

    <!-- Utterance to announce that the search box is shown. This is spoken to a blind user. [CHAR LIMIT=none] -->
    <string name="print_search_box_shown_utterance">Search box shown</string>

    <!-- Utterance to announce that the search box is hidden. This is spoken to a blind user. [CHAR LIMIT=none] -->
    <string name="print_search_box_hidden_utterance">Search box hidden</string>

    <!-- Label of add printers button when no printers are found. [CHAR LIMIT=25] -->
    <string name="print_add_printer">Add printer</string>

    <!-- Title of the menu item to select a printer. [CHAR LIMIT=25] -->
    <string name="print_select_printer">Select printer</string>

    <!-- Title of the menu item to forget a printer. [CHAR LIMIT=25] -->
    <string name="print_forget_printer">Forget printer</string>

    <!-- Utterance to announce a change in the number of matches during a search. This is spoken to a blind user. [CHAR LIMIT=none] -->
    <plurals name="print_search_result_count_utterance">
        <item quantity="one"><xliff:g id="count" example="1">%1$s</xliff:g> printer found</item>
        <item quantity="other"><xliff:g id="count" example="2">%1$s</xliff:g> printers found</item>
    </plurals>

    <!-- Template for an extended description of a printer. [CHAR LIMIT=50] -->
    <string name="printer_extended_description_template"><xliff:g id="print_service_label" example="Canon Print Service">%1$s</xliff:g> - <xliff:g id="printer_description" example="Printer under the stairs">%2$s</xliff:g></string>

    <!-- Description of printer info icon. [CHAR LIMIT=50] -->
    <string name="printer_info_desc">More information about this printer</string>

    <!-- Notification that print services as disabled. [CHAR LIMIT=50] -->
    <string name="print_services_disabled_toast">Some print services are disabled</string>

    <!-- Title for the prompt shown as a placeholder if no printers are found while not searching. [CHAR LIMIT=50] -->
    <string name="print_searching_for_printers">Searching for printers</string>

    <!-- Title for the prompt shown as a placeholder if there are no print services. [CHAR LIMIT=50] -->
    <string name="print_no_print_services">No print services enabled</string>

    <!-- Title for the prompt shown as a placeholder if there are no printers while searching. [CHAR LIMIT=50] -->
    <string name="print_no_printers">No printers found</string>

    <!-- Add printer activity -->

    <!-- Subtitle for services that cannot add printers. [CHAR LIMIT=50] -->
    <string name="cannot_add_printer">Cannot add printers</string>

    <!-- Subtitle for services that can add printers. [CHAR LIMIT=50] -->
    <string name="select_to_add_printers">Select to add printer</string>

    <!-- Subtitle for disabled services. [CHAR LIMIT=50] -->
    <string name="enable_print_service">Select to enable</string>

    <!-- Header for the list of enabled print services. [CHAR LIMIT=50] -->
    <string name="enabled_services_title">Enabled services</string>

    <!-- Header for the list of recommended print services. [CHAR LIMIT=50] -->
    <string name="recommended_services_title">Recommended services</string>

    <!-- Header for the list of disabled print services. [CHAR LIMIT=50] -->
    <string name="disabled_services_title">Disabled services</string>

    <!-- Label for the list item that links to the list of all print services. [CHAR LIMIT=50] -->
    <string name="all_services_title">All services</string>

    <!-- Notifications -->

    <!-- Template for the notification label for a printing print job. [CHAR LIMIT=25] -->
    <string name="printing_notification_title_template">Printing <xliff:g id="print_job_name" example="foo.jpg">%1$s</xliff:g></string>

    <!-- Template for the notification label for a cancelling print job. [CHAR LIMIT=25] -->
    <string name="cancelling_notification_title_template">Cancelling <xliff:g id="print_job_name" example="foo.jpg">%1$s</xliff:g></string>

    <!-- Template for the notification label for a failed print job. [CHAR LIMIT=25] -->
    <string name="failed_notification_title_template">Printer error <xliff:g id="print_job_name" example="foo.jpg">%1$s</xliff:g></string>

    <!-- Template for the notification label for a blocked print job. [CHAR LIMIT=25] -->
    <string name="blocked_notification_title_template">Printer blocked <xliff:g id="print_job_name" example="foo.jpg">%1$s</xliff:g></string>

    <!-- Label for the notification button for cancelling a print job. [CHAR LIMIT=25] -->
    <string name="cancel">Cancel</string>

    <!-- Label for the notification button for restarting a filed print job. [CHAR LIMIT=25] -->
    <string name="restart">Restart</string>

    <!-- Message that there is no connection to a printer. [CHAR LIMIT=40] -->
    <string name="no_connection_to_printer">No connection to printer</string>

    <!-- Label for an unknown reason for failed or blocked print job. [CHAR LIMIT=25] -->
    <string name="reason_unknown">unknown</string>

    <!-- Title for a warning message about security implications of using a print service,
         displayed as a dialog message when the user prints using a print service that has not been
         used before. [CHAR LIMIT=NONE] -->
    <string name="print_service_security_warning_title">Use
         <xliff:g id="service" example="My Print Service">%1$s</xliff:g>?</string>

    <!-- Summary for a warning message about security implications of using a print service,
         displayed as a dialog message when the user prints using a print service that has not been
         used before. [CHAR LIMIT=NONE] -->
    <string name="print_service_security_warning_summary">Your document may pass through one or
         more servers on its way to the printer.</string>

    <!-- Arrays -->

    <!-- Color mode labels. -->
    <string-array name="color_mode_labels">
        <!-- Color mode label: Monochrome color scheme, e.g. one color is used. [CHAR LIMIT=20] -->
        <item>Black &amp; White</item>
        <!-- Color mode label: Color color scheme, e.g. many colors are used. [CHAR LIMIT=20] -->
        <item>Color</item>
    </string-array>

    <!-- Duplex mode labels. -->
    <string-array name="duplex_mode_labels">
        <!-- Duplex mode label: No duplex supported. [CHAR LIMIT=20] -->
        <item>None</item>
        <!-- Duplex mode label: Turn page sideways along the long edge like a book. [CHAR LIMIT=20] -->
        <item>Long edge</item>
        <!-- Duplex mode label: Turn page upwards along the short edge like a notepad. [CHAR LIMIT=20] -->
        <item>Short edge</item>
    </string-array>

    <!-- Orientation labels. -->
    <string-array name="orientation_labels">
        <!-- Orientation label: Portrait page orientation. [CHAR LIMIT=30] -->
        <item>Portrait</item>
        <!-- Orientation label: Landscape page orientation [CHAR LIMIT=30] -->
        <item>Landscape</item>
    </string-array>

    <!-- Error messages -->

    <!-- Message for an error when trying to print to a PDF file. [CHAR LIMIT=50] -->
    <string name="print_write_error_message">Couldn\'t write to file</string>

    <!-- Default message for an error while generating a print job. [CHAR LIMIT=50] -->
    <string name="print_error_default_message">Sorry, that didn\'t work. Try again.</string>

    <!-- Label for the retry button in the error message. [CHAR LIMIT=50] -->
    <string name="print_error_retry">Retry</string>

    <!-- Message for the currently selected printer being unavailable. [CHAR LIMIT=100] -->
    <string name="print_error_printer_unavailable">This printer isn\'t available right now.</string>

    <!-- Message for the case when a preview of a page cannot be loaded because the printing app
         provided a broken print preview rendering for this page. [CHAR LIMIT=50] -->
    <string name="print_cannot_load_page">Can\'t display preview</string>

    <!-- Long running operations -->

    <!-- Message long running operation when preparing print preview. [CHAR LIMIT=50] -->
    <string name="print_preparing_preview">Preparing preview\u2026</string>

</resources>
