<?xml version="1.0" encoding="utf-8"?>
<!--
  ~ Copyright (C) 2015 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>
    <style name="PreferenceThemeOverlay">
        <item name="preferenceScreenStyle">@style/Preference.PreferenceScreen</item>
        <item name="preferenceFragmentCompatStyle">@style/PreferenceFragment</item>
        <item name="preferenceCategoryStyle">@style/Preference.Category</item>
        <item name="preferenceStyle">@style/Preference</item>
        <item name="preferenceInformationStyle">@style/Preference.Information</item>
        <item name="checkBoxPreferenceStyle">@style/Preference.CheckBoxPreference</item>
        <item name="switchPreferenceCompatStyle">@style/Preference.SwitchPreferenceCompat</item>
        <item name="seekBarPreferenceStyle">@style/Preference.SeekBarPreference</item>
        <item name="dialogPreferenceStyle">@style/Preference.DialogPreference</item>
        <item name="editTextPreferenceStyle">@style/Preference.DialogPreference.EditTextPreference</item>
        <item name="preferenceFragmentListStyle">@style/PreferenceFragmentList</item>
        <item name="dropdownPreferenceStyle">@style/Preference.DropDown</item>
    </style>

    <style name="PreferenceThemeOverlay.v14">
        <item name="switchPreferenceStyle">@style/Preference.SwitchPreference</item>
        <item name="preferenceFragmentStyle">@style/PreferenceFragment</item>
    </style>

    <style name="PreferenceThemeOverlay.v14.Material">
        <item name="preferenceScreenStyle">@style/Preference.PreferenceScreen.Material</item>
        <item name="preferenceFragmentCompatStyle">@style/PreferenceFragment.Material</item>
        <item name="preferenceFragmentStyle">@style/PreferenceFragment.Material</item>
        <item name="preferenceCategoryStyle">@style/Preference.Category.Material</item>
        <item name="preferenceStyle">@style/Preference.Material</item>
        <item name="preferenceInformationStyle">@style/Preference.Information.Material</item>
        <item name="checkBoxPreferenceStyle">@style/Preference.CheckBoxPreference.Material</item>
        <item name="switchPreferenceCompatStyle">@style/Preference.SwitchPreferenceCompat.Material</item>
        <item name="switchPreferenceStyle">@style/Preference.SwitchPreference.Material</item>
        <item name="seekBarPreferenceStyle">@style/Preference.SeekBarPreference.Material</item>
        <item name="dialogPreferenceStyle">@style/Preference.DialogPreference.Material</item>
        <item name="editTextPreferenceStyle">@style/Preference.DialogPreference.EditTextPreference.Material</item>
        <item name="dropdownPreferenceStyle">@style/Preference.DropDown.Material</item>
        <item name="preferenceFragmentListStyle">@style/PreferenceFragmentList.Material</item>
        <item name="android:scrollbars">vertical</item>
    </style>
</resources>
