<?xml version="1.0" encoding="UTF-8"?>
<!--
    Copyright (C) 2015 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:tools="http://schemas.android.com/tools">

    <!-- Device default style -->

    <!-- Copy from Widget.DeviceDefault.Button.ButtonBar.AlertDialog -->
    <!-- Dialog button bar width -->
    <dimen name="sud_alert_dialog_button_bar_width">64dp</dimen>
    <!-- Dialog button bar height -->
    <dimen name="sud_alert_dialog_button_bar_height">48dip</dimen>

    <!-- Dialog button bar button text size -->
    <dimen name="sud_alert_dialog_button_bar_button_text_size">14sp</dimen>
    <!-- Dialog title text size -->
    <dimen name="sud_alert_dialog_title_text_size">20sp</dimen>

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

    <!-- General -->
    <dimen name="sud_layout_margin_sides">40dp</dimen>

    <dimen name="sud_glif_button_corner_radius">2dp</dimen>
    <!-- Calculated by (sud_glif_margin_start - 4dp internal padding of button) -->
    <dimen name="sud_glif_button_margin_end">20dp</dimen>
    <!-- Calculated by (sud_glif_margin_start - sud_glif_button_padding) -->
    <dimen name="sud_glif_button_margin_start">8dp</dimen>
    <dimen name="sud_glif_button_padding">16dp</dimen>
    <dimen name="sud_glif_button_min_height">48dp</dimen>
    <!-- Negative of sud_glif_button_padding -->
    <dimen name="sud_glif_negative_button_padding">-16dp</dimen>
    <dimen name="sud_glif_footer_padding_vertical">8dp</dimen>
    <dimen name="sud_glif_footer_padding_start">8dp</dimen>
    <!-- Calculated by (sud_glif_margin_end - 4dp internal padding of button) -->
    <dimen name="sud_glif_footer_padding_end">20dp</dimen>
    <dimen name="sud_glif_footer_min_height">72dp</dimen>
    <dimen name="sud_glif_margin_start">24dp</dimen>
    <dimen name="sud_glif_margin_end">24dp</dimen>
    <dimen name="sud_glif_icon_margin_top">56dp</dimen>
    <dimen name="sud_glif_content_padding_top">0dp</dimen>
    <dimen name="sud_horizontal_icon_height">32dp</dimen>

    <dimen name="sud_glif_alert_dialog_corner_radius">8dp</dimen>
    <dimen name="sud_glif_v3_button_corner_radius">4dp</dimen>
    <dimen name="sud_glif_device_default_dialog_corner_radius">28dp</dimen>
    <dimen name="sud_glif_land_header_area_weight">1</dimen>
    <dimen name="sud_glif_land_content_area_weight">1</dimen>
    <dimen name="sud_glif_land_middle_horizontal_spacing">48dp</dimen>

    <!-- Content styles -->
    <dimen name="sud_check_box_line_spacing_extra">4sp</dimen>
    <dimen name="sud_check_box_margin_bottom">12dp</dimen>
    <dimen name="sud_check_box_margin_start">1dp</dimen>
    <dimen name="sud_check_box_margin_top">24dp</dimen>
    <dimen name="sud_check_box_padding_start">15dp</dimen>

    <dimen name="sud_content_frame_padding_top">0dp</dimen>
    <dimen name="sud_content_frame_padding_bottom">16dp</dimen>

    <dimen name="sud_description_margin_top">24dp</dimen>
    <dimen name="sud_description_margin_bottom">12dp</dimen>
    <dimen name="sud_description_margin_bottom_lists">24dp</dimen>
    <dimen name="sud_description_line_spacing_extra">4sp</dimen>
    <dimen name="sud_description_text_size">16sp</dimen>
    <!-- This value is the margin bottom difference between DescriptionItem and DescriptionMixin. -->
    <dimen name="sud_description_margin_top_extra">1dp</dimen>
    <dimen name="sud_description_margin_bottom_extra">12dp</dimen>

    <!-- TODO: Remove sud_description_glif_margin_xxx once all apps migrate to sud_glif_description_margin_xxx -->
    <dimen name="sud_description_glif_margin_top">3dp</dimen>
    <dimen name="sud_description_glif_margin_bottom_lists">24dp</dimen>

    <dimen name="sud_content_glif_margin_top">32dp</dimen>
    <dimen name="sud_content_glif_margin_bottom">6dp</dimen>

    <dimen name="sud_content_illustration_max_height">312dp</dimen>
    <dimen name="sud_content_illustration_max_width">312dp</dimen>
    <dimen name="sud_content_illustration_min_height">172dp</dimen>
    <dimen name="sud_content_illustration_min_width">172dp</dimen>
    <dimen name="sud_content_illustration_padding_vertical">24dp</dimen>

    <!-- Loading content styles -->
    <dimen name="sud_content_loading_frame_padding_top">0dp</dimen>
    <dimen name="sud_content_loading_frame_padding_start">40dp</dimen>
    <dimen name="sud_content_loading_frame_padding_end">40dp</dimen>
    <dimen name="sud_content_loading_frame_padding_bottom">144dp</dimen>

    <dimen name="sud_loading_header_height">274dp</dimen>

    <!--  Glif Content info text -->
    <dimen name="sud_content_info_text_size">16sp</dimen>
    <dimen name="sud_content_info_line_spacing_extra">3sp</dimen>
    <dimen name="sud_content_info_icon_size">18dp</dimen>
    <dimen name="sud_content_info_icon_margin_end">16dp</dimen>
    <dimen name="sud_content_info_padding_top">0dp</dimen>
    <dimen name="sud_content_info_padding_bottom">0dp</dimen>

    <!-- Margin on the start to offset for margin in the drawable -->
    <dimen name="sud_radio_button_margin_start">-6dp</dimen>
    <dimen name="sud_radio_button_margin_top">0dp</dimen>
    <dimen name="sud_radio_button_margin_bottom">12dp</dimen>
    <dimen name="sud_radio_button_padding_start">18dp</dimen>
    <dimen name="sud_radio_button_line_spacing_extra">5sp</dimen>

    <!-- Card layout (for tablets) -->
    <dimen name="sud_card_corner_radius">2dp</dimen>
    <dimen name="sud_card_elevation">5dp</dimen>
    <dimen name="sud_card_land_header_text_margin_top">128dp</dimen>
    <dimen name="sud_card_port_margin_sides">56dp</dimen>

    <dimen name="sud_card_title_padding_end">0dp</dimen>
    <dimen name="sud_card_title_padding_start">0dp</dimen>
    <dimen name="sud_card_title_padding_top">16dp</dimen>
    <dimen name="sud_card_title_padding_bottom">28dp</dimen>

    <!-- Decor view (illustration or the header without illustration) -->
    <dimen name="sud_decor_padding_top">0dp</dimen>

    <!-- GLIF card layout (for tablets) -->
    <dimen name="sud_glif_card_elevation">5dp</dimen>
    <dimen name="sud_glif_card_width">560dp</dimen>
    <dimen name="sud_glif_card_height">672dp</dimen>

    <!-- Header layout (for phones) -->
    <dimen name="sud_title_area_elevation">3dp</dimen>
    <!-- Hack to force the header (and its shadow) to be drawn on top of the list contents -->
    <dimen name="sud_header_elevation_hack">1dp</dimen>

    <dimen name="sud_header_title_size">24sp</dimen>
    <dimen name="sud_header_title_margin_bottom">16dp</dimen>
    <dimen name="sud_header_title_padding_top">16dp</dimen>
    <dimen name="sud_header_title_padding_bottom">2dp</dimen>
    <!-- This is the extra spacing required to make the leading exactly 32sp -->
    <dimen name="sud_header_title_line_spacing_extra">3.67sp</dimen>

    <dimen name="sud_glif_header_title_margin_top">16dp</dimen>
    <dimen name="sud_glif_header_title_margin_bottom">2dp</dimen>
    <dimen name="sud_header_container_margin_bottom">0dp</dimen>

    <!-- This value leverages sud_description_glif_margin_top -->
    <dimen name="sud_glif_description_margin_top">3dp</dimen>
    <dimen name="sud_glif_description_margin_bottom">12dp</dimen>

    <dimen name="sud_glif_icon_max_height">32dp</dimen>
    <!-- Illustration -->
    <item name="sud_illustration_aspect_ratio" format="float" type="dimen">2.22</item>

    <!-- Items -->
    <dimen name="sud_items_icon_container_width">48dp</dimen>
    <!-- TODO: Remove it when all attributes being used migrated into new one. -->
    <dimen name="sud_items_padding_vertical">15dp</dimen>
    <dimen name="sud_items_verbose_padding_vertical">20dp</dimen>
    <dimen name="sud_items_title_text_size">16sp</dimen>
    <dimen name="sud_items_summary_text_size">14sp</dimen>
    <dimen name="sud_items_summary_margin_top">4dp</dimen>
    <dimen name="sud_items_padding_top">15dp</dimen>
    <dimen name="sud_items_padding_bottom">15dp</dimen>

    <!-- Page Margins Material You -->
    <!-- Default margins start are 40dp in portrait mode for the large screen. However, If here
         set this value, it cannot be overwrited by a smaller value from partner config. So here
         set to 24dp and rewritten to 40dp through partner config the partner config
         "setup_design_layout_margin_start" for glifv4 default margins. -->
    <!-- TODO: b/221404901 to remove this limitation -->
    <dimen name="sud_glif_margin_start_material_you">24dp</dimen>
    <dimen name="sud_glif_margin_end_material_you">24dp</dimen>

    <!-- Header Area Material You -->
    <dimen name="sud_header_container_margin_bottom_material_you">24dp</dimen>
    <dimen name="sud_glif_header_title_size_material_you">36sp</dimen>
    <dimen name="sud_glif_header_title_margin_top_material_you">24dp</dimen>
    <dimen name="sud_glif_header_title_margin_bottom_material_you">0dp</dimen>
    <dimen name="sud_glif_description_text_size_material_you">18sp</dimen>
    <dimen name="sud_glif_description_margin_top_material_you">24dp</dimen>
    <dimen name="sud_glif_description_margin_bottom_material_you">0dp</dimen>

    <dimen name="sud_glif_icon_margin_top_material_you">32dp</dimen>
    <dimen name="sud_glif_icon_max_height_material_you">48dp</dimen>

    <!-- Items Material You -->
    <dimen name="sud_items_padding_top_material_you">18dp</dimen>
    <dimen name="sud_items_padding_bottom_material_you">18dp</dimen>
    <dimen name="sud_items_title_text_size_material_you">20sp</dimen>
    <dimen name="sud_items_summary_text_size_material_you">14sp</dimen>
    <dimen name="sud_items_summary_margin_top_material_you">4dp</dimen>
    <dimen name="sud_items_min_height_material_you">72dp</dimen>

    <!-- Ignore UnusedResources: can be used by clients -->
    <dimen name="sud_items_icon_divider_inset" tools:ignore="UnusedResources">88dp</dimen>
    <!-- Ignore UnusedResources: can be used by clients -->
    <dimen name="sud_items_text_divider_inset" tools:ignore="UnusedResources">40dp</dimen>

    <!-- Ignore UnusedResources: can be used by clients -->
    <dimen name="sud_items_glif_icon_divider_inset" tools:ignore="UnusedResources">72dp</dimen>
    <!-- Ignore UnusedResources: can be used by clients -->
    <dimen name="sud_items_glif_text_divider_inset" tools:ignore="UnusedResources">24dp</dimen>

    <!-- Extra padding in the bottom to compensate for difference between descent and (top) internal leading -->
    <dimen name="sud_items_padding_bottom_extra">1dp</dimen>
    <dimen name="sud_items_verbose_padding_bottom_extra">0dp</dimen>
    <dimen name="sud_items_preferred_height">56dp</dimen>

    <!-- Navigation bar -->
    <!-- TODO: Move this dimen to gingerbread, or see if it should be in platform style as well -->
    <dimen name="sud_navbar_button_drawable_padding" tools:ignore="UnusedResources">6dp</dimen>
    <dimen name="sud_navbar_button_padding_sides">10dp</dimen>
    <dimen name="sud_navbar_height">56dp</dimen>
    <dimen name="sud_navbar_ic_intrinsic_size">24dp</dimen>
    <dimen name="sud_navbar_padding_sides">24dp</dimen>
    <dimen name="sud_navbar_text_size">16sp</dimen>

    <!-- Progress bar -->
    <!-- The margin to compensate for the padding built-in to the widget itself -->
    <dimen name="sud_progress_bar_margin_vertical">-7dp</dimen>
    <dimen name="sud_progress_bar_margin_top">-7dp</dimen>
    <dimen name="sud_progress_bar_margin_bottom">-7dp</dimen>
    <dimen name="sud_glif_progress_bar_margin_vertical">7dp</dimen>
    <dimen name="sud_glif_progress_bar_padding">40dp</dimen>

    <!-- Edit Text dimensions -->
    <dimen name="sud_edit_text_min_height">56dp</dimen>
    <dimen name="sud_edit_text_padding_horizontal">12dp</dimen>
    <dimen name="sud_edit_text_corner_radius">28dp</dimen>

    <!-- SwitchItem -->
    <dimen name="sud_switch_padding_start">16dp</dimen>
    <dimen name="sud_switch_padding_end">0dp</dimen>
    <dimen name="sud_switch_padding_top">39dp</dimen>
    <dimen name="sud_switch_divider_height">32dp</dimen>
    <dimen name="sud_switch_divider_padding_top">36dp</dimen>
    <dimen name="sud_switch_content_padding_end">16dp</dimen>

    <!-- ExpandableSwithItem -->
    <dimen name="sud_expand_arrow_drawable_padding">4dp</dimen>

    <!-- SwitchBar -->
    <!-- Minimum width of switch -->
    <dimen name="sud_switch_min_width">52dp</dimen>
    <!-- Margin of switch thumb -->
    <dimen name="sud_switch_thumb_margin">4dp</dimen>
    <!-- Size of switch thumb -->
    <dimen name="sud_switch_thumb_size">20dp</dimen>
    <!-- Width of switch track -->
    <dimen name="sud_switch_track_width">52dp</dimen>
    <!-- Height of switch track -->
    <dimen name="sud_switch_track_height">28dp</dimen>
    <!-- Radius of switch track -->
    <dimen name="sud_switch_track_radius">35dp</dimen>

    <!-- IconUniformityAppImageView -->
    <!-- Set 0dp since we don't want shadow. -->
    <dimen name="sud_icon_uniformity_elevation">0dp</dimen>

</resources>
