<?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_top_margin">12dp</dimen>

    <!-- Overload default clock widget parameters -->
    <dimen name="widget_big_font_size">100dp</dimen>
    <dimen name="widget_label_font_size">16sp</dimen>
    <dimen name="bottom_text_spacing_digital">-1dp</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>
