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

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

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

    <!-- Overload default clock widget parameters -->
    <dimen name="widget_big_font_size">125dp</dimen>
    <dimen name="widget_label_font_size">16sp</dimen>
    <dimen name="bottom_text_spacing_digital">-16dp</dimen>

    <!-- EmergencyCarrierArea overlap - amount to overlap the emergency button and carrier text.
         Should be 0 on devices with plenty of room (e.g. tablets) -->
    <dimen name="eca_overlap">0dip</dimen>
</resources>
