<?xml version="1.0" encoding="utf-8"?>
<!--
 Copyright (C) 2008-2012  OMRON SOFTWARE Co., Ltd.

 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>

    <string-array name="keyboard_skin">
        <item>@string/preference_keyboard_android_default</item>
        <item>@string/preference_keyboard_simple</item>
        <item>@string/preference_keyboard_metal</item>
    </string-array>

    <string name="keyboard_skin_id_default">keyboard_android_default</string>

    <string-array name="keyboard_skin_id">
        <item>keyboard_android_default</item>
        <item>keyboard_simple</item>
        <item>keyboard_metal</item>
    </string-array>
</resources>
