<?xml version="1.0" encoding="utf-8"?>
<!--
     Copyright (C) 2011 Google Inc.
     Licensed to 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">

    <!-- Layout tests strings -->
    <string name="mock_content_provider" translatable="false">Mock Content Provider</string>
    <string name="conversation_content_provider" translatable="false">Conversation Content Provider</string>
    <string name="account_cache_provider" translatable="false">Account Cache Provider</string>
    <string name="dummy_gmail_provider" translatable="false">Dummy Gmail Provider</string>
    <string name="test_application" translatable="false">Test Application</string>

    <string name="app_name" translatable="false">Unified Email</string>

    <!-- Compose -->
    <!-- Shown in Compose; the recipient(s) of the message [CHAR LIMIT=10] -->
    <string name="to">To</string>
    <!-- Shown in Compose; the cc recipient(s) of the message [CHAR LIMIT=10] -->
    <string name="cc">Cc</string>
    <!-- Shown in Compose; the bcc recipient(s) of the message [CHAR LIMIT=10] -->
    <string name="bcc">Bcc</string>
    <!-- Shown in Compose; the subject of the message [CHAR LIMIT=100] -->
    <string name="subject_hint">Subject</string>
    <!-- Shown in Compose; the subject of the message [CHAR LIMIT=100] -->
    <string name="body_hint">Compose email</string>
    <!-- Compose screen, button: add Cc/Bcc fields [CHAR LIMIT=1]-->
    <string name="plus_cc_label">+</string>
    <!-- Compose screen, button: add bcc fields [CHAR LIMIT=1]-->
    <string name="plus_bcc_label">+</string>
    <!--  Compose screen button. Add an attachment to this message [CHAR LIMIT=20] -->
    <string name="add_file_attachment">Attach file</string>
    <!-- Button name: save this message as draft [CHAR LIMIT=25]-->
    <string name="save_draft">Save draft</string>
    <!--  Button name: discard this message [CHAR LIMIT=15] -->
    <string name="discard">Discard</string>
    <!-- The possible ways to reply to a message [CHAR LIMIT=15] -->
    <string name="compose">Compose</string>
    <!-- The possible ways to reply to a message [CHAR LIMIT=15] -->
    <string-array name="compose_modes">
        <!-- Reply -->
        <item>Reply</item>
        <!-- Reply all -->
        <item>Reply all</item>
        <!-- Forward -->
        <item>Forward</item>
    </string-array>
        <!-- Formatting string for the subject when it contains a reply or forward identifier. Do not translate.-->
    <string name="formatted_subject"><xliff:g id="prefix">%1$s</xliff:g> <xliff:g id="subject">%2$s</xliff:g></string>
    <!-- Compose screen, prefixed to the subject of a message when replying to it (if not already present). Do not translate. -->
    <string name="reply_subject_label" translatable="false">Re:</string>
    <!-- Compose screen, Prefix to forwarded message subject. Do not translate. -->
    <string name="forward_subject_label" translatable="false">Fwd:</string>
    <!-- Compose screen, displayed at the top of a message being replied to. Please preserve the HTML entities (surrounded by & and ;).  The two %s strings will be replaced by 1) the date 2) the person who wrote the email being responded to. [CHAR LIMIT=1000]-->
    <string name="reply_attribution">On <xliff:g id="date">%s</xliff:g>, <xliff:g id="person">%s</xliff:g> wrote:</string>
    <!-- Compose screen, displayed at the top of a message being forwarded. Please preserve the HTML entities (surrounded by & and ;). [CHAR LIMIT=1000] -->
    <string name="forward_attribution">---------- Forwarded message ----------&lt;br&gt;From: <xliff:g id="from">%1$s</xliff:g>&lt;br&gt;Date: <xliff:g id="date">%2$s</xliff:g>&lt;br&gt;Subject: <xliff:g id="subject">%3$s</xliff:g>&lt;br&gt;To: <xliff:g id="to">%4$s</xliff:g>&lt;br&gt;</string>
    <!-- Compose screen, displayed at the top of a message being forwarded if there are any email addresses in the CC list. Please preserve the HTML entities (surrounded by & and ;). [CHAR LIMIT=1000]-->
    <string name="cc_attribution">Cc: <xliff:g id="cc">%1$s</xliff:g>&lt;br&gt;</string>
    <!-- Dialog text: select the type of an attachment while composing [CHAR LIMIT=100]-->
    <string name="select_attachment_type">Choose type of attachment</string>
    <!-- Toast, attachment too large [CHAR LIMIT=100] -->
    <string name="too_large_to_attach">File is too large to attach.</string>
    <!-- Toast, problem attaching file [CHAR LIMIT=100] -->
    <string name="generic_attachment_problem">Couldn\'t attach file.</string>
    <!-- Displayed for one second after trying to send with no recipients in To field [CHAR LIMIT=200]-->
    <string name="recipient_needed">Add at least one recipient.</string>
    <!-- Title for recipient error dialog [CHAR LIMIT=200]-->
    <string name="recipient_error_dialog_title">Recipient error</string>
    <!-- Title for send confirmation dialog [CHAR LIMIT=200]-->
    <string name="confirm_send_title">Send message?</string>
    <!-- Messages for send confirmation dialog [CHAR LIMIT=100]-->
    <string name="confirm_send_message_with_no_subject">There\'s no text in the message subject.</string>
    <string name="confirm_send_message_with_no_body">There\'s no text in the message body.</string>
    <string name="confirm_send_message">Send this message?</string>
    <!-- Displayed for one second after discarding draft message [CHAR LIMIT=50]-->
    <string name="message_discarded">Message discarded.</string>

    <!-- Menu item: send this message -->
    <string name="send">Send</string>
    <!-- Menu item: mark this conversation as read -->
    <string name="mark_read">Mark read</string>
    <!-- Menu item: mark this conversation as unread -->
    <string name="mark_unread">Mark unread</string>
    <!--  Menu item: mute this conversation -->
    <string name="mute">Mute</string>
    <!-- Menu item: add a star to this conversation -->
    <string name="add_star">Add star</string>
    <!-- Menu item: remove the star from this conversation -->
    <string name="remove_star">Remove star</string>
    <!-- Menu item: archive this conversation -->
    <string name="archive">Archive</string>
    <!-- Menu item: report this conversation as spam -->
    <string name="report_spam">Report spam</string>
    <!-- Menu item: delete this conversation -->
    <string name="delete">Delete</string>
    <!-- Menu item: next conversation -->
    <string name="next">Older</string>
    <!-- Menu item: previous conversation -->
    <string name="previous">Newer</string>
    <!-- Menu item: refresh the inbox -->
    <string name="refresh">Refresh</string>
    <!-- Menu item: reply to this message -->
    <string name="reply">Reply</string>
    <!-- Menu item: reply to all recipients in this message [CHAR LIMIT=18] -->
    <string name="reply_all">Reply all</string>
    <!-- Menu item: resume a draft message [CHAR LIMIT=12] -->
    <string name="resume_draft">Edit</string>
    <!-- Menu item: forward this message -->
    <string name="forward">Forward</string>
    <!-- Menu item: compose a new email -->
    <string name="menu_compose">Compose</string>
    <!-- Menu item: change the labels for this conversion. -->
    <string name="menu_change_labels">Change labels</string>
    <!-- Menu item: change the labels for this conversation. -->
    <string name="menu_change_folders">Change folders</string>
    <!-- Menu item: manages the labels for this account. [CHAR LIMIT = 30] -->
    <string name="menu_manage_labels">Manage labels</string>
    <!-- Title for the Label list screen. [CHAR LIMIT = 30] -->
    <string name="label_list_title">Labels</string>
    <!-- action bar sub title for manage label mode. [CHAR LIMIT = 30] -->
    <string name="manage_labels_subtitle">Sync &amp; notify</string>
    <!-- Menu item: options for this label. When source text cannot be translated within the char limit, please translate the shorter "Label options" instead. [CHAR LIMIT = 30] -->
    <string name="menu_label_options">Label settings</string>
    <!-- Menu item: done editing label options. [CHAR LIMIT = 30] -->
    <string name="menu_done">Done</string>
    <!-- Menu item: launch the Global Account Settings activity -->
    <string name="menu_account_preferences">Account settings</string>
    <!-- Menu item: launch the Settings activity -->
    <string name="menu_preferences">Settings</string>
    <!-- Menu item: search through the Gmail inbox -->
    <string name="menu_search">Search</string>
    <!-- Menu item: show more menu options in a popup. Portrait mode string. [CHAR LIMIT=15] -->
    <string name="more">More</string>
    <!-- Menu item: show message number out of total in conversation view [CHAR LIMIT=50]-->
    <string name="message_count"><xliff:g id="count">%1$s</xliff:g> of <xliff:g id="total">%2$s</xliff:g></string>
    <!--  Menu item: shown in conversation menu. Tap this to move to a newer message. [CHAR LIMIT=20] -->
    <string name="newer">Newer</string>
    <!--  Menu item: shown in conversation menu. Tap this to move to an older message. [CHAR LIMIT=20] -->
    <string name="older">Older</string>
    <!--  Menu item: shown in conversation menu. Tap this to move to mark conversation as important [CHAR LIMIT=30] -->

    <!--  Menu item: shown in conversation menu. Tap this to move to mark conversation as important [CHAR LIMIT=30] -->
    <string name="mark_important">Mark important</string>
    <!--  Menu item: shown in conversation menu. Tap this to move to mark conversation as not important [CHAR LIMIT=30] -->
    <string name="mark_not_important">Mark not important</string>

    <!-- Compose screen, menu item: add Cc/Bcc fields -->
    <string name="add_cc_label">Add Cc/Bcc</string>
    <!-- Compose screen, menu item: add Bcc field [CHAR_LIMIT=20]-->
    <string name="add_bcc_label">Add Bcc</string>
    <!-- Solicit feedback string in about screen [CHAR LIMIT=50]-->
    <string name="feedback">Send feedback</string>
    <!-- Menu item that displays the help page for Gmail. [CHAR LIMIT=50]-->
    <string name="help_and_info">Help</string>
    <!-- Compose screen, Prefix to quoted text in forwarded/replied message [CHAR LIMIT=50]-->
    <string name="quoted_text">Include quoted text</string>
    <!-- Compose screen, Prefix to quoted text in forwarded/replied message; label for the quoted text area. [CHAR LIMIT=25] -->
    <string name="quoted_text_label">Quote text</string>
    <!--  Button for including inline responses. [CHAR LIMIT=25] -->
    <string name="respond_inline">Respond inline</string>

    <!-- Attachments -->
    <!-- Size unit, displayed in a button next to an attachment [CHAR LIMIT=5]-->
    <string name="bytes">B</string>
    <!-- Size unit, displayed in a button next to an attachment [CHAR LIMIT=5] -->
    <string name="kilobytes">KB</string>
    <!-- Size unit, displayed in a button next to an attachment  [CHAR LIMIT=5]-->
    <string name="megabytes">MB</string>
    <!-- Attachment description for image files [CHAR LIMIT=30] -->
    <string name="attachment_image">Image</string>
    <!-- Attachment description for video files [CHAR LIMIT=30] -->
    <string name="attachment_video">Video</string>
    <!-- Attachment description for audio files [CHAR LIMIT=30] -->
    <string name="attachment_audio">Audio</string>
    <!-- Attachment description for text files [CHAR LIMIT=30] -->
    <string name="attachment_text">Text</string>
    <!-- Attachment description for .doc files [CHAR LIMIT=30] -->
    <string name="attachment_application_msword">Document</string>
    <!-- Attachment description for .ppt files [CHAR LIMIT=30] -->
    <string name="attachment_application_vnd_ms_powerpoint">Presentation</string>
    <!-- Attachment description for .pdf files [CHAR LIMIT=30] -->
    <string name="attachment_application_vnd_ms_excel">Spreadsheet</string>
    <!-- Attachment description for .pdf files [CHAR LIMIT=30] -->
    <string name="attachment_application_pdf">PDF</string>
    <!-- Attachment description for unknown files [CHAR LIMIT=30]-->
    <string name="attachment_unknown"><xliff:g id="attachmentExtension">%s</xliff:g> File</string>

    <!-- Shown in light gray in the Search box when no text has been entered [CHAR LIMIT=30] -->
    <string name="search_hint">Search mail</string>

    <!-- Webview Context Menu Strings -->
    <!-- Title of dialog for choosing which activity to share a link with. [CHAR LIMIT=50]-->
    <string name="choosertitle_sharevia">Share via</string>
    <!-- Menu item to open a link  [CHAR LIMIT=50]-->
    <string name="contextmenu_openlink">Open in Browser</string>
    <!-- Menu item to copy the selection  [CHAR LIMIT=50]-->
    <string name="contextmenu_copy">Copy</string>
    <!-- Menu item to copy a link  [CHAR LIMIT=50]-->
    <string name="contextmenu_copylink">Copy link URL</string>
    <!-- Menu item to dial a number  [CHAR LIMIT=50]-->
    <string name="contextmenu_dial_dot">Dial\u2026</string>
    <!-- Menu item to send an SMS  [CHAR LIMIT=50]-->
    <string name="contextmenu_sms_dot">SMS\u2026</string>
    <!-- Menu item to add a contact  [CHAR LIMIT=50]-->
    <string name="contextmenu_add_contact">Add contact</string>
    <!-- Menu item to send an email [CHAR LIMIT=50] -->
    <string name="contextmenu_send_mail">Send email</string>
    <!-- Menu item to show a map  [CHAR LIMIT=50]-->
    <string name="contextmenu_map">Map</string>
    <!-- Menu item to share link  [CHAR LIMIT=50]-->
    <string name="contextmenu_sharelink">Share link</string>
    <!-- Menu item that displays the help page for Gmail.  [CHAR LIMIT=50]-->
    <string name="contextmenu_help">Help</string>
    <!-- Solicit feedback string in about screen [CHAR LIMIT=50]-->
    <string name="contextmenu_feedback">Send feedback</string>

    <!-- Browse list item strings -->
    <!-- Text indicating how many messages are selected in the top action bar
    [CHAR LIMIT=40] -->
    <string name="num_selected"><xliff:g id="number" example="7">%d</xliff:g> selected</string>
    <!--  Displayed when drag and drop conversations "Move ? conversations" [CHAR LIMIT=50] -->
    <plurals name="move_conversation">
        <!-- Move 1 conversation -->
        <item quantity="one">Move conversation</item>
        <!-- Move several conversations -->
        <item quantity="other">Move <xliff:g>%1$d</xliff:g> conversations</item>
    </plurals>
    <!-- Formatting string for the content description field of a conversation list item when device is in accessibility mode. [CHAR LIMI=250] -->
    <string name="content_description">Subject: <xliff:g id="subject">%1$s</xliff:g> Snippet:<xliff:g id="snippet">%2$s</xliff:g></string>
    <!-- Formatting string. If the subject contains the tag of a mailing-list (text surrounded with
    return the subject with that tag ellipsized, e.g. "[android-gmail-team] Hello" -> "[andr...] Hello" [CHAR LIMIT=100] -->
    <string name="filtered_tag"> [<xliff:g id="tag">%1$s</xliff:g>]<xliff:g id="subject">%2$s</xliff:g></string>
    <!-- Displayed in Conversation Header View and Widget in the form of "subject - snippet"
         [CHAR LIMIT=5] -->
    <string name="subject_and_snippet"><xliff:g>%s</xliff:g> \u2014 <xliff:g>%s</xliff:g></string>
    <!-- Displayed in browse list item when the list item is a draft message instead of showing the subject [CHAR LIMIT=100] -->
    <plurals name="draft">
        <!-- Title of the screen when there is exactly one draft -->
        <item quantity="one">Draft</item>
        <!-- Title of the screen when there are more than one draft -->
        <item quantity="other">Drafts</item>
    </plurals>
    <!-- Message displayed in a browse list item for one second when message is being sent [CHAR LIMIT=20]-->
    <string name="sending">Sending\u2026</string>
    <!-- Message displayed in a browse list item for one second after a send failed [CHAR LIMIT=26]-->
    <string name="send_failed">Message wasn\'t sent.</string>
    <!-- Strings used to show myself in a To/Cc list. [CHAR LIMIT=15] -->
    <string name="me">me</string>
    <string name="labels">Labels</string>
    <!-- List item to open fodlers view in account dropdown [CHAR LIMIT=50] -->
    <string name="show_all_folders">Show all folders</string>

    <!-- Undo bar strings -->
    <!-- Displayed in the middle of the screen when the inbox is empty [CHAR LIMIT 100]-->
    <string name="no_conversations">No conversations.</string>
    <!-- Menu item: undo latest action [CHAR LIMIT=12]-->
    <string name="undo">Undo</string>
    <!-- Undo Strings: The following are shown in a dialog while we're waiting for the operation to complete --><skip />
    <plurals name="conversation_marking_read">
        <!-- Displayed while marking one conversation read -->
        <item quantity="one">Marking <xliff:g id="count">%1$d</xliff:g> conversation read.</item>
        <!-- Displayed while marking multiple conversations read -->
        <item quantity="other">Marking <xliff:g id="count">%1$d</xliff:g> conversations read.</item>
    </plurals>

    <plurals name="conversation_marking_unread">
        <!-- Displayed while marking one conversation unread -->
        <item quantity="one">Marking <xliff:g id="count">%1$d</xliff:g> conversation unread.</item>
        <!-- Displayed while marking multiple conversations unread -->
        <item quantity="other">Marking <xliff:g id="count">%1$d</xliff:g> conversations unread.</item>
    </plurals>

    <plurals name="conversation_starring">
        <!-- Displayed while starring one conversation -->
        <item quantity="one">Starring <xliff:g id="count">%1$d</xliff:g> conversation.</item>
        <!-- Displayed while starring multiple conversations -->
        <item quantity="other">Starring <xliff:g id="count">%1$d</xliff:g> conversations.</item>
    </plurals>

    <plurals name="conversation_unstarring">
        <item quantity="one">Unstarring <xliff:g id="count">%1$d</xliff:g> conversation.</item>
        <item quantity="other">Unstarring <xliff:g id="count">%1$d</xliff:g> conversations.</item>
    </plurals>

    <plurals name="conversation_unknown_operation">
        <!-- Displayed while waiting for an operation one conversation -->
        <item quantity="one">Waiting for operation on <xliff:g id="count">%1$d</xliff:g> conversation.</item>
        <!-- Displayed while waiting for an operation on several conversations -->
        <item quantity="other">Waiting for operation on <xliff:g id="count">%1$d</xliff:g> conversations.</item>
    </plurals>

    <!-- The following are shown as a toast after the operation has completed --><skip />
    <plurals name="conversation_muted">
        <!-- Displayed while muting one conversation -->
        <item quantity="one">&lt;b><xliff:g id="count">%1$d</xliff:g>&lt;/b> muted.</item>
        <!-- Displayed while muting several conversations -->
        <item quantity="other">&lt;b><xliff:g id="count">%1$d</xliff:g>&lt;/b> muted.</item>
    </plurals>

    <plurals name="conversation_spammed">
        <!-- Displayed while reporting one conversation as spam -->
        <item quantity="one">&lt;b><xliff:g id="count">%1$d</xliff:g>&lt;/b> reported as spam.</item>
        <!-- Displayed while reporting several conversations as spam -->
        <item quantity="other">&lt;b><xliff:g id="count">%1$d</xliff:g>&lt;/b> reported as spam.</item>
    </plurals>

    <plurals name="conversation_archived">
        <!-- Displayed while archiving one conversation -->
        <item quantity="one">&lt;b><xliff:g id="count">%1$d</xliff:g>&lt;/b> archived.</item>
        <!-- Displayed while archiving multiple conversations -->
        <item quantity="other">&lt;b><xliff:g id="count">%1$d</xliff:g>&lt;/b> archived.</item>
    </plurals>

    <plurals name="conversation_moved_to_inbox">
        <!-- Displayed while moving one conversation to the inbox. [CHAR LIMIT=80] -->
        <item quantity="one">&lt;b><xliff:g id="count">%1$d</xliff:g>&lt;/b> moved to the Inbox.</item>
        <!-- Displayed while moving multiple conversations to the inbox. [CHAR LIMIT=80]-->
        <item quantity="other">&lt;b><xliff:g id="count">%1$d</xliff:g>&lt;/b> moved to the Inbox.</item>
    </plurals>

    <plurals name="conversation_deleted">
        <!-- Displayed while deleting one conversation -->
        <item quantity="one">&lt;b><xliff:g id="count">%1$d</xliff:g>&lt;/b> deleted.</item>
        <!-- Displayed while deleting multiple conversations -->
        <item quantity="other">&lt;b><xliff:g id="count">%1$d</xliff:g>&lt;/b> deleted.</item>
    </plurals>

    <plurals name="conversation_marked_important">
        <!-- Displayed while marking a single conversation as important. [CHAR LIMIT=80] -->
        <item quantity="one">&lt;b><xliff:g id="count">%1$d</xliff:g>&lt;/b> marked important.</item>
        <!-- Displayed while marking multiple conversations as important. [CHAR LIMIT=80] -->
        <item quantity="other">&lt;b><xliff:g id="count">%1$d</xliff:g>&lt;/b> marked important.</item>
    </plurals>

    <plurals name="conversation_marked_not_important">
        <!-- Displayed while marking a single conversation as unimportant.
             [CHAR LIMIT=80] -->
        <item quantity="one">&lt;b><xliff:g id="count">%1$d</xliff:g>&lt;/b> marked not important.</item>
        <!-- Displayed while marking multiple conversations as unimportant.
             [CHAR LIMIT=80] -->
        <item quantity="other">&lt;b><xliff:g id="count">%1$d</xliff:g>&lt;/b> marked not important.</item>
    </plurals>

    <plurals name="conversation_marked_read">
        <!-- Displayed while marking a single conversation as read. [CHAR LIMIT=80] -->
        <item quantity="one">&lt;b><xliff:g id="count">%1$d</xliff:g>&lt;/b> marked read.</item>
        <!-- Displayed while marking multiple conversations as read. [CHAR LIMIT=80]-->
        <item quantity="other">&lt;b><xliff:g id="count">%1$d</xliff:g>&lt;/b> marked read.</item>
    </plurals>

    <plurals name="conversation_marked_unread">
        <!-- Displayed while marking a single conversation as unread. [CHAR LIMIT=80] -->
        <item quantity="one">&lt;b><xliff:g id="count">%1$d</xliff:g>&lt;/b> marked unread.</item>
        <!-- Displayed while marking multiple conversations as unread. [CHAR LIMIT=80]-->
        <item quantity="other">&lt;b><xliff:g id="count">%1$d</xliff:g>&lt;/b> marked unread.</item>
    </plurals>

    <plurals name="conversation_folder_changed">
        <!-- Displayed while adding and removing folders to a single conversation. [CHAR LIMIT=100] -->
        <item quantity="one">Changed folder.</item>
        <!-- Displayed while adding and removing folders to multiple conversations. [CHAR LIMIT=100] -->
        <item quantity="other">Changed folders.</item>
    </plurals>

    <!-- Search Results: Text for header that is shown above search results [CHAR LIMIT=30] -->
    <string name="search_results_header">Results</string>

    <string name="searchMode" translate="false">Search Mode</string>
    <string name="searchConversationMode" translate="false">Search Conversation Mode</string>
    <string name="setBackButton" translate="false">Set Back Button</string>
    <string name="removeBackButton" translate="false">Remove Back Button</string>
    <string name="normalMode" translate="false">Set Normal Mode</string>
    <string name="searchResultMode" translate="false">Search Result Mode</string>
    <string name="labelMode" translate="false">Set Label Mode</string>
    <!-- Search Results: Text for header that is shown above search results, while waiting for search results from the server [CHAR LIMIT=30] -->
    <string name="search_results_searching_header">Searching\u2026</string>

    <!-- List header for recent labels for current account in account dropdown [CHAR LIMIT=100] -->
    <string name="recent_labels">Recent</string>

    <!-- Conversation message header strings -->
    <!--  Icon name for expanding recipient details in a message when viewing it. [CHAR LIMIT=40] -->
    <string name="expand_recipient_details">Expand recipient details</string>
    <!--  Icon name for collapsing recipient details in a message when viewing it. [CHAR LIMIT=40] -->
    <string name="collapse_recipient_details">Collapse recipient details</string>
    <!--  Icon name for showing sender contact information. [CHAR LIMIT=100] -->
    <string name="contact_info_string">Show contact information for <xliff:g id="name">%1$s</xliff:g></string>
    <!--  Icon name for showing sender contact information when we cannot get sender info. [CHAR LIMIT=100] -->
    <string name="contact_info_string_default">Show contact information</string>
    <!--  Div name for providing accessibility to collapsed read messages when viewing a conversation. [CHAR LIMIT=40] -->
    <string name="expand_read_messages">Expand read messages</string>
    <!-- Shown in collapsed mode when a conversation has more than one read message.
         The message count is shown to the right of this text. [CHAR LIMIT=70] -->
    <string name="show_messages_read">Previously read messages</string>
    <!-- Shown to display the date of the message [CHAR LIMIT=10] -->
    <string name="date_heading">Date:</string>
    <!-- Shown to display the reply to address of the message [CHAR LIMIT=20] -->
    <string name="replyto_heading">Reply-to:</string>
    <!-- Shown to display the recipient(s) of the message [CHAR LIMIT=10] -->
    <string name="to_heading">To:</string>
    <!-- Shown to display the recipient(s) of the message [CHAR LIMIT=10] -->
    <string name="cc_heading">Cc:</string>
    <!-- Shown to display the recipient(s) of the message [CHAR LIMIT=10] -->
    <string name="bcc_heading">Bcc:</string>
    <!-- Displayed above an HTML message to show the images in that message [CHAR LIMIT=40] -->
    <string name="show_images">Show pictures</string>
    <!-- Displayed above an HTML message to always show images in messages from that sender [CHAR LIMIT=40] -->
    <string name="always_show_images">Always show pictures from this sender</string>
    <!-- Shown in a toast to acknowledge always showing images for a sender [CHAR LIMIT=100] -->
    <string name="always_show_images_toast">Pictures from this sender will be shown automatically.</string>
    <!-- Display format of an email recipient, displayed in expanded message details [CHAR LIMIT=10] -->
    <string name="address_display_format"><xliff:g id="name">%1$s</xliff:g> &lt;<xliff:g id="email">%2$s</xliff:g>&gt;</string>
    <!-- Displayed for one second after user saves message as draft [CHAR LIMIT=50]-->
    <string name="message_saved">Message saved as draft.</string>
    <!-- Displayed for one second while message is being sent [CHAR LIMIT=50]-->
    <string name="sending_message">Sending message\u2026</string>
    <!-- Displayed for one second after trying to send with invalid recipients [CHAR LIMIT=50]-->
    <string name="invalid_recipient">The address <xliff:g id="wrongemail" example="foo@@gmail..com">%s</xliff:g> is invalid.</string>
    <!-- Shown in HTML to allow the user to see quoted text; should match Gmail web UI. 25B6 is Unicode for a right-pointing triangle. [CHAR LIMIT=50] -->
    <string name="show_elided">\u25B6 Show quoted text</string>
    <!-- Shown in HTML to allow the user to hide quoted text; should match Gmail web UI. 25BC is Unicode for a downward-pointing triangle. [CHAR LIMIT=50] -->
    <string name="hide_elided">\u25BC Hide quoted text</string>

    <!-- An enumeration comma for separating items in lists. [CHAR LIMIT=2] -->
    <string name="enumeration_comma">,\u0020</string>

    <!-- Button name, displayed in dialogs [CHAR LIMIT=10]-->
    <string name="ok">OK</string>
    <string name="done">Done</string>
    <string name="cancel">Cancel</string>
    <string name="close">Close</string>

    <!-- Folders -->
    <!-- Displayed in the middle of the Folders screen when no folders have been defined -->
    <string name="folders_activity_instructions">No folders have been set for this account.</string>

    <!-- Sync status errors translate="false" [CHAR LIMIT=100] -->
    <string-array name="sync_status">
        <item>Success</item>
        <item>Connection error</item>
        <item>Authentication error</item>
        <item>Security error</item>
        <item>Storage error</item>
        <item>Internal error</item>
    </string-array>

    <!-- Widget strings -->
    <!-- Displayed when user adds a new widget. Tapping on the widget in this
          mode will bring user to the account selection screen [CHAR LIMIT=35] -->
    <string name="tap_to_configure">Touch to set up</string>

    <!-- Displayed within a widget that was setup for a non-synced label [CHAR LIMIT=60] -->
    <string name="non_synced_folder_description">To view conversations, sync this folder.</string>

    <!-- Displayed within a widget that was setup for a non-synced folder.  This is the text of the
         button that will allow the user to configure sync for the folder [CHAR LIMIT=35] -->
    <string name="tap_to_configure_folder_sync">Sync Folder</string>

    <!-- Displayed in widget when unread count > 100. [CHAR LIMIT=4] -->
    <string name="widget_large_unread_count">%d+</string>

    <!-- Displayed at the end of the conversation list in the widget. Tapping on this will open the default Inbox. [CHAR LIMIT=35] -->
    <string name="view_more_conversations">View more conversations</string>

    <!-- Displayed while we load a conversation. [CHAR LIMIT=100] -->
    <string name="loading_conversation">Loading\u2026</string>

    <!-- Name of the Mailboxes activity [CHAR LIMIT=30] -->
    <string name="activity_mailbox_selection">Choose account</string>

    <!-- Name of the Folders activity [CHAR LIMIT=30] -->
    <string name="activity_folder_selection">Choose folder</string>

    <!-- Manange folders mode, sync option: synchronize all conversations with this folder. [CHAR LIMIT=100] -->
    <string name="sync_all">Sync: All</string>
    <plurals name="sync_recent">
        <!-- Manage folders mode, sync option: synchronize conversations in the last day with this folder [CHAR LIMIT=100] -->
        <item quantity="one">Sync: Last <xliff:g id="count" example="1">%1$d</xliff:g> day</item>
        <!-- Manage folders mode, sync option: synchronize conversations in the last 2+ day with this folder [CHAR LIMIT=100] -->
        <item quantity="other">Sync: Last <xliff:g id="count" example="4">%1$d</xliff:g> days</item>
    </plurals>
    <!-- Manage folders mode, sync option: don't synchronize any conversation with this folder [CHAR LIMIT=100] -->
    <string name="sync_none">Sync: None</string>

    <!-- Title for dialog encouraging users enable sync for a currently non-synced folder [CHAR LIMIT=30] -->
    <string name="folder_sync_for_widget_title">Sync folder</string>

    <!-- Dialog text encouraging users to enable sync for a newly created widget [CHAR LIMIT=400] -->
    <string name="folder_sync_for_widget_description">To view conversations in the widget, sync this folder.</string>

    <!-- Checkbox text to enable sync for a folder where a widget is in the processes of being added, and sync had been not been enabled [CHAR LIMIT=30] -->
    <string name="folder_sync_for_widget_checkbox">Sync last <xliff:g id="numSyncDays" example="30">%d</xliff:g> days</string>

    <!-- Folder selection dialog -->
    <!-- Title for change folders dialog [CHAR LIMIT=30] -->
    <string name="folder_selection_dialog_title">Change folders</string>
</resources>
