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

    <!-- Themes in the "Theme.AppCompat" family will contain an action bar by default.
         If Holo themes are available on the current platform version they will be used.
         A limited Holo-styled action bar will be provided on platform versions older
         than 3.0. (API 11)

         These theme declarations contain any version-independent specification. Items
         that need to vary based on platform version should be defined in the corresponding
         "Theme.Base" theme. -->

    <!-- Platform-independent theme providing an action bar in a dark-themed activity. -->
    <style name="Theme.AppCompat" parent="Theme.Base.AppCompat">
        <item name="isLightTheme">false</item>

        <!-- Required for use of support_simple_spinner_dropdown_item.xml -->
        <item name="spinnerDropDownItemStyle">
            @style/Widget.AppCompat.DropDownItem.Spinner
        </item>
        <item name="dropdownListPreferredItemHeight">?attr/listPreferredItemHeightSmall</item>
        <item name="searchResultListItemHeight">58dip</item>

        <!-- Popup Menu styles -->
        <item name="popupMenuStyle">@style/Widget.AppCompat.PopupMenu</item>
        <item name="textAppearanceLargePopupMenu">
            @style/TextAppearance.AppCompat.Widget.PopupMenu.Large
        </item>
        <item name="textAppearanceSmallPopupMenu">
            @style/TextAppearance.AppCompat.Widget.PopupMenu.Small
        </item>

        <item name="listPopupWindowStyle">@style/Widget.AppCompat.ListPopupWindow</item>
        <item name="dropDownListViewStyle">@style/Widget.AppCompat.ListView.DropDown</item>

        <!-- SearchView attributes -->
        <item name="searchDropdownBackground">@drawable/abc_search_dropdown_dark</item>
        <item name="searchViewTextField">@drawable/abc_textfield_searchview_holo_dark</item>
        <item name="searchViewTextFieldRight">@drawable/abc_textfield_searchview_right_holo_dark
        </item>
        <item name="searchViewCloseIcon">@drawable/abc_ic_clear</item>
        <item name="searchViewSearchIcon">@drawable/abc_ic_search</item>
        <item name="searchViewGoIcon">@drawable/abc_ic_go</item>
        <item name="searchViewVoiceIcon">@drawable/abc_ic_voice_search</item>
        <item name="searchViewEditQuery">@drawable/abc_ic_commit_search_api_holo_dark</item>
        <item name="searchViewEditQueryBackground">?attr/selectableItemBackground</item>
        <item name="searchViewAutoCompleteTextView">
            @style/Widget.AppCompat.AutoCompleteTextView</item>
        <item name="textColorSearchUrl">@color/abc_search_url_text_holo</item>
        <item name="textAppearanceSearchResultTitle">
            @style/TextAppearance.AppCompat.SearchResult.Title
        </item>
        <item name="textAppearanceSearchResultSubtitle">
            @style/TextAppearance.AppCompat.SearchResult.Subtitle
        </item>

        <item name="actionModeShareDrawable">@drawable/abc_ic_menu_share_holo_dark</item>

        <!-- ShareActionProvider attributes -->
        <item name="activityChooserViewStyle">@style/Widget.AppCompat.ActivityChooserView</item>

    </style>

    <!-- Platform-independent theme providing an action bar in a light-themed activity. -->
    <style name="Theme.AppCompat.Light" parent="Theme.Base.AppCompat.Light">
        <item name="isLightTheme">true</item>

        <!-- Required for use of support_simple_spinner_dropdown_item.xml -->
        <item name="spinnerDropDownItemStyle">
            @style/Widget.AppCompat.Light.DropDownItem.Spinner
        </item>
        <item name="dropdownListPreferredItemHeight">?attr/listPreferredItemHeightSmall</item>
        <item name="searchResultListItemHeight">58dip</item>

        <!-- Popup Menu styles -->
        <item name="popupMenuStyle">@style/Widget.AppCompat.Light.PopupMenu</item>
        <item name="textAppearanceLargePopupMenu">
            @style/TextAppearance.AppCompat.Light.Widget.PopupMenu.Large
        </item>
        <item name="textAppearanceSmallPopupMenu">
            @style/TextAppearance.AppCompat.Light.Widget.PopupMenu.Small
        </item>

        <item name="listPopupWindowStyle">@style/Widget.AppCompat.Light.ListPopupWindow</item>
        <item name="dropDownListViewStyle">@style/Widget.AppCompat.Light.ListView.DropDown</item>

        <!-- SearchView attributes -->
        <item name="searchDropdownBackground">@drawable/abc_search_dropdown_light</item>
        <item name="searchViewTextField">@drawable/abc_textfield_searchview_holo_light</item>
        <item name="searchViewTextFieldRight">@drawable/abc_textfield_searchview_right_holo_light
        </item>
        <item name="searchViewCloseIcon">@drawable/abc_ic_clear_holo_light</item>
        <item name="searchViewSearchIcon">@drawable/abc_ic_search_api_holo_light</item>
        <item name="searchViewGoIcon">@drawable/abc_ic_go_search_api_holo_light</item>
        <item name="searchViewVoiceIcon">@drawable/abc_ic_voice_search_api_holo_light</item>
        <item name="searchViewEditQuery">@drawable/abc_ic_commit_search_api_holo_light</item>
        <item name="searchViewEditQueryBackground">?attr/selectableItemBackground</item>
        <item name="searchViewAutoCompleteTextView">
            @style/Widget.AppCompat.Light.AutoCompleteTextView</item>
        <item name="textColorSearchUrl">@color/abc_search_url_text_holo</item>
        <item name="textAppearanceSearchResultTitle">
            @style/TextAppearance.AppCompat.Light.SearchResult.Title
        </item>
        <item name="textAppearanceSearchResultSubtitle">
            @style/TextAppearance.AppCompat.Light.SearchResult.Subtitle
        </item>

        <item name="actionModeShareDrawable">@drawable/abc_ic_menu_share_holo_light</item>

        <!-- ShareActionProvider attributes -->
        <item name="activityChooserViewStyle">@style/Widget.AppCompat.Light.ActivityChooserView
        </item>

    </style>

    <!-- Platform-independent theme providing an action bar in a dark-themed activity. -->
    <style name="Theme.AppCompat.Light.DarkActionBar"
           parent="Theme.Base.AppCompat.Light.DarkActionBar">
        <item name="isLightTheme">true</item>

        <!-- Required for use of support_simple_spinner_dropdown_item.xml -->
        <item name="spinnerDropDownItemStyle">
            @style/Widget.AppCompat.Light.DropDownItem.Spinner
        </item>
        <item name="dropdownListPreferredItemHeight">?attr/listPreferredItemHeightSmall</item>
        <item name="searchResultListItemHeight">58dip</item>

        <!-- Popup Menu styles -->
        <item name="popupMenuStyle">@style/Widget.AppCompat.Light.PopupMenu</item>
        <item name="textAppearanceLargePopupMenu">
            @style/TextAppearance.AppCompat.Light.Widget.PopupMenu.Large
        </item>
        <item name="textAppearanceSmallPopupMenu">
            @style/TextAppearance.AppCompat.Light.Widget.PopupMenu.Small
        </item>

        <item name="listPopupWindowStyle">@style/Widget.AppCompat.ListPopupWindow</item>
        <item name="dropDownListViewStyle">@style/Widget.AppCompat.ListView.DropDown</item>

        <!-- SearchView attributes -->
        <item name="searchDropdownBackground">@drawable/abc_search_dropdown_dark</item>
        <item name="searchViewTextField">@drawable/abc_textfield_searchview_holo_dark</item>
        <item name="searchViewTextFieldRight">@drawable/abc_textfield_searchview_right_holo_dark
        </item>
        <item name="searchViewCloseIcon">@drawable/abc_ic_clear</item>
        <item name="searchViewSearchIcon">@drawable/abc_ic_search</item>
        <item name="searchViewGoIcon">@drawable/abc_ic_go</item>
        <item name="searchViewVoiceIcon">@drawable/abc_ic_voice_search</item>
        <item name="searchViewEditQuery">@drawable/abc_ic_commit_search_api_holo_dark</item>
        <item name="searchViewEditQueryBackground">?attr/selectableItemBackground</item>
        <item name="searchViewAutoCompleteTextView">
            @style/Widget.AppCompat.AutoCompleteTextView</item>
        <item name="textColorSearchUrl">@color/abc_search_url_text_holo</item>
        <item name="textAppearanceSearchResultTitle">
            @style/TextAppearance.AppCompat.SearchResult.Title
        </item>
        <item name="textAppearanceSearchResultSubtitle">
            @style/TextAppearance.AppCompat.SearchResult.Subtitle
        </item>

        <item name="actionModeShareDrawable">@drawable/abc_ic_menu_share_holo_dark</item>

        <!-- ShareActionProvider attributes -->
        <item name="activityChooserViewStyle">@style/Widget.AppCompat.ActivityChooserView
        </item>

    </style>


    <!-- Menu/item attributes -->
    <style name="Theme.AppCompat.CompactMenu" parent="Theme.AppCompat.Base.CompactMenu">
    </style>

    <style name="Theme.AppCompat.CompactMenu.Dialog"
           parent="Theme.AppCompat.Base.CompactMenu.Dialog">
    </style>

</resources>
