<?xml version="1.0" encoding="utf-8"?>
<!--
 * Copyright (c) 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>
    <!-- size at which Notification icons will be drawn in the status bar -->
    <dimen name="system_bar_icon_drawing_size">24dip</dimen>

    <!-- opacity at which Notification icons will be drawn in the status bar -->
    <item type="dimen" name="system_bar_icon_drawing_alpha">100%</item>

    <!-- The width of the view containing non-menu status bar icons -->
    <dimen name="system_bar_navigation_key_width">80dip</dimen>

    <!-- The width of the view containing the menu status bar icon -->
    <dimen name="system_bar_navigation_menu_key_width">80dip</dimen>

    <!-- ======================================== -->
    <!-- The following resources were recently moved from sw600dp; there may
         be situations where they don't sync up perfectly with
         PhoneStatusBar/TabletStatusBar. -->
    <!-- ======================================== -->

    <!-- The width of the ticker, including the icon -->
    <dimen name="notification_ticker_width">360dp</dimen>
    <!-- Status bar panel bottom offset (height of status bar - overlap) -->
    <dimen name="status_bar_panel_bottom_offset">36dp</dimen>
    <!-- gap on either side of status bar notification icons -->
    <dimen name="status_bar_icon_padding">1dp</dimen>
    <!-- The width of the notification panel window -->
    <dimen name="notification_panel_width">512dp</dimen>
    <!-- The minimum height of the notification panel window -->
    <dimen name="notification_panel_min_height">770dp</dimen>
    <!-- Bottom margin (from display edge) for status bar panels -->
    <dimen name="panel_float">56dp</dimen>

    <!-- Recent Applications parameters -->
    <!-- How far the thumbnail for a recent app appears from left edge -->
    <dimen name="status_bar_recents_thumbnail_left_margin">28dp</dimen>
    <!-- Upper width limit for application icon -->
    <dimen name="status_bar_recents_app_icon_max_width">64dp</dimen>
    <!-- Upper height limit for application icon -->
    <dimen name="status_bar_recents_app_icon_max_height">64dp</dimen>

    <!-- Size of application icon -->
    <dimen name="status_bar_recents_thumbnail_width">208dp</dimen>
    <dimen name="status_bar_recents_thumbnail_height">130dp</dimen>

    <!-- Width of recents panel -->
    <dimen name="status_bar_recents_width">600dp</dimen>
    <!-- Padding for text descriptions -->
    <dimen name="status_bar_recents_text_description_padding">8dp</dimen>
    <!-- Size of application label text -->
    <dimen name="status_bar_recents_app_label_text_size">18dip</dimen>
    <!-- Size of application description text -->
    <dimen name="status_bar_recents_app_description_text_size">18dip</dimen>
    <!-- Width of application label text -->
    <dimen name="status_bar_recents_app_label_width">97dip</dimen>
    <!-- Left margin for application label -->
    <dimen name="status_bar_recents_app_label_left_margin">16dip</dimen>
    <!-- Size of fading edge for text -->
    <dimen name="status_bar_recents_text_fading_edge_length">20dip</dimen>
    <!-- Size of fading edge for scrolling -->
    <dimen name="status_bar_recents_scroll_fading_edge_length">10dip</dimen>

    <!-- Where to place the app icon over the thumbnail -->
    <dimen name="status_bar_recents_app_icon_left_margin">0dp</dimen>
    <dimen name="status_bar_recents_app_icon_top_margin">8dp</dimen>
</resources>

