<?xml version="1.0" encoding="utf-8"?>
<!-- Copyright (C) 2009 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>
    <!-- Initial height of transparent space above QuickContacts -->
    <dimen name="quickcontact_starting_empty_height">150dp</dimen>
    <!-- Initial size of QuickContact's title size -->
    <dimen name="quickcontact_maximum_title_size">32dp</dimen>
    <!-- Initial size of QuickContact's phonetic name size -->
    <dimen name="quickcontact_maximum_phonetic_name_size">28dp</dimen>
    <!-- When QC is uncollapsed, the title has this much margin on its left and right. -->
    <dimen name="quickcontact_title_initial_margin">16dp</dimen>
    <!-- When QC is uncollapsed, the title has this much margin on its bottom -->
    <dimen name="quickcontact_title_initial_bottom_margin">8dp</dimen>
    <!-- The ratio of width:height for the contact's photo in landscape -->
    <item name="quickcontact_landscape_photo_ratio" type="dimen" format="float">0.7</item>
    <!-- How far QuickContacts can be dragged and released from the top of the window before we dismiss it. -->
    <dimen name="quickcontact_dismiss_distance_on_release">40dp</dimen>
    <!-- How far QuickContacts can be dragged from the top of the window before we dismiss it. -->
    <dimen name="quickcontact_dismiss_distance_on_scroll">100dp</dimen>
    <!-- When first flinging QuickContacts towards the top of the window if the fling is
        predicted to scroll past the window top by less than this amount, then QuickContacts
        snaps to the top of the window. -->
    <dimen name="quickcontact_snap_to_top_slop_height">33dp</dimen>

    <!-- Account info left margin in editor. -->
    <dimen name="editor_account_left_margin">4dp</dimen>

    <!-- Margin between name field and whatever fields are above it. -->
    <dimen name="editor_name_top_margin">8dp</dimen>

    <!-- Top margin for "Saving to" account header text field. -->
    <dimen name="editor_account_header_top_margin">3dp</dimen>

    <!-- The ratio of width:height (360:184) for the editor contact photo in portrait -->
    <item name="editor_portrait_photo_ratio" type="dimen" format="float">1.96</item>

    <!-- Padding of the rounded plus/minus/expand/collapse buttons in the editor  -->
    <dimen name="editor_round_button_padding_left">16dip</dimen>
    <dimen name="editor_round_button_padding_right">16dip</dimen>
    <dimen name="editor_round_button_padding_top">16dip</dimen>
    <dimen name="editor_round_button_padding_bottom">16dip</dimen>

    <!-- Minimum height of a row in the Editor. This is the target height for editor "rows",
        including the "More fields" button/row. -->
    <dimen name="editor_min_line_item_height">54dp</dimen>

    <!-- The height and width of the delete button should be the same size as an editor row -->
    <dimen name="editor_delete_button_size">@dimen/editor_min_line_item_height</dimen>

    <!-- Top margin applied to mime-type icons inside the editor. This is needed to give the
        appearance that the icons are top aligned with the text, since visible text doesn't
        start at the very top of TextViews. -->
    <dimen name="editor_kind_icon_top_margin">14dp</dimen>

    <!-- RHS padding added to spinners in the editor. This separates the spinner text from the
        spinner graphic since b/18194928 causes the spinner to always be on the RHS.
        In LTR mode this shouldn't have an observable affect. We set paddingRight instead of
        drawablePadding since the spinner graphic is not a normal drawable.  -->
    <dimen name="editor_spinner_right_padding_workaround">24dip</dimen>

    <!-- RHS padding added to spinners for L devices -->
    <dimen name="editor_spinner_right_padding">40dip</dimen>

    <!-- Size of input form text inside the contact editor -->
    <dimen name="editor_form_text_size">16sp</dimen>

    <!-- Total width of data-kind icon, including its start and end padding -->
    <dimen name="editor_kind_icon_total_width">68dp</dimen>

    <!-- Padding below every editor view, such as LabeledEditorView. This value is chosen
        to give 19dp of apparent padding between EditText's in the Raw Contact Editor. -->
    <dimen name="editor_padding_between_editor_views">2dp</dimen>

    <!-- Padding below every readonly editor view. This value is chosen to give 19dp of apparent
        padding between TextView's in the readonly Raw Contact Editor. -->
    <dimen name="editor_padding_between_read_only_editor_views">9dp</dimen>

    <!-- Width of the Type-Label in the Editor -->
    <dimen name="editor_type_label_width">150dip</dimen>

    <!-- Minimum width for the photo action popup options -->
    <dimen name="photo_action_popup_min_width">300dip</dimen>

    <!-- Minimum width for the custom label edit dialog -->
    <dimen name="custom_dialog_min_width">300dip</dimen>

    <!-- Custom dialog padding dimens -->
    <dimen name="custom_dialog_layout_padding">24dip</dimen>

    <!-- Custom dialog layout dimens -->
    <dimen name="custom_dialog_layout">4dip</dimen>

    <!-- For join screen. Mainly for tablet. -->
    <dimen name="join_header_left_margin">@dimen/contact_browser_list_header_left_margin</dimen>
    <dimen name="join_header_right_margin">@dimen/contact_browser_list_header_right_margin</dimen>
    <dimen name="join_header_top_margin">12dip</dimen>
    <dimen name="join_header_bottom_margin">12dip</dimen>

    <dimen name="contact_filter_header_min_height">24dip</dimen>

    <!-- Margins for ExpandingEntryCardView -->
    <dimen name="expanding_entry_card_marginStartEnd">8dp</dimen>
    <dimen name="expanding_entry_card_marginBottom">12dp</dimen>

    <!-- Top margin for the communication card, used to add space from header. -->
    <dimen name="first_card_marginTop">12dp</dimen>

    <!-- Elevation of an ExpandingEntryCard, for the sake of shadow casting -->
    <dimen name="expanding_entry_card_elevation">2dp</dimen>
    <!-- Elevation of the QuickContact's Toolbar, for the sake of shadow casting -->
    <dimen name="quick_contact_toolbar_elevation">4.5dp</dimen>

    <!-- Size of the title text for a ExpandingEntryCardView -->
    <dimen name="expanding_entry_card_title_text_size">16sp</dimen>
    <!-- Padding for the title text for a ExpandingEntryCardView -->
    <dimen name="expanding_entry_card_title_padding">16dp</dimen>
    <!-- Extra top padding if the title is set to null -->
    <dimen name="expanding_entry_card_null_title_top_extra_padding">2dp</dimen>

    <!-- Height of the separator between entries in an ExpandingEntryCardView and contact editor. -->
    <dimen name="divider_line_height">1dp</dimen>

    <!-- Dimensions for an entry in ExpandingEntryCardView -->
    <dimen name="expanding_entry_card_item_padding_start">20dp</dimen>
    <dimen name="expanding_entry_card_item_padding_end">8dp</dimen>
    <dimen name="expanding_entry_card_item_padding_top">13dp</dimen>
    <dimen name="expanding_entry_card_item_padding_bottom">16dp</dimen>
    <dimen name="expanding_entry_card_item_image_spacing">27dp</dimen>

    <!-- Dimensions for a button in ExpandingEntryCardView -->
    <dimen name="expanding_entry_card_button_padding_vertical">18dp</dimen>

    <dimen name="expanding_entry_card_item_text_icon_margin_top">7dp</dimen>
    <dimen name="expanding_entry_card_item_text_icon_margin_right">7dp</dimen>
    <dimen name="expanding_entry_card_item_sub_header_icon_margin_right">4dp</dimen>
    <dimen name="expanding_entry_card_item_sub_header_icon_margin_bottom">14dp</dimen>

    <dimen name="expanding_entry_card_item_icon_margin_top">12dp</dimen>
    <dimen name="expanding_entry_card_item_icon_margin_bottom">12dp</dimen>
    <dimen name="expanding_entry_card_item_icon_margin_left">12dp</dimen>
    <dimen name="expanding_entry_card_item_icon_margin_right">12dp</dimen>
    <dimen name="expanding_entry_card_item_header_only_margin_top">6dp</dimen>

    <dimen name="expanding_entry_card_card_corner_radius">2dp</dimen>
    <dimen name="expanding_entry_card_header_margin_bottom">2dp</dimen>
    <!-- The top margin when the sub header and text views are both gone -->
    <dimen name="expanding_entry_card_item_header_only_margin_bottom">2dp</dimen>
    <dimen name="expanding_entry_card_item_no_icon_margin_top">6dp</dimen>

    <dimen name="quickcontact_suggestion_card_icon_height">40dp</dimen>
    <dimen name="quickcontact_suggestion_card_icon_width">40dp</dimen>
    <dimen name="quickcontact_suggestion_card_image_spacing">20dp</dimen>
    <dimen name="quickcontact_suggestion_card_layout_margin">8dp</dimen>
    <dimen name="quickcontact_collapse_view_height">48dp</dimen>
    <dimen name="quickcontact_collapse_icon_size">24dp</dimen>
    <dimen name="quickcontact_collapse_text_padding">12dp</dimen>
    <dimen name="quickcontact_collapse_image_padding">20dp</dimen>
    <dimen name="quickcontact_expanding_help_text_size">14sp</dimen>
    <dimen name="quickcontact_expanding_button_right_padding">16dp</dimen>
    <dimen name="quickcontact_expanding_item_height">72dp</dimen>
    <dimen name="quickcontact_expanding_item_image_padding">12dp</dimen>
    <dimen name="quickcontact_expanding_button_section_height">48dp</dimen>
    <dimen name="quickcontact_expanding_button_section_padding">8dp</dimen>

    <dimen name="expanding_entry_card_item_icon_height">24dp</dimen>
    <dimen name="expanding_entry_card_item_icon_width">24dp</dimen>

    <dimen name="contact_browser_list_item_padding_top_or_bottom">7dp</dimen>

    <dimen name="contact_browser_list_item_height">56dp</dimen>

    <!-- Navigation drawer header height, the same as the status bar in landscape and portrait modes -->
    <dimen name="nav_header_height">24dp</dimen>

    <!-- Default activity margins, per the Android Material Design guidelines. -->
    <dimen name="activity_horizontal_margin">16dp</dimen>
    <dimen name="activity_vertical_margin">16dp</dimen>

    <dimen name="nav_new_badge_corners">3dp</dimen>
    <dimen name="nav_new_badge_vertical_pad">2dp</dimen>
    <dimen name="nav_new_badge_horizontal_pad">5dp</dimen>
    <dimen name="nav_new_badge_font_size">11sp</dimen>

    <!-- Top padding for the image for empty group view -->
    <dimen name="empty_group_view_image_padding_top">8dp</dimen>

    <!-- Height for the image for empty group and main view-->
    <dimen name="empty_view_image_height">180dp</dimen>

    <!-- Top padding for the text for empty group view -->
    <dimen name="empty_group_view_text_padding_top">32dp</dimen>

    <!-- Top padding for the text for empty account view -->
    <dimen name="empty_account_view_text_padding_top">24dp</dimen>

    <!-- End margin of edit group title -->
    <dimen name="edit_group_end_margin">72dp</dimen>

    <!-- Minimum height for group name EditText -->
    <dimen name="dialog_edit_text_min_height">48dp</dimen>

    <!-- Distance to pull down before causing a refresh. -->
    <dimen name="pull_to_refresh_distance">40dp</dimen>

    <!-- Elevation of contact list header -->
    <dimen name="contact_list_header_elevation">2dp</dimen>

    <!-- Gap b/w image view and top of the screen in empty main view -->
    <dimen name="empty_home_view_image_offset">210dp</dimen>

    <!-- Top padding for the text for empty main view -->
    <dimen name="empty_home_view_text_padding_top">32dp</dimen>

    <!-- Extra margin above image in empty account view -->
    <dimen name="empty_account_view_image_offset">30dp</dimen>

    <!-- Margin offset b/w the image top and app bar bottom for no account empty view -->
    <dimen name="contacts_no_account_empty_image_offset">230dp</dimen>

    <!-- Width for the image for contacts no account empty view -->
    <dimen name="contacts_no_account_empty_image_width">180dp</dimen>

    <!-- Top padding for the text for no account empty view -->
    <dimen name="contacts_no_account_empty_text_padding_top">32dp</dimen>

    <!-- Top padding for add account button for no account empty view -->
    <dimen name="contacts_no_account_empty_button_padding_top">16dp</dimen>

    <!-- Margin b/w add account button and import contacts button for no account empty view -->
    <dimen name="contacts_no_account_buttons_margin">8dp</dimen>

    <!-- Padding between the action bar's bottom edge and the first header
         in contacts/group lists. -->
    <dimen name="list_header_extra_top_padding">0dip</dimen>

    <dimen name="list_section_divider_min_height">32dip</dimen>

    <dimen name="directory_header_extra_top_padding">18dp</dimen>
    <dimen name="directory_header_extra_bottom_padding">8dp</dimen>
    <dimen name="directory_header_left_padding">16dp</dimen>

    <!--  Horizontal padding in between contact tiles -->
    <dimen name="contact_tile_divider_padding">23dip</dimen>
    <!--  Horizontal whitespace (both padding and margin) before the first tile and after the last tile -->
    <dimen name="contact_tile_start_end_whitespace">16dip</dimen>

    <!-- ContactTile Layouts -->
    <!--
      Use sp instead of dip so that the shadowbox heights can all scale uniformly
      when the font size is scaled for accessibility purposes
    -->
    <dimen name="contact_tile_shadowbox_height">48sp</dimen>

    <!-- For contact filter setting screens -->
    <dimen name="contact_filter_left_margin">8dp</dimen>
    <dimen name="contact_filter_right_margin">16dip</dimen>
    <dimen name="contact_filter_item_min_height">48dip</dimen>
    <dimen name="contact_filter_icon_size">32dip</dimen>
    <dimen name="contact_filter_list_item_height">56dp</dimen>
    <dimen name="contact_filter_list_item_padding_start">16dp</dimen>
    <!-- contact_filter_indicator is the arrow in expandable list view -->
    <dimen name="contact_filter_indicator_padding_start">6dp</dimen>
    <dimen name="contact_filter_indicator_padding_end">46dp</dimen>
    <dimen name="contact_filter_action_button_width">72dp</dimen>

    <!-- Padding to be used between a visible scrollbar and the contact list -->
    <dimen name="list_visible_scrollbar_padding">32dip</dimen>

    <dimen name="contact_browser_list_header_icon_left_margin">16dp</dimen>
    <dimen name="contact_browser_list_header_icon_right_margin">14dp</dimen>
    <dimen name="contact_browser_list_header_icon_left_margin_alt">18dp</dimen>
    <dimen name="contact_browser_list_header_icon_right_margin_alt">16dp</dimen>
    <dimen name="contact_browser_list_header_left_margin">16dip</dimen>
    <dimen name="contact_browser_list_header_right_margin">@dimen/list_visible_scrollbar_padding</dimen>
    <dimen name="contact_browser_list_item_text_indent">8dip</dimen>
    <dimen name="contact_browser_list_header_height">48dp</dimen>
    <dimen name="contact_browser_list_header_icon_size">24dp</dimen>
    <dimen name="contact_browser_list_header_icon_size_alt">20dp</dimen>
    <dimen name="contact_browser_list_header_text_margin">10dp</dimen>
    <!-- Width of a contact list item section header. -->
    <dimen name="contact_list_section_header_width">56dp</dimen>

    <!-- Size of the shortcut icon. 0dip means: use the system default -->
    <dimen name="shortcut_icon_size">0dip</dimen>

    <!-- Text size of shortcut icon overlay text -->
    <dimen name="shortcut_overlay_text_size">12dp</dimen>

    <!-- Extra vertical padding for darkened background behind shortcut icon overlay text -->
    <dimen name="shortcut_overlay_text_background_padding">1dp</dimen>

    <!-- Width of height of an icon from a third-party app in the networks section of the contact card. -->
    <dimen name="detail_network_icon_size">40dp</dimen>

    <!-- contact browser list margins -->
    <dimen name="contact_browser_list_item_text_size">16sp</dimen>
    <dimen name="contact_browser_list_item_photo_size">40dp</dimen>
    <dimen name="contact_browser_list_item_gap_between_image_and_text">15dp</dimen>
    <dimen name="contact_browser_list_item_gap_between_indexer_and_image">16dp</dimen>

    <!-- Dimensions for contact letter tiles -->
    <item name="letter_to_tile_ratio" type="dimen">67%</item>

    <!-- Height of the floating action button -->
    <dimen name="floating_action_button_height">56dp</dimen>
    <!-- Width of the floating action button -->
    <dimen name="floating_action_button_width">56dp</dimen>
    <!-- Z translation of the floating action button -->
    <dimen name="floating_action_button_translation_z">8dp</dimen>
    <!-- Padding to be applied to the bottom of lists to make space for the floating action
         button -->
    <dimen name="floating_action_button_list_bottom_padding">88dp</dimen>
    <!-- Right margin of the floating action button -->
    <dimen name="floating_action_button_margin_right">16dp</dimen>
    <!-- Bottom margin of the floating action button -->
    <dimen name="floating_action_button_margin_bottom">16dp</dimen>

    <!-- Size of text in tabs. -->
    <dimen name="tab_elevation">2dp</dimen>

    <!-- Size of the icon (voice search, back arrow) in the search box. -->
    <dimen name="search_box_icon_size">56dp</dimen>
    <!-- Size of the close icon.-->
    <dimen name="search_box_close_icon_size">56dp</dimen>
    <!-- Padding around the close button. It's visible size without padding is 24dp. -->
    <dimen name="search_box_close_icon_padding">16dp</dimen>
    <!-- End margin of the back arrow icon in the search box -->
    <dimen name="search_box_navigation_icon_margin">8dp</dimen>
    <!-- Left margin of the text field in the search box. -->
    <dimen name="search_box_text_left_margin">8dp</dimen>
    <!-- Search box text size -->
    <dimen name="search_text_size">16sp</dimen>

    <!-- Size of the close icon in selection bar.-->
    <dimen name="selection_bar_close_icon_size">56dp</dimen>

    <!-- Top margin for the Frequently Contacted section title -->
    <dimen name="frequently_contacted_title_top_margin_when_first_row">16dp</dimen>
    <!-- Top margin for the Frequently Contacted section title, when the title is the first
         item in the list -->
    <dimen name="frequently_contacted_title_top_margin">57dp</dimen>

    <dimen name="frequently_contacted_title_text_size">24sp</dimen>

    <!-- Padding used around the periphery of the call subject dialog, as well as in between the
         items. -->
    <dimen name="call_subject_dialog_margin">20dp</dimen>
    <!-- Padding used between lines of text in the call subject dialog. -->
    <dimen name="call_subject_dialog_between_line_margin">8dp</dimen>
    <!-- Size of the contact photo in the call subject dialog. -->
    <dimen name="call_subject_dialog_contact_photo_size">50dp</dimen>
    <!-- Margin above the edit text in the call subject dialog. -->
    <dimen name="call_subject_dialog_edit_spacing">60dp</dimen>
    <!-- Size of primary text in the call subject dialog. -->
    <dimen name="call_subject_dialog_primary_text_size">16sp</dimen>
    <!-- Size of secondary text in the call subject dialog. -->
    <dimen name="call_subject_dialog_secondary_text_size">14sp</dimen>
    <!-- Row padding for call subject history items. -->
    <dimen name="call_subject_history_item_padding">15dp</dimen>

</resources>
