<?xml version="1.0" encoding="utf-8"?>
<!-- Copyright (C) 2011 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>
    <!-- Dimensions for CallCard elements (the normal in-call UI) -->

    <!-- Height of the "call banner" overlay on top of the upper part of
         the call info area. -->
    <dimen name="call_banner_height">80dp</dimen>

    <!-- Margin between the bottom of the "call card" photo
         and the top of the in-call button cluster. -->
    <dimen name="in_call_touch_ui_upper_margin">2dp</dimen>

    <!-- Padding at the left and right edges of the "call banner". -->
    <dimen name="call_banner_side_padding">24dp</dimen>
    <!-- Padding at the top and bottom edges of the "call banner". -->
    <dimen name="call_banner_top_bottom_padding">16dp</dimen>

    <!-- Padding at the top and bottom edges of the "provider information" -->
    <dimen name="provider_info_top_bottom_padding">8dp</dimen>

    <!-- Right padding for name and number fields in the call banner.
         This padding is used to ensure that ultra-long names or
         numbers won't overlap the elapsed time indication. -->
    <dimen name="call_banner_name_number_right_padding">50sp</dimen>

    <!-- Height of the main row of in-call buttons. -->
    <dimen name="in_call_button_height">76dp</dimen>

    <!-- Height of the in-call "End" button. Match with Contact's dimens/call_button_height -->
    <dimen name="in_call_end_button_height">74dp</dimen>

    <!-- Width of buttons in the extra button row. -->
    <dimen name="extra_row_button_width">56dp</dimen>

    <!-- Height of buttons in the extra button row. -->
    <dimen name="extra_row_button_height">@dimen/in_call_button_height</dimen>

    <!-- Padding at the left and right edges of the incall_touch_ui button
         cluster.  This padding is necessary because we can't allow the
         buttons to be very close to the edges of the screen, due to the
         risk of false touches (from your finger wrapping around while
         holding the phone, *before* moving it up to your face and having
         the prox sensor kick in.) -->
    <dimen name="button_cluster_side_padding">20dp</dimen>


    <!-- Dimensions for OTA Call Card -->
    <dimen name="otaactivate_layout_marginTop">10dp</dimen>
    <dimen name="otalistenprogress_layout_marginTop">5dp</dimen>
    <dimen name="otasuccessfail_layout_marginTop">10dp</dimen>


    <!-- Dimensions for Emergency Dialer and dialpad inside the in-call screen -->
    <dimen name="dialpad_horizontal_margin">4dp</dimen>
    <dimen name="dialpad_vertical_margin">2dp</dimen>
    <dimen name="dialpad_digits_text_size">40sp</dimen>
    <dimen name="dialpad_space_above_keys">29dp</dimen>
    <dimen name="dialpad_bottom_key_height">113dp</dimen>
    <dimen name="dialpad_bottom_padding">0dp</dimen>

    <!-- Just used in landscape mode -->
    <dimen name="emergency_dialer_digits_height">0px</dimen>
    <dimen name="dialpad_center_margin">3dp</dimen>
    <dimen name="dialpad_button_margin">3dp</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>

    <!-- Dimension used to possibly down-scale high-res photo into what is suitable
         for notification's large icon. -->
    <dimen name="notification_icon_size">64dp</dimen>

    <!-- Circle size for incoming call widget's each item. -->
    <dimen name="incoming_call_widget_circle_size">94dp</dimen>
    <!-- Margin used for incoming call widget's icon for each item.
         This should be same as "(incoming_call_widget_circle_size - icon_size)/2".
         Right now answer/decline/reject icons have 38dp width/height.
         So, (94 - 38)/2 ==> 28dp -->
    <dimen name="incoming_call_widget_asset_margin">28dp</dimen>
    <!-- Action bar dimensions.  Keep in sync with same value in Dialer. -->
    <dimen name="action_bar_height">56dp</dimen>
    <dimen name="action_bar_elevation">2dp</dimen>
    <dimen name="actionbar_contentInsetStart">72dp</dimen>

    <!-- Width, height and bottom margin for the floating action button. These values are
         intentionally larger than the values used inside Dialer, since the dialpad is larger
         inside the Emergency Dialer than the regular Dialer. -->
    <dimen name="floating_action_button_width">67dp</dimen>
    <dimen name="floating_action_button_height">67dp</dimen>
    <dimen name="floating_action_button_margin_bottom">32dp</dimen>

    <dimen name="signal_strength_icon_size">24dp</dimen>

    <!-- The size of the "emergency calling unavailable" message shown in the emergency dialer -->
    <dimen name="emergency_call_warning_size">16sp</dimen>

    <!-- Horizontal margin for the image on emergency dialer.-->
    <dimen name="emergency_dialer_image_margin_start">20dp</dimen>
    <dimen name="emergency_dialer_image_margin_end">16dp</dimen>

    <!-- Horizontal margin for button of emergency shortcut. -->
    <dimen name="emergency_shortcut_buttons_margin_horizontal">16dp</dimen>

    <!-- Horizontal padding for group of emergency number title-->
    <dimen name="emergency_number_title_group_padding_horizontal">16dp</dimen>

    <!-- Margin for the emergency information button text. -->
    <dimen name="emergency_info_text_margin_end">20dp</dimen>

    <!-- The height and width for the image of emergency information. -->
    <dimen name="emergency_info_image_height">40dp</dimen>
    <dimen name="emergency_info_image_width">40dp</dimen>

    <!-- The height and width for the function icon of emergency shortcuts. -->
    <dimen name="emergency_shortcuts_function_icon_height">24dp</dimen>
    <dimen name="emergency_shortcuts_function_icon_width">24dp</dimen>

    <!-- The height and width for the circle image of phone number type.-->
    <dimen name="phone_number_type_circle_image_height">40dp</dimen>
    <dimen name="phone_number_type_circle_image_width">40dp</dimen>

    <!-- Margin for the emergency shortcut button.-->
    <dimen name="emergency_shortcuts_margin_end">60dp</dimen>

    <!-- The line height and margin start for location text.-->
    <dimen name="location_text_line_height">20sp</dimen>
    <dimen name="location_text_margin_start">4dp</dimen>

    <!-- The line height for emergency number title.-->
    <dimen name="emergency_number_title_line_height">20sp</dimen>

    <!-- The line height for phone number.-->
    <dimen name="phone_number_line_height">40sp</dimen>

    <!-- The line height for phone call hint.-->
    <dimen name="phone_call_hint_line_height">24sp</dimen>

    <!-- The line height for emergency info name.-->
    <dimen name="emergency_info_name_line_height">28sp</dimen>

    <!-- The line height for emergency info hint.-->
    <dimen name="emergency_info_hint_line_height">20sp</dimen>

    <!-- The line height for confirmed emergency info.-->
    <dimen name="confirmed_emergency_info_line_height">24sp</dimen>

    <!-- The width for emergency number title container.-->
    <dimen name="emergency_number_title_container_width">210dp</dimen>

    <!-- The text size for titles in settings page.-->
    <dimen name="dialer_head1_font_size">18dp</dimen>

    <!-- The text size for items in settings page.-->
    <dimen name="dialer_primary2_font_size">16dp</dimen>

    <!-- The text size for description in settings page.-->
    <dimen name="dialer_secondary_font_size">14dp</dimen>


    <!-- Shortcut view vertical dimens. These values are tuned according to display
         height in values-h<height>dp/dimens.xml -->
    <!-- Height and vertical margin for the emergency information button. -->
    <dimen name="emergency_info_button_height">74dp</dimen>
    <dimen name="emergency_info_button_margin_top">32dp</dimen>
    <dimen name="emergency_info_button_margin_bottom">37dp</dimen>

    <!-- The text size of emergency info name and hint -->
    <dimen name="emergency_info_name_text_size">16.9sp</dimen>
    <dimen name="emergency_info_hint_text_size">12.3sp</dimen>
    <dimen name="emergency_info_tap_hint_text_size">13.8sp</dimen>

    <!-- The height for title of emergency number and location info. -->
    <dimen name="emergency_number_title_height">37dp</dimen>
    <!-- The text size for emergency number title.-->
    <dimen name="emergency_number_title_text_size">10.7sp</dimen>

    <!-- The height and width for the image of location info.-->
    <dimen name="location_image_height">12.3dp</dimen>
    <dimen name="location_image_width">12.3dp</dimen>

    <!-- The text size for emergency location.-->
    <dimen name="emergency_location_text_size">10.7sp</dimen>

    <!-- The height and margin for button of emergency shortcut. -->
    <dimen name="emergency_shortcut_button_height">74dp</dimen>
    <dimen name="emergency_shortcut_button_margin_bottom">6.2dp</dimen>

    <!-- The text size of emergency number, type and hint -->
    <dimen name="emergency_shortcut_number_text_size">25sp</dimen>
    <dimen name="emergency_shortcut_type_text_size">10.7sp</dimen>
    <dimen name="emergency_shortcut_tap_hint_text_size">13.8sp</dimen>

    <!-- The height and width for the image of phone number type.-->
    <dimen name="phone_number_type_image_height">31dp</dimen>
    <dimen name="phone_number_type_image_width">31dp</dimen>

    <!-- The height and width of phone icon.-->
    <dimen name="phone_icon_height">18.4dp</dimen>
    <dimen name="phone_icon_width">18.4dp</dimen>

    <!-- Margin of dialpad button -->
    <dimen name="emergency_dialer_dialpad_button_margin">25dp</dimen>

    <!-- The height and width for the dialpad button -->
    <dimen name="dialpad_button_height">43dp</dimen>
    <dimen name="dialpad_button_width">43dp</dimen>
    <!-- End of Shortcut view vertical dimens. -->
</resources>
