<?xml version="1.0" encoding="utf-8"?>
<!-- Copyright (C) 2014 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>
    <!-- Preference activity, vertical padding for the header list -->
    <dimen name="preference_screen_header_vertical_padding_material">0dp</dimen>

    <!-- Preference activity side margins -->
    <dimen name="preference_screen_side_margin_material">0dp</dimen>
    <!-- Preference activity side margins negative-->
    <dimen name="preference_screen_side_margin_negative_material">0dp</dimen>

    <!-- Preference fragment padding, sides -->
    <dimen name="preference_fragment_padding_side_material">8dp</dimen>

    <!-- Preference breadcrumbs padding, start padding -->
    <dimen name="preference_breadcrumbs_padding_start_material">12dp</dimen>

    <!-- Preference breadcrumbs padding, end padding -->
    <dimen name="preference_breadcrumbs_padding_end_material">24dp</dimen>

    <dimen name="preference_screen_header_padding_side_material">0dp</dimen>

    <!-- Default height of an action bar. -->
    <dimen name="action_bar_default_height_material">56dp</dimen>
    <!-- Default padding of an action bar. -->
    <dimen name="action_bar_default_padding_material">4dp</dimen>
    <!-- Default content inset of an action bar. -->
    <dimen name="action_bar_content_inset_material">16dp</dimen>
    <!-- Vertical padding around action bar icons. -->
    <dimen name="action_bar_icon_vertical_padding_material">16dp</dimen>
    <!-- Top margin for action bar subtitles -->
    <dimen name="action_bar_subtitle_top_margin_material">-3dp</dimen>
    <!-- Bottom margin for action bar subtitles -->
    <dimen name="action_bar_subtitle_bottom_margin_material">5dp</dimen>

    <!-- Default padding for list items. This should match the action bar
         content inset so that ListActivity items line up correctly. -->
    <dimen name="list_item_padding_horizontal_material">@dimen/action_bar_content_inset_material</dimen>

    <!-- Padding to add to the start of the overflow action button. -->
    <dimen name="action_bar_navigation_padding_start_material">0dp</dimen>
    <!-- Padding to add to the start of the overflow action button. -->
    <dimen name="action_bar_overflow_padding_start_material">6dp</dimen>
    <!-- Padding to add to the end of the overflow action button. -->
    <dimen name="action_bar_overflow_padding_end_material">10dp</dimen>
    <dimen name="action_bar_elevation_material">4dp</dimen>

    <dimen name="action_button_min_width_overflow_material">36dp</dimen>
    <dimen name="action_button_min_width_material">48dp</dimen>
    <dimen name="action_button_min_height_material">48dp</dimen>

    <dimen name="text_size_display_4_material">112sp</dimen>
    <dimen name="text_size_display_3_material">56sp</dimen>
    <dimen name="text_size_display_2_material">45sp</dimen>
    <dimen name="text_size_display_1_material">34sp</dimen>
    <dimen name="text_size_headline_material">24sp</dimen>
    <dimen name="text_size_title_material">20sp</dimen>
    <dimen name="text_size_subhead_material">16sp</dimen>
    <dimen name="text_size_title_material_toolbar">20dp</dimen>
    <dimen name="text_size_subtitle_material_toolbar">16dp</dimen>
    <dimen name="text_size_menu_material">16sp</dimen>
    <dimen name="text_size_body_2_material">14sp</dimen>
    <dimen name="text_size_body_1_material">14sp</dimen>
    <dimen name="text_size_caption_material">12sp</dimen>
    <dimen name="text_size_button_material">14sp</dimen>

    <dimen name="text_size_large_material">22sp</dimen>
    <dimen name="text_size_medium_material">18sp</dimen>
    <dimen name="text_size_small_material">14sp</dimen>

    <dimen name="floating_window_z">16dp</dimen>
    <dimen name="floating_window_margin_left">16dp</dimen>
    <dimen name="floating_window_margin_top">8dp</dimen>
    <dimen name="floating_window_margin_right">16dp</dimen>
    <dimen name="floating_window_margin_bottom">32dp</dimen>

    <!-- Elevation when button is pressed -->
    <dimen name="button_elevation_material">2dp</dimen>
    <!-- Z translation to apply when button is pressed -->
    <dimen name="button_pressed_z_material">4dp</dimen>
    <!-- Default insets (outer padding) around buttons -->
    <dimen name="button_inset_vertical_material">6dp</dimen>
    <dimen name="button_inset_horizontal_material">@dimen/control_inset_material</dimen>
    <!-- Default inner padding within buttons -->
    <dimen name="button_padding_vertical_material">@dimen/control_padding_material</dimen>
    <dimen name="button_padding_horizontal_material">8dp</dimen>

    <!-- Default insets (outer padding) around controls -->
    <dimen name="control_inset_material">4dp</dimen>
    <!-- Default inner padding within controls -->
    <dimen name="control_padding_material">4dp</dimen>
    <!-- Default rounded corner for controls -->
    <dimen name="control_corner_material">2dp</dimen>

    <dimen name="edit_text_inset_horizontal_material">4dp</dimen>
    <dimen name="edit_text_inset_top_material">10dp</dimen>
    <dimen name="edit_text_inset_bottom_material">7dp</dimen>

    <dimen name="dialog_padding_material">24dp</dimen>
    <dimen name="dialog_padding_top_material">18dp</dimen>

    <!-- Padding above and below selection dialog lists. -->
    <dimen name="dialog_list_padding_vertical_material">8dp</dimen>
</resources>
