<?xml version="1.0" encoding="utf-8"?>
<!--
  ~ Copyright (C) 2021 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>
    <!-- Dimensions for CustomizationPickerFragment. -->
    <dimen name="wallpaper_section_horizontal_padding">64dp</dimen>
    <dimen name="section_horizontal_padding">64dp</dimen>
    <dimen name="separated_tabs_inset_horizontal">4dp</dimen>

    <!--  Default page horizontal margin (64dp) - separated tabs inset horizontal (4dp) -->
    <dimen name="separated_tabs_horizontal_padding">60dp</dimen>

    <!-- Dimensions for CategorySelectorFragment. -->
    <dimen name="category_grid_edge_space">64dp</dimen>
    <dimen name="grid_item_featured_category_padding_bottom">24dp</dimen>
    <dimen name="grid_item_category_padding_bottom">24dp</dimen>

    <!-- Dimensions for IndividualPickerFragment. -->
    <dimen name="wallpaper_grid_edge_space">64dp</dimen>
    <dimen name="featured_wallpaper_grid_edge_space">57dp</dimen>

    <!-- Dimensions for PreviewFragment. -->
    <dimen name="full_preview_page_tabs_horizontal_padding">134dp</dimen>
    <dimen name="full_preview_page_default_horizontal_padding">138dp</dimen>
    <dimen name="preview_attribution_pane_horizontal_padding">36dp</dimen>
    <dimen name="wallpaper_info_pane_subtitle1_top_margin">8dp</dimen>
    <dimen name="wallpaper_info_pane_explore_button_top_margin">24dp</dimen>

    <!-- Dimensions for BottomActionBar. -->
    <dimen name="bottom_actions_horizontal_padding">130dp</dimen>
    <dimen name="bottom_sheet_margin">64dp</dimen>
    <dimen name="wallpaper_info_pane_padding">36dp</dimen>


    <!-- Dimensions for GridFragment. -->
    <dimen name="grid_options_container_horizontal_margin">64dp</dimen>

    <!-- Clipping of the home screen overlay -->
    <dimen name="home_screen_overlay_top_clipping">0dp</dimen>
    <dimen name="home_screen_overlay_bottom_clipping">100dp</dimen>
</resources>