<?xml version="1.0" encoding="utf-8"?>
<!-- Copyright (C) 2006 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">
    <!-- This is the label underneath the icon for Calendar -->
    <string name="app_label">Calendar</string>
    <!-- on permission of read_calendar -->
    <string name="on_permission_read_calendar">You have disabled a required permission.</string>
    <!-- Shared Labels. These labels are shared among the activities. -->
    <skip/>
    <!-- This is the label for the title or name of an event -->
    <string name="what_label">What</string>
    <!-- This is the label for the location of an event -->
    <string name="where_label">Where</string>
    <!-- This is the label for the time of an event [CHAR LIMIT=30] -->
    <string name="when_label">When</string>
    <!-- This is the label for the timezone of an event [CHAR LIMIT=30] -->
    <string name="timezone_label">Time zone</string>
    <!-- This is the label for the Guests/Attendees of an event -->
    <string name="attendees_label">Guests</string>
    <!-- Text to show when an event starts on the current day -->
    <string name="today">Today</string>
    <!-- Text to show when an event starts on the next day -->
    <string name="tomorrow">Tomorrow</string>
    <!-- Text for an event starting on the current day with a start and end time.
         For ex, "Today at 5:00pm-6:00pm" [CHAR LIMIT=NONE] -->
    <string name="today_at_time_fmt">"Today at <xliff:g id="time_interval">%s</xliff:g>"</string>
    <!-- Text for an event starting on the next day with a start and end time.
         For ex, "Tomorrow at 5:00pm-6:00pm" [CHAR LIMIT=NONE] -->
    <string name="tomorrow_at_time_fmt">"Tomorrow at <xliff:g id="time_interval">%s</xliff:g>"</string>
    <!-- Format string for a date and time description.  For ex:
         "April 19, 2012, 3:00pm - 4:00pm" [CHAR LIMIT=NONE] -->
    <string name="date_time_fmt">"<xliff:g id="date">%s</xliff:g>, <xliff:g id="time_interval">%s</xliff:g>"</string>

    <!-- Some events repeat daily, weekly, monthly, or yearly.  This is the label
         for all the choices about how often an event repeats (including the choice
         of not repeating). -->
    <string name="repeats_label">Repetition</string>
    <!-- Title of event when no explicit title is specified by the user -->
    <string name="no_title_label">(No title)</string>

    <!-- Reminder format strings -->
    <plurals name="Nminutes">
        <!-- This is the label for a 1-minute reminder. -->
        <item quantity="one">1 minute</item>
        <!-- This is the label for 2 or more minutes. The actual number of
             minutes is a parameter. -->
        <item quantity="other"><xliff:g id="count">%d</xliff:g> minutes</item>
    </plurals>
    <!-- We use the abbreviation "mins" instead of "minutes" to keep the string short.
         This is the number of minutes displayed for a calendar reminder.  For example,
         a reminder of 10 minutes would be displayed as '10 mins'.  The translation
         should use the shortest acceptable abbreviation to save space. -->
    <plurals name="Nmins">
        <!-- This is the label for a 1-minute reminder. -->
        <item quantity="one">1 min</item>
        <!-- This is the label for 2 or more minutes. The actual number of
             minutes is a parameter. -->
        <item quantity="other"><xliff:g id="count">%d</xliff:g> mins</item>
    </plurals>
    <!-- This is the number of hours displayed for a calendar reminder.  For example,
         a reminder of 1 hour would be displayed as '1 hour'.  The translation
         should use the shortest acceptable abbreviation of 'hour' to save space. -->
    <plurals name="Nhours">
        <!-- This is the label for a 1-hour reminder. -->
        <item quantity="one">1 hour</item>
        <!-- This is the label for a reminder of 2 or more hours. The actual number of
             hours is a parameter. -->
        <item quantity="other"><xliff:g id="count">%d</xliff:g> hours</item>
    </plurals>
    <!-- This is the number of days displayed for a calendar reminder.  For example,
         a reminder of 2 days would be displayed as '2 days'.  The translation
         should use the shortest acceptable abbreviation of 'day' to save space. -->
    <plurals name="Ndays">
        <!-- This is the label for a reminder of 1 day. -->
        <item quantity="one">1 day</item>
        <!-- This is the label for a reminder of 2 or more days. The actual number of
             days is a parameter. -->
        <item quantity="other"><xliff:g id="count">%d</xliff:g> days</item>
    </plurals>
    <!-- This is for displaying the week of the year near the date. Eg. "January, 2011 Week 1" -->
    <plurals name="weekN">
        <!-- Label for displaying week of the year for all week values [CHAR LIMIT=16] -->
        <item quantity="other">WEEK <xliff:g id="count">%d</xliff:g></item>
    </plurals>

    <!-- Menu items: -->
    <skip/>
    <!-- This is a label on a context menu item. Pressing this menu item to initiate
        syncing of your Calendar data with the server. [CHAR LIMIT=11] -->
    <string name="calendar_refresh"> "Refresh"</string>
    <!-- This is a label on a context menu item. Pressing this menu item displays the
         Agenda view. -->

    <!-- This is a label on a context menu item. Pressing this menu item displays the
         Day view. -->
    <string name="show_day_view">"Show day"</string>
    <!-- This is a label on a menu item. Pressing this menu item displays the
         Agenda view. -->
    <string name="agenda_view">"Agenda"</string>
    <!-- This is a label on a menu item. Pressing this menu item displays the
         Day view. -->
    <string name="day_view">"Day"</string>
    <!-- This is a label on a menu item. Pressing this menu item displays the
         Week view. -->
    <string name="week_view">"Week"</string>
    <!-- This is a label on a menu item. Pressing this menu item displays the
         Month view. -->
    <string name="month_view">"Month"</string>
    <!-- This is a label on a menu item. Pressing this menu item displays the
         details of an event. -->
    <string name="event_view">"View event"</string>
    <!-- This is a label on a menu item. Pressing this menu item allows the
         user to create a new event. -->
    <string name="event_create">"New event"</string>
    <!-- This is a label on a menu item in a popup window. Pressing this menu
         item allows the user to edit or change an existing event. -->
    <string name="event_edit">"Edit event"</string>
    <!-- This is a label on a menu item in a popup window. Pressing this menu
         item allows the user to delete an existing event. -->
    <string name="event_delete">"Delete event"</string>
    <!-- This is a label on a menu item. Pressing this menu
         item takes the user to the current day (today) in whatever view
         (Day view, Week view, Agenda view, Month view) they are currently in. -->
    <string name="goto_today">"Today"</string>
    <!-- This is a label on a menu item. Pressing this menu item allows the
         user to see the list of calendars that he is viewing and to then add
         or remove selected calendars. -->

    <!-- This is a label on a menu item. Pressing this menu item allows the
         user to view and edit his Settings (or Preferences) -->
    <string name="menu_preferences">"Settings"</string>
    <!-- This is a label on a menu item. Pressing this menu item allows the
         user to select the calendars to display [CHAR LIMIT=20] -->
    <string name="menu_select_visible_calendars">"Calendars to display"</string>
    <!-- This is a label on a menu item. Pressing this menu item allows the
         user to select the calendars to display [CHAR LIMIT=20] -->
    <string name="search">"Search"</string>
    <!-- This is a label on a menu item. Pressing this menu item hides
         the navigation controls on the right side. [CHAR LIMIT=20] -->
    <string name="hide_controls">"Hide controls"</string>
    <!-- This is a label on a menu item. Pressing this menu item shows the
         navigation controls on the right side. [CHAR LIMIT=20] -->
    <string name="show_controls">"Show controls"</string>

    <!-- Month view -->
    <skip/>

    <!-- Select Visible Calendars activity -->
    <skip/>
    <!-- Title of "My calendars" screen -->
    <string name="select_visible_calendars_title">"Calendars to display"</string>
    <!-- Synced and visible status message -->

    <!-- Synced but not visible status message -->

    <!-- not Synced or visible status message -->

    <!-- Synced status message displayed when the given calendar is stored/synced on the device
        [CHAR LIMIT=60] -->
    <string name="synced"> synced</string>
    <!-- Not synced status message displayed when the given calendar is not stored/synced on the
        device [CHAR LIMIT=60] -->
    <string name="not_synced"> not synced</string>
    <!-- Message displayed to user when an account with Calendars is not being auto-synced
        [CHAR LIMIT=120]-->
    <string name="acct_not_synced">This account isn\'t being synced so your calendars may
        not be up-to-date.</string>
    <!-- Label on button that takes user to the Accounts and Sync settings page [CHAR LIMIT=60] -->
    <string name="accounts">Accounts &amp; sync</string>

    <!-- Select Synced Calendars activity -->
    <!-- Select the set of calendars to sync [CHAR LIMIT=60] -->
    <string name="select_synced_calendars_title">Calendars to sync</string>
    <!-- Select the set of calendars to sync [CHAR LIMIT=60] -->
    <string name="select_synced_calendars_button">Calendars to sync</string>

    <!-- Event edit activity -->
    <skip/>
    <!-- The title of the screen where the user edits an event [CHAR LIMIT=17] -->

    <!-- Default value of What field (as a hint to the user) [CHAR LIMIT=15] -->
    <string name="hint_what">"Event name"</string>
    <!-- Default value of Where field (as a hint to the user)[CHAR LIMIT=15] -->
    <string name="hint_where">"Location"</string>
    <!-- Default value of Description field (as a hint to the user) [CHAR LIMIT=15]-->
    <string name="hint_description">"Description"</string>
    <!-- Default value of Attendees/Guests field (as a hint to the user) [CHAR LIMIT=10] -->
    <string name="hint_attendees">"Guests"</string>
    <!-- Toast message displayed when a new event is created -->
    <string name="creating_event">"Event created."</string>
    <!-- Toast message displayed when an existing event is saved after being modified -->
    <string name="saving_event">"Event saved."</string>
    <!-- Toast message displayed when a new event was not saved because it was empty [CHAR LIMIT=30] -->
    <string name="empty_event">"Empty event not created."</string>
    <!-- Toast message displayed when a new event with guests is created -->
    <string name="creating_event_with_guest">"Invitations will be sent."</string>
    <!-- Toast message displayed when an existing event with guests is saved after being modified -->
    <string name="saving_event_with_guest">"Updates will be sent."</string>

    <!-- Toast message displayed responding to an event from an email as accepted
     [CHAR LIMIT=50] -->
    <string name="rsvp_accepted">"Responded yes."</string>
    <!-- Toast message displayed responding to an event from an email as tentative
     [CHAR LIMIT=50] -->
    <string name="rsvp_tentative">"Responded maybe."</string>
    <!-- Toast message displayed responding to an event from an email as declined
     [CHAR LIMIT=50] -->
    <string name="rsvp_declined">"Responded no."</string>


    <!-- Title of message displayed to indicate available calendars are being loaded when creating
         a new event -->

    <!-- Body of message displayed to indicate available calendars are being loaded when creating
         a new event -->


    <!-- Create event dialog -->
    <skip/>
    <!-- Create event dialog save button [CHAR LIMIT=10] -->
    <string name="create_event_dialog_save">Save</string>

    <!-- The alert toast is not actually being displayed for some reason. -->
    <skip/>
    <!-- the title of the alert/notification activity -->
    <string name="alert_title">Calendar notifications</string>
    <!-- Notification window messages: -->
    <skip/>

    <!-- Event info/edit screen labels:-->
    <skip/>
    <!-- This is the title of the screen used to view the details of an event -->
    <string name="event_info_title">View event</string>
    <!-- This is the title of the screen used to view the details of an invitation
         to a meeting or event -->
    <string name="event_info_title_invite">Meeting invitation</string>

    <!-- EditEventActivity specific strings: -->
    <skip/>
    <!-- Events have a start date/time and an end date/time. The display shows
         the start and end times like 'From start date To end date'. This is the
         label before the 'end date'. -->
    <string name="edit_event_to_label">To</string>
    <!-- Events have a start date/time and an end date/time. The display shows
         the start and end times like 'From start date To end date'. This is the
         label before the 'start date'. -->
    <string name="edit_event_from_label">From</string>
    <!-- Check box label that specifies if this is an all-day event -->
    <string name="edit_event_all_day_label">All day</string>
    <!-- Label for choosing one of the calendars -->
    <string name="edit_event_calendar_label">Calendar</string>
    <!-- Menu item to show all choices [CHAR LIMIT=22]-->
    <string name="edit_event_show_all">Show all</string>
    <!-- Label for the event description -->
    <string name="description_label">Description</string>
    <!-- Label for the 'Presence' of an event, which can be either 'busy' (the default)
         or 'available'  [CHAR LIMIT=15] -->
    <string name="presence_label">Show me as</string>
    <!-- Label for the 'Privacy' of an event, which can be either 'private'
         or 'public' [CHAR LIMIT=15] -->
    <string name="privacy_label">Privacy</string>
    <!-- Label for the list of reminders for an event [CHAR LIMIT=20] -->
    <string name="reminders_label">Add reminder</string>
    <!-- Title of alert shown if the user tries to create an event and has no calendars -->
    <string name="no_syncable_calendars">No calendars</string>
    <!-- Body of alert shown if the user tries to create an event and has no calendars. Users can start adding an account here. [CHAR LIMIT=NONE] -->
    <string name="no_calendars_found">Before you can add an event, you must add at least one Calendar account to your device and make a calendar visible. Touch Add Account to add an account (if you just added an account, wait for it to finish syncing and try again). Or touch Cancel and make sure at least one calendar is visible.</string>
    <!-- Body of dialog prompting the user to create an account.[CHAR LIMIT=NONE] -->
    <string name="create_an_account_desc">"Calendar works better with a Google Account.\n\n\u2022 Access it from any web browser\n\u2022 Back up your events securely"</string>
    <!-- Title of a button shown when there is no account available and the system prompt a user to add one. [CHAR LIMIT=none] -->
    <string name="add_account">Add account</string>

    <!-- View Event -->
    <skip/>
    <!-- Label for which calendar an event is part of -->
    <string name="view_event_calendar_label">Calendar:</string>
    <!-- Label for the event organizer -->
    <string name="view_event_organizer_label">Organizer:</string>
    <!-- Label for the local timezone -->

    <!-- Label for showing event color picker -->
    <string name="choose_event_color_label">Choose event color</string>
    <!-- Title for event color picker dialog -->
    <string name="event_color_picker_dialog_title">Event Color</string>
    <!-- Label for button which sets event color to default calendar color -->
    <string name="event_color_set_to_default">Set to default calendar color</string>

    <!-- Title for calendar color picker dialog -->
    <string name="calendar_color_picker_dialog_title">Calendar Color</string>
    <!-- Description for calendar color squares, which bring up the color picker. -->
    <string name="calendar_square_color_picker_description">Color picker</string>

    <!-- Label for whether the user is attending this event. This is shown when
         a user is invited to a meeting or event.  The possible answers are
         'yes', 'no', and 'maybe' (and, initially, 'no response'). -->
    <string name="view_event_response_label">Attending?</string>
    <!-- Response for whether attending an event - accepted [CHAR LIMIT=10]-->
    <string name="response_yes">Yes</string>
    <!-- Response for whether attending an event - tentative [CHAR LIMIT=10]-->
    <string name="response_maybe">Maybe</string>
    <!-- Response for whether attending an event - declined [CHAR LIMIT=10]-->
    <string name="response_no">No</string>
    <!-- Label for emailing attendees -->
    <string name="email_guests_label">Email guests</string>
    <!-- Label for emailing the organizer (when there are no attendees) -->
    <string name="email_organizer_label">Email organizer</string>
    <!-- This is shown in the popup picker when emailing attendees -->
    <string name="email_picker_label">Email with</string>
    <!-- The is shown in the email subject as the prefix appended to the event title -->
    <string translatable="false" name="email_subject_prefix">Re:\u0020</string>
    <!-- Toast message displayed when the event id was not found LIMIT=30] -->
    <string name="event_not_found">"Event not found."</string>

    <!-- Notification label for getting a map of the location. -->
    <string name="map_label">Map</string>
    <!-- Notification label for calling a phone number in the location. -->
    <string name="call_label">Call</string>

    <!-- Title of the quick response item in Settings [CHAR LIMIT=18]-->
    <string name="quick_response_settings">Quick responses</string>
    <!-- Summary of the quick response item in Settings [CHAR LIMIT=80]-->
    <string name="quick_response_settings_summary">Edit default responses when emailing guests</string>
    <!-- Title of the quick response screen in Settings->Quick Response [CHAR LIMIT=27]-->
    <string name="quick_response_settings_title">Edit quick responses</string>
    <!-- Title of the quick response item in Settings [CHAR LIMIT=18]-->
    <string name="quick_response_settings_edit_title">Quick response</string>

    <!-- Title of the dialog prompting the user choose a response when emailing guests  [CHAR LIMIT=none]-->
    <string name="quick_response_dialog_title">Choose quick response</string>
    <!-- Error to user when an email program can't be found[CHAR LIMIT=none]-->
    <string name="quick_response_email_failed">Failed to find an email program</string>
    <!-- The is shown in the email subject as the prefix appended to the event title [CHAR LIMIT=none]-->
    <string-array name="quick_response_defaults">
        <item>Running just a couple of minutes late.</item>
        <item>Be there in about 10 minutes.</item>
        <item>Go ahead and start without me.</item>
        <item>Sorry, I can\'t make it. We\'ll have to reschedule.</item>
        </string-array>
    <!-- Option to create a custom response instead of using defaults [CHAR LIMIT=none] -->
    <string name="quick_response_custom_msg">Write your own\u2026</string>

    <!-- Event Info strings-->
    <!-- Time Zone Label [CHAR LIMIT=12]-->

    <!-- Repetition Label [CHAR LIMIT=12]-->

    <!-- Organizer Label [CHAR LIMIT=12]-->
    <string name="event_info_organizer">Organizer:</string>
    <!-- Reminders label [CHAR LIMIT=15]-->
    <string name="event_info_reminders_label">Reminders</string>

    <!-- Agenda View strings -->
    <skip/>
    <!-- This is shown as part of the heading at the top of a list of today's events. -->
    <string name="agenda_today">TODAY, <xliff:g id="date">%1$s</xliff:g></string>
    <!-- This is shown as part of the heading at the top of a list of today's events. -->
    <string name="agenda_yesterday">YESTERDAY, <xliff:g id="date">%1$s</xliff:g></string>
    <!-- This is shown as part of the heading at the top of a list of today's events. -->
    <string name="agenda_tomorrow">TOMORROW, <xliff:g id="date">%1$s</xliff:g></string>
    <!-- This is shown while the calendar events are being loading to the screen. -->
    <string name="loading">Loading\u2026</string>
    <!-- This is shown at the top of the agenda view showing the beginning of the searched range. If the user taps on this string and Calendar will find events older than what is visible and display them to the user -->
    <string name="show_older_events">Touch to view events before <xliff:g id="oldest_search_range">%1$s</xliff:g></string>
    <!-- This is shown at the bottom of the agenda view showing the end of the searched range. If the user taps on this string and Calendar will find events later/newer than what is visible and display them to the user -->
    <string name="show_newer_events">Touch to view events after <xliff:g id="newest_search_range">%1$s</xliff:g></string>

    <!-- Search activity strings -->
    <skip/>
    <!-- Title of the search screen [CHAR LIMIT=30] -->
    <string name="search_title">Search my calendars</string>

    <!-- Button labels: -->
    <skip/>
    <!-- This is the title of a popup window that is displayed when the user
         edits a repeating event. [CHAR LIMIT=20]-->
    <string name="edit_event_label">"Details"</string>
    <!-- This is a menu button for switching into edit mode when viewing an event.
        [CHAR LIMIT=10] -->
    <string name="edit_label">"Edit"</string>
    <!-- The button label for deleting an event -->
    <string name="delete_label">"Delete"</string>
    <!-- A menu item for deleting an event -->

    <!-- The button label for saving an event -->
    <string name="save_label">Done</string>
    <!-- The button label for discarding changes to an event -->
    <string name="discard_label">Cancel</string>

    <!-- Button labels on expanded notification reminders: -->
    <skip/>
    <!-- The button label for making the reminder alarms go away temporarily.
         The reminder alarms will fire off again in 5 minutes. -->
    <string name="snooze_all_label">"Snooze all"</string>
    <!-- The button label for dismissing all the current reminder alarms. This
         causes them to disappear from the notification screen. -->
    <string name="dismiss_all_label">"Dismiss all"</string>
    <!-- The button label for making the reminder alarms go away temporarily
         and re-fire in 5 minutes. [CHAR LIMIT=12]-->
    <string name="snooze_label">"Snooze"</string>

    <!-- Repetition dialog options: -->
    <skip/>
    <!-- A label in a multiple-choice list for the specifying that an event does
         not repeat -->
    <string name="does_not_repeat">One-time event</string>
    <!-- Part of a description of an repeating event. This part states the date when a repeating
         event ends. The part before the semi-colon describes how it repeats.
         e.g. Every 2 weeks; until 1/1/2030 [CHAR LIMIT=21] -->
    <string name="endByDate">; until <xliff:g id="date">%s</xliff:g></string>
    <!-- Part of a description of an repeating event. This part how many times the event repeats.
         The part before the semi-colon describes how it repeats.
         e.g. Every 2 weeks; for 15 times [CHAR LIMIT=15] -->
    <plurals name="endByCount">
        <item quantity="one">; for one time</item>
        <item quantity="other">; for <xliff:g id="number">%d</xliff:g> times</item>
    </plurals>
    <!-- A description for an event that repeats daily. For example, Every 2 days [CHAR LIMIT=15]-->
    <plurals name="daily">
        <item quantity="one">Daily</item>
        <item quantity="other">Every <xliff:g id="number">%d</xliff:g> days</item>
    </plurals>
    <!-- A label in a multiple-choice list for the specifying that an event
         repeats every weekday (Monday through Friday) -->
    <string name="every_weekday">"Every weekday (Mon\u2013Fri)"</string>
    <!-- A description for an event that repeats weekly on some day of the week. For example,
         'Weekly on Tuesday' or Every 2 weeks on Monday, Tuesday.  [CHAR LIMIT=25]-->
    <plurals name="weekly">
        <item quantity="one">Weekly on <xliff:g id="days_of_week">%2$s</xliff:g></item>
        <item quantity="other">Every <xliff:g id="number">%1$d</xliff:g> weeks on <xliff:g id="days_of_week">%2$s</xliff:g></item>
    </plurals>

    <!-- The common portion of a string describing how often an event repeats,
         example: 'Monthly (on day 2)' -->
    <string name="monthly">Monthly</string>
    <!-- Calendar spinner item, to select that an event recurs every year. -->
    <string name="yearly_plain">Yearly</string>
    <!-- Example: "Monthly (on day 15)" -->
    <string name="monthly_on_day">"Monthly (on day <xliff:g id="day_of_month">%s</xliff:g>)"</string>
    <!-- Example: "Yearly (on April 15)" -->
    <string name="yearly">"Yearly (on <xliff:g id="dates">%s</xliff:g>)"</string>
    <!-- This is a label for telling the user that this event repeats in
         custom (non-standard) way from the usual repeat rates (such as daily,
         weekly, etc.) and that the user cannot change this on the phone
         (but only on the web). -->
    <string name="custom" product="tablet">"Custom (can\'t customize on tablet)"</string>
    <!-- This is a label for telling the user that this event repeats in
         custom (non-standard) way from the usual repeat rates (such as daily,
         weekly, etc.) and that the user cannot change this on the phone
         (but only on the web). -->
    <string name="custom" product="default">"Custom (can\'t customize on phone)"</string>

    <!-- This is a choice in a list that the user sees when he tries to modify
         a repeating event.  This choice says to change just this one instance
         of this repeating event. -->
    <string name="modify_event">Change only this event</string>
    <!-- This is a choice in a list that the user sees when he tries to modify
         a repeating event.  This choice says to change all occurrences of
         this repeating event. -->
    <string name="modify_all">Change all events in the series</string>
    <!-- This is a choice in a list that the user sees when he tries to modify
         a repeating event.  This choice says to change this instance and all
         future occurrences of this repeating event. -->
    <string name="modify_all_following">Change this and all future events</string>

    <!-- Dialogs -->

    <!-- This is a label on the dialog for creating a new event. [CHAR LIMIT=30] -->
    <string name="new_event_dialog_label">"New event"</string>
    <!-- This is the button to create a new event in a dialog window. [CHAR LIMIT=30] -->
    <string name="new_event_dialog_option">"New event"</string>
    <!-- Confirmation dialog message -->
    <skip/>
    <!-- This is a confirmation message in a popup dialog that appears when the
         user has asked to delete an event. The user still has a chance to cancel
         this operation. -->
    <string name="delete_this_event_title">Delete this event?</string>
    <!-- This is a confirmation message in a popup dialog that appears when the
         user has asked to delete an event that is recurring. The user still has a chance to cancel
         this operation. -->
    <string name="delete_recurring_event_title">Delete <xliff:g id="eventtitle">%s</xliff:g>?</string>
    <!-- This is the title of a popup dialog that asks for confirmation before
         changing the response to an invitation. -->
    <string name="change_response_title">Change response</string>

    <!-- This the title of a menu for General Preferences.
         Pressing the menu item lets user to view and edit his general settings
         (or preferences) [CHAR LIMIT=30] -->
    <string name="menu_general_preferences">General settings</string>

    <!-- This the title of a menu for "About Calendar" Preferences.
         Pressing the menu item lets user to view the current settings
         [CHAR LIMIT=30] -->
    <string name="menu_about_preferences">About Calendar</string>

    <!-- This is the title of the screen for setting user preferences. -->
    <string name="preferences_title">"Settings"</string>
    <!-- This is the title of a section in the Settings screen for settings
         related to viewing calendar events -->
    <string name="preferences_general_title">Calendar view setting</string>
    <!-- This is the title of a section in the Settings screen for settings
         related to reminders for calendar events -->
    <string name="preferences_reminder_title">Notifications \u0026 reminders</string>
    <!-- Settings check box label to hide events that the user has declined to attend -->
    <string name="preferences_hide_declined_title">Hide declined events</string>
    <!-- Settings week start label to start week on specific day-->
    <string name="preferences_week_start_day_title">Week starts on</string>
    <!-- Title of popup for week start day setting-->
    <string name="preferences_week_start_day_dialog">Week starts on</string>
    <!-- DO NOT TRANSLATE -->
    <string name="preferences_week_start_day_default">-1</string>
    <!-- Title of the settings item to clear the recent search history [CHAR LIMIT=40] -->
    <string name="preferences_clear_search_history_title">Clear search history</string>
    <!-- Summary of the settings item to clear the recent search history [CHAR LIMIT=70]-->
    <string name="preferences_clear_search_history_summary">Remove all the searches you\'ve performed</string>
    <!-- Message to show in a toast when the history is cleared [CHAR LIMIT=40] -->
    <string name="search_history_cleared">Search history cleared.</string>
    <!-- Settings check box label to enable or disable notifications -->
    <string name="preferences_alerts_title">Notifications</string>
    <!-- Settings dialog label that specifies when the phone should vibrate -->
    <string name="preferences_alerts_vibrateWhen_title">Vibrate</string>
    <!-- The old value for enabling vibration. used only for migrating -->
    <string translatable="false" name="prefDefault_alerts_vibrate_true">always</string>
    <!-- Title of ringtone selector dialog -->
    <string name="preferences_alerts_ringtone_title">Sound</string>
    <!-- Title of check box label to enable or disable pop-up notifications -->
    <string name="preferences_alerts_popup_title">Pop-up notification</string>
    <!-- List item label for setting the default number of reminder minutes -->
    <string name="preferences_default_reminder_title">Default reminder time</string>
    <!-- Title of dialog for setting the default number of reminder minutes -->
    <string name="preferences_default_reminder_dialog">Default reminder time</string>
    <!-- Default value for the number of reminder minutes -->
    <string name="preferences_default_reminder_default">10</string>
    <!-- Settings check box label to keep Calendar in a fixed 'home' time zone [CHAR LIMIT = 18] -->
    <string name="preferences_use_home_tz_title">Use home time zone</string>
    <!-- Settings description of what setting Calendar to use a fixed 'home' time
        zone does [CHAR LIMIT = 60]-->
    <string name="preferences_use_home_tz_descrip">Displays calendars and event times in your home time zone when traveling</string>
    <!-- Settings title for selecting a 'home' time zone to display Calendar in [CHAR LIMIT = 18] -->
    <string name="preferences_home_tz_title">Home time zone</string>
    <!-- DO NOT TRANSLATE -->
    <string name="preferences_home_tz_default">America/Los_Angeles</string>

    <!-- Title of the settings item to show week number in week view [CHAR LIMIT=40] -->
    <string name="preferences_show_week_num_title">Show week number</string>

    <!-- This is the title of a section in the Settings screen for "About" this application -->
    <string name="preferences_about_title">About</string>
    <!-- Build version of the application -->
    <string name="preferences_build_version">Build version</string>

    <!-- Widget -->
    <skip/>
    <!-- Title for calendar gadget when displayed in list of all other gadgets -->
    <string name="gadget_title">Calendar</string>

    <!-- Shown in month view next to event icon when additional events exist for that day, but no
        room remaining -->
    <plurals name="month_more_events">
        <!-- additional events message for 1 event, the quotes force a literal interpretation of the
            string [CHAR LIMIT = 10] -->
        <item quantity="one">"+1"</item>
        <!-- additional events message for multiple events [CHAR LIMIT = 10] -->
        <item quantity="other">+<xliff:g id="number">%d</xliff:g></item>
    </plurals>

    <!-- Caption to show on gadget when there are no upcoming calendar events -->
    <string name="gadget_no_events">No upcoming calendar events</string>

    <!-- Text to show on gadget when an event is currently in progress -->


    <!-- Text to show on gadget when an all-day event is in progress -->


    <!-- DO NOT TRANSLATE -->
    <string name="tardis">TARDIS</string>

    <!-- Experimental settings [CHAR LIMIT = 30]-->
    <string name="preferences_experimental_category">Experimental</string>

    <!-- Reminders settings [CHAR LIMIT = 30]-->
    <string name="preferences_reminders_category">Reminders</string>
    <!-- Preference label for when to skip reminders [CHAR LIMIT = 25] -->
    <string name="preferences_reminders_responded_label">Skip Reminders</string>
    <!-- Dialog title for when to skip reminders [CHAR LIMIT = 25] -->
    <string name="preferences_reminders_responded_dialog">Skip Reminders</string>
    <!-- Preference label for quiet hours [CHAR LIMIT = 25]-->
    <string name="preferences_reminders_quiet_hours_label">Quiet hours</string>
    <!-- Preference description for quiet hours [CHAR LIMIT = NONE]-->
    <string name="preferences_reminders_quiet_hours_description">Silence event reminders during specified time.</string>
    <!-- Preference label for quiet hours start time [CHAR LIMIT = 25]-->
    <string name="preferences_reminders_quiet_hours_start">Quiet hours start time</string>
    <!-- Preference label for quiet hours end time [CHAR LIMIT = 25]-->
    <string name="preferences_reminders_quiet_hours_end">Quiet hours end time</string>

    <!-- Preferences used for debugging purposes [CHAR LIMIT = 30]-->
    <string name="preferences_debug_category">Debugging</string>

    <!-- Send a copy of the database to developers for debugging [CHAR LIMIT="NONE"] -->
    <string name="copy_db">Send database</string>

    <!-- Displayed in email address autocomplete list when searching for contacts
         in corporate directories. Example:  "Searching bigcompany.com..." [CHAR LIMIT=64] -->
    <string name="directory_searching_fmt">Searching <xliff:g id="domain">%s</xliff:g>\u2026</string>

    <!-- Accessibility Events -->
    <!-- Strings that describes actions for buttons without text -->
    <!-- Create a new calendar event [CHAR LIMIT = NONE]-->

    <!-- Remove a name of an attendee from a calendar event [CHAR LIMIT = NONE]-->
    <string name="accessibility_remove_attendee">Remove attendee</string>
    <!-- Pick a starting date for a new event [CHAR LIMIT = NONE]-->
    <string name="accessibility_pick_start_date">Start date</string>
    <!-- Pick a starting time for a new event [CHAR LIMIT = NONE]-->
    <string name="accessibility_pick_start_time">Start time</string>
    <!-- Pick the ending date for a new event [CHAR LIMIT = NONE]-->
    <string name="accessibility_pick_end_date">End date</string>
    <!-- Pick the ending time for a new event[CHAR LIMIT = NONE]-->
    <string name="accessibility_pick_end_time">End time</string>
    <!-- Select a time zone for a new event [CHAR LIMIT = NONE]-->
    <string name="accessibility_pick_time_zone">Time zone</string>
    <!-- Select a time zone for a new event [CHAR LIMIT = NONE]-->
    <string name="accessibility_pick_recurrence">Repeat event</string>
    <!-- Add a reminder to an event [CHAR LIMIT = NONE]-->
    <string name="accessibility_add_reminder">Add reminder</string>
    <!-- Remove a reminder from an event [CHAR LIMIT = NONE]-->
    <string name="accessibility_remove_reminder">Remove reminder</string>
    <!-- Add a new attendee to an event [CHAR LIMIT = NONE]-->
    <string name="accessibility_add_attendee">Add attendee</string>
    <!-- Choose if to sync/unsync this calendar with its server [CHAR LIMIT = NONE]-->
    <string name="accessibility_sync_cal">Sync calendar</string>
    <!-- Mark this event as an "all day event" [CHAR LIMIT = NONE]-->
    <string name="accessibility_all_day">All day event</string>
    <!-- Refresh the data in the calendar [CHAR LIMIT = NONE]-->

    <!-- Choose the type of repetition for the event (daily, weekly, etc.[CHAR LIMIT = NONE]-->
    <string name="accessibility_repeats">Repetition</string>
    <!-- Set the time for the reminder[CHAR LIMIT = NONE]-->
    <string name="accessibility_reminder_time">Reminder time</string>
    <!-- Set the type of the reminder (popup/email/sms)[CHAR LIMIT = NONE]-->
    <string name="accessibility_reminder_type">Reminder type</string>
    <!-- Select the way you are visible for the event (busy/free) [CHAR LIMIT = NONE]-->
    <string name="accessibility_reminder_showmeas">Show me as</string>
    <!-- Set the event as private/public/default [CHAR LIMIT = NONE]-->
    <string name="accessibility_reminder_privacy">Privacy</string>
    <!-- Calendar notification [CHAR LIMIT = NONE]-->
    <string name="acessibility_cal_notification">Calendar Notification</string>
    <!-- Calendar notification snooze button [CHAR LIMIT = NONE]-->
    <string name="acessibility_snooze_notification">Snooze Notification</string>
    <!-- Calendar notification email button [CHAR LIMIT = NONE]-->
    <string name="accessibility_email_notification">Email guests</string>

    <!-- A "new event" hint for the user when selecting a specific hour in the day view [CHAR LIMIT = 30]-->
    <string name="day_view_new_event_hint">+ New event</string>

    <!--
      Source: A value for announcing the current event index (example: "Event 2 of 6").
      Description: This is spoken to the user. [CHAR LIMIT="NONE"]
    -->
    <string name="template_announce_item_index">Event <xliff:g id="item_index">%1$s</xliff:g> of <xliff:g id="item_count">%2$s</xliff:g>.</string>

        <!-- number of events in the notification bar -->
    <plurals name="Nevents">
        <!-- This is the label for a 1 event. -->
        <item quantity="one">1 event</item>
        <!-- This is the label for 2 or more events. -->
        <item quantity="other"><xliff:g id="count">%d</xliff:g> events</item>
    </plurals>

    <!-- number of remaining events for an alert digest in the notification bar [CHAR LIMIT = 30] -->
    <plurals name="N_remaining_events">
        <!-- This is the label for 1 event. -->
        <item quantity="one">+1 event</item>
        <!-- This is the label for 2 or more events. -->
        <item quantity="other">+<xliff:g id="count">%d</xliff:g> events</item>
    </plurals>

    <!-- Description of the selected marker for accessibility support [CHAR LIMIT = NONE]-->
    <string name="acessibility_selected_marker_description">Selected event</string>

    <!-- Tell user not to check a checkbox [CHAR LIMIT=30] -->
    <string name="do_not_check">Do NOT check -></string>

    <!-- Dialog title for recurrence picker for configuring a repeating event[CHAR LIMIT=20] -->
    <string name="recurrence_dialog_title">Repeat</string>
    <!-- Dialog title for recurrence picker when one-time event is selected [CHAR LIMIT=20] -->
    <string name="recurrence_dialog_title_never">Never repeats</string>

    <!-- Strings to describe how frequently to repeat an event (e.g. every 5 days) -->
    <plurals name="recurrence_interval_daily">
        <!-- Singular form [CHAR LIMIT=30] -->
        <item quantity="one">Every <xliff:g id="count">%d</xliff:g> day</item>
        <!-- Plural form [CHAR LIMIT=30] -->
        <item quantity="other">Every <xliff:g id="count">%d</xliff:g> days</item>
    </plurals>
    <!-- Strings to describe how frequently to repeat an event (e.g. every 5 weeks) -->
    <plurals name="recurrence_interval_weekly">
        <!-- Singular form [CHAR LIMIT=30] -->
        <item quantity="one">Every <xliff:g id="count">%d</xliff:g> week</item>
        <!-- Plural form [CHAR LIMIT=30] -->
        <item quantity="other">Every <xliff:g id="count">%d</xliff:g> weeks</item>
    </plurals>
    <!-- Strings to describe how frequently to repeat an event (e.g. every 5 months) -->
    <plurals name="recurrence_interval_monthly">
        <!-- Singular form [CHAR LIMIT=30] -->
        <item quantity="one">Every <xliff:g id="count">%d</xliff:g> month</item>
        <!-- Plural form [CHAR LIMIT=30] -->
        <item quantity="other">Every <xliff:g id="count">%d</xliff:g> months</item>
    </plurals>
    <!-- Strings to describe how frequently to repeat an event (e.g. every 5 years) -->
    <plurals name="recurrence_interval_yearly">
        <!-- Singular form [CHAR LIMIT=30] -->
        <item quantity="one">Every <xliff:g id="count">%d</xliff:g> year</item>
        <!-- Plural form [CHAR LIMIT=30] -->
        <item quantity="other">Every <xliff:g id="count">%d</xliff:g> years</item>
    </plurals>

    <!-- Repeat an monthly event on the same day of every month [CHAR LIMIT=20] -->
    <string name="recurrence_month_pattern_by_day">on the same day each month</string>

    <!-- Specifies that a repeating event to repeat forever (based on the defined frequency) instead of ending at a future date[CHAR LIMIT=20] -->
    <string name="recurrence_end_continously">Forever</string>
    <!-- Specifies that a repeating event to repeat until a certain date[CHAR LIMIT=25] -->
    <string name="recurrence_end_date_label">Until a date</string>
    <!-- Specifies that a repeating event to repeat until a certain date[CHAR LIMIT=20] -->
    <string name="recurrence_end_date">Until <xliff:g id="date">%s</xliff:g></string>
    <!-- Specifies that a repeating event to repeat for a number of times. A repeating event can repeat forever, repeat in a certain frequency until a certain date, or repeat for a number of times. e.g. repeat 10 times and stop. This string is for the last case [CHAR LIMIT=25] -->
    <string name="recurrence_end_count_label">For a number of events</string>

    <!-- Specifies that a repeating event should repeat for a certain number of iterations. [CHAR LIMIT=20]-->
    <plurals name="recurrence_end_count">
        <item quantity="one">For <xliff:g id="event_count">%d</xliff:g> event</item>
        <item quantity="other">For <xliff:g id="event_count">%d</xliff:g> events</item>
    </plurals>

    <!-- Description of the selected marker for accessibility support [CHAR LIMIT = NONE]-->
    <string name="acessibility_recurrence_choose_end_date_description">change end date</string>

    <!-- Do Not Translate.  Sender identity for global notification synchronization. -->
    <string name="notification_sender_id"></string>
</resources>
