<?xml version="1.0" encoding="utf-8"?>
<!--
/* //device/apps/common/assets/res/any/dimens.xml
**
** Copyright 2006, 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>
    <!-- The width that is used when creating thumbnails of applications. -->
    <dimen name="thumbnail_width">192dp</dimen>
    <!-- The height that is used when creating thumbnails of applications. -->
    <dimen name="thumbnail_height">192dp</dimen>
    <!-- The amount to scale a fullscreen screenshot thumbnail. -->
    <item name="thumbnail_fullscreen_scale" type="fraction">60%</item>
    <!-- The width used to calculate scale for full screen thumbnail on TV -->
    <integer name="thumbnail_width_tv">240</integer>
    <!-- The standard size (both width and height) of an application icon that
         will be displayed in the app launcher and elsewhere. -->
    <dimen name="app_icon_size">48dip</dimen>

    <dimen name="toast_y_offset">24dp</dimen>
    <!-- Height of the status bar -->
    <dimen name="status_bar_height">@dimen/status_bar_height_portrait</dimen>
    <!-- Height of the status bar in portrait -->
    <dimen name="status_bar_height_portrait">24dp</dimen>
    <!-- Height of the status bar in landscape -->
    <dimen name="status_bar_height_landscape">@dimen/status_bar_height_portrait</dimen>
    <!-- Height of area above QQS where battery/time go -->
    <dimen name="quick_qs_offset_height">48dp</dimen>
    <!-- Total height of QQS (quick_qs_offset_height + 128) -->
    <dimen name="quick_qs_total_height">176dp</dimen>
    <!-- Height of the bottom navigation / system bar. -->
    <dimen name="navigation_bar_height">48dp</dimen>
    <!-- Height of the bottom navigation bar in portrait; often the same as @dimen/navigation_bar_height -->
    <dimen name="navigation_bar_height_landscape">48dp</dimen>
    <!-- Width of the navigation bar when it is placed vertically on the screen -->
    <dimen name="navigation_bar_width">48dp</dimen>
    <!-- How much we expand the touchable region of the status bar below the notch to catch touches
         that just start below the notch. -->
    <dimen name="display_cutout_touchable_region_size">12dp</dimen>

    <!-- Height of the bottom navigation bar frame; this is different than navigation_bar_height
         where that is the height reported to all the other windows to resize themselves around the
         navigation bar window but navigation_bar_frame_height is reported to SystemUI navigation
         bar view's window -->
    <dimen name="navigation_bar_frame_height">@dimen/navigation_bar_height</dimen>
    <!-- Height of the bottom navigation bar frame in landscape -->
    <dimen name="navigation_bar_frame_height_landscape">@dimen/navigation_bar_frame_height</dimen>

    <!-- The height of the navigation gesture area if the gesture is starting from the bottom. -->
    <dimen name="navigation_bar_gesture_height">@dimen/navigation_bar_frame_height</dimen>

    <!-- Height of the bottom navigation / system bar in car mode. -->
    <dimen name="navigation_bar_height_car_mode">96dp</dimen>
    <!-- Height of the bottom navigation bar in portrait; often the same as
         @dimen/navigation_bar_height_car_mode -->
    <dimen name="navigation_bar_height_landscape_car_mode">96dp</dimen>
    <!-- Width of the navigation bar when it is placed vertically on the screen in car mode -->
    <dimen name="navigation_bar_width_car_mode">96dp</dimen>
    <!-- Height of notification icons in the status bar -->
    <dimen name="status_bar_icon_size">22dip</dimen>
    <!-- Desired size of system icons in status bar. -->
    <dimen name="status_bar_system_icon_size">15dp</dimen>
    <!-- Intrinsic size of most system icons in status bar. This is the default value that
         is used if a Drawable reports an intrinsic size of 0. -->
    <dimen name="status_bar_system_icon_intrinsic_size">17dp</dimen>
    <!-- Size of the giant number (unread count) in the notifications -->
    <dimen name="status_bar_content_number_size">48sp</dimen>
    <!-- Margin at the edge of the screen to ignore touch events for in the windowshade. -->
    <dimen name="status_bar_edge_ignore">5dp</dimen>

    <!-- Default radius of the software rounded corners. -->
    <dimen name="rounded_corner_radius">0dp</dimen>
    <!-- Radius of the software rounded corners at the top of the display in its natural
        orientation. If zero, the value of rounded_corner_radius is used. -->
    <dimen name="rounded_corner_radius_top">0dp</dimen>
    <!-- Radius of the software rounded corners at the bottom of the display in its natural
        orientation. If zero, the value of rounded_corner_radius is used. -->
    <dimen name="rounded_corner_radius_bottom">0dp</dimen>

    <!-- Default adjustment for the software rounded corners since corners are not perfectly
        round. This value is used when retrieving the "radius" of the rounded corner in cases
        where the exact bezier curve cannot be retrieved.  This value will be subtracted from
        rounded_corner_radius to more accurately provide a "radius" for the rounded corner. -->
    <dimen name="rounded_corner_radius_adjustment">0px</dimen>
    <!-- Top adjustment for the software rounded corners since corners are not perfectly
        round.  This value is used when retrieving the "radius" of the top rounded corner in cases
        where the exact bezier curve cannot be retrieved.  This value will be subtracted from
        rounded_corner_radius_top to more accurately provide a "radius" for the top rounded corners.
         -->
    <dimen name="rounded_corner_radius_top_adjustment">0px</dimen>
    <!-- Bottom adjustment for the software rounded corners since corners are not perfectly
        round.  This value is used when retrieving the "radius" of the bottom rounded corner in
        cases where the exact bezier curve cannot be retrieved.  This value will be subtracted from
        rounded_corner_radius_bottom to more accurately provide a "radius" for the bottom rounded
        corners. -->
    <dimen name="rounded_corner_radius_bottom_adjustment">0px</dimen>

    <!-- Width of the window of the divider bar used to resize docked stacks. -->
    <dimen name="docked_stack_divider_thickness">48dp</dimen>

    <!-- How much the content in the divider is inset from the window bounds when resting. Used to
         calculate the bounds of the stacks-->
    <dimen name="docked_stack_divider_insets">19dp</dimen>

    <!-- To how much the docked stack gets reduced when we decide to minimize the docked stack, i.e.
         when the user opens homescreen. -->
    <dimen name="docked_stack_minimize_thickness">8dp</dimen>

    <!-- The amount to leave on-screen when the PIP is minimized. -->
    <dimen name="pip_minimized_visible_size">48dp</dimen>

    <!-- The the PIP decelerates at while moving from a fling. -->
    <dimen name="pip_fling_deceleration">-3000dp</dimen>

    <!-- Min width for a tablet device -->
    <dimen name="min_xlarge_screen_width">800dp</dimen>

    <!-- Default height of a key in the password keyboard for alpha (used by keyguard) -->
    <dimen name="password_keyboard_key_height_alpha">56dip</dimen>
    <!-- Default height of a key in the password keyboard for numeric (used by keyguard) -->
    <dimen name="password_keyboard_key_height_numeric">56dip</dimen>
    <!-- Default correction for the space key in the password keyboard  (used by keyguard) -->
    <dimen name="password_keyboard_spacebar_vertical_correction">4dip</dimen>
    <!-- Default horizontal gap between keys in the password keyboard (used by keyguard) -->
    <dimen name="password_keyboard_horizontalGap">3dip</dimen>
    <!-- Default vertical gap between keys in the password keyboard (used by keyguard) -->
    <dimen name="password_keyboard_verticalGap">9dip</dimen>

    <!-- Size of lockscreen outerring on unsecure unlock LockScreen -->
    <dimen name="keyguard_lockscreen_outerring_diameter">270dp</dimen>

    <!-- Preference activity side margins -->
    <dimen name="preference_screen_side_margin">0dp</dimen>
    <!-- Preference activity side margins negative-->
    <dimen name="preference_screen_side_margin_negative">0dp</dimen>
    <!-- Preference activity top margin -->
    <dimen name="preference_screen_top_margin">0dp</dimen>
    <!-- Preference activity bottom margin -->
    <dimen name="preference_screen_bottom_margin">0dp</dimen>
    <!-- Preference widget area width (to the left of the text) -->
    <dimen name="preference_widget_width">48dp</dimen>
    <!-- Preference fragment padding, bottom -->
    <dimen name="preference_fragment_padding_bottom">0dp</dimen>
    <!-- Preference fragment padding, sides -->
    <dimen name="preference_fragment_padding_side">16dp</dimen>
    <!-- Weight of the left pane in a multi-pane preference layout. -->
    <integer name="preferences_left_pane_weight">4</integer>
    <!-- Weight of the right pane in a multi-pane preference layout. So the split is 40:60 -->
    <integer name="preferences_right_pane_weight">6</integer>
    <!-- Padding to the left of the preference panel breadcrumb -->
    <dimen name="preference_breadcrumb_paddingLeft">0dp</dimen>
    <!-- Padding to the right of the preference panel breadcrumb -->
    <dimen name="preference_breadcrumb_paddingRight">0dp</dimen>
    <!-- Minimum space to allocate to the left of a preference item for an icon.
        This helps in aligning titles when some items have icons and some don't. When space is
        at a premium, we don't pre-allocate any space. -->
    <dimen name="preference_icon_minWidth">0dp</dimen>
    <!-- The platform's desired minimum size for a dialog's width when it
         is along the major axis (that is the screen is landscape).  This may
         be either a fraction or a dimension. -->
    <item type="dimen" name="dialog_min_width_major">65%</item>

    <!-- The platform's desired fixed width for a dialog along the major axis
         (the screen is in landscape). This may be either a fraction or a dimension.-->
    <item type="dimen" name="dialog_fixed_width_major">100%</item>
    <!-- The platform's desired fixed width for a dialog along the minor axis
         (the screen is in portrait). This may be either a fraction or a dimension.-->
    <item type="dimen" name="dialog_fixed_width_minor">100%</item>
    <!-- The platform's desired fixed height for a dialog along the major axis
         (the screen is in portrait). This may be either a fraction or a dimension.-->
    <item type="dimen" name="dialog_fixed_height_major">80%</item>
    <!-- The platform's desired fixed height for a dialog along the minor axis
         (the screen is in landscape). This may be either a fraction or a dimension.-->
    <item type="dimen" name="dialog_fixed_height_minor">100%</item>

    <!-- Preference activity, vertical padding for the header list -->
    <dimen name="preference_screen_header_vertical_padding">0dp</dimen>

    <dimen name="preference_screen_header_padding_side">16dip</dimen>
    <integer name="preference_screen_header_scrollbarStyle">0x02000000</integer> <!-- outsideOverlay -->

    <integer name="preference_fragment_scrollbarStyle">0x02000000</integer> <!-- outsideOverlay -->

    <dimen name="preference_item_padding_side">8dip</dimen>
    <dimen name="preference_item_padding_inner">8dip</dimen>
    <dimen name="preference_child_padding_side">16dip</dimen>

    <!-- The platform's desired minimum size for a dialog's width when it
         is along the minor axis (that is the screen is portrait).  This may
         be either a fraction or a dimension. -->
    <item type="dimen" name="dialog_min_width_minor">95%</item>

    <!-- Default padding for dialogs. -->
    <dimen name="dialog_padding">16dp</dimen>

    <!-- The margin on the start of the content view -->
    <dimen name="notification_content_margin_start">16dp</dimen>

    <!-- The margin on the end of the content view. -->
    <dimen name="notification_content_margin_end">16dp</dimen>

    <!-- The inset of the reply icon. -->
    <dimen name="notification_reply_inset">8dp</dimen>

    <!-- The margin for text at the end of the image view for media notifications -->
    <dimen name="notification_media_image_margin_end">72dp</dimen>

    <!-- The height of the notification action list -->
    <dimen name="notification_action_list_height">60dp</dimen>

    <!-- The margin of the notification action list at the top -->
    <dimen name="notification_action_list_margin_top">0dp</dimen>

    <!-- The height of the notification action list -->
    <dimen name="notification_action_emphasized_height">48dp</dimen>

    <!-- Size of the stroke with for the emphasized notification button style -->
    <dimen name="emphasized_button_stroke_width">1dp</dimen>

    <!-- height of the content margin to accomodate for the header -->
    <dimen name="notification_content_margin_top">46dp</dimen>

    <!-- height of the content margin that is applied at the end of the notification content -->
    <dimen name="notification_content_margin">20dp</dimen>

    <!-- The height of the progress bar. -->
    <dimen name="notification_progress_bar_height">15dp</dimen>

    <!-- The top margin before the notification progress bar. -->
    <dimen name="notification_progress_margin_top">8dp</dimen>

    <!-- height of the notification header (for icon and package name) -->
    <dimen name="notification_header_height">50dp</dimen>

    <!-- The height of the background for a notification header on a group -->
    <dimen name="notification_header_background_height">49.5dp</dimen>

    <!-- The top padding for the notification header -->
    <dimen name="notification_header_padding_top">16dp</dimen>

    <!-- The bottom padding for the notification header -->
    <dimen name="notification_header_padding_bottom">16dp</dimen>

    <!-- The margin at the bottom of the notification header. -->
    <dimen name="notification_header_margin_bottom">0dp</dimen>

    <!-- The end margin after the application icon in the notification header -->
    <dimen name="notification_header_icon_margin_end">3dp</dimen>

    <!-- size (width and height) of the icon in the notification header -->
    <dimen name="notification_header_icon_size">18dp</dimen>

    <!-- size (width and height) of the icon in the notification header -->
    <dimen name="notification_header_icon_size_ambient">18dp</dimen>

    <!-- The margin before the start of the app name in the header. -->
    <dimen name="notification_header_app_name_margin_start">3dp</dimen>

    <!-- The margin before and after each of the items in the notification header. -->
    <dimen name="notification_header_separating_margin">2dp</dimen>

    <!-- The absolute size of the notification expand icon. -2 for wrap_content. -->
    <dimen name="notification_header_expand_icon_size">-2px</dimen>

    <!-- The top padding for the notification expand button. -->
    <dimen name="notification_expand_button_padding_top">1dp</dimen>

    <!-- Height of a small notification in the status bar -->
    <dimen name="notification_min_height">106dp</dimen>

    <!-- The width of the big icons in notifications. -->
    <dimen name="notification_large_icon_width">64dp</dimen>

    <!-- The width of the big icons in notifications. -->
    <dimen name="notification_large_icon_height">64dp</dimen>

    <!-- The minimum width of the app name in the header if it shrinks -->
    <dimen name="notification_header_shrink_min_width">72dp</dimen>

    <!-- The minimum height of the content if there are at least two lines or a picture-->
    <dimen name="notification_min_content_height">39dp</dimen>

    <!-- The size of the media actions in the media notification. -->
    <dimen name="media_notification_action_button_size">48dp</dimen>

    <!-- The bottom padding for the media actions container. -->
    <dimen name="media_notification_actions_padding_bottom">12dp</dimen>

    <!-- The maximum size of the image in the expanded media notification -->
    <dimen name="media_notification_expanded_image_max_size">94dp</dimen>

    <!-- The maximum size of the image in the expanded media notification -->
    <dimen name="media_notification_expanded_image_margin_bottom">20dp</dimen>

    <!-- The absolute height for the header in a media notification. -->
    <dimen name="media_notification_header_height">@dimen/notification_header_height</dimen>

    <!-- The margin of the content to an image-->
    <dimen name="notification_content_image_margin_end">8dp</dimen>

    <!-- The spacing between messages in Notification.MessagingStyle -->
    <dimen name="notification_messaging_spacing">6dp</dimen>

    <!-- The rounding for messaging images -->
    <dimen name="messaging_image_rounding">4dp</dimen>

    <!-- The minimum size for any image in messaging style in order to be displayed -->
    <dimen name="messaging_image_min_size">44dp</dimen>

    <!-- The maximum size for any image in messaging style in order to be displayed -->
    <dimen name="messaging_image_max_height">136dp</dimen>

    <!-- Extra spacing before and after images in messaging style -->
    <dimen name="messaging_image_extra_spacing">8dp</dimen>

    <!-- Preferred width and height of the search view. -->
    <dimen name="search_view_preferred_width">320dip</dimen>
    <dimen name="search_view_preferred_height">48dip</dimen>

    <!-- Dialog padding for round display -->
    <dimen name="alert_dialog_round_padding">27dip</dimen>
    <!-- Dialog title height -->
    <dimen name="alert_dialog_title_height">64dip</dimen>
    <!-- Dialog button bar width -->
    <dimen name="alert_dialog_button_bar_width">64dp</dimen>
    <!-- Dialog button bar height -->
    <dimen name="alert_dialog_button_bar_height">48dip</dimen>
    <!-- Leanback dialog vertical margin -->
    <dimen name="leanback_alert_dialog_vertical_margin">27dip</dimen>
    <!-- Leanback dialog horizontal margin -->
    <dimen name="leanback_alert_dialog_horizontal_margin">54dip</dimen>

    <!-- Default height of an action bar. -->
    <dimen name="action_bar_default_height">48dip</dimen>
    <!-- Vertical padding around action bar icons. -->
    <dimen name="action_bar_icon_vertical_padding">8dip</dimen>
    <!-- Text size for action bar titles -->
    <dimen name="action_bar_title_text_size">18dp</dimen>
    <!-- Text size for action bar subtitles -->
    <dimen name="action_bar_subtitle_text_size">14dp</dimen>
    <!-- Top margin for action bar subtitles -->
    <dimen name="action_bar_subtitle_top_margin">-3dp</dimen>
    <!-- Bottom margin for action bar subtitles -->
    <dimen name="action_bar_subtitle_bottom_margin">5dip</dimen>

    <!-- Size of clock font in LockScreen on Unsecure unlock screen. -->
    <dimen name="keyguard_lockscreen_clock_font_size">80dip</dimen>

    <!-- Size of status line font on Unsecure unlock LockScreen. -->
    <dimen name="keyguard_lockscreen_status_line_font_size">14dip</dimen>

    <!-- Size of right margin on Unsecure unlock LockScreen -->
    <dimen name="keyguard_lockscreen_status_line_font_right_margin">42dip</dimen>

    <!-- Size of top margin on Clock font to edge on unlock LockScreen -->
    <dimen name="keyguard_lockscreen_status_line_clockfont_top_margin">22dip</dimen>

    <!-- Size of top margin on Clock font to edge on unlock LockScreen -->
    <dimen name="keyguard_lockscreen_status_line_clockfont_bottom_margin">12dip</dimen>

    <!-- Padding on left margin of PIN text entry field to center it when del button is showing -->
    <dimen name="keyguard_lockscreen_pin_margin_left">40dip</dimen>

    <!-- Height of FaceUnlock view in keyguard -->
    <dimen name="face_unlock_height">330dip</dimen>

    <!-- Minimum popup width for selecting an activity in ActivityChooserDialog/ActivityChooserView. -->
    <dimen name="activity_chooser_popup_min_width">200dip</dimen>

    <!-- The default gap between components in a layout. -->
    <dimen name="default_gap">8dip</dimen>

    <!-- Text padding for dropdown items -->
    <dimen name="dropdownitem_text_padding_left">8dip</dimen>

    <!-- Text padding for dropdown items -->
    <dimen name="dropdownitem_text_padding_right">8dip</dimen>

    <!-- Width of the icon in a dropdown list -->
    <dimen name="dropdownitem_icon_width">32dip</dimen>

    <!-- Default width for a textview error popup -->
    <dimen name="textview_error_popup_default_width">240dip</dimen>

    <!-- Default padding to apply to AppWidgetHostViews containing widgets targeting API level 14 and up. -->
    <dimen name="default_app_widget_padding_left">8dp</dimen>
    <dimen name="default_app_widget_padding_top">8dp</dimen>
    <dimen name="default_app_widget_padding_right">8dp</dimen>
    <dimen name="default_app_widget_padding_bottom">8dp</dimen>

    <!-- Minimum width for an action button in the menu area of an action bar -->
    <dimen name="action_button_min_width">56dip</dimen>

    <!-- Maximum height for a stacked tab bar as part of an action bar -->
    <dimen name="action_bar_stacked_max_height">48dp</dimen>

    <!-- Maximum width for a stacked action bar tab. This prevents
         action bar tabs from becoming too wide on a wide screen when only
         a few are present. -->
    <dimen name="action_bar_stacked_tab_max_width">180dp</dimen>

    <!-- Size of notification text (see TextAppearance.StatusBar.EventContent) -->
    <dimen name="notification_text_size">14sp</dimen>
    <!-- Size of notification text titles (see TextAppearance.StatusBar.EventContent.Title) -->
    <dimen name="notification_title_text_size">14sp</dimen>
    <!-- Size of smaller notification text (see TextAppearance.StatusBar.EventContent.Line2, Info, Time) -->
    <dimen name="notification_subtext_size">12sp</dimen>
    <!-- Top padding for notifications in the standard layout. -->
    <dimen name="notification_top_pad">10dp</dimen>

    <!-- Top padding for notifications when narrow (i.e. it has 3 lines) -->
    <dimen name="notification_top_pad_narrow">4dp</dimen>

    <!-- Top padding for notification when text is large -->
    <dimen name="notification_top_pad_large_text">5dp</dimen>

    <!-- Top padding for notification when text is large and narrow (i.e. it has 3 lines -->
    <dimen name="notification_top_pad_large_text_narrow">-4dp</dimen>

    <!-- Padding for notification icon when drawn with circle around it -->
    <dimen name="notification_large_icon_circle_padding">11dp</dimen>

    <!-- The margin on top of the text of the notification -->
    <dimen name="notification_text_margin_top">0.5dp</dimen>

    <!-- The padding on top of inbox style elements -->
    <dimen name="notification_inbox_item_top_padding">5dp</dimen>

    <!-- Size of the profile badge for notifications -->
    <dimen name="notification_badge_size">12dp</dimen>

    <!-- Size of the alerted icon for notifications -->
    <dimen name="notification_alerted_size">12dp</dimen>

    <!-- Keyguard dimensions -->
    <!-- TEMP -->
    <dimen name="kg_security_panel_height">600dp</dimen>

    <!-- Height of security view in keyguard. -->
    <dimen name="kg_security_view_height">480dp</dimen>

    <!-- Width of widget view in keyguard. -->
    <dimen name="kg_widget_view_width">0dp</dimen>

    <!-- Height of widget view in keyguard. -->
    <dimen name="kg_widget_view_height">0dp</dimen>

    <!-- Size of the clock font in keyguard's status view -->
    <dimen name="kg_status_clock_font_size">75dp</dimen>

    <!-- Size of the date font in keyguard's status view  -->
    <dimen name="kg_status_date_font_size">15dp</dimen>

    <!-- Size of the generic status lines keyguard's status view  -->
    <dimen name="kg_status_line_font_size">13dp</dimen>

    <!-- Size of margin on the right of keyguard's status view -->
    <dimen name="kg_status_line_font_right_margin">16dp</dimen>

    <!-- Top margin for the clock view -->
    <dimen name="kg_clock_top_margin">-16dp</dimen>

    <!-- Horizontal gap between keys in PIN and SIM PIN numeric keyboards in keyguard -->
    <dimen name="kg_key_horizontal_gap">0dp</dimen>

    <!-- Horizontal gap between keys in PIN and SIM PIN numeric keyboards in keyguard -->
    <dimen name="kg_key_vertical_gap">0dp</dimen>

    <!-- Horizontal gap between keys in PIN and SIM PIN numeric keyboards in keyguard -->
    <dimen name="kg_pin_key_height">60dp</dimen>

    <!-- Space reserved at the bottom of secure views (pin/pattern/password/SIM pin/SIM puk) -->
    <dimen name="kg_secure_padding_height">46dp</dimen>

    <!-- The height of the runway lights strip -->
    <dimen name="kg_runway_lights_height">7dp</dimen>

    <!-- The height of the runway lights strip -->
    <dimen name="kg_runway_lights_vertical_padding">2dp</dimen>

    <!-- Horizontal padding for the widget pager -->
    <dimen name="kg_widget_pager_horizontal_padding">16dp</dimen>

    <!-- Top padding for the widget pager -->
    <dimen name="kg_widget_pager_top_padding">0dp</dimen>

    <!-- Bottom padding for the widget pager -->
    <dimen name="kg_widget_pager_bottom_padding">64dp</dimen>

    <!-- Top margin for the runway lights. We add a negative margin in large
        devices to account for the widget pager padding -->
    <dimen name="kg_runway_lights_top_margin">0dp</dimen>

    <!-- Touch slop for the global toggle accessibility gesture -->
    <dimen name="accessibility_touch_slop">80dip</dimen>

    <!-- Width of the outline stroke used by the accessibility screen magnification indicator -->
    <dimen name="accessibility_magnification_indicator_width">4dip</dimen>

    <!-- Margin around the various security views -->
    <dimen name="keyguard_muliuser_selector_margin">8dp</dimen>

    <!-- Stroke width of the frame for the circular avatars. -->
    <dimen name="keyguard_avatar_frame_stroke_width">2dp</dimen>

    <!-- Shadow radius under the frame for the circular avatars. -->
    <dimen name="keyguard_avatar_frame_shadow_radius">1dp</dimen>

    <!-- Size of the avator on hte multiuser lockscreen. -->
    <dimen name="keyguard_avatar_size">66dp</dimen>

    <!-- Size of the text under the avator on the multiuser lockscreen. -->
    <dimen name="keyguard_avatar_name_size">10sp</dimen>

    <!-- Size of the region along the edge of the screen that will accept
         swipes to scroll the widget area. -->
    <dimen name="kg_edge_swipe_region_size">24dp</dimen>

    <!-- If the height if keyguard drops below this threshold (most likely
    due to the appearance of the IME), then drop the multiuser selector. -->
    <dimen name="kg_squashed_layout_threshold">600dp</dimen>

    <!-- The height of widgets which do not support vertical resizing. This is only
    used on tablets; on phones, this size is determined by the space left by the
    security mode. -->
    <dimen name="kg_small_widget_height">160dp</dimen>

    <!-- Rounded corner radius for video subtitles. -->
    <dimen name="subtitle_corner_radius">2dp</dimen>

    <!-- Shadow radius for video subtitles. -->
    <dimen name="subtitle_shadow_radius">2dp</dimen>

    <!-- Shadow offset for video subtitles. -->
    <dimen name="subtitle_shadow_offset">2dp</dimen>

    <!-- Outline width for video subtitles. -->
    <dimen name="subtitle_outline_width">2dp</dimen>

    <!-- Minimum size of the fast scroller thumb's touch target. -->
    <dimen name="fast_scroller_minimum_touch_target">48dp</dimen>

    <!-- width of ImmersiveModeConfirmation (-1 for match_parent) -->
    <dimen name="immersive_mode_cling_width">-1px</dimen>

    <dimen name="resolver_max_width">480dp</dimen>

    <!-- Amount to reduce the size of the circular mask by (to compensate for
         aliasing effects). This is only used on circular displays. -->
    <dimen name="circular_display_mask_thickness">1px</dimen>

    <dimen name="lock_pattern_dot_line_width">3dp</dimen>
    <dimen name="lock_pattern_dot_size">12dp</dimen>
    <dimen name="lock_pattern_dot_size_activated">28dp</dimen>

    <dimen name="text_handle_min_size">40dp</dimen>

    <!-- Lighting and shadow properties -->
    <dimen name="light_y">0dp</dimen>
    <dimen name="light_z">600dp</dimen>
    <dimen name="light_radius">800dp</dimen>
    <item type="dimen" format="float" name="ambient_shadow_alpha">0.039</item>
    <item type="dimen" format="float" name="spot_shadow_alpha">0.19</item>

    <!-- Floating toolbar dimensions -->
    <dimen name="floating_toolbar_height">48dp</dimen>
    <dimen name="floating_toolbar_menu_image_width">24dp</dimen>
    <dimen name="floating_toolbar_menu_image_button_width">56dp</dimen>
    <dimen name="floating_toolbar_menu_image_button_vertical_padding">12dp</dimen>
    <dimen name="floating_toolbar_menu_button_side_padding">11dp</dimen>
    <dimen name="floating_toolbar_overflow_image_button_width">60dp</dimen>
    <dimen name="floating_toolbar_overflow_side_padding">18dp</dimen>
    <dimen name="floating_toolbar_text_size">14sp</dimen>
    <dimen name="floating_toolbar_menu_button_minimum_width">48dp</dimen>
    <dimen name="floating_toolbar_preferred_width">400dp</dimen>
    <dimen name="floating_toolbar_minimum_overflow_height">96dp</dimen>
    <dimen name="floating_toolbar_maximum_overflow_height">192dp</dimen>
    <dimen name="floating_toolbar_horizontal_margin">16dp</dimen>
    <dimen name="floating_toolbar_vertical_margin">8dp</dimen>
    <dimen name="content_rect_bottom_clip_allowance">20dp</dimen>
    <dimen name="floating_toolbar_icon_text_spacing">8dp</dimen>

    <!-- Magnifier dimensions -->
    <dimen name="default_magnifier_width">100dp</dimen>
    <dimen name="default_magnifier_height">48dp</dimen>
    <dimen name="default_magnifier_elevation">4dp</dimen>
    <dimen name="default_magnifier_corner_radius">2dp</dimen>
    <dimen name="default_magnifier_vertical_offset">-42dp</dimen>
    <dimen name="default_magnifier_horizontal_offset">0dp</dimen>
    <item type="dimen" format="float" name="default_magnifier_zoom">1.25</item>

    <!-- Spacing around the background change frome service to non-service -->
    <dimen name="chooser_service_spacing">8dp</dimen>

    <item type="dimen" name="aerr_padding_list_top">15dp</item>
    <item type="dimen" name="aerr_padding_list_bottom">8dp</item>

    <item type="fraction" name="docked_stack_divider_fixed_ratio">34.15%</item>

    <dimen name="resize_shadow_size">5dp</dimen>

    <!-- The default minimal size of a resizable task, in both dimensions. -->
    <dimen name="default_minimal_size_resizable_task">220dp</dimen>

    <!-- The default minimal size of a PiP task, in both dimensions. -->
    <dimen name="default_minimal_size_pip_resizable_task">108dp</dimen>

    <!-- Height of a task when in minimized mode from the top when launcher is resizable. -->
    <dimen name="task_height_of_minimized_mode">80dp</dimen>

    <!-- Minimum "smallest width" of the display for cascading menus to be enabled. -->
    <dimen name="cascading_menus_min_smallest_width">720dp</dimen>

    <!-- Tooltip dimensions. -->
    <!-- Vertical offset from the edge of the anchor view for a touch-triggered tooltip. -->
    <dimen name="tooltip_y_offset_touch">16dp</dimen>
    <!-- Vertical offset from the edge of the anchor view for a non-touch-triggered tooltip. -->
    <dimen name="tooltip_y_offset_non_touch">0dp</dimen>
    <!-- The tooltip does not get closer than this to the window edge -->
    <dimen name="tooltip_margin">8dp</dimen>
    <!-- Left/right padding of the tooltip text. -->
    <dimen name="tooltip_horizontal_padding">16dp</dimen>
    <!-- Top/bottom padding of the tooltip text. -->
    <dimen name="tooltip_vertical_padding">6.5dp</dimen>
    <!-- Border corner radius of the tooltip window. -->
    <dimen name="tooltip_corner_radius">2dp</dimen>
    <!-- View with the height equal or above this threshold will have a tooltip anchored
    to the mouse/touch position -->
    <dimen name="tooltip_precise_anchor_threshold">96dp</dimen>
    <!-- Extra tooltip offset used when anchoring to the mouse/touch position -->
    <dimen name="tooltip_precise_anchor_extra_offset">8dp</dimen>

    <!-- The max amount of scroll ItemTouchHelper will trigger if dragged view is out of
         RecyclerView's bounds.-->
    <dimen name="item_touch_helper_max_drag_scroll_per_frame">20dp</dimen>
    <dimen name="item_touch_helper_swipe_escape_velocity">120dp</dimen>
    <dimen name="item_touch_helper_swipe_escape_max_velocity">800dp</dimen>

    <!-- The maximum height of any image in a remote view. This is applied to all images in custom remoteviews. This value is determined by the maximum notification height -->
    <dimen name="notification_custom_view_max_image_height">284dp</dimen>
    <!-- The maximum height of any image in a remote view. This is applied to all images in custom remoteviews. This value is determined a maximum notification width -->
    <dimen name="notification_custom_view_max_image_width">450dp</dimen>
    <!-- The maximum height of a big picture in a notification. The images will be reduced to that height in case they are bigger. This value is determined by the maximum notification height -->
    <dimen name="notification_big_picture_max_height">284dp</dimen>
    <!-- The maximum width of a big picture in a notification. The images will be reduced to that width in case they are bigger. This value is determined by the standard panel size -->
    <dimen name="notification_big_picture_max_width">416dp</dimen>
    <!-- The maximum height of a image in a media notification. The images will be reduced to that height in case they are bigger. This value is determined by the expanded media template-->
    <dimen name="notification_media_image_max_height">140dp</dimen>
    <!-- The maximum width of a image in a media notification. The images will be reduced to that width in case they are bigger.-->
    <dimen name="notification_media_image_max_width">280dp</dimen>
    <!-- The size of the right icon -->
    <dimen name="notification_right_icon_size">36dp</dimen>
    <!-- The alpha of a disabled notification button -->
    <item type="dimen" format="float" name="notification_action_disabled_alpha">0.5</item>

    <!-- The maximum height of any image in a remote view. This is applied to all images in custom remoteviews. -->
    <dimen name="notification_custom_view_max_image_height_low_ram">208dp</dimen>
    <!-- The maximum height of any image in a remote view. This is applied to all images in custom remoteviews. -->
    <dimen name="notification_custom_view_max_image_width_low_ram">294dp</dimen>
    <!-- The maximum height of a big picture in a notification. The images will be reduced to that height in case they are bigger. -->
    <dimen name="notification_big_picture_max_height_low_ram">208dp</dimen>
    <!-- The maximum width of a big picture in a notification. The images will be reduced to that width in case they are bigger. -->
    <dimen name="notification_big_picture_max_width_low_ram">294dp</dimen>
    <!-- The maximum height of a image in a media notification. The images will be reduced to that height in case they are bigger. -->
    <dimen name="notification_media_image_max_height_low_ram">100dp</dimen>
    <!-- The maximum width of a image in a media notification. The images will be reduced to that width in case they are bigger.-->
    <dimen name="notification_media_image_max_width_low_ram">100dp</dimen>
    <!-- The size of the right icon image when on low ram -->
    <dimen name="notification_right_icon_size_low_ram">@dimen/notification_right_icon_size</dimen>

    <dimen name="messaging_avatar_size">@dimen/notification_right_icon_size</dimen>

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

    <!-- Max width/height of the autofill data set picker as a fraction of the screen width/height -->
    <dimen name="autofill_dataset_picker_max_width">90%</dimen>
    <dimen name="autofill_dataset_picker_max_height">90%</dimen>

    <!-- Autofill save dialog padding -->
    <dimen name="autofill_save_outer_top_margin">32dp</dimen>
    <dimen name="autofill_save_outer_top_padding">16dp</dimen>
    <dimen name="autofill_elevation">32dp</dimen>
    <dimen name="autofill_save_inner_padding">16dp</dimen>
    <dimen name="autofill_save_icon_size">24dp</dimen>
    <dimen name="autofill_save_title_start_padding">8dp</dimen>
    <dimen name="autofill_save_scroll_view_top_margin">4dp</dimen>
    <dimen name="autofill_save_button_bar_padding">16dp</dimen>

    <!-- Max height of the the autofill save custom subtitle as a fraction of the screen width/height -->
    <dimen name="autofill_save_custom_subtitle_max_height">20%</dimen>

    <!-- Max (absolute) dimensions (both width and height) of autofill service icon on autofill save affordance.
      NOTE: the actual displayed size might is actually smaller than this and is hardcoded in the
      autofill_save.xml layout; this dimension is just used to avoid a crash in the UI (if the icon provided
      by the autofill service metadata is bigger than these dimentionsit will not be displayed).
    -->
    <dimen name="autofill_save_icon_max_size">300dp</dimen>

    <!-- Maximum number of datasets that are visible in the UX picker without scrolling -->
    <integer name="autofill_max_visible_datasets">3</integer>

    <!-- Size of a slice shortcut view -->
    <dimen name="slice_shortcut_size">56dp</dimen>
    <!-- Size of action icons in a slice -->
    <dimen name="slice_icon_size">24dp</dimen>
    <!-- Standard padding used in a slice view -->
    <dimen name="slice_padding">16dp</dimen>

    <!-- Default dialog corner radius -->
    <dimen name="dialog_corner_radius">2dp</dimen>

    <!-- Size of thumbnail used in the cross profile apps animation -->
    <dimen name="cross_profile_apps_thumbnail_size">72dp</dimen>

    <!-- Padding between the title and content in the harmful app dialog -->
    <dimen name="harmful_app_padding_top">10dp</dimen>
    <!-- Bottom padding for the "app name" section of the harmful app dialog -->
    <dimen name="harmful_app_name_padding_bottom">20dp</dimen>
    <!-- Left padding for the "app name" section of the harmful app dialog -->
    <dimen name="harmful_app_name_padding_left">24dp</dimen>
    <!-- Right padding for the "app name" section of the harmful app dialog -->
    <dimen name="harmful_app_name_padding_right">24dp</dimen>
    <!-- Top padding for the "app name" section of the harmful app dialog -->
    <dimen name="harmful_app_name_padding_top">8dp</dimen>
    <!-- Padding between the icon and app name in the harmful app dialog -->
    <dimen name="harmful_app_icon_name_padding">20dp</dimen>
    <!-- The size of the icon on the harmful app dialog -->
    <dimen name="harmful_app_icon_size">44dp</dimen>
    <!-- Left padding for the message section of the harmful app dialog -->
    <dimen name="harmful_app_message_padding_left">24dp</dimen>
    <!-- Right padding for the message section of the harmful app dialog -->
    <dimen name="harmful_app_message_padding_right">24dp</dimen>
    <!-- Bottom padding for the message section of the harmful app dialog -->
    <dimen name="harmful_app_message_padding_bottom">24dp</dimen>
    <!-- Line spacing modifier for the message field of the harmful app dialog -->
    <item name="harmful_app_message_line_spacing_modifier" type="dimen">1.22</item>

    <dimen name="seekbar_thumb_exclusion_max_size">48dp</dimen>

    <!-- chooser (sharesheet) spacing -->
    <dimen name="chooser_corner_radius">8dp</dimen>
    <dimen name="chooser_row_text_option_translate">25dp</dimen>
    <dimen name="chooser_view_spacing">18dp</dimen>
    <dimen name="chooser_edge_margin_thin">16dp</dimen>
    <dimen name="chooser_edge_margin_normal">24dp</dimen>
    <dimen name="chooser_preview_image_font_size">20sp</dimen>
    <dimen name="chooser_preview_image_border">1dp</dimen>
    <dimen name="chooser_preview_width">-1px</dimen>
    <dimen name="resolver_icon_size">42dp</dimen>
    <dimen name="resolver_button_bar_spacing">8dp</dimen>
    <dimen name="resolver_badge_size">18dp</dimen>
    <dimen name="chooser_target_width">90dp</dimen>
    <dimen name="chooser_header_scroll_elevation">4dp</dimen>
    <dimen name="chooser_max_collapsed_height">288dp</dimen>
    <dimen name="chooser_direct_share_label_placeholder_max_width">72dp</dimen>
</resources>
