<?xml version="1.0" encoding="utf-8"?>
<!--
/*
 *
 * Copyright 2006,2007,2008 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="BrowserTheme" parent="@android:Theme.Holo">
        <item name="android:windowBackground">@color/white</item>
        <item name="android:colorBackground">#FFFFFFFF</item>
        <item name="android:windowActionBar">false</item>
        <item name="android:windowNoTitle">true</item>
        <item name="android:windowActionModeOverlay">true</item>
        <item name="android:actionBarStyle">@style/ActionBarStyle</item>
    </style>
    <style name="DialogWhenLarge" parent="@android:style/Theme.Holo.DialogWhenLarge" >
        <item name="android:windowActionBar">false</item>
    </style>
    <style name="BookmarkTheme" parent="@android:Theme.Holo">
        <item name="android:windowActionBar">false</item>
        <item name="android:windowNoTitle">true</item>
        <item name="android:colorBackgroundCacheHint">@null</item>
        <item name="android:windowFrame">@null</item>
        <item name="android:windowContentOverlay">@null</item>
        <item name="android:windowIsFloating">true</item>
        <item name="android:backgroundDimEnabled">false</item>
        <item name="android:windowIsTranslucent">true</item>
    </style>
    <style name="ActionBarStyle" parent="@android:style/Widget.Holo.ActionBar">
        <item name="android:background">@drawable/bg_urlbar</item>
        <item name="android:displayOptions"></item>
    </style>
    <style name="Suggestions" parent="@android:style/Widget.Holo.AutoCompleteTextView">
        <item name="android:popupBackground">#D0000000</item>
        <item name="android:dropDownVerticalOffset">0dip</item>
    </style>
    <style name="SuggestionLineMedium"
            parent="@android:style/TextAppearance.Holo.Medium">
        <item name="android:textSize">16sp</item>
    </style>
    <style name="SuggestionLineSmall"
            parent="@android:style/TextAppearance.Holo.Small">
        <item name="android:textSize">12sp</item>
    </style>
    <style name="ActionBar" parent="@android:style/Widget.ActionBar">
        <item name="android:background">@color/black</item>
    </style>
    <style name="ShortcutTheme" parent="@android:Theme.Holo.DialogWhenLarge">
    </style>
    <style name="TitleBar">
        <item name="android:windowEnterAnimation">@anim/title_bar_enter</item>
        <item name="android:windowExitAnimation">@anim/title_bar_exit</item>
    </style>
    <style name="HoloIcon">
        <item name="android:layout_marginLeft">16dip</item>
    </style>
    <style name="HoloButton">
        <item name="android:background">?android:attr/selectableItemBackground</item>
        <item name="android:paddingLeft">8dip</item>
        <item name="android:paddingRight">8dip</item>
    </style>
    <style name="TabTitleSelected" parent="@android:style/TextAppearance.Small">
        <item name="android:textColor">?android:attr/textColorPrimary</item>
        <item name="android:textStyle">bold</item>
    </style>
    <style name="TabTitleUnselected" parent="@android:style/TextAppearance.Small">
        <item name="android:textColor">?android:attr/textColorSecondary</item>
        <item name="android:textStyle">normal</item>
    </style>

    <style name="AutofillProfileTextView">
        <item name="android:layout_width">wrap_content</item>
        <item name="android:layout_height">wrap_content</item>
        <item name="android:gravity">center_vertical</item>
        <item name="android:layout_margin">2dip</item>
        <item name="android:textAppearance">?android:attr/textAppearanceMedium</item>
    </style>
    <style name="AutofillProfileEditText" parent="@style/AutofillProfileTextView">
        <item name="android:layout_width">match_parent</item>
        <item name="android:imeOptions">flagNoExtractUi|actionNext</item>
        <item name="android:singleLine">true</item>
    </style>
</resources>
