554 lines
20 KiB
Java
554 lines
20 KiB
Java
|
/*
|
||
|
|
* Copyright (C) 2007 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.
|
||
|
|
*/
|
||
|
|
|
||
|
|
package android.view;
|
||
|
|
|
||
|
|
import android.text.method.MetaKeyKeyListener;
|
||
|
|
import android.util.SparseIntArray;
|
||
|
|
import android.os.RemoteException;
|
||
|
|
import android.os.ServiceManager;
|
||
|
|
import android.os.SystemClock;
|
||
|
|
import android.util.SparseArray;
|
||
|
|
|
||
|
|
import java.lang.Character;
|
||
|
|
import java.lang.ref.WeakReference;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Describes the keys provided by a device and their associated labels.
|
||
|
|
*/
|
||
|
|
public class KeyCharacterMap
|
||
|
|
{
|
||
|
|
/**
|
||
|
|
* The id of the device's primary built in keyboard is always 0.
|
||
|
|
*/
|
||
|
|
public static final int BUILT_IN_KEYBOARD = 0;
|
||
|
|
|
||
|
|
/** A numeric (12-key) keyboard. */
|
||
|
|
public static final int NUMERIC = 1;
|
||
|
|
|
||
|
|
/** A keyboard with all the letters, but with more than one letter
|
||
|
|
* per key. */
|
||
|
|
public static final int PREDICTIVE = 2;
|
||
|
|
|
||
|
|
/** A keyboard with all the letters, and maybe some numbers. */
|
||
|
|
public static final int ALPHA = 3;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* This private-use character is used to trigger Unicode character
|
||
|
|
* input by hex digits.
|
||
|
|
*/
|
||
|
|
public static final char HEX_INPUT = '\uEF00';
|
||
|
|
|
||
|
|
/**
|
||
|
|
* This private-use character is used to bring up a character picker for
|
||
|
|
* miscellaneous symbols.
|
||
|
|
*/
|
||
|
|
public static final char PICKER_DIALOG_INPUT = '\uEF01';
|
||
|
|
|
||
|
|
private static Object sLock = new Object();
|
||
|
|
private static SparseArray<WeakReference<KeyCharacterMap>> sInstances
|
||
|
|
= new SparseArray<WeakReference<KeyCharacterMap>>();
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Loads the key character maps for the keyboard with the specified device id.
|
||
|
|
* @param keyboard The device id of the keyboard.
|
||
|
|
* @return The associated key character map.
|
||
|
|
*/
|
||
|
|
public static KeyCharacterMap load(int keyboard)
|
||
|
|
{
|
||
|
|
synchronized (sLock) {
|
||
|
|
KeyCharacterMap result;
|
||
|
|
WeakReference<KeyCharacterMap> ref = sInstances.get(keyboard);
|
||
|
|
if (ref != null) {
|
||
|
|
result = ref.get();
|
||
|
|
if (result != null) {
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
result = new KeyCharacterMap(keyboard);
|
||
|
|
sInstances.put(keyboard, new WeakReference<KeyCharacterMap>(result));
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private KeyCharacterMap(int keyboardDevice)
|
||
|
|
{
|
||
|
|
mKeyboardDevice = keyboardDevice;
|
||
|
|
mPointer = ctor_native(keyboardDevice);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* <p>
|
||
|
|
* Returns the Unicode character that the specified key would produce
|
||
|
|
* when the specified meta bits (see {@link MetaKeyKeyListener})
|
||
|
|
* were active.
|
||
|
|
* </p><p>
|
||
|
|
* Returns 0 if the key is not one that is used to type Unicode
|
||
|
|
* characters.
|
||
|
|
* </p><p>
|
||
|
|
* If the return value has bit {@link #COMBINING_ACCENT} set, the
|
||
|
|
* key is a "dead key" that should be combined with another to
|
||
|
|
* actually produce a character -- see {@link #getDeadChar} --
|
||
|
|
* after masking with {@link #COMBINING_ACCENT_MASK}.
|
||
|
|
* </p>
|
||
|
|
*/
|
||
|
|
public int get(int keyCode, int meta)
|
||
|
|
{
|
||
|
|
if ((meta & MetaKeyKeyListener.META_CAP_LOCKED) != 0) {
|
||
|
|
meta |= KeyEvent.META_SHIFT_ON;
|
||
|
|
}
|
||
|
|
if ((meta & MetaKeyKeyListener.META_ALT_LOCKED) != 0) {
|
||
|
|
meta |= KeyEvent.META_ALT_ON;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Ignore caps lock on keys where alt and shift have the same effect.
|
||
|
|
if ((meta & MetaKeyKeyListener.META_CAP_LOCKED) != 0) {
|
||
|
|
if (get_native(mPointer, keyCode, KeyEvent.META_SHIFT_ON) ==
|
||
|
|
get_native(mPointer, keyCode, KeyEvent.META_ALT_ON)) {
|
||
|
|
meta &= ~KeyEvent.META_SHIFT_ON;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
int ret = get_native(mPointer, keyCode, meta);
|
||
|
|
int map = COMBINING.get(ret);
|
||
|
|
|
||
|
|
if (map != 0) {
|
||
|
|
return map;
|
||
|
|
} else {
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Gets the number or symbol associated with the key. The character value
|
||
|
|
* is returned, not the numeric value. If the key is not a number, but is
|
||
|
|
* a symbol, the symbol is retuned.
|
||
|
|
*/
|
||
|
|
public char getNumber(int keyCode)
|
||
|
|
{
|
||
|
|
return getNumber_native(mPointer, keyCode);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* The same as {@link #getMatch(int,char[],int) getMatch(keyCode, chars, 0)}.
|
||
|
|
*/
|
||
|
|
public char getMatch(int keyCode, char[] chars)
|
||
|
|
{
|
||
|
|
return getMatch(keyCode, chars, 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* If one of the chars in the array can be generated by keyCode,
|
||
|
|
* return the char; otherwise return '\0'.
|
||
|
|
* @param keyCode the key code to look at
|
||
|
|
* @param chars the characters to try to find
|
||
|
|
* @param modifiers the modifier bits to prefer. If any of these bits
|
||
|
|
* are set, if there are multiple choices, that could
|
||
|
|
* work, the one for this modifier will be set.
|
||
|
|
*/
|
||
|
|
public char getMatch(int keyCode, char[] chars, int modifiers)
|
||
|
|
{
|
||
|
|
if (chars == null) {
|
||
|
|
// catch it here instead of in native
|
||
|
|
throw new NullPointerException();
|
||
|
|
}
|
||
|
|
return getMatch_native(mPointer, keyCode, chars, modifiers);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Get the primary character for this key. In other words, the label
|
||
|
|
* that is physically printed on it.
|
||
|
|
*/
|
||
|
|
public char getDisplayLabel(int keyCode)
|
||
|
|
{
|
||
|
|
return getDisplayLabel_native(mPointer, keyCode);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Get the character that is produced by putting accent on the character
|
||
|
|
* c.
|
||
|
|
* For example, getDeadChar('`', 'e') returns è.
|
||
|
|
*/
|
||
|
|
public static int getDeadChar(int accent, int c)
|
||
|
|
{
|
||
|
|
return DEAD.get((accent << 16) | c);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static class KeyData {
|
||
|
|
public static final int META_LENGTH = 4;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* The display label (see {@link #getDisplayLabel}).
|
||
|
|
*/
|
||
|
|
public char displayLabel;
|
||
|
|
/**
|
||
|
|
* The "number" value (see {@link #getNumber}).
|
||
|
|
*/
|
||
|
|
public char number;
|
||
|
|
/**
|
||
|
|
* The character that will be generated in various meta states
|
||
|
|
* (the same ones used for {@link #get} and defined as
|
||
|
|
* {@link KeyEvent#META_SHIFT_ON} and {@link KeyEvent#META_ALT_ON}).
|
||
|
|
* <table>
|
||
|
|
* <tr><th>Index</th><th align="left">Value</th></tr>
|
||
|
|
* <tr><td>0</td><td>no modifiers</td></tr>
|
||
|
|
* <tr><td>1</td><td>caps</td></tr>
|
||
|
|
* <tr><td>2</td><td>alt</td></tr>
|
||
|
|
* <tr><td>3</td><td>caps + alt</td></tr>
|
||
|
|
* </table>
|
||
|
|
*/
|
||
|
|
public char[] meta = new char[META_LENGTH];
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Get the characters conversion data for a given keyCode.
|
||
|
|
*
|
||
|
|
* @param keyCode the keyCode to look for
|
||
|
|
* @param results a {@link KeyData} that will be filled with the results.
|
||
|
|
*
|
||
|
|
* @return whether the key was mapped or not. If the key was not mapped,
|
||
|
|
* results is not modified.
|
||
|
|
*/
|
||
|
|
public boolean getKeyData(int keyCode, KeyData results)
|
||
|
|
{
|
||
|
|
if (results.meta.length >= KeyData.META_LENGTH) {
|
||
|
|
return getKeyData_native(mPointer, keyCode, results);
|
||
|
|
} else {
|
||
|
|
throw new IndexOutOfBoundsException("results.meta.length must be >= " +
|
||
|
|
KeyData.META_LENGTH);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Get an array of KeyEvent objects that if put into the input stream
|
||
|
|
* could plausibly generate the provided sequence of characters. It is
|
||
|
|
* not guaranteed that the sequence is the only way to generate these
|
||
|
|
* events or that it is optimal.
|
||
|
|
*
|
||
|
|
* @return an array of KeyEvent objects, or null if the given char array
|
||
|
|
* can not be generated using the current key character map.
|
||
|
|
*/
|
||
|
|
public KeyEvent[] getEvents(char[] chars)
|
||
|
|
{
|
||
|
|
if (chars == null) {
|
||
|
|
throw new NullPointerException();
|
||
|
|
}
|
||
|
|
|
||
|
|
long[] keys = getEvents_native(mPointer, chars);
|
||
|
|
if (keys == null) {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
|
||
|
|
// how big should the array be
|
||
|
|
int len = keys.length*2;
|
||
|
|
int N = keys.length;
|
||
|
|
for (int i=0; i<N; i++) {
|
||
|
|
int mods = (int)(keys[i] >> 32);
|
||
|
|
if ((mods & KeyEvent.META_ALT_ON) != 0) {
|
||
|
|
len += 2;
|
||
|
|
}
|
||
|
|
if ((mods & KeyEvent.META_SHIFT_ON) != 0) {
|
||
|
|
len += 2;
|
||
|
|
}
|
||
|
|
if ((mods & KeyEvent.META_SYM_ON) != 0) {
|
||
|
|
len += 2;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// create the events
|
||
|
|
KeyEvent[] rv = new KeyEvent[len];
|
||
|
|
int index = 0;
|
||
|
|
long now = SystemClock.uptimeMillis();
|
||
|
|
int device = mKeyboardDevice;
|
||
|
|
for (int i=0; i<N; i++) {
|
||
|
|
int mods = (int)(keys[i] >> 32);
|
||
|
|
int meta = 0;
|
||
|
|
|
||
|
|
if ((mods & KeyEvent.META_ALT_ON) != 0) {
|
||
|
|
meta |= KeyEvent.META_ALT_ON;
|
||
|
|
rv[index] = new KeyEvent(now, now, KeyEvent.ACTION_DOWN,
|
||
|
|
KeyEvent.KEYCODE_ALT_LEFT, 0, meta, device, 0);
|
||
|
|
index++;
|
||
|
|
}
|
||
|
|
if ((mods & KeyEvent.META_SHIFT_ON) != 0) {
|
||
|
|
meta |= KeyEvent.META_SHIFT_ON;
|
||
|
|
rv[index] = new KeyEvent(now, now, KeyEvent.ACTION_DOWN,
|
||
|
|
KeyEvent.KEYCODE_SHIFT_LEFT, 0, meta, device, 0);
|
||
|
|
index++;
|
||
|
|
}
|
||
|
|
if ((mods & KeyEvent.META_SYM_ON) != 0) {
|
||
|
|
meta |= KeyEvent.META_SYM_ON;
|
||
|
|
rv[index] = new KeyEvent(now, now, KeyEvent.ACTION_DOWN,
|
||
|
|
KeyEvent.KEYCODE_SYM, 0, meta, device, 0);
|
||
|
|
index++;
|
||
|
|
}
|
||
|
|
|
||
|
|
int key = (int)(keys[i]);
|
||
|
|
rv[index] = new KeyEvent(now, now, KeyEvent.ACTION_DOWN,
|
||
|
|
key, 0, meta, device, 0);
|
||
|
|
index++;
|
||
|
|
rv[index] = new KeyEvent(now, now, KeyEvent.ACTION_UP,
|
||
|
|
key, 0, meta, device, 0);
|
||
|
|
index++;
|
||
|
|
|
||
|
|
if ((mods & KeyEvent.META_ALT_ON) != 0) {
|
||
|
|
meta &= ~KeyEvent.META_ALT_ON;
|
||
|
|
rv[index] = new KeyEvent(now, now, KeyEvent.ACTION_UP,
|
||
|
|
KeyEvent.KEYCODE_ALT_LEFT, 0, meta, device, 0);
|
||
|
|
index++;
|
||
|
|
}
|
||
|
|
if ((mods & KeyEvent.META_SHIFT_ON) != 0) {
|
||
|
|
meta &= ~KeyEvent.META_SHIFT_ON;
|
||
|
|
rv[index] = new KeyEvent(now, now, KeyEvent.ACTION_UP,
|
||
|
|
KeyEvent.KEYCODE_SHIFT_LEFT, 0, meta, device, 0);
|
||
|
|
index++;
|
||
|
|
}
|
||
|
|
if ((mods & KeyEvent.META_SYM_ON) != 0) {
|
||
|
|
meta &= ~KeyEvent.META_SYM_ON;
|
||
|
|
rv[index] = new KeyEvent(now, now, KeyEvent.ACTION_UP,
|
||
|
|
KeyEvent.KEYCODE_SYM, 0, meta, device, 0);
|
||
|
|
index++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return rv;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Does this character key produce a glyph?
|
||
|
|
*/
|
||
|
|
public boolean isPrintingKey(int keyCode)
|
||
|
|
{
|
||
|
|
int type = Character.getType(get(keyCode, 0));
|
||
|
|
|
||
|
|
switch (type)
|
||
|
|
{
|
||
|
|
case Character.SPACE_SEPARATOR:
|
||
|
|
case Character.LINE_SEPARATOR:
|
||
|
|
case Character.PARAGRAPH_SEPARATOR:
|
||
|
|
case Character.CONTROL:
|
||
|
|
case Character.FORMAT:
|
||
|
|
return false;
|
||
|
|
default:
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
protected void finalize() throws Throwable
|
||
|
|
{
|
||
|
|
dtor_native(mPointer);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns {@link #NUMERIC}, {@link #PREDICTIVE} or {@link #ALPHA}.
|
||
|
|
*/
|
||
|
|
public int getKeyboardType()
|
||
|
|
{
|
||
|
|
return getKeyboardType_native(mPointer);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Queries the framework about whether any physical keys exist on the
|
||
|
|
* device that are capable of producing the given key codes.
|
||
|
|
*/
|
||
|
|
public static boolean deviceHasKey(int keyCode) {
|
||
|
|
int[] codeArray = new int[1];
|
||
|
|
codeArray[0] = keyCode;
|
||
|
|
boolean[] ret = deviceHasKeys(codeArray);
|
||
|
|
return ret[0];
|
||
|
|
}
|
||
|
|
|
||
|
|
public static boolean[] deviceHasKeys(int[] keyCodes) {
|
||
|
|
boolean[] ret = new boolean[keyCodes.length];
|
||
|
|
IWindowManager wm = IWindowManager.Stub.asInterface(ServiceManager.getService("window"));
|
||
|
|
try {
|
||
|
|
wm.hasKeys(keyCodes, ret);
|
||
|
|
} catch (RemoteException e) {
|
||
|
|
// no fallback; just return the empty array
|
||
|
|
}
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
|
||
|
|
private int mPointer;
|
||
|
|
private int mKeyboardDevice;
|
||
|
|
|
||
|
|
private static native int ctor_native(int id);
|
||
|
|
private static native void dtor_native(int ptr);
|
||
|
|
private static native char get_native(int ptr, int keycode,
|
||
|
|
int meta);
|
||
|
|
private static native char getNumber_native(int ptr, int keycode);
|
||
|
|
private static native char getMatch_native(int ptr, int keycode,
|
||
|
|
char[] chars, int modifiers);
|
||
|
|
private static native char getDisplayLabel_native(int ptr, int keycode);
|
||
|
|
private static native boolean getKeyData_native(int ptr, int keycode,
|
||
|
|
KeyData results);
|
||
|
|
private static native int getKeyboardType_native(int ptr);
|
||
|
|
private static native long[] getEvents_native(int ptr, char[] str);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Maps Unicode combining diacritical to display-form dead key
|
||
|
|
* (display character shifted left 16 bits).
|
||
|
|
*/
|
||
|
|
private static SparseIntArray COMBINING = new SparseIntArray();
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Maps combinations of (display-form) dead key and second character
|
||
|
|
* to combined output character.
|
||
|
|
*/
|
||
|
|
private static SparseIntArray DEAD = new SparseIntArray();
|
||
|
|
|
||
|
|
/*
|
||
|
|
* TODO: Change the table format to support full 21-bit-wide
|
||
|
|
* accent characters and combined characters if ever necessary.
|
||
|
|
*/
|
||
|
|
private static final int ACUTE = '\u00B4' << 16;
|
||
|
|
private static final int GRAVE = '`' << 16;
|
||
|
|
private static final int CIRCUMFLEX = '^' << 16;
|
||
|
|
private static final int TILDE = '~' << 16;
|
||
|
|
private static final int UMLAUT = '\u00A8' << 16;
|
||
|
|
|
||
|
|
/*
|
||
|
|
* This bit will be set in the return value of {@link #get(int, int)} if the
|
||
|
|
* key is a "dead key."
|
||
|
|
*/
|
||
|
|
public static final int COMBINING_ACCENT = 0x80000000;
|
||
|
|
/**
|
||
|
|
* Mask the return value from {@link #get(int, int)} with this value to get
|
||
|
|
* a printable representation of the accent character of a "dead key."
|
||
|
|
*/
|
||
|
|
public static final int COMBINING_ACCENT_MASK = 0x7FFFFFFF;
|
||
|
|
|
||
|
|
static {
|
||
|
|
COMBINING.put('\u0300', (GRAVE >> 16) | COMBINING_ACCENT);
|
||
|
|
COMBINING.put('\u0301', (ACUTE >> 16) | COMBINING_ACCENT);
|
||
|
|
COMBINING.put('\u0302', (CIRCUMFLEX >> 16) | COMBINING_ACCENT);
|
||
|
|
COMBINING.put('\u0303', (TILDE >> 16) | COMBINING_ACCENT);
|
||
|
|
COMBINING.put('\u0308', (UMLAUT >> 16) | COMBINING_ACCENT);
|
||
|
|
|
||
|
|
DEAD.put(ACUTE | 'A', '\u00C1');
|
||
|
|
DEAD.put(ACUTE | 'C', '\u0106');
|
||
|
|
DEAD.put(ACUTE | 'E', '\u00C9');
|
||
|
|
DEAD.put(ACUTE | 'G', '\u01F4');
|
||
|
|
DEAD.put(ACUTE | 'I', '\u00CD');
|
||
|
|
DEAD.put(ACUTE | 'K', '\u1E30');
|
||
|
|
DEAD.put(ACUTE | 'L', '\u0139');
|
||
|
|
DEAD.put(ACUTE | 'M', '\u1E3E');
|
||
|
|
DEAD.put(ACUTE | 'N', '\u0143');
|
||
|
|
DEAD.put(ACUTE | 'O', '\u00D3');
|
||
|
|
DEAD.put(ACUTE | 'P', '\u1E54');
|
||
|
|
DEAD.put(ACUTE | 'R', '\u0154');
|
||
|
|
DEAD.put(ACUTE | 'S', '\u015A');
|
||
|
|
DEAD.put(ACUTE | 'U', '\u00DA');
|
||
|
|
DEAD.put(ACUTE | 'W', '\u1E82');
|
||
|
|
DEAD.put(ACUTE | 'Y', '\u00DD');
|
||
|
|
DEAD.put(ACUTE | 'Z', '\u0179');
|
||
|
|
DEAD.put(ACUTE | 'a', '\u00E1');
|
||
|
|
DEAD.put(ACUTE | 'c', '\u0107');
|
||
|
|
DEAD.put(ACUTE | 'e', '\u00E9');
|
||
|
|
DEAD.put(ACUTE | 'g', '\u01F5');
|
||
|
|
DEAD.put(ACUTE | 'i', '\u00ED');
|
||
|
|
DEAD.put(ACUTE | 'k', '\u1E31');
|
||
|
|
DEAD.put(ACUTE | 'l', '\u013A');
|
||
|
|
DEAD.put(ACUTE | 'm', '\u1E3F');
|
||
|
|
DEAD.put(ACUTE | 'n', '\u0144');
|
||
|
|
DEAD.put(ACUTE | 'o', '\u00F3');
|
||
|
|
DEAD.put(ACUTE | 'p', '\u1E55');
|
||
|
|
DEAD.put(ACUTE | 'r', '\u0155');
|
||
|
|
DEAD.put(ACUTE | 's', '\u015B');
|
||
|
|
DEAD.put(ACUTE | 'u', '\u00FA');
|
||
|
|
DEAD.put(ACUTE | 'w', '\u1E83');
|
||
|
|
DEAD.put(ACUTE | 'y', '\u00FD');
|
||
|
|
DEAD.put(ACUTE | 'z', '\u017A');
|
||
|
|
DEAD.put(CIRCUMFLEX | 'A', '\u00C2');
|
||
|
|
DEAD.put(CIRCUMFLEX | 'C', '\u0108');
|
||
|
|
DEAD.put(CIRCUMFLEX | 'E', '\u00CA');
|
||
|
|
DEAD.put(CIRCUMFLEX | 'G', '\u011C');
|
||
|
|
DEAD.put(CIRCUMFLEX | 'H', '\u0124');
|
||
|
|
DEAD.put(CIRCUMFLEX | 'I', '\u00CE');
|
||
|
|
DEAD.put(CIRCUMFLEX | 'J', '\u0134');
|
||
|
|
DEAD.put(CIRCUMFLEX | 'O', '\u00D4');
|
||
|
|
DEAD.put(CIRCUMFLEX | 'S', '\u015C');
|
||
|
|
DEAD.put(CIRCUMFLEX | 'U', '\u00DB');
|
||
|
|
DEAD.put(CIRCUMFLEX | 'W', '\u0174');
|
||
|
|
DEAD.put(CIRCUMFLEX | 'Y', '\u0176');
|
||
|
|
DEAD.put(CIRCUMFLEX | 'Z', '\u1E90');
|
||
|
|
DEAD.put(CIRCUMFLEX | 'a', '\u00E2');
|
||
|
|
DEAD.put(CIRCUMFLEX | 'c', '\u0109');
|
||
|
|
DEAD.put(CIRCUMFLEX | 'e', '\u00EA');
|
||
|
|
DEAD.put(CIRCUMFLEX | 'g', '\u011D');
|
||
|
|
DEAD.put(CIRCUMFLEX | 'h', '\u0125');
|
||
|
|
DEAD.put(CIRCUMFLEX | 'i', '\u00EE');
|
||
|
|
DEAD.put(CIRCUMFLEX | 'j', '\u0135');
|
||
|
|
DEAD.put(CIRCUMFLEX | 'o', '\u00F4');
|
||
|
|
DEAD.put(CIRCUMFLEX | 's', '\u015D');
|
||
|
|
DEAD.put(CIRCUMFLEX | 'u', '\u00FB');
|
||
|
|
DEAD.put(CIRCUMFLEX | 'w', '\u0175');
|
||
|
|
DEAD.put(CIRCUMFLEX | 'y', '\u0177');
|
||
|
|
DEAD.put(CIRCUMFLEX | 'z', '\u1E91');
|
||
|
|
DEAD.put(GRAVE | 'A', '\u00C0');
|
||
|
|
DEAD.put(GRAVE | 'E', '\u00C8');
|
||
|
|
DEAD.put(GRAVE | 'I', '\u00CC');
|
||
|
|
DEAD.put(GRAVE | 'N', '\u01F8');
|
||
|
|
DEAD.put(GRAVE | 'O', '\u00D2');
|
||
|
|
DEAD.put(GRAVE | 'U', '\u00D9');
|
||
|
|
DEAD.put(GRAVE | 'W', '\u1E80');
|
||
|
|
DEAD.put(GRAVE | 'Y', '\u1EF2');
|
||
|
|
DEAD.put(GRAVE | 'a', '\u00E0');
|
||
|
|
DEAD.put(GRAVE | 'e', '\u00E8');
|
||
|
|
DEAD.put(GRAVE | 'i', '\u00EC');
|
||
|
|
DEAD.put(GRAVE | 'n', '\u01F9');
|
||
|
|
DEAD.put(GRAVE | 'o', '\u00F2');
|
||
|
|
DEAD.put(GRAVE | 'u', '\u00F9');
|
||
|
|
DEAD.put(GRAVE | 'w', '\u1E81');
|
||
|
|
DEAD.put(GRAVE | 'y', '\u1EF3');
|
||
|
|
DEAD.put(TILDE | 'A', '\u00C3');
|
||
|
|
DEAD.put(TILDE | 'E', '\u1EBC');
|
||
|
|
DEAD.put(TILDE | 'I', '\u0128');
|
||
|
|
DEAD.put(TILDE | 'N', '\u00D1');
|
||
|
|
DEAD.put(TILDE | 'O', '\u00D5');
|
||
|
|
DEAD.put(TILDE | 'U', '\u0168');
|
||
|
|
DEAD.put(TILDE | 'V', '\u1E7C');
|
||
|
|
DEAD.put(TILDE | 'Y', '\u1EF8');
|
||
|
|
DEAD.put(TILDE | 'a', '\u00E3');
|
||
|
|
DEAD.put(TILDE | 'e', '\u1EBD');
|
||
|
|
DEAD.put(TILDE | 'i', '\u0129');
|
||
|
|
DEAD.put(TILDE | 'n', '\u00F1');
|
||
|
|
DEAD.put(TILDE | 'o', '\u00F5');
|
||
|
|
DEAD.put(TILDE | 'u', '\u0169');
|
||
|
|
DEAD.put(TILDE | 'v', '\u1E7D');
|
||
|
|
DEAD.put(TILDE | 'y', '\u1EF9');
|
||
|
|
DEAD.put(UMLAUT | 'A', '\u00C4');
|
||
|
|
DEAD.put(UMLAUT | 'E', '\u00CB');
|
||
|
|
DEAD.put(UMLAUT | 'H', '\u1E26');
|
||
|
|
DEAD.put(UMLAUT | 'I', '\u00CF');
|
||
|
|
DEAD.put(UMLAUT | 'O', '\u00D6');
|
||
|
|
DEAD.put(UMLAUT | 'U', '\u00DC');
|
||
|
|
DEAD.put(UMLAUT | 'W', '\u1E84');
|
||
|
|
DEAD.put(UMLAUT | 'X', '\u1E8C');
|
||
|
|
DEAD.put(UMLAUT | 'Y', '\u0178');
|
||
|
|
DEAD.put(UMLAUT | 'a', '\u00E4');
|
||
|
|
DEAD.put(UMLAUT | 'e', '\u00EB');
|
||
|
|
DEAD.put(UMLAUT | 'h', '\u1E27');
|
||
|
|
DEAD.put(UMLAUT | 'i', '\u00EF');
|
||
|
|
DEAD.put(UMLAUT | 'o', '\u00F6');
|
||
|
|
DEAD.put(UMLAUT | 't', '\u1E97');
|
||
|
|
DEAD.put(UMLAUT | 'u', '\u00FC');
|
||
|
|
DEAD.put(UMLAUT | 'w', '\u1E85');
|
||
|
|
DEAD.put(UMLAUT | 'x', '\u1E8D');
|
||
|
|
DEAD.put(UMLAUT | 'y', '\u00FF');
|
||
|
|
}
|
||
|
|
}
|