extern/Unexpected-Keyboard
1
0
Fork 1
mirror of https://github.com/Julow/Unexpected-Keyboard.git synced 2025-06-26 12:41:43 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity

Refactor: Separate Events and Keyevents and use enums

Browse Source 
Negative values for internal events are preventing further refactoring.

Add a new kind of key and split internal events (now Event) and
Android's key events (now Keyevent).

Use enums events and modifiers outside of the KeyValue class.
Internally, they are converted to and from integer.
This commit is contained in:
Jules Aguillon 2022-06-05 19:30:53 +02:00
parent cc571ea1ca
commit 5cc7fdf6d7
6 changed files with 209 additions and 199 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
srcs/juloo.keyboard2/Config.java
View File

@ -36,7 +36,7 @@ final class Config
public float keyVerticalInterval; public float keyVerticalInterval;
public float keyHorizontalInterval; public float keyHorizontalInterval;
public boolean preciseRepeat; public boolean preciseRepeat;
public Set<Integer> lockable_modifiers = new HashSet<Integer>(); public Set<KeyValue.Modifier> lockable_modifiers = new HashSet<KeyValue.Modifier>();
public float characterSize; // Ratio public float characterSize; // Ratio
public int accents; // Values are R.values.pref_accents_v_* public int accents; // Values are R.values.pref_accents_v_*
public int theme; // Values are R.style.* public int theme; // Values are R.style.*
@ -128,14 +128,14 @@ final class Config
horizontalMargin = getDipPref(dm, prefs, "horizontal_margin", horizontalMargin) + res.getDimension(R.dimen.extra_horizontal_margin); horizontalMargin = getDipPref(dm, prefs, "horizontal_margin", horizontalMargin) + res.getDimension(R.dimen.extra_horizontal_margin);
preciseRepeat = prefs.getBoolean("precise_repeat", preciseRepeat); preciseRepeat = prefs.getBoolean("precise_repeat", preciseRepeat);
lockable_modifiers.clear(); lockable_modifiers.clear();
if (prefs.getBoolean("lockable_shift", true)) lockable_modifiers.add(KeyValue.MOD_SHIFT); if (prefs.getBoolean("lockable_shift", true)) lockable_modifiers.add(KeyValue.Modifier.SHIFT);
if (prefs.getBoolean("lockable_ctrl", false)) lockable_modifiers.add(KeyValue.MOD_CTRL); if (prefs.getBoolean("lockable_ctrl", false)) lockable_modifiers.add(KeyValue.Modifier.CTRL);
if (prefs.getBoolean("lockable_alt", false)) lockable_modifiers.add(KeyValue.MOD_ALT); if (prefs.getBoolean("lockable_alt", false)) lockable_modifiers.add(KeyValue.Modifier.ALT);
if (prefs.getBoolean("lockable_fn", false)) lockable_modifiers.add(KeyValue.MOD_FN); if (prefs.getBoolean("lockable_fn", false)) lockable_modifiers.add(KeyValue.Modifier.FN);
if (prefs.getBoolean("lockable_meta", false)) lockable_modifiers.add(KeyValue.MOD_META); if (prefs.getBoolean("lockable_meta", false)) lockable_modifiers.add(KeyValue.Modifier.META);
if (prefs.getBoolean("lockable_sup", false)) lockable_modifiers.add(KeyValue.MOD_SUPERSCRIPT); if (prefs.getBoolean("lockable_sup", false)) lockable_modifiers.add(KeyValue.Modifier.SUPERSCRIPT);
if (prefs.getBoolean("lockable_sub", false)) lockable_modifiers.add(KeyValue.MOD_SUBSCRIPT); if (prefs.getBoolean("lockable_sub", false)) lockable_modifiers.add(KeyValue.Modifier.SUBSCRIPT);
if (prefs.getBoolean("lockable_box", false)) lockable_modifiers.add(KeyValue.MOD_BOX); if (prefs.getBoolean("lockable_box", false)) lockable_modifiers.add(KeyValue.Modifier.BOX);
characterSize = prefs.getFloat("character_size", characterSize); characterSize = prefs.getFloat("character_size", characterSize);
accents = Integer.valueOf(prefs.getString("accents", "1")); accents = Integer.valueOf(prefs.getString("accents", "1"));
theme = getThemeId(res, prefs.getString("theme", "")); theme = getThemeId(res, prefs.getString("theme", ""));
@ -171,17 +171,22 @@ final class Config
case Event: case Event:
switch (key.getEvent()) switch (key.getEvent())
{ {
case KeyValue.EVENT_CHANGE_METHOD: case CHANGE_METHOD:
return shouldOfferSwitchingToNextInputMethod ? key : null; return shouldOfferSwitchingToNextInputMethod ? key : null;
case KeyEvent.KEYCODE_ENTER: case ACTION:
return (swapEnterActionKey && action_key != null) ? action_key : key;
case KeyValue.EVENT_ACTION:
return (swapEnterActionKey && action_key != null) ? return (swapEnterActionKey && action_key != null) ?
KeyValue.getKeyByName("enter") : action_key; KeyValue.getKeyByName("enter") : action_key;
case KeyValue.EVENT_SWITCH_PROGRAMMING: case SWITCH_PROGRAMMING:
return shouldOfferSwitchingToProgramming ? key : null; return shouldOfferSwitchingToProgramming ? key : null;
} }
break; break;
case Keyevent:
switch (key.getKeyevent())
{
case KeyEvent.KEYCODE_ENTER:
return (swapEnterActionKey && action_key != null) ? action_key : key;
}
break;
case Modifier: case Modifier:
if (lockable_modifiers.contains(key.getModifier())) if (lockable_modifiers.contains(key.getModifier()))
return key.withFlags(flags | KeyValue.FLAG_LOCK); return key.withFlags(flags | KeyValue.FLAG_LOCK);

36
srcs/juloo.keyboard2/KeyEventHandler.java
View File

@ -15,7 +15,6 @@ class KeyEventHandler implements Config.IKeyEventHandler
{ {
if (key == null) if (key == null)
return; return;
int event;
switch (key.getKind()) switch (key.getKind())
{ {
case Char: case Char:
@ -25,22 +24,21 @@ class KeyEventHandler implements Config.IKeyEventHandler
_recv.commitText(key.getString()); _recv.commitText(key.getString());
break; break;
case Event: case Event:
event = key.getEvent(); switch (key.getEvent())
switch (event)
{ {
case KeyValue.EVENT_CONFIG: _recv.showKeyboardConfig(); break; case CONFIG: _recv.showKeyboardConfig(); break;
case KeyValue.EVENT_SWITCH_TEXT: _recv.switchMain(); break; case SWITCH_TEXT: _recv.switchMain(); break;
case KeyValue.EVENT_SWITCH_NUMERIC: _recv.switchNumeric(); break; case SWITCH_NUMERIC: _recv.switchNumeric(); break;
case KeyValue.EVENT_SWITCH_EMOJI: _recv.setPane_emoji(); break; case SWITCH_EMOJI: _recv.setPane_emoji(); break;
case KeyValue.EVENT_SWITCH_BACK_EMOJI: _recv.setPane_normal(); break; case SWITCH_BACK_EMOJI: _recv.setPane_normal(); break;
case KeyValue.EVENT_CHANGE_METHOD: _recv.switchToNextInputMethod(); break; case CHANGE_METHOD: _recv.switchToNextInputMethod(); break;
case KeyValue.EVENT_ACTION: _recv.performAction(); break; case ACTION: _recv.performAction(); break;
case KeyValue.EVENT_SWITCH_PROGRAMMING: _recv.switchProgramming(); break; case SWITCH_PROGRAMMING: _recv.switchProgramming(); break;
default:
handleKeyUpWithModifier(event, mods);
break;
} }
break; break;
case Keyevent:
handleKeyUpWithModifier(key.getKeyevent(), mods);
break;
case Modifier: case Modifier:
break; break;
} }
@ -66,17 +64,17 @@ class KeyEventHandler implements Config.IKeyEventHandler
return updatedMetaState; return updatedMetaState;
} }
private int sendMetaKeyForModifier(int mod, int metaState, boolean down) private int sendMetaKeyForModifier(KeyValue.Modifier mod, int metaState, boolean down)
{ {
switch (mod) switch (mod)
{ {
case KeyValue.MOD_CTRL: case CTRL:
return sendMetaKey(KeyEvent.KEYCODE_CTRL_LEFT, KeyEvent.META_CTRL_LEFT_ON | KeyEvent.META_CTRL_ON, metaState, down); return sendMetaKey(KeyEvent.KEYCODE_CTRL_LEFT, KeyEvent.META_CTRL_LEFT_ON | KeyEvent.META_CTRL_ON, metaState, down);
case KeyValue.MOD_ALT: case ALT:
return sendMetaKey(KeyEvent.KEYCODE_ALT_LEFT, KeyEvent.META_ALT_LEFT_ON | KeyEvent.META_ALT_ON, metaState, down); return sendMetaKey(KeyEvent.KEYCODE_ALT_LEFT, KeyEvent.META_ALT_LEFT_ON | KeyEvent.META_ALT_ON, metaState, down);
case KeyValue.MOD_SHIFT: case SHIFT:
return sendMetaKey(KeyEvent.KEYCODE_SHIFT_LEFT, KeyEvent.META_SHIFT_LEFT_ON | KeyEvent.META_SHIFT_ON, metaState, down); return sendMetaKey(KeyEvent.KEYCODE_SHIFT_LEFT, KeyEvent.META_SHIFT_LEFT_ON | KeyEvent.META_SHIFT_ON, metaState, down);
case KeyValue.MOD_META: case META:
return sendMetaKey(KeyEvent.KEYCODE_META_LEFT, KeyEvent.META_META_LEFT_ON | KeyEvent.META_META_ON, metaState, down); return sendMetaKey(KeyEvent.KEYCODE_META_LEFT, KeyEvent.META_META_LEFT_ON | KeyEvent.META_META_ON, metaState, down);
default: return metaState; default: return metaState;
} }

52
srcs/juloo.keyboard2/KeyModifier.java
View File

@ -33,34 +33,34 @@ class KeyModifier
return (r == removed_key) ? null : r; return (r == removed_key) ? null : r;
} }
public static KeyValue modify(KeyValue k, int mod) public static KeyValue modify(KeyValue k, KeyValue.Modifier mod)
{ {
switch (mod) switch (mod)
{ {
case KeyValue.MOD_CTRL: case CTRL:
case KeyValue.MOD_ALT: case ALT:
case KeyValue.MOD_META: return turn_into_keyevent(k); case META: return turn_into_keyevent(k);
case KeyValue.MOD_FN: return apply_fn(k); case FN: return apply_fn(k);
case KeyValue.MOD_SHIFT: return apply_shift(k); case SHIFT: return apply_shift(k);
case KeyValue.MOD_GRAVE: return apply_dead_char(k, '\u02CB'); case GRAVE: return apply_dead_char(k, '\u02CB');
case KeyValue.MOD_AIGU: return apply_dead_char(k, '\u00B4'); case AIGU: return apply_dead_char(k, '\u00B4');
case KeyValue.MOD_CIRCONFLEXE: return apply_dead_char(k, '\u02C6'); case CIRCONFLEXE: return apply_dead_char(k, '\u02C6');
case KeyValue.MOD_TILDE: return apply_dead_char(k, '\u02DC'); case TILDE: return apply_dead_char(k, '\u02DC');
case KeyValue.MOD_CEDILLE: return apply_dead_char(k, '\u00B8'); case CEDILLE: return apply_dead_char(k, '\u00B8');
case KeyValue.MOD_TREMA: return apply_dead_char(k, '\u00A8'); case TREMA: return apply_dead_char(k, '\u00A8');
case KeyValue.MOD_CARON: return apply_dead_char(k, '\u02C7'); case CARON: return apply_dead_char(k, '\u02C7');
case KeyValue.MOD_RING: return apply_dead_char(k, '\u02DA'); case RING: return apply_dead_char(k, '\u02DA');
case KeyValue.MOD_MACRON: return apply_dead_char(k, '\u00AF'); case MACRON: return apply_dead_char(k, '\u00AF');
case KeyValue.MOD_OGONEK: return apply_dead_char(k, '\u02DB'); case OGONEK: return apply_dead_char(k, '\u02DB');
case KeyValue.MOD_DOT_ABOVE: return apply_dead_char(k, '\u02D9'); case DOT_ABOVE: return apply_dead_char(k, '\u02D9');
case KeyValue.MOD_DOUBLE_AIGU: return apply_map_char(k, map_char_double_aigu); case DOUBLE_AIGU: return apply_map_char(k, map_char_double_aigu);
case KeyValue.MOD_ORDINAL: return apply_map_char(k, map_char_ordinal); case ORDINAL: return apply_map_char(k, map_char_ordinal);
case KeyValue.MOD_SUPERSCRIPT: return apply_map_char(k, map_char_superscript); case SUPERSCRIPT: return apply_map_char(k, map_char_superscript);
case KeyValue.MOD_SUBSCRIPT: return apply_map_char(k, map_char_subscript); case SUBSCRIPT: return apply_map_char(k, map_char_subscript);
case KeyValue.MOD_ARROWS: return apply_map_char(k, map_char_arrows); case ARROWS: return apply_map_char(k, map_char_arrows);
case KeyValue.MOD_BOX: return apply_map_char(k, map_char_box); case BOX: return apply_map_char(k, map_char_box);
case KeyValue.MOD_SLASH: return apply_map_char(k, map_char_slash); case SLASH: return apply_map_char(k, map_char_slash);
case KeyValue.MOD_ARROW_RIGHT: return apply_combining(k, "\u20D7"); case ARROW_RIGHT: return apply_combining(k, "\u20D7");
default: return k; default: return k;
} }
} }
@ -246,7 +246,7 @@ class KeyModifier
case ' ': e = KeyEvent.KEYCODE_SPACE; break; case ' ': e = KeyEvent.KEYCODE_SPACE; break;
default: return k; default: return k;
} }
return k.withEvent(e); return k.withKeyevent(e);
} }
/** Remove placeholder keys that haven't been modified into something. */ /** Remove placeholder keys that haven't been modified into something. */

243
srcs/juloo.keyboard2/KeyValue.java
View File

@ -6,45 +6,46 @@ import java.util.HashMap;
class KeyValue class KeyValue
{ {
/** Values for the [code] field. */ public static enum Event
{
CONFIG,
SWITCH_TEXT,
SWITCH_NUMERIC,
SWITCH_EMOJI,
SWITCH_BACK_EMOJI,
CHANGE_METHOD,
ACTION,
SWITCH_PROGRAMMING
}
public static final int EVENT_CONFIG = -2;
public static final int EVENT_SWITCH_TEXT = -3;
public static final int EVENT_SWITCH_NUMERIC = -4;
public static final int EVENT_SWITCH_EMOJI = -5;
public static final int EVENT_SWITCH_BACK_EMOJI = -6;
public static final int EVENT_CHANGE_METHOD = -7;
public static final int EVENT_ACTION = -8;
public static final int EVENT_SWITCH_PROGRAMMING = -9;
// Modifiers
// Must be evaluated in the reverse order of their values. // Must be evaluated in the reverse order of their values.
public static final int MOD_SHIFT = -100; public static enum Modifier
public static final int MOD_FN = -101; {
public static final int MOD_CTRL = -102; SHIFT,
public static final int MOD_ALT = -103; FN,
public static final int MOD_META = -104; CTRL,
ALT,
// Dead-keys META,
public static final int MOD_DOUBLE_AIGU = -200; DOUBLE_AIGU,
public static final int MOD_DOT_ABOVE = -201; DOT_ABOVE,
public static final int MOD_GRAVE = -202; GRAVE,
public static final int MOD_AIGU = -203; AIGU,
public static final int MOD_CIRCONFLEXE = -204; CIRCONFLEXE,
public static final int MOD_TILDE = -205; TILDE,
public static final int MOD_CEDILLE = -206; CEDILLE,
public static final int MOD_TREMA = -207; TREMA,
public static final int MOD_SUPERSCRIPT = -208; SUPERSCRIPT,
public static final int MOD_SUBSCRIPT = -209; SUBSCRIPT,
public static final int MOD_RING = -210; RING,
public static final int MOD_CARON = -211; CARON,
public static final int MOD_MACRON = -212; MACRON,
public static final int MOD_ORDINAL = -213; ORDINAL,
public static final int MOD_ARROWS = -214; ARROWS,
public static final int MOD_BOX = -215; BOX,
public static final int MOD_OGONEK = -216; OGONEK,
public static final int MOD_SLASH = -217; SLASH,
public static final int MOD_ARROW_RIGHT = -218; ARROW_RIGHT
}
// Behavior flags // Behavior flags
public static final int FLAG_LATCH = 1; public static final int FLAG_LATCH = 1;
@ -64,12 +65,13 @@ class KeyValue
public static final int FLAG_LOCALIZED = (1 << 8); public static final int FLAG_LOCALIZED = (1 << 8);
// Kind flags // Kind flags
public static final int KIND_CHAR = (0 << 30); public static final int KIND_CHAR = (0 << 29);
public static final int KIND_STRING = (1 << 30); public static final int KIND_STRING = (1 << 29);
public static final int KIND_EVENT = (2 << 30); public static final int KIND_KEYEVENT = (2 << 29);
public static final int KIND_MODIFIER = (3 << 30); public static final int KIND_EVENT = (3 << 29);
public static final int KIND_MODIFIER = (4 << 29);
public static final int KIND_FLAGS = (0b11 << 30); public static final int KIND_FLAGS = (0b111 << 29);
public final String name; public final String name;
private final String _symbol; private final String _symbol;
@ -82,7 +84,7 @@ class KeyValue
public static enum Kind public static enum Kind
{ {
Char, String, Event, Modifier Char, String, Keyevent, Event, Modifier
} }
public Kind getKind() public Kind getKind()
@ -91,6 +93,7 @@ class KeyValue
{ {
case KIND_CHAR: return Kind.Char; case KIND_CHAR: return Kind.Char;
case KIND_STRING: return Kind.String; case KIND_STRING: return Kind.String;
case KIND_KEYEVENT: return Kind.Keyevent;
case KIND_EVENT: return Kind.Event; case KIND_EVENT: return Kind.Event;
case KIND_MODIFIER: return Kind.Modifier; case KIND_MODIFIER: return Kind.Modifier;
default: throw new RuntimeException("Corrupted kind flags"); default: throw new RuntimeException("Corrupted kind flags");
@ -114,25 +117,28 @@ class KeyValue
return _symbol; return _symbol;
} }
/** The char to be sent when the key is pressed. /** Defined only when [getKind() == Kind.Char]. */
Defined only when [getKind() == Kind.Char]. */
public char getChar() public char getChar()
{ {
return (char)_code; return (char)_code;
} }
/** An Android event or one of the [EVENT_*] constants. /** Defined only when [getKind() == Kind.Keyevent]. */
Defined only when [getKind() == Kind.Event]. */ public int getKeyevent()
public int getEvent()
{ {
return _code; return _code;
} }
/** Modifier activated by this key. /** Defined only when [getKind() == Kind.Event]. */
Defined only when [getKind() == Kind.Modifier]. */ public Event getEvent()
public int getModifier()
{ {
return _code; return Event.values()[_code];
}
/** Defined only when [getKind() == Kind.Modifier]. */
public Modifier getModifier()
{
return Modifier.values()[_code];
} }
/* Update the char and the symbol. */ /* Update the char and the symbol. */
@ -151,9 +157,9 @@ class KeyValue
return new KeyValue(n, s, (_flags & KIND_FLAGS), _code, _flags); return new KeyValue(n, s, (_flags & KIND_FLAGS), _code, _flags);
} }
public KeyValue withEvent(int e) public KeyValue withKeyevent(int code)
{ {
return new KeyValue(name, _symbol, KIND_EVENT, e, _flags); return new KeyValue(name, _symbol, KIND_KEYEVENT, code, _flags);
} }
public KeyValue withFlags(int f) public KeyValue withFlags(int f)
@ -209,87 +215,86 @@ class KeyValue
addKey(name, symbol, KIND_CHAR, c, flags); addKey(name, symbol, KIND_CHAR, c, flags);
} }
private static void addModifierKey(String name, String symbol, int code, int extra_flags) private static void addModifierKey(String name, String symbol, Modifier m, int extra_flags)
{ {
assert(code >= 100 && code < 300); addKey(name, symbol, KIND_MODIFIER, m.ordinal(),
addKey(name, symbol, KIND_MODIFIER, code,
FLAG_LATCH | FLAG_SPECIAL | extra_flags); FLAG_LATCH | FLAG_SPECIAL | extra_flags);
} }
private static void addSpecialKey(String name, String symbol, int event, int flags) private static void addEventKey(String name, String symbol, Event e, int flags)
{ {
addKey(name, symbol, KIND_EVENT, event, flags | FLAG_SPECIAL); addKey(name, symbol, KIND_EVENT, e.ordinal(), flags | FLAG_SPECIAL);
} }
private static void addEventKey(String name, String symbol, int event, int flags) private static void addKeyeventKey(String name, String symbol, int code, int flags)
{ {
addKey(name, symbol, KIND_EVENT, event, flags); addKey(name, symbol, KIND_KEYEVENT, code, flags);
} }
static static
{ {
addModifierKey("shift", "\n", // Can't write u000A because Java is stupid addModifierKey("shift", "\n", // Can't write u000A because Java is stupid
MOD_SHIFT, FLAG_KEY_FONT | FLAG_SMALLER_FONT); Modifier.SHIFT, FLAG_KEY_FONT | FLAG_SMALLER_FONT);
addModifierKey("ctrl", "Ctrl", MOD_CTRL, FLAG_SMALLER_FONT); addModifierKey("ctrl", "Ctrl", Modifier.CTRL, FLAG_SMALLER_FONT);
addModifierKey("alt", "Alt", MOD_ALT, FLAG_SMALLER_FONT); addModifierKey("alt", "Alt", Modifier.ALT, FLAG_SMALLER_FONT);
addModifierKey("accent_aigu", "\u0050", MOD_AIGU, FLAG_KEY_FONT); addModifierKey("accent_aigu", "\u0050", Modifier.AIGU, FLAG_KEY_FONT);
addModifierKey("accent_caron", "\u0051", MOD_CARON, FLAG_KEY_FONT); addModifierKey("accent_caron", "\u0051", Modifier.CARON, FLAG_KEY_FONT);
addModifierKey("accent_cedille", "\u0052", MOD_CEDILLE, FLAG_KEY_FONT); addModifierKey("accent_cedille", "\u0052", Modifier.CEDILLE, FLAG_KEY_FONT);
addModifierKey("accent_circonflexe", "\u0053", MOD_CIRCONFLEXE, FLAG_KEY_FONT); addModifierKey("accent_circonflexe", "\u0053", Modifier.CIRCONFLEXE, FLAG_KEY_FONT);
addModifierKey("accent_grave", "\u0054", MOD_GRAVE, FLAG_KEY_FONT); addModifierKey("accent_grave", "\u0054", Modifier.GRAVE, FLAG_KEY_FONT);
addModifierKey("accent_macron", "\u0055", MOD_MACRON, FLAG_KEY_FONT); addModifierKey("accent_macron", "\u0055", Modifier.MACRON, FLAG_KEY_FONT);
addModifierKey("accent_ring", "\u0056", MOD_RING, FLAG_KEY_FONT); addModifierKey("accent_ring", "\u0056", Modifier.RING, FLAG_KEY_FONT);
addModifierKey("accent_tilde", "\u0057", MOD_TILDE, FLAG_KEY_FONT); addModifierKey("accent_tilde", "\u0057", Modifier.TILDE, FLAG_KEY_FONT);
addModifierKey("accent_trema", "\u0058", MOD_TREMA, FLAG_KEY_FONT); addModifierKey("accent_trema", "\u0058", Modifier.TREMA, FLAG_KEY_FONT);
addModifierKey("accent_ogonek", "\u0059", MOD_OGONEK, FLAG_KEY_FONT); addModifierKey("accent_ogonek", "\u0059", Modifier.OGONEK, FLAG_KEY_FONT);
addModifierKey("accent_dot_above", "\u005a", MOD_DOT_ABOVE, FLAG_KEY_FONT); addModifierKey("accent_dot_above", "\u005a", Modifier.DOT_ABOVE, FLAG_KEY_FONT);
addModifierKey("accent_double_aigu", "\u005b", MOD_DOUBLE_AIGU, FLAG_KEY_FONT); addModifierKey("accent_double_aigu", "\u005b", Modifier.DOUBLE_AIGU, FLAG_KEY_FONT);
addModifierKey("accent_slash", "\134", // Can't write u005c addModifierKey("accent_slash", "\134", // Can't write u005c
MOD_SLASH, FLAG_KEY_FONT); Modifier.SLASH, FLAG_KEY_FONT);
addModifierKey("accent_arrow_right", "\u005d", MOD_ARROW_RIGHT, FLAG_KEY_FONT); addModifierKey("accent_arrow_right", "\u005d", Modifier.ARROW_RIGHT, FLAG_KEY_FONT);
addModifierKey("superscript", "Sup", MOD_SUPERSCRIPT, FLAG_SMALLER_FONT); addModifierKey("superscript", "Sup", Modifier.SUPERSCRIPT, FLAG_SMALLER_FONT);
addModifierKey("subscript", "Sub", MOD_SUBSCRIPT, FLAG_SMALLER_FONT); addModifierKey("subscript", "Sub", Modifier.SUBSCRIPT, FLAG_SMALLER_FONT);
addModifierKey("ordinal", "Ord", MOD_ORDINAL, FLAG_SMALLER_FONT); addModifierKey("ordinal", "Ord", Modifier.ORDINAL, FLAG_SMALLER_FONT);
addModifierKey("arrows", "Arr", MOD_ARROWS, FLAG_SMALLER_FONT); addModifierKey("arrows", "Arr", Modifier.ARROWS, FLAG_SMALLER_FONT);
addModifierKey("box", "Box", MOD_BOX, FLAG_SMALLER_FONT); addModifierKey("box", "Box", Modifier.BOX, FLAG_SMALLER_FONT);
addModifierKey("fn", "Fn", MOD_FN, FLAG_SMALLER_FONT); addModifierKey("fn", "Fn", Modifier.FN, FLAG_SMALLER_FONT);
addModifierKey("meta", "Meta", MOD_META, FLAG_SMALLER_FONT); addModifierKey("meta", "Meta", Modifier.META, FLAG_SMALLER_FONT);
addSpecialKey("config", "\u0004", EVENT_CONFIG, FLAG_KEY_FONT | FLAG_SMALLER_FONT); addEventKey("config", "\u0004", Event.CONFIG, FLAG_KEY_FONT | FLAG_SMALLER_FONT);
addSpecialKey("switch_text", "ABC", EVENT_SWITCH_TEXT, FLAG_SMALLER_FONT); addEventKey("switch_text", "ABC", Event.SWITCH_TEXT, FLAG_SMALLER_FONT);
addSpecialKey("switch_numeric", "123+", EVENT_SWITCH_NUMERIC, FLAG_SMALLER_FONT); addEventKey("switch_numeric", "123+", Event.SWITCH_NUMERIC, FLAG_SMALLER_FONT);
addSpecialKey("switch_emoji", "\u0001" , EVENT_SWITCH_EMOJI, FLAG_KEY_FONT | FLAG_SMALLER_FONT); addEventKey("switch_emoji", "\u0001" , Event.SWITCH_EMOJI, FLAG_KEY_FONT | FLAG_SMALLER_FONT);
addSpecialKey("switch_back_emoji", "ABC", EVENT_SWITCH_BACK_EMOJI, 0); addEventKey("switch_back_emoji", "ABC", Event.SWITCH_BACK_EMOJI, 0);
addSpecialKey("switch_programming", "Prog", EVENT_SWITCH_PROGRAMMING, FLAG_SMALLER_FONT); addEventKey("switch_programming", "Prog", Event.SWITCH_PROGRAMMING, FLAG_SMALLER_FONT);
addSpecialKey("change_method", "\u0009", EVENT_CHANGE_METHOD, FLAG_KEY_FONT | FLAG_SMALLER_FONT); addEventKey("change_method", "\u0009", Event.CHANGE_METHOD, FLAG_KEY_FONT | FLAG_SMALLER_FONT);
addSpecialKey("action", "Action", EVENT_ACTION, FLAG_SMALLER_FONT); // Will always be replaced addEventKey("action", "Action", Event.ACTION, FLAG_SMALLER_FONT); // Will always be replaced
addEventKey("esc", "Esc", KeyEvent.KEYCODE_ESCAPE, FLAG_SMALLER_FONT); addKeyeventKey("esc", "Esc", KeyEvent.KEYCODE_ESCAPE, FLAG_SMALLER_FONT);
addEventKey("enter", "\u000E", KeyEvent.KEYCODE_ENTER, FLAG_KEY_FONT); addKeyeventKey("enter", "\u000E", KeyEvent.KEYCODE_ENTER, FLAG_KEY_FONT);
addEventKey("up", "\u0005", KeyEvent.KEYCODE_DPAD_UP, FLAG_KEY_FONT | FLAG_PRECISE_REPEAT); addKeyeventKey("up", "\u0005", KeyEvent.KEYCODE_DPAD_UP, FLAG_KEY_FONT | FLAG_PRECISE_REPEAT);
addEventKey("right", "\u0006", KeyEvent.KEYCODE_DPAD_RIGHT, FLAG_KEY_FONT | FLAG_PRECISE_REPEAT); addKeyeventKey("right", "\u0006", KeyEvent.KEYCODE_DPAD_RIGHT, FLAG_KEY_FONT | FLAG_PRECISE_REPEAT);
addEventKey("down", "\u0007", KeyEvent.KEYCODE_DPAD_DOWN, FLAG_KEY_FONT | FLAG_PRECISE_REPEAT); addKeyeventKey("down", "\u0007", KeyEvent.KEYCODE_DPAD_DOWN, FLAG_KEY_FONT | FLAG_PRECISE_REPEAT);
addEventKey("left", "\u0008", KeyEvent.KEYCODE_DPAD_LEFT, FLAG_KEY_FONT | FLAG_PRECISE_REPEAT); addKeyeventKey("left", "\u0008", KeyEvent.KEYCODE_DPAD_LEFT, FLAG_KEY_FONT | FLAG_PRECISE_REPEAT);
addEventKey("page_up", "\u0002", KeyEvent.KEYCODE_PAGE_UP, FLAG_KEY_FONT); addKeyeventKey("page_up", "\u0002", KeyEvent.KEYCODE_PAGE_UP, FLAG_KEY_FONT);
addEventKey("page_down", "\u0003", KeyEvent.KEYCODE_PAGE_DOWN, FLAG_KEY_FONT); addKeyeventKey("page_down", "\u0003", KeyEvent.KEYCODE_PAGE_DOWN, FLAG_KEY_FONT);
addEventKey("home", "\u000B", KeyEvent.KEYCODE_MOVE_HOME, FLAG_KEY_FONT); addKeyeventKey("home", "\u000B", KeyEvent.KEYCODE_MOVE_HOME, FLAG_KEY_FONT);
addEventKey("end", "\u000C", KeyEvent.KEYCODE_MOVE_END, FLAG_KEY_FONT); addKeyeventKey("end", "\u000C", KeyEvent.KEYCODE_MOVE_END, FLAG_KEY_FONT);
addEventKey("backspace", "\u0011", KeyEvent.KEYCODE_DEL, FLAG_KEY_FONT); addKeyeventKey("backspace", "\u0011", KeyEvent.KEYCODE_DEL, FLAG_KEY_FONT);
addEventKey("delete", "\u0010", KeyEvent.KEYCODE_FORWARD_DEL, FLAG_KEY_FONT); addKeyeventKey("delete", "\u0010", KeyEvent.KEYCODE_FORWARD_DEL, FLAG_KEY_FONT);
addEventKey("insert", "Ins", KeyEvent.KEYCODE_INSERT, FLAG_SMALLER_FONT); addKeyeventKey("insert", "Ins", KeyEvent.KEYCODE_INSERT, FLAG_SMALLER_FONT);
addEventKey("f1", "F1", KeyEvent.KEYCODE_F1, 0); addKeyeventKey("f1", "F1", KeyEvent.KEYCODE_F1, 0);
addEventKey("f2", "F2", KeyEvent.KEYCODE_F2, 0); addKeyeventKey("f2", "F2", KeyEvent.KEYCODE_F2, 0);
addEventKey("f3", "F3", KeyEvent.KEYCODE_F3, 0); addKeyeventKey("f3", "F3", KeyEvent.KEYCODE_F3, 0);
addEventKey("f4", "F4", KeyEvent.KEYCODE_F4, 0); addKeyeventKey("f4", "F4", KeyEvent.KEYCODE_F4, 0);
addEventKey("f5", "F5", KeyEvent.KEYCODE_F5, 0); addKeyeventKey("f5", "F5", KeyEvent.KEYCODE_F5, 0);
addEventKey("f6", "F6", KeyEvent.KEYCODE_F6, 0); addKeyeventKey("f6", "F6", KeyEvent.KEYCODE_F6, 0);
addEventKey("f7", "F7", KeyEvent.KEYCODE_F7, 0); addKeyeventKey("f7", "F7", KeyEvent.KEYCODE_F7, 0);
addEventKey("f8", "F8", KeyEvent.KEYCODE_F8, 0); addKeyeventKey("f8", "F8", KeyEvent.KEYCODE_F8, 0);
addEventKey("f9", "F9", KeyEvent.KEYCODE_F9, 0); addKeyeventKey("f9", "F9", KeyEvent.KEYCODE_F9, 0);
addEventKey("f10", "F10", KeyEvent.KEYCODE_F10, 0); addKeyeventKey("f10", "F10", KeyEvent.KEYCODE_F10, 0);
addEventKey("f11", "F11", KeyEvent.KEYCODE_F11, FLAG_SMALLER_FONT); addKeyeventKey("f11", "F11", KeyEvent.KEYCODE_F11, FLAG_SMALLER_FONT);
addEventKey("f12", "F12", KeyEvent.KEYCODE_F12, FLAG_SMALLER_FONT); addKeyeventKey("f12", "F12", KeyEvent.KEYCODE_F12, FLAG_SMALLER_FONT);
addEventKey("tab", "\u000F", KeyEvent.KEYCODE_TAB, FLAG_KEY_FONT | FLAG_SMALLER_FONT); addKeyeventKey("tab", "\u000F", KeyEvent.KEYCODE_TAB, FLAG_KEY_FONT | FLAG_SMALLER_FONT);
addCharKey("\\t", "\\t", '\t', 0); // Send the tab character addCharKey("\\t", "\\t", '\t', 0); // Send the tab character
addCharKey("space", "\r", ' ', FLAG_KEY_FONT); addCharKey("space", "\r", ' ', FLAG_KEY_FONT);

2
srcs/juloo.keyboard2/Keyboard2.java
View File

@ -300,7 +300,7 @@ public class Keyboard2 extends InputMethodService
{ {
if (key != null if (key != null
&& key.getKind() == KeyValue.Kind.Event && key.getKind() == KeyValue.Kind.Event
&& key.getEvent() == KeyValue.EVENT_SWITCH_PROGRAMMING) && key.getEvent() == KeyValue.Event.SWITCH_PROGRAMMING)
return KeyValue.getKeyByName("switch_text"); return KeyValue.getKeyByName("switch_text");
return key; return key;
} }

42
srcs/juloo.keyboard2/Pointers.java
View File

@ -32,19 +32,18 @@ public final class Pointers implements Handler.Callback
/** When [skip_latched] is true, don't take flags of latched keys into account. */ /** When [skip_latched] is true, don't take flags of latched keys into account. */
private Modifiers getModifiers(boolean skip_latched) private Modifiers getModifiers(boolean skip_latched)
{ {
int size = _ptrs.size(); int n_ptrs = _ptrs.size();
int[] mods = new int[size]; KeyValue.Modifier[] mods = new KeyValue.Modifier[n_ptrs];
for (int i = 0; i < size; i++) int n_mods = 0;
for (int i = 0; i < n_ptrs; i++)
{ {
Pointer p = _ptrs.get(i); Pointer p = _ptrs.get(i);
mods[i] = if (p.value != null && p.value.getKind() == KeyValue.Kind.Modifier
((skip_latched && p.pointerId == -1 && !(skip_latched && p.pointerId == -1
&& (p.flags & KeyValue.FLAG_LOCKED) == 0) && (p.flags & KeyValue.FLAG_LOCKED) == 0))
|| p.value == null mods[n_mods++] = p.value.getModifier();
|| p.value.getKind() != KeyValue.Kind.Modifier)
? 0 : p.value.getModifier();
} }
return Modifiers.ofArray(mods); return Modifiers.ofArray(mods, n_mods);
} }
public void clear() public void clear()
@ -386,12 +385,15 @@ public final class Pointers implements Handler.Callback
Sorted in the order they should be evaluated. */ Sorted in the order they should be evaluated. */
public static final class Modifiers public static final class Modifiers
{ {
private final int[] _mods; private final KeyValue.Modifier[] _mods;
private final int _size; private final int _size;
private Modifiers(int[] m, int s) { _mods = m; _size = s; } private Modifiers(KeyValue.Modifier[] m, int s)
{
_mods = m; _size = s;
}
public int get(int i) { return _mods[i]; } public KeyValue.Modifier get(int i) { return _mods[_size - 1 - i]; }
public int size() { return _size; } public int size() { return _size; }
@Override @Override
@ -402,20 +404,20 @@ public final class Pointers implements Handler.Callback
return Arrays.equals(_mods, ((Modifiers)obj)._mods); return Arrays.equals(_mods, ((Modifiers)obj)._mods);
} }
public static final Modifiers EMPTY = new Modifiers(new int[0], 0); public static final Modifiers EMPTY =
new Modifiers(new KeyValue.Modifier[0], 0);
protected static Modifiers ofArray(int[] mods) protected static Modifiers ofArray(KeyValue.Modifier[] mods, int size)
{ {
int size = mods.length; // Sort and remove duplicates and nulls.
// Sort and remove duplicates and [0]s.
if (size > 1) if (size > 1)
{ {
Arrays.sort(mods); Arrays.sort(mods, 0, size);
int j = 0; int j = 0;
for (int i = 0; i < size; i++) for (int i = 0; i < size; i++)
{ {
int m = mods[i]; KeyValue.Modifier m = mods[i];
if (m != 0 && (i + 1 >= size || m != mods[i + 1])) if (m != null && (i + 1 >= size || m != mods[i + 1]))
{ {
mods[j] = m; mods[j] = m;
j++; j++;