<?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>
    <dimen name="account_selector_popup_width">400dip</dimen>

    <!-- Top position of quick contact. If this is -1, the vertical position is determined
    based on the source of the request -->
    <dimen name="quick_contact_top_position">48dip</dimen>

    <!-- Top padding of the entire contact editor  -->
    <dimen name="editor_padding_top">0dip</dimen>

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

    <!-- Left padding of the label in the add field button for the contact editor -->
    <dimen name="editor_add_field_label_left_padding">16dip</dimen>

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

    <!-- Left padding of a field in the Editor -->
    <dimen name="editor_field_left_padding">4dip</dimen>

    <!-- Right padding of a field in the Editor -->
    <dimen name="editor_field_right_padding">4dip</dimen>

    <!-- Minimum height of a row in the Editor -->
    <dimen name="editor_min_line_item_height">48dip</dimen>

    <!-- Height of the shadow asset under the photo on the contact detail page -->
    <dimen name="detail_contact_photo_shadow_height">10dip</dimen>

    <!-- Height of the tab text label in the tab carousel on the contact detail page -->
    <dimen name="detail_tab_carousel_tab_label_height">45dip</dimen>

    <!-- Height of the tab text label in the tab carousel on the contact detail page -->
    <dimen name="detail_tab_carousel_tab_label_indent">24dip</dimen>

    <!-- Left and right padding of the text within the update tab in the tab carousel -->
    <dimen name="detail_update_tab_side_padding">24dip</dimen>

    <!-- Left and right padding of the update section in the contact detail card -->
    <dimen name="detail_update_section_side_padding">16dip</dimen>

    <!-- Vertical padding above and below individual stream items -->
    <dimen name="detail_update_section_item_vertical_padding">16dip</dimen>

    <!-- Vertical padding between text and images in a single stream item -->
    <dimen name="detail_update_section_between_items_vertical_padding">8dip</dimen>

    <!-- Horizontal padding for individual stream items -->
    <dimen name="detail_update_section_item_horizontal_padding">8dip</dimen>

    <!-- Padding between images in a single stream item -->
    <dimen name="detail_update_section_between_items_padding">1dip</dimen>

    <!-- Horizontal padding between attribution and comments -->
    <dimen name="detail_update_section_attribution_comments_padding">4dip</dimen>

    <!-- Margin around the contact's photo on the contact card -->
    <dimen name="detail_contact_photo_margin">8dip</dimen>

    <!-- Width and height of the contact photo on the contact detail page -->
    <dimen name="detail_contact_photo_size">128dip</dimen>

    <!-- Width and height of the expanded contact photo on the contact detail page -->
    <dimen name="detail_contact_photo_expanded_size">400dip</dimen>

    <!-- This is the minimum amount of space to leave underneath an expanded contact detail
         photo -->
    <dimen name="expanded_photo_height_offset">100dip</dimen>

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

    <!-- Left and right padding for a contact detail item -->
    <dimen name="detail_item_icon_margin">8dip</dimen>

    <!-- Left and right padding for a contact detail item -->
    <dimen name="detail_item_side_margin">16dip</dimen>

    <!-- Top and bottom padding for a contact detail item -->
    <dimen name="detail_item_vertical_margin">8dip</dimen>

    <!-- Minimum height of a row in the contact detail -->
    <dimen name="detail_min_line_item_height">48dip</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">32dip</dimen>

    <!-- Font size for the display name in header of the contact detail page -->
    <dimen name="detail_header_name_text_size">36sp</dimen>

    <!-- Vertical margin for vertical dividers existing between primary data
         (phone number, email, etc.) and a secondary action button -->
    <dimen name="detail_vertical_divider_vertical_margin">16dip</dimen>

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

    <!-- Font size used for the contact name in the widget -->
    <dimen name="widget_text_size_name">14sp</dimen>

    <!-- Font size used for the social status in the widget -->
    <dimen name="widget_text_size_snippet">13sp</dimen>

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

    <!-- Width of darkened border for shortcut icon -->
    <dimen name="shortcut_icon_border_width">1dp</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>

    <!-- Height of list sections (A, B, C) that show the first character of the contacts -->
    <dimen name="list_section_height">25dip</dimen>

    <!-- Account title left padding -->
    <dimen name="account_container_left_padding">16dip</dimen>

    <!-- Left padding for a group member list item -->
    <dimen name="group_member_item_left_padding">4dip</dimen>

    <!-- Left and right padding for the group editor view -->
    <dimen name="group_editor_side_padding">16dip</dimen>

    <!-- Left margin for the group member list to match the built in margin in the autocomplete asset -->
    <dimen name="group_editor_member_list_left_margin">4dip</dimen>

    <!-- Right margin for the group member list to match the built in margin in the autocomplete asset -->
    <dimen name="group_editor_member_list_right_margin">4dip</dimen>

    <!-- Left padding of the auto complete field to line hint text up with member list -->
    <dimen name="group_editor_autocomplete_left_padding">8dip</dimen>

    <!-- Border padding for the group detail fragment -->
    <dimen name="group_detail_border_padding">0dip</dimen>

    <!-- Height of the quick contact photo container (for screens that are too large to use the screen width/height as a constraint)-->
    <dimen name="quick_contact_photo_container_height">180dip</dimen>

    <!-- Height of edit text in dialpad fragment -->
    <dimen name="dialpad_horizontal_margin">0dip</dimen>
    <dimen name="dialpad_vertical_margin">2dip</dimen>
    <dimen name="dialpad_digits_text_size">35sp</dimen>

    <!-- Just used in landscape mode -->
    <dimen name="dialpad_digits_height">0px</dimen>
    <dimen name="dialpad_digits_margin_bottom">0px</dimen>

    <!-- Width of search view in action bar.  Use 0dip for MATCH_PARENT -->
    <dimen name="search_view_width">0dip</dimen>

    <!-- contact browser list margins -->
    <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_photo_size">64dip</dimen>
    <dimen name="contact_browser_list_item_text_indent">8dip</dimen>
    <dimen name="contact_browser_list_top_margin">8dip</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">16dip</dimen>
    <dimen name="join_header_bottom_margin">0dip</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>

    <!-- 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>

    <!-- Top padding of the ListView in the contact tile list -->
    <dimen name="contact_tile_list_padding_top">0dip</dimen>

    <!-- Call Log -->
    <dimen name="call_log_call_action_size">32dip</dimen>
    <dimen name="call_log_call_action_width">48dip</dimen>
    <dimen name="call_log_icon_margin">4dip</dimen>
    <dimen name="call_log_inner_margin">8dip</dimen>
    <dimen name="call_log_outer_margin">16dip</dimen>
    <dimen name="call_log_indent_margin">24dip</dimen>
    <dimen name="call_log_list_item_height">56dip</dimen>
    <dimen name="call_log_list_contact_photo_size">64dip</dimen>
    <dimen name="call_detail_contact_name_margin">24dip</dimen>
    <dimen name="call_detail_button_spacing">2dip</dimen>

    <!-- Empty message margins -->
    <dimen name="empty_message_top_margin">48dip</dimen>
    <dimen name="no_accounts_message_margin">20dip</dimen>

    <!-- For contact filter setting screens -->
    <dimen name="contact_filter_left_margin">16dip</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_header_min_height">24dip</dimen>

    <!--  Vertical and horizontal padding in between contact tiles -->
    <dimen name="contact_tile_divider_padding">1dip</dimen>

    <!--  Width of the lead margin on the left of a block quote inside a stream item -->
    <dimen name="stream_item_stripe_width">8dip</dimen>

    <!-- Layout weight values for dialpad screen. These layouts will be used in one
         LinearLayout (dialpad_fragment.xml), configuring dialpad screen's vertical
         ratio. -->
    <integer name="dialpad_layout_weight_digits">20</integer>
    <integer name="dialpad_layout_weight_dialpad">65</integer>
    <integer name="dialpad_layout_weight_additional_buttons">15</integer>

    <!-- Minimum height used with @drawable/list_section_divider_holo_custom.
         Right now the drawable has implicit 32dip minimal height, which is confusing.
         This value is for making the hidden configuration explicit in xml. -->
    <dimen name="list_section_divider_min_height">32dip</dimen>

    <!-- Max width of the SearchView when the contact picker is a dialog (on wide
         screen devices). -->
    <dimen name="contact_picker_search_view_max_width">550dip</dimen>

    <!-- Min height of the list of contacts when the contact picker is a dialog (on
        wide screen devices). -->
    <dimen name="contact_picker_contact_list_min_height">550dip</dimen>

    <!-- Min with of fake menu buttons, which should be same as ActionBar's one -->
    <dimen name="fake_menu_button_min_width">56dip</dimen>
</resources>
