<?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.
-->

<Keyboard xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:wnn="http://schemas.android.com/apk/res/jp.co.omronsoft.openwnn"
    android:keyHeight="@dimen/key_height_4key"
    >

    <Row>
        <Key android:codes="-300" android:keyLabel="@string/key_symbol_mode" android:keyEdgeFlags="left" android:keyWidth="25%p" wnn:isSecondKey="true"/>
        <Key android:codes="-301" android:keyWidth="25%p" android:keyLabel="\u25b2" wnn:isSecondKey="true" />
        <Key android:codes="-302" android:keyWidth="25%p" android:keyLabel="\u25bc" wnn:isSecondKey="true" />
        <Key android:codes="-303" android:keyIcon="@drawable/key_del" android:iconPreview="@drawable/key_del_b" android:isRepeatable="true" android:keyEdgeFlags="right" android:keyWidth="25%p" wnn:isSecondKey="true" />
    </Row>
</Keyboard>

