<?xml version="1.0" encoding="utf-8"?>
<!--
/*
** Copyright 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>
    <!-- Default height of a key in the password keyboard for alpha -->
    <dimen name="password_keyboard_key_height_alpha">75dip</dimen>
    <!-- Default height of a key in the password keyboard for numeric -->
    <dimen name="password_keyboard_key_height_numeric">75dip</dimen>
    <!-- keyboardHeight = key_height*4 + key_bottom_gap*3 -->
    <dimen name="password_keyboard_height">48.0mm</dimen>

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

    <item type="dimen" name="dialog_min_width_major">55%</item>
    <item type="dimen" name="dialog_min_width_minor">80%</item>

    <!-- Preference UI dimensions for larger screens. -->
    <dimen name="preference_widget_width">56dp</dimen>
</resources>
