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

    <!-- Default height of an action bar. -->
    <dimen name="action_bar_default_height_material">48dp</dimen>
    <!-- Default text size for action bar title.-->
    <dimen name="text_size_title_material_toolbar">14dp</dimen>
    <!-- Default text size for action bar subtitle.-->
    <dimen name="text_size_subtitle_material_toolbar">12dp</dimen>

    <!-- Floating window margins are small until we hit sw380dp-land. -->
    <dimen name="floating_window_margin_left">16dp</dimen>
    <dimen name="floating_window_margin_top">4dp</dimen>
    <dimen name="floating_window_margin_right">16dp</dimen>
    <dimen name="floating_window_margin_bottom">16dp</dimen>

    <!-- Material time picker dimensions. -->
    <!-- Text size for the time picker header HH:MM label. This value is large
         enough that we don't need to use scaled pixels, dp is fine. -->
    <dimen name="timepicker_time_label_size">48dp</dimen>
    <dimen name="timepicker_ampm_label_size">16sp</dimen>
    <dimen name="timepicker_am_top_padding">8dp</dimen>
    <dimen name="timepicker_pm_top_padding">3dp</dimen>
    <!-- Radial picker is small until we hit sw380dp-land. -->
    <dimen name="timepicker_radial_picker_dimen">180dp</dimen>
    <dimen name="timepicker_radial_picker_top_margin">16dp</dimen>
    <dimen name="timepicker_radial_picker_horizontal_margin">24dp</dimen>

    <!-- Used by RadialTimePicker in clock-style TimePicker. -->
    <dimen name="timepicker_text_inset_normal">22dp</dimen>
    <!-- Landscape inset is small until we hit sw380dp-land. -->
    <dimen name="timepicker_text_inset_inner">46dp</dimen>
    <dimen name="timepicker_text_size_normal">14sp</dimen>
    <dimen name="timepicker_text_size_inner">12sp</dimen>

    <!-- Used by Material-style SimpleMonthView -->
    <dimen name="date_picker_month_height">40dp</dimen>
    <dimen name="date_picker_day_of_week_height">14dp</dimen>
    <dimen name="date_picker_day_height">32dp</dimen>
    <dimen name="date_picker_day_width">46dp</dimen>
    <dimen name="date_picker_day_selector_radius">16dp</dimen>
    <dimen name="day_picker_padding_horizontal">18dp</dimen>
    <dimen name="day_picker_padding_top">0dp</dimen>
    <dimen name="day_picker_button_margin_top">-8dp</dimen>
</resources>
