<?xml version="1.0" encoding="utf-8"?>
<!-- Copyright (C) 2017 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>

    <dimen name="task_thumbnail_top_margin">24dp</dimen>
    <dimen name="task_thumbnail_icon_size">48dp</dimen>
    <dimen name="task_menu_background_radius">12dp</dimen>
    <dimen name="task_corner_radius">2dp</dimen>
    <dimen name="recents_page_spacing">10dp</dimen>
    <dimen name="quickscrub_adjacent_visible_width">20dp</dimen>

    <!-- The speed in dp/s at which the user needs to be scrolling in recents such that we start
             loading full resolution screenshots. -->
    <dimen name="recents_fast_fling_velocity">600dp</dimen>

    <dimen name="quickstep_fling_threshold_velocity">500dp</dimen>
    <dimen name="quickstep_fling_min_velocity">250dp</dimen>

    <!-- Launcher app transition -->
    <dimen name="content_trans_y">50dp</dimen>
    <dimen name="workspace_trans_y">50dp</dimen>
    <dimen name="closing_window_trans_y">115dp</dimen>

    <dimen name="recents_empty_message_text_size">16sp</dimen>
    <dimen name="recents_empty_message_text_padding">16dp</dimen>

    <!-- Total space (start + end) between the task card and the edge of the screen
         in various configurations -->
    <dimen name="task_card_vert_space">40dp</dimen>
    <dimen name="portrait_task_card_horz_space">136dp</dimen>
    <dimen name="landscape_task_card_horz_space">200dp</dimen>
    <dimen name="multi_window_task_card_horz_space">100dp</dimen>
    <!-- Copied from framework resource:
       docked_stack_divider_thickness - 2 * docked_stack_divider_insets -->
    <dimen name="multi_window_task_divider_size">10dp</dimen>

    <!-- Width of the space behind the last task in Overview. In the center of it, there is "Clear all" button. -->
    <dimen name="clear_all_container_width">168dp</dimen>

    <dimen name="shelf_surface_radius">16dp</dimen>
</resources>
