From cc571ea1ca6e583024f9295b131ec199aa66cfd8 Mon Sep 17 00:00:00 2001 From: Jules Aguillon Date: Sun, 5 Jun 2022 18:14:50 +0200 Subject: [PATCH] Refactor: Merge KeyValue.char and code fields These two fields couldn't have an interesting value at the same time. As we can no longer rely on a special value to distinguish between what's the kind, the kind of the key is explicitly encoded in the two most significative bits of the _flags field. Extra nice thing: This removes the special values 'EVENT_NONE' and 'CHAR_NONE'. --- srcs/juloo.keyboard2/Emoji.java | 2 +- srcs/juloo.keyboard2/KeyEventHandler.java | 2 - srcs/juloo.keyboard2/KeyModifier.java | 16 ++-- srcs/juloo.keyboard2/KeyValue.java | 95 ++++++++++------------- srcs/juloo.keyboard2/Pointers.java | 2 +- 5 files changed, 50 insertions(+), 67 deletions(-) diff --git a/srcs/juloo.keyboard2/Emoji.java b/srcs/juloo.keyboard2/Emoji.java index e8ee8a1..b75069d 100644 --- a/srcs/juloo.keyboard2/Emoji.java +++ b/srcs/juloo.keyboard2/Emoji.java @@ -16,7 +16,7 @@ public class Emoji extends KeyValue protected Emoji(String name, String bytecode, String desc) { - super(name, bytecode, CHAR_NONE, EVENT_NONE, 0); + super(name, bytecode, KIND_STRING, 0, 0); _desc = desc; emojis_by_name.put(name, this); } diff --git a/srcs/juloo.keyboard2/KeyEventHandler.java b/srcs/juloo.keyboard2/KeyEventHandler.java index 8be8bf7..96c2971 100644 --- a/srcs/juloo.keyboard2/KeyEventHandler.java +++ b/srcs/juloo.keyboard2/KeyEventHandler.java @@ -87,8 +87,6 @@ class KeyEventHandler implements Config.IKeyEventHandler */ private void handleKeyUpWithModifier(int keyCode, Pointers.Modifiers mods) { - if (keyCode == KeyValue.EVENT_NONE) - return ; int metaState = 0; for (int i = 0; i < mods.size(); i++) metaState = sendMetaKeyForModifier(mods.get(i), metaState, true); diff --git a/srcs/juloo.keyboard2/KeyModifier.java b/srcs/juloo.keyboard2/KeyModifier.java index 7d01560..a69b5a1 100644 --- a/srcs/juloo.keyboard2/KeyModifier.java +++ b/srcs/juloo.keyboard2/KeyModifier.java @@ -72,7 +72,7 @@ class KeyModifier case Char: char kc = k.getChar(); char c = map.apply(kc); - return (kc == c) ? k : k.withCharAndSymbol(c); + return (kc == c) ? k : k.withChar(c); default: return k; } } @@ -84,9 +84,7 @@ class KeyModifier case Char: char kc = k.getChar(); char c = (char)KeyCharacterMap.getDeadChar(dead_char, kc); - if (c == 0 || kc == c) - return k; - return k.withCharAndSymbol(c); + return (c == 0 || kc == c) ? k : k.withChar(c); default: return k; } } @@ -96,8 +94,7 @@ class KeyModifier switch (k.getKind()) { case Char: - String s = String.valueOf(k.getChar()) + combining; - return k.withCharAndSymbol(s, KeyValue.CHAR_NONE); + return k.withString(String.valueOf(k.getChar()) + combining); default: return k; } } @@ -111,12 +108,9 @@ class KeyModifier char c = map_char_shift(kc); if (kc == c) c = Character.toUpperCase(kc); - if (kc == c) - return k; - return k.withCharAndSymbol(c); + return (kc == c) ? k : k.withChar(c); case String: - String s = k.getString().toUpperCase(); - return k.withCharAndSymbol(s, KeyValue.CHAR_NONE); + return k.withString(k.getString().toUpperCase()); default: return k; } } diff --git a/srcs/juloo.keyboard2/KeyValue.java b/srcs/juloo.keyboard2/KeyValue.java index 24dd84a..eaec387 100644 --- a/srcs/juloo.keyboard2/KeyValue.java +++ b/srcs/juloo.keyboard2/KeyValue.java @@ -8,7 +8,6 @@ class KeyValue { /** Values for the [code] field. */ - public static final int EVENT_NONE = -1; public static final int EVENT_CONFIG = -2; public static final int EVENT_SWITCH_TEXT = -3; public static final int EVENT_SWITCH_NUMERIC = -4; @@ -47,15 +46,11 @@ class KeyValue public static final int MOD_SLASH = -217; public static final int MOD_ARROW_RIGHT = -218; - /** Special value for the [_char] field. */ - public static final char CHAR_NONE = '\0'; - // Behavior flags public static final int FLAG_LATCH = 1; public static final int FLAG_LOCK = (1 << 1); // Special keys are not repeated and don't clear latched modifiers public static final int FLAG_SPECIAL = (1 << 2); - public static final int FLAG_MODIFIER = (1 << 3); public static final int FLAG_PRECISE_REPEAT = (1 << 4); // Rendering flags @@ -68,19 +63,20 @@ class KeyValue // Language specific keys that are removed from the keyboard by default public static final int FLAG_LOCALIZED = (1 << 8); + // Kind flags + public static final int KIND_CHAR = (0 << 30); + public static final int KIND_STRING = (1 << 30); + public static final int KIND_EVENT = (2 << 30); + public static final int KIND_MODIFIER = (3 << 30); + + public static final int KIND_FLAGS = (0b11 << 30); + public final String name; private final String _symbol; - private final char _char; /** Describe what the key does when it isn't a simple character. - Can be one of: - - When [FLAG_MODIFIER] is set, a modifier. See [KeyModifier]. - - [EVENT_NONE], no event is associated with the key. - - A positive integer, an Android [KeyEvent]. - - One of the [EVENT_*] constants, an action performed in [KeyEventHandler]. - A key can have both a character and a key event associated, the key event - is used when certain modifiers are active, the character is used - otherwise. See [KeyEventHandler]. */ + The meaning of this value depends on [_flags & KIND_FLAGS], which + corresponds to the [Kind] enum. */ private final int _code; private final int _flags; @@ -91,13 +87,14 @@ class KeyValue public Kind getKind() { - if ((_flags & FLAG_MODIFIER) != 0) - return Kind.Modifier; - if (_code != EVENT_NONE) - return Kind.Event; - if (_char != CHAR_NONE) - return Kind.Char; - return Kind.String; + switch (_flags & KIND_FLAGS) + { + case KIND_CHAR: return Kind.Char; + case KIND_STRING: return Kind.String; + case KIND_EVENT: return Kind.Event; + case KIND_MODIFIER: return Kind.Modifier; + default: throw new RuntimeException("Corrupted kind flags"); + } } public int getFlags() @@ -121,18 +118,10 @@ class KeyValue Defined only when [getKind() == Kind.Char]. */ public char getChar() { - return _char; + return (char)_code; } - /** An Android event or one of the [EVENT_*] constants, including - [EVENT_NONE]. - Defined only when [getKind() == Kind.Char]. */ - public int getCharEvent() - { - return _code; - } - - /** An Android event or one of the [EVENT_*] constants, except [EVENT_NONE]. + /** An Android event or one of the [EVENT_*] constants. Defined only when [getKind() == Kind.Event]. */ public int getEvent() { @@ -147,40 +136,40 @@ class KeyValue } /* Update the char and the symbol. */ - public KeyValue withCharAndSymbol(char c) + public KeyValue withChar(char c) { - return withCharAndSymbol(String.valueOf(c), c); + return new KeyValue(name, String.valueOf(c), KIND_CHAR, c, _flags); } - public KeyValue withCharAndSymbol(String s, char c) + public KeyValue withString(String s) { - return new KeyValue(name, s, c, _code, _flags); + return new KeyValue(name, s, KIND_STRING, 0, _flags); } public KeyValue withNameAndSymbol(String n, String s) { - return new KeyValue(n, s, _char, _code, _flags); + return new KeyValue(n, s, (_flags & KIND_FLAGS), _code, _flags); } - public KeyValue withEvent(int event) + public KeyValue withEvent(int e) { - return new KeyValue(name, _symbol, _char, event, (_flags & ~FLAG_MODIFIER)); + return new KeyValue(name, _symbol, KIND_EVENT, e, _flags); } public KeyValue withFlags(int f) { - return new KeyValue(name, _symbol, _char, _code, f); + return new KeyValue(name, _symbol, (_flags & KIND_FLAGS), _code, f); } private static HashMap keys = new HashMap(); - public KeyValue(String n, String s, char c, int e, int f) + public KeyValue(String n, String s, int kind, int c, int f) { + assert((kind & ~KIND_FLAGS) == 0); name = n; _symbol = s; - _char = c; - _code = e; - _flags = f; + _code = c; + _flags = (f & ~KIND_FLAGS) | kind; } private static String stripPrefix(String s, String prefix) @@ -204,35 +193,37 @@ class KeyValue kv = getKeyByName(localized); return kv.withFlags(kv._flags | FLAG_LOCALIZED); } - char c = (name.length() == 1) ? name.charAt(0) : CHAR_NONE; - return new KeyValue(name, name, c, EVENT_NONE, 0); + if (name.length() == 1) + return new KeyValue(name, name, KIND_CHAR, name.charAt(0), 0); + else + return new KeyValue(name, name, KIND_STRING, 0, 0); } - private static void addKey(String name, String symbol, char c, int event, int flags) + private static void addKey(String name, String symbol, int kind, int code, int flags) { - keys.put(name, new KeyValue(name, symbol, c, event, flags)); + keys.put(name, new KeyValue(name, symbol, kind, code, flags)); } private static void addCharKey(String name, String symbol, char c, int flags) { - addKey(name, symbol, c, EVENT_NONE, flags); + addKey(name, symbol, KIND_CHAR, c, flags); } private static void addModifierKey(String name, String symbol, int code, int extra_flags) { assert(code >= 100 && code < 300); - addKey(name, symbol, CHAR_NONE, code, - FLAG_LATCH | FLAG_MODIFIER | FLAG_SPECIAL | extra_flags); + addKey(name, symbol, KIND_MODIFIER, code, + FLAG_LATCH | FLAG_SPECIAL | extra_flags); } private static void addSpecialKey(String name, String symbol, int event, int flags) { - addKey(name, symbol, CHAR_NONE, event, flags | FLAG_SPECIAL); + addKey(name, symbol, KIND_EVENT, event, flags | FLAG_SPECIAL); } private static void addEventKey(String name, String symbol, int event, int flags) { - addKey(name, symbol, CHAR_NONE, event, flags); + addKey(name, symbol, KIND_EVENT, event, flags); } static diff --git a/srcs/juloo.keyboard2/Pointers.java b/srcs/juloo.keyboard2/Pointers.java index 6a9cef9..b26616e 100644 --- a/srcs/juloo.keyboard2/Pointers.java +++ b/srcs/juloo.keyboard2/Pointers.java @@ -407,7 +407,7 @@ public final class Pointers implements Handler.Callback protected static Modifiers ofArray(int[] mods) { int size = mods.length; - // Sort and remove duplicates and [EVENT_NONE]s. + // Sort and remove duplicates and [0]s. if (size > 1) { Arrays.sort(mods);