<?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">120dp</dimen>
    <!-- The height that is used when creating thumbnails of applications. -->
    <dimen name="thumbnail_height">120dp</dimen>
    <!-- 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>
    <!-- The maximum number of action buttons that should be permitted within
         an action bar/action mode. This will be used to determine how many
         showAsAction="ifRoom" items can fit. "always" items can override this. -->
    <integer name="max_action_buttons">3</integer>
    <dimen name="toast_y_offset">64dip</dimen>
    <!-- Height of the status bar -->
    <dimen name="status_bar_height">25dip</dimen>
    <!-- Height of the system bar -->
    <dimen name="system_bar_height">48dip</dimen>
    <!-- Height of notification icons in the status bar -->
    <dimen name="status_bar_icon_size">25dip</dimen>
    <!-- Size of the giant number (unread count) in the notifications -->
    <dimen name="status_bar_content_number_size">48sp</dimen>
    <!-- Height of notification icons in the system bar -->
    <dimen name="system_bar_icon_size">32dip</dimen>
    <!-- Margin at the edge of the screen to ignore touch events for in the windowshade. -->
    <dimen name="status_bar_edge_ignore">5dp</dimen>
    <!-- Size of the fastscroll hint letter -->
    <dimen name="fastscroll_overlay_size">104dp</dimen>
    <!-- Width of the fastscroll thumb -->
    <dimen name="fastscroll_thumb_width">64dp</dimen>
    <!-- Height of the fastscroll thumb -->
    <dimen name="fastscroll_thumb_height">52dp</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 -->
    <dimen name="password_keyboard_key_height_alpha">56dip</dimen>
    <!-- Default height of a key in the password keyboard for numeric -->
    <dimen name="password_keyboard_key_height_numeric">56dip</dimen>
    <!-- Default correction for the space key in the password keyboard -->
    <dimen name="password_keyboard_spacebar_vertical_correction">4dip</dimen>

    <!-- Default target placement radius for MultiWaveView -->
    <dimen name="multiwaveview_target_placement_radius">135dip</dimen>

    <!-- Default distance beyond which MultiWaveView snaps to the target radius -->
    <dimen name="multiwaveview_snap_margin">20dip</dimen>

    <!-- Default distance from each snap target that MultiWaveView considers a "hit" -->
    <dimen name="multiwaveview_hit_radius">60dip</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">0dp</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 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>

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

    <!-- Minimum width of the search view text entry area. -->
    <dimen name="search_view_text_min_width">160dip</dimen>

    <!-- Dialog title height -->
    <dimen name="alert_dialog_title_height">64dip</dimen>
    <!-- Dialog button bar height -->
    <dimen name="alert_dialog_button_bar_height">48dip</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>

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

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

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

</resources>
