holm/Unexpected-Keyboard
1
0
Fork 0
forked from extern/Unexpected-Keyboard
Code Pull Requests Activity
294ebee6f1
Unexpected-Keyboard/srcs/juloo.keyboard2/KeyModifier.java

1084 lines
31 KiB
Java
Raw Normal View History

Separate handling of modifiers from KeyValue class KeyValue defines an ADT and some of its values, it now contains public final fields and no internal logic. KeyModifier handles modifiers and accents and creates new instances of KeyValue when needed. This operation is now properly cached.
2021-04-18 23:28:49 +02:00
package juloo.keyboard2;
import android.view.KeyCharacterMap;
Add function keys Add the Fn modifier that change the digits into F1 to F10.
2021-04-18 23:58:35 +02:00
import android.view.KeyEvent;
Separate handling of modifiers from KeyValue class KeyValue defines an ADT and some of its values, it now contains public final fields and no internal logic. KeyModifier handles modifiers and accents and creates new instances of KeyValue when needed. This operation is now properly cached.
2021-04-18 23:28:49 +02:00
import java.util.HashMap;
class KeyModifier
{
Add F11 and F12 These keys are shown only when Fn is activated, "placeholder" keys are placed in the layouts.
2022-03-19 16:27:57 +01:00
/** Cache key is KeyValue's name */
Refactor: Remove KeyValue.name This makes KeyValue objects smaller. 'equals' and 'hashCode' are now implemented too. Key names are still used to recognise keys with special meaning, but not for comparing keys anymore.
2022-06-06 00:23:45 +02:00
private static HashMap<KeyValue, HashMap<Pointers.Modifiers, KeyValue>> _cache =
new HashMap<KeyValue, HashMap<Pointers.Modifiers, KeyValue>>();
Add F11 and F12 These keys are shown only when Fn is activated, "placeholder" keys are placed in the layouts.
2022-03-19 16:27:57 +01:00
/** Modify a key according to modifiers. */
Stop using flags for modifiers There was no free bits left to add new modifiers. Instead of increasing the width of the 'flags' field, refactor the way modifiers are represented and used. Modifers are now represented as independent values and stored in the 'code' field. A flag is added to distinguish between modifiers and keys with a key event. The most notable change is that modifiers can no longer be or-ed into a single value but have to be represented as an array.
2022-06-05 01:38:42 +02:00
public static KeyValue modify(KeyValue k, Pointers.Modifiers mods)
Separate handling of modifiers from KeyValue class KeyValue defines an ADT and some of its values, it now contains public final fields and no internal logic. KeyModifier handles modifiers and accents and creates new instances of KeyValue when needed. This operation is now properly cached.
2021-04-18 23:28:49 +02:00
{
Add F11 and F12 These keys are shown only when Fn is activated, "placeholder" keys are placed in the layouts.
2022-03-19 16:27:57 +01:00
if (k == null)
return null;
Stop using flags for modifiers There was no free bits left to add new modifiers. Instead of increasing the width of the 'flags' field, refactor the way modifiers are represented and used. Modifers are now represented as independent values and stored in the 'code' field. A flag is added to distinguish between modifiers and keys with a key event. The most notable change is that modifiers can no longer be or-ed into a single value but have to be represented as an array.
2022-06-05 01:38:42 +02:00
int n_mods = mods.size();
HashMap<Pointers.Modifiers, KeyValue> ks = cacheEntry(k);
KeyValue r = ks.get(mods);
if (r == null)
Add F11 and F12 These keys are shown only when Fn is activated, "placeholder" keys are placed in the layouts.
2022-03-19 16:27:57 +01:00
{
r = k;
Stop using flags for modifiers There was no free bits left to add new modifiers. Instead of increasing the width of the 'flags' field, refactor the way modifiers are represented and used. Modifers are now represented as independent values and stored in the 'code' field. A flag is added to distinguish between modifiers and keys with a key event. The most notable change is that modifiers can no longer be or-ed into a single value but have to be represented as an array.
2022-06-05 01:38:42 +02:00
/* Order: Fn, Shift, accents */
for (int i = 0; i < n_mods; i++)
r = modify(r, mods.get(i));
ks.put(mods, r);
Add F11 and F12 These keys are shown only when Fn is activated, "placeholder" keys are placed in the layouts.
2022-03-19 16:27:57 +01:00
}
Refactor: Remove KeyValue.name This makes KeyValue objects smaller. 'equals' and 'hashCode' are now implemented too. Key names are still used to recognise keys with special meaning, but not for comparing keys anymore.
2022-06-06 00:23:45 +02:00
/* Keys with an empty string are placeholder keys. */
return (r.getString().length() == 0) ? null : r;
Separate handling of modifiers from KeyValue class KeyValue defines an ADT and some of its values, it now contains public final fields and no internal logic. KeyModifier handles modifiers and accents and creates new instances of KeyValue when needed. This operation is now properly cached.
2021-04-18 23:28:49 +02:00
}
Refactor: Separate Events and Keyevents and use enums 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.
2022-06-05 19:30:53 +02:00
public static KeyValue modify(KeyValue k, KeyValue.Modifier mod)
Separate handling of modifiers from KeyValue class KeyValue defines an ADT and some of its values, it now contains public final fields and no internal logic. KeyModifier handles modifiers and accents and creates new instances of KeyValue when needed. This operation is now properly cached.
2021-04-18 23:28:49 +02:00
{
Stop using flags for modifiers There was no free bits left to add new modifiers. Instead of increasing the width of the 'flags' field, refactor the way modifiers are represented and used. Modifers are now represented as independent values and stored in the 'code' field. A flag is added to distinguish between modifiers and keys with a key event. The most notable change is that modifiers can no longer be or-ed into a single value but have to be represented as an array.
2022-06-05 01:38:42 +02:00
switch (mod)
{
Refactor: Separate Events and Keyevents and use enums 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.
2022-06-05 19:30:53 +02:00
case CTRL:
case ALT:
case META: return turn_into_keyevent(k);
case FN: return apply_fn(k);
case SHIFT: return apply_shift(k);
Refactor: Allow combining diacritics modifiers Change the API of `KeyModifier.Map_char` to allow returning a string instead of a single 16 bits char. This allows to return combining diacritics. This also gets rid of `apply_map_or_dead_char`, maps can have their own fallback.
2023-08-20 00:44:22 +02:00
case GRAVE: return apply_map_char(k, map_char_grave);
case AIGU: return apply_map_char(k, map_char_aigu);
case CIRCONFLEXE: return apply_map_char(k, map_char_circonflexe);
case TILDE: return apply_map_char(k, map_char_tilde);
case CEDILLE: return apply_map_char(k, map_char_cedille);
case TREMA: return apply_map_char(k, map_char_trema);
case CARON: return apply_map_char(k, map_char_caron);
case RING: return apply_map_char(k, map_char_ring);
case MACRON: return apply_map_char(k, map_char_macron);
case OGONEK: return apply_map_char(k, map_char_ogonek);
case DOT_ABOVE: return apply_map_char(k, map_char_dot_above);
Add missing combining accents Implement the combinations that were previously not possible and were commented out. Also remove `apply_dead_char` and `apply_combining` and make all dead-keys definitions uniform.
2023-08-20 01:01:38 +02:00
case BREVE: return apply_map_char(k, map_char_breve);
Refactor: Separate Events and Keyevents and use enums 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.
2022-06-05 19:30:53 +02:00
case DOUBLE_AIGU: return apply_map_char(k, map_char_double_aigu);
case ORDINAL: return apply_map_char(k, map_char_ordinal);
case SUPERSCRIPT: return apply_map_char(k, map_char_superscript);
case SUBSCRIPT: return apply_map_char(k, map_char_subscript);
case ARROWS: return apply_map_char(k, map_char_arrows);
case BOX: return apply_map_char(k, map_char_box);
case SLASH: return apply_map_char(k, map_char_slash);
Add the bar diacritic dead key Allows to type many of the "with stroke" or "with bar" latin letters.
2022-11-05 19:26:49 +01:00
case BAR: return apply_map_char(k, map_char_bar);
Add missing combining accents Implement the combinations that were previously not possible and were commented out. Also remove `apply_dead_char` and `apply_combining` and make all dead-keys definitions uniform.
2023-08-20 01:01:38 +02:00
case ARROW_RIGHT: return apply_map_char(k, map_char_arrow_right);
Vietnamese keyboard (#291) Added missing accent (horn, hook, dot below) Added layout Added accent font svg (by modified existing accent)
2023-02-09 18:40:48 +01:00
case DOT_BELOW: return apply_map_char(k, map_char_dot_below);
case HORN: return apply_map_char(k, map_char_horn);
case HOOK_ABOVE: return apply_map_char(k, map_char_hook_above);
Stop using flags for modifiers There was no free bits left to add new modifiers. Instead of increasing the width of the 'flags' field, refactor the way modifiers are represented and used. Modifers are now represented as independent values and stored in the 'code' field. A flag is added to distinguish between modifiers and keys with a key event. The most notable change is that modifiers can no longer be or-ed into a single value but have to be represented as an array.
2022-06-05 01:38:42 +02:00
default: return k;
}
Improve the numeric keyboard
2021-05-08 02:00:47 +02:00
}
Modify keys after a long press
2023-02-12 23:14:57 +01:00
/** Modify a key after a long press. */
public static KeyValue modify_long_press(KeyValue k)
{
Option to switch to the previous input method A new option changes the "change_method" into the new "change_method_prev". It switch to the previously used input method. A long press on "change_method_prev" sends "change_method". A new section is added in the settings and existing options are moved.
2023-02-12 23:20:11 +01:00
switch (k.getKind())
{
case Event:
switch (k.getEvent())
{
case CHANGE_METHOD_PREV:
return KeyValue.getKeyByName("change_method");
}
break;
}
Modify keys after a long press
2023-02-12 23:14:57 +01:00
return k;
}
Per-script numpad The numeric layout and the optional right hand side numpad are modified to show the digits belonging to the script used in the current layout. The numpads are still defined as it was before. The digits are changed in `modify_numpad` if needed.
2023-09-03 23:38:55 +02:00
public static Map_char modify_numpad_script(String script)
{
if (script == null)
return map_char_none;
switch (script)
{
case "arabic": return map_char_numpad_arabic;
case "bengali": return map_char_numpad_bengali;
case "devanagari": return map_char_numpad_devanagari;
case "persian": return map_char_numpad_persian;
default: return map_char_none;
}
}
Refactor: Abstract KeyValue fields The meaning of the public fields of KeyValue was quite complicated and not handled consistently accross the app. Make these fields private and add a more abstract API on top. The meaning of these fields changed recently and it wasn't an easy change. I plan on making more changes in the future.
2022-06-05 17:26:34 +02:00
private static KeyValue apply_map_char(KeyValue k, Map_char map)
{
switch (k.getKind())
{
case Char:
char kc = k.getChar();
Refactor: Allow combining diacritics modifiers Change the API of `KeyModifier.Map_char` to allow returning a string instead of a single 16 bits char. This allows to return combining diacritics. This also gets rid of `apply_map_or_dead_char`, maps can have their own fallback.
2023-08-20 00:44:22 +02:00
String modified = map.apply(kc);
if (modified == null)
return k;
return KeyValue.makeStringKey(modified, k.getFlags());
Refactor: Abstract KeyValue fields The meaning of the public fields of KeyValue was quite complicated and not handled consistently accross the app. Make these fields private and add a more abstract API on top. The meaning of these fields changed recently and it wasn't an easy change. I plan on making more changes in the future.
2022-06-05 17:26:34 +02:00
default: return k;
}
}
Stop using flags for modifiers There was no free bits left to add new modifiers. Instead of increasing the width of the 'flags' field, refactor the way modifiers are represented and used. Modifers are now represented as independent values and stored in the 'code' field. A flag is added to distinguish between modifiers and keys with a key event. The most notable change is that modifiers can no longer be or-ed into a single value but have to be represented as an array.
2022-06-05 01:38:42 +02:00
private static KeyValue apply_shift(KeyValue k)
Separate handling of modifiers from KeyValue class KeyValue defines an ADT and some of its values, it now contains public final fields and no internal logic. KeyModifier handles modifiers and accents and creates new instances of KeyValue when needed. This operation is now properly cached.
2021-04-18 23:28:49 +02:00
{
Refactor: Abstract KeyValue fields The meaning of the public fields of KeyValue was quite complicated and not handled consistently accross the app. Make these fields private and add a more abstract API on top. The meaning of these fields changed recently and it wasn't an easy change. I plan on making more changes in the future.
2022-06-05 17:26:34 +02:00
switch (k.getKind())
Add combining 'accent_arrow_right' It's the first modifier that uses combining diacritics. Whether it should be represented as a modifier or a new kind of key can be reconsidered later.
2022-06-05 13:51:09 +02:00
{
Refactor: Abstract KeyValue fields The meaning of the public fields of KeyValue was quite complicated and not handled consistently accross the app. Make these fields private and add a more abstract API on top. The meaning of these fields changed recently and it wasn't an easy change. I plan on making more changes in the future.
2022-06-05 17:26:34 +02:00
case Char:
char kc = k.getChar();
char c = map_char_shift(kc);
if (kc == c)
c = Character.toUpperCase(kc);
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'.
2022-06-05 18:14:50 +02:00
return (kc == c) ? k : k.withChar(c);
Refactor: Abstract KeyValue fields The meaning of the public fields of KeyValue was quite complicated and not handled consistently accross the app. Make these fields private and add a more abstract API on top. The meaning of these fields changed recently and it wasn't an easy change. I plan on making more changes in the future.
2022-06-05 17:26:34 +02:00
case String:
Capitalize the first letter of custom keys This is more useful than turning the entire string full caps.
2023-09-09 14:32:03 +02:00
String s = Utils.capitalize_string(k.getString());
return KeyValue.makeStringKey(s, k.getFlags());
Refactor: Abstract KeyValue fields The meaning of the public fields of KeyValue was quite complicated and not handled consistently accross the app. Make these fields private and add a more abstract API on top. The meaning of these fields changed recently and it wasn't an easy change. I plan on making more changes in the future.
2022-06-05 17:26:34 +02:00
default: return k;
Add combining 'accent_arrow_right' It's the first modifier that uses combining diacritics. Whether it should be represented as a modifier or a new kind of key can be reconsidered later.
2022-06-05 13:51:09 +02:00
}
Separate handling of modifiers from KeyValue class KeyValue defines an ADT and some of its values, it now contains public final fields and no internal logic. KeyModifier handles modifiers and accents and creates new instances of KeyValue when needed. This operation is now properly cached.
2021-04-18 23:28:49 +02:00
}
Stop using flags for modifiers There was no free bits left to add new modifiers. Instead of increasing the width of the 'flags' field, refactor the way modifiers are represented and used. Modifers are now represented as independent values and stored in the 'code' field. A flag is added to distinguish between modifiers and keys with a key event. The most notable change is that modifiers can no longer be or-ed into a single value but have to be represented as an array.
2022-06-05 01:38:42 +02:00
private static KeyValue apply_fn(KeyValue k)
Add function keys Add the Fn modifier that change the digits into F1 to F10.
2021-04-18 23:58:35 +02:00
{
Refactor: Remove KeyValue.name This makes KeyValue objects smaller. 'equals' and 'hashCode' are now implemented too. Key names are still used to recognise keys with special meaning, but not for comparing keys anymore.
2022-06-06 00:23:45 +02:00
String name = null;
switch (k.getKind())
Add function keys Add the Fn modifier that change the digits into F1 to F10.
2021-04-18 23:58:35 +02:00
{
Refactor: Remove KeyValue.name This makes KeyValue objects smaller. 'equals' and 'hashCode' are now implemented too. Key names are still used to recognise keys with special meaning, but not for comparing keys anymore.
2022-06-06 00:23:45 +02:00
case Char: name = apply_fn_char(k.getChar()); break;
case Keyevent: name = apply_fn_keyevent(k.getKeyevent()); break;
Switch to greekmath with Fn+switch_numeric Add a shortcut to switch to the greekmath pane directly from the main layout.
2022-07-09 17:31:44 +02:00
case Event: name = apply_fn_event(k.getEvent()); break;
Fix placeholder key not replaced Since fecc4dd, placeholder keys can't be compared by reference. Add a placeholder kind and defined placeholder values.
2023-01-30 21:29:59 +01:00
case Placeholder: name = apply_fn_placeholder(k.getPlaceholder()); break;
Refactor: Remove KeyValue.name This makes KeyValue objects smaller. 'equals' and 'hashCode' are now implemented too. Key names are still used to recognise keys with special meaning, but not for comparing keys anymore.
2022-06-06 00:23:45 +02:00
}
return (name == null) ? k : KeyValue.getKeyByName(name);
}
private static String apply_fn_keyevent(int code)
{
switch (code)
{
case KeyEvent.KEYCODE_DPAD_UP: return "page_up";
case KeyEvent.KEYCODE_DPAD_DOWN: return "page_down";
case KeyEvent.KEYCODE_DPAD_LEFT: return "home";
case KeyEvent.KEYCODE_DPAD_RIGHT: return "end";
case KeyEvent.KEYCODE_ESCAPE: return "insert";
Fix literal tab key Broken since 31d6a70d.
2022-10-16 00:04:06 +02:00
case KeyEvent.KEYCODE_TAB: return "\\t";
Add page_up, page_down, home, end to extra keys The new keys are placed on the corner of the arrow keys. Key descriptions are added. They are removed from the Fn layer to avoid showing up twice.
2023-10-20 12:15:50 +02:00
case KeyEvent.KEYCODE_PAGE_UP:
case KeyEvent.KEYCODE_PAGE_DOWN:
case KeyEvent.KEYCODE_MOVE_HOME:
case KeyEvent.KEYCODE_MOVE_END: return "removed";
Refactor: Remove KeyValue.name This makes KeyValue objects smaller. 'equals' and 'hashCode' are now implemented too. Key names are still used to recognise keys with special meaning, but not for comparing keys anymore.
2022-06-06 00:23:45 +02:00
default: return null;
}
}
Switch to greekmath with Fn+switch_numeric Add a shortcut to switch to the greekmath pane directly from the main layout.
2022-07-09 17:31:44 +02:00
private static String apply_fn_event(KeyValue.Event ev)
{
switch (ev)
{
case SWITCH_NUMERIC: return "switch_greekmath";
default: return null;
}
}
Fix placeholder key not replaced Since fecc4dd, placeholder keys can't be compared by reference. Add a placeholder kind and defined placeholder values.
2023-01-30 21:29:59 +01:00
private static String apply_fn_placeholder(KeyValue.Placeholder p)
{
switch (p)
{
case F11: return "f11";
case F12: return "f12";
Add layouts 'he_il_1452_1' and 'he_il_1452_2'
2023-01-20 03:58:40 +01:00
case SHINDOT: return "shindot";
case SINDOT: return "sindot";
case OLE: return "ole";
case METEG: return "meteg";
Fix placeholder key not replaced Since fecc4dd, placeholder keys can't be compared by reference. Add a placeholder kind and defined placeholder values.
2023-01-30 21:29:59 +01:00
default: return null;
}
}
Refactor: Remove KeyValue.name This makes KeyValue objects smaller. 'equals' and 'hashCode' are now implemented too. Key names are still used to recognise keys with special meaning, but not for comparing keys anymore.
2022-06-06 00:23:45 +02:00
/** Return the name of modified key, or [null]. */
private static String apply_fn_char(char c)
{
switch (c)
{
case '1': return "f1";
case '2': return "f2";
case '3': return "f3";
case '4': return "f4";
case '5': return "f5";
case '6': return "f6";
case '7': return "f7";
case '8': return "f8";
case '9': return "f9";
case '0': return "f10";
case '<': return "«";
case '>': return "»";
case '{': return "‹";
case '}': return "›";
case '[': return "‘";
case ']': return "’";
case '(': return "“";
case ')': return "”";
case '\'': return "‚";
case '"': return "„";
case '-': return "–";
case '_': return "—";
case '^': return "¬";
case '%': return "‰";
case '=': return "≈";
case 'u': return "µ";
case 'a': return "æ";
case 'o': return "œ";
case '*': return "°";
case '.': return "…";
case ',': return "·";
case '!': return "¡";
case '?': return "¿";
Add layouts 'he_il_1452_1' and 'he_il_1452_2'
2023-01-20 03:58:40 +01:00
case '|': return "¦";
Updated/Added Czech translation + 2 common Fn keys (#387)
2023-07-02 16:12:19 +02:00
case '§': return "";
Add dagger, double dagger, section mark, and pilcrow as extra keys on QWERTY-like layouts (#410) * Add section mark as an extra key in QWERTY-like layouts that don't have it already * Add dagger (also double dagger) as an extra key in QWERTY-like layouts
2023-07-29 18:42:20 +02:00
case '†': return "‡";
Updated/Added Czech translation + 2 common Fn keys (#387)
2023-07-02 16:12:19 +02:00
case '×': return "∙";
Modify arabic and persian numbers info function keys And add function keys placeholders in the layouts.
2023-08-05 19:20:48 +02:00
case ' ': return "nbsp";
Add alternative greek and math symbols
2022-07-09 17:40:20 +02:00
// arrows
Refactor: Remove KeyValue.name This makes KeyValue objects smaller. 'equals' and 'hashCode' are now implemented too. Key names are still used to recognise keys with special meaning, but not for comparing keys anymore.
2022-06-06 00:23:45 +02:00
case '↖': return "⇖";
case '↑': return "⇑";
case '↗': return "⇗";
case '←': return "⇐";
case '→': return "⇒";
case '↙': return "⇙";
case '↓': return "⇓";
case '↘': return "⇘";
Add alternative greek and math symbols
2022-07-09 17:40:20 +02:00
case '↔': return "⇔";
case '↕': return "⇕";
Add currency symbols under the Fn key Fn+e = € Fn+l = £ Fn+r = ₹ Fn+y = ¥ Fn+c = ¢ Fn+p = ₱
2022-04-02 16:56:40 +02:00
// Currency symbols
Refactor: Remove KeyValue.name This makes KeyValue objects smaller. 'equals' and 'hashCode' are now implemented too. Key names are still used to recognise keys with special meaning, but not for comparing keys anymore.
2022-06-06 00:23:45 +02:00
case 'e': return "€";
case 'l': return "£";
case 'r': return "₹";
case 'y': return "¥";
case 'c': return "¢";
Add '₽' to Russian layout and to the Fn layer Other currencies are moved on the Fn layer for consistency with the compose key.
2023-10-21 11:56:56 +02:00
case 'p': return "₽";
case 'b': return "₱";
Add symbol ₴ to Fn+h and to Ukrainian
2023-07-09 16:12:13 +02:00
case 'h': return "₴";
Add '₽' to Russian layout and to the Fn layer Other currencies are moved on the Fn layer for consistency with the compose key.
2023-10-21 11:56:56 +02:00
case 'z': return "₿";
Refactor: Remove KeyValue.name This makes KeyValue objects smaller. 'equals' and 'hashCode' are now implemented too. Key names are still used to recognise keys with special meaning, but not for comparing keys anymore.
2022-06-06 00:23:45 +02:00
case '€': case '£': return "removed"; // Avoid showing these twice
Add alternative greek and math symbols
2022-07-09 17:40:20 +02:00
// alternating greek letters
case 'π': return "ϖ";
case 'θ': return "ϑ";
case 'Θ': return "ϴ";
case 'ε': return "ϵ";
case 'β': return "ϐ";
case 'ρ': return "ϱ";
case 'σ': return "ς";
case 'γ': return "ɣ";
case 'φ': return "ϕ";
case 'υ': return "ϒ";
case 'κ': return "ϰ";
// alternating math characters
case '∪': return "⋃";
case '∩': return "⋂";
case '∃': return "∄";
case '∈': return "∉";
case '∫': return "∮";
case 'Π': return "∏";
case 'Σ': return "∑";
case '∨': return "⋁";
case '∧': return "⋀";
case '⊷': return "⊶";
case '⊂': return "⊆";
case '⊃': return "⊇";
case '±': return "∓";
Add layouts 'he_il_1452_1' and 'he_il_1452_2'
2023-01-20 03:58:40 +01:00
// hebrew niqqud
case 'ק': return "qamats"; // kamatz
case 'ר': return "hataf_qamats"; // reduced kamatz
case 'ו': return "holam";
case 'ם': return "rafe";
case 'פ': return "patah"; // patach
case 'ש': return "sheva";
case 'ד': return "dagesh"; // or mapiq
case 'ח': return "hiriq";
case 'ף': return "hataf_patah"; // reduced patach
case 'ז': return "qubuts"; // kubuts
case 'ס': return "segol";
case 'ב': return "hataf_segol"; // reduced segol
case 'צ': return "tsere";
New Hindi layout (#313) * New Hindi layout * Update default layout for Marathi, Nepali * Consistent naming for Devanagari layouts
2023-03-11 16:43:17 +01:00
// Devanagari symbols
case 'ए': return "ऍ";
case 'े': return "ॅ";
case 'ऐ': return "ऎ";
case 'ै': return "ॆ";
case 'ऋ': return "ॠ";
case 'ृ': return "ॄ";
case 'ळ': return "ऴ";
case 'र': return "ऱ";
case 'क': return "क़";
case 'ख': return "ख़";
case 'ग': return "ग़";
case 'घ': return "ॻ";
case 'ढ': return "ढ़";
case 'न': return "ऩ";
case 'ड': return "ड़";
case 'ट': return "ॸ";
case 'ण': return "ॾ";
case 'फ': return "फ़";
case 'ऌ': return "ॡ";
case 'ॢ': return "ॣ";
case 'औ': return "ॵ";
case 'ौ': return "ॏ";
case 'ओ': return "ऒ";
case 'ो': return "ॊ";
case 'च': return "ॼ";
case 'ज': return "ज़";
case 'ब': return "ॿ";
case 'व': return "ॺ";
case 'य': return "य़";
case 'अ': return "ॲ";
case 'आ': return "ऑ";
case 'ा': return "ॉ";
case 'झ': return "ॹ";
case 'ई': return "ॴ";
case 'ी': return "ऻ";
case 'इ': return "ॳ";
case 'ि': return "ऺ";
case 'उ': return "ॶ";
case 'ऊ': return "ॷ";
case 'ु': return "ऄ";
case 'ष': return "क्ष";
case 'थ': return "त्र";
case 'द': return "द्र";
case 'प': return "प्र";
case 'श': return "श्र";
case 'छ': return "श्च";
case 'ँ': return "ऀ";
case '₹': return "₨";
case 'ॖ': return "ॗ";
case '॓': return "॔";
case '॰': return "ॱ";
case '।': return "॥";
case 'ं': return "ॕ";
case '़': return "ॎ";
case 'ऽ': return "ॽ";
Modify arabic and persian numbers info function keys And add function keys placeholders in the layouts.
2023-08-05 19:20:48 +02:00
// Persian numbers
case '۱': return "f1";
case '۲': return "f2";
case '۳': return "f3";
case '۴': return "f4";
case '۵': return "f5";
case '۶': return "f6";
case '۷': return "f7";
case '۸': return "f8";
case '۹': return "f9";
case '۰': return "f10";
// Arabic numbers
case '١': return "f1";
case '٢': return "f2";
case '٣': return "f3";
case '٤': return "f4";
case '٥': return "f5";
case '٦': return "f6";
case '٧': return "f7";
case '٨': return "f8";
case '٩': return "f9";
case '٠': return "f10";
Refactor: Remove KeyValue.name This makes KeyValue objects smaller. 'equals' and 'hashCode' are now implemented too. Key names are still used to recognise keys with special meaning, but not for comparing keys anymore.
2022-06-06 00:23:45 +02:00
default: return null;
Add function keys Add the Fn modifier that change the digits into F1 to F10.
2021-04-18 23:58:35 +02:00
}
}
Refactor: Associate key events in KeyModifier Two advantages: - No need to distinguish modifiers in KeyEventHandler. The KeyValue is enough to decide what action to do. - Keys are never a Char and Event at the same time, fields can be merged.
2022-06-05 17:44:00 +02:00
private static KeyValue turn_into_keyevent(KeyValue k)
{
if (k.getKind() != KeyValue.Kind.Char)
return k;
int e;
switch (k.getChar())
{
case 'a': e = KeyEvent.KEYCODE_A; break;
case 'b': e = KeyEvent.KEYCODE_B; break;
case 'c': e = KeyEvent.KEYCODE_C; break;
case 'd': e = KeyEvent.KEYCODE_D; break;
case 'e': e = KeyEvent.KEYCODE_E; break;
case 'f': e = KeyEvent.KEYCODE_F; break;
case 'g': e = KeyEvent.KEYCODE_G; break;
case 'h': e = KeyEvent.KEYCODE_H; break;
case 'i': e = KeyEvent.KEYCODE_I; break;
case 'j': e = KeyEvent.KEYCODE_J; break;
case 'k': e = KeyEvent.KEYCODE_K; break;
case 'l': e = KeyEvent.KEYCODE_L; break;
case 'm': e = KeyEvent.KEYCODE_M; break;
case 'n': e = KeyEvent.KEYCODE_N; break;
case 'o': e = KeyEvent.KEYCODE_O; break;
case 'p': e = KeyEvent.KEYCODE_P; break;
case 'q': e = KeyEvent.KEYCODE_Q; break;
case 'r': e = KeyEvent.KEYCODE_R; break;
case 's': e = KeyEvent.KEYCODE_S; break;
case 't': e = KeyEvent.KEYCODE_T; break;
case 'u': e = KeyEvent.KEYCODE_U; break;
case 'v': e = KeyEvent.KEYCODE_V; break;
case 'w': e = KeyEvent.KEYCODE_W; break;
case 'x': e = KeyEvent.KEYCODE_X; break;
case 'y': e = KeyEvent.KEYCODE_Y; break;
case 'z': e = KeyEvent.KEYCODE_Z; break;
case '0': e = KeyEvent.KEYCODE_0; break;
case '1': e = KeyEvent.KEYCODE_1; break;
case '2': e = KeyEvent.KEYCODE_2; break;
case '3': e = KeyEvent.KEYCODE_3; break;
case '4': e = KeyEvent.KEYCODE_4; break;
case '5': e = KeyEvent.KEYCODE_5; break;
case '6': e = KeyEvent.KEYCODE_6; break;
case '7': e = KeyEvent.KEYCODE_7; break;
case '8': e = KeyEvent.KEYCODE_8; break;
case '9': e = KeyEvent.KEYCODE_9; break;
case '`': e = KeyEvent.KEYCODE_GRAVE; break;
case '-': e = KeyEvent.KEYCODE_MINUS; break;
case '=': e = KeyEvent.KEYCODE_EQUALS; break;
case '[': e = KeyEvent.KEYCODE_LEFT_BRACKET; break;
case ']': e = KeyEvent.KEYCODE_RIGHT_BRACKET; break;
case '\\': e = KeyEvent.KEYCODE_BACKSLASH; break;
case ';': e = KeyEvent.KEYCODE_SEMICOLON; break;
case '\'': e = KeyEvent.KEYCODE_APOSTROPHE; break;
case '/': e = KeyEvent.KEYCODE_SLASH; break;
case '@': e = KeyEvent.KEYCODE_AT; break;
case '+': e = KeyEvent.KEYCODE_PLUS; break;
case ',': e = KeyEvent.KEYCODE_COMMA; break;
case '.': e = KeyEvent.KEYCODE_PERIOD; break;
case '*': e = KeyEvent.KEYCODE_STAR; break;
case '#': e = KeyEvent.KEYCODE_POUND; break;
case '(': e = KeyEvent.KEYCODE_NUMPAD_LEFT_PAREN; break;
case ')': e = KeyEvent.KEYCODE_NUMPAD_RIGHT_PAREN; break;
case ' ': e = KeyEvent.KEYCODE_SPACE; break;
default: return k;
}
Refactor: Separate Events and Keyevents and use enums 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.
2022-06-05 19:30:53 +02:00
return k.withKeyevent(e);
Refactor: Associate key events in KeyModifier Two advantages: - No need to distinguish modifiers in KeyEventHandler. The KeyValue is enough to decide what action to do. - Keys are never a Char and Event at the same time, fields can be merged.
2022-06-05 17:44:00 +02:00
}
Separate handling of modifiers from KeyValue class KeyValue defines an ADT and some of its values, it now contains public final fields and no internal logic. KeyModifier handles modifiers and accents and creates new instances of KeyValue when needed. This operation is now properly cached.
2021-04-18 23:28:49 +02:00
/* Lookup the cache entry for a key. Create it needed. */
Stop using flags for modifiers There was no free bits left to add new modifiers. Instead of increasing the width of the 'flags' field, refactor the way modifiers are represented and used. Modifers are now represented as independent values and stored in the 'code' field. A flag is added to distinguish between modifiers and keys with a key event. The most notable change is that modifiers can no longer be or-ed into a single value but have to be represented as an array.
2022-06-05 01:38:42 +02:00
private static HashMap<Pointers.Modifiers, KeyValue> cacheEntry(KeyValue k)
Separate handling of modifiers from KeyValue class KeyValue defines an ADT and some of its values, it now contains public final fields and no internal logic. KeyModifier handles modifiers and accents and creates new instances of KeyValue when needed. This operation is now properly cached.
2021-04-18 23:28:49 +02:00
{
Refactor: Remove KeyValue.name This makes KeyValue objects smaller. 'equals' and 'hashCode' are now implemented too. Key names are still used to recognise keys with special meaning, but not for comparing keys anymore.
2022-06-06 00:23:45 +02:00
HashMap<Pointers.Modifiers, KeyValue> ks = _cache.get(k);
Separate handling of modifiers from KeyValue class KeyValue defines an ADT and some of its values, it now contains public final fields and no internal logic. KeyModifier handles modifiers and accents and creates new instances of KeyValue when needed. This operation is now properly cached.
2021-04-18 23:28:49 +02:00
if (ks == null)
{
Stop using flags for modifiers There was no free bits left to add new modifiers. Instead of increasing the width of the 'flags' field, refactor the way modifiers are represented and used. Modifers are now represented as independent values and stored in the 'code' field. A flag is added to distinguish between modifiers and keys with a key event. The most notable change is that modifiers can no longer be or-ed into a single value but have to be represented as an array.
2022-06-05 01:38:42 +02:00
ks = new HashMap<Pointers.Modifiers, KeyValue>();
Refactor: Remove KeyValue.name This makes KeyValue objects smaller. 'equals' and 'hashCode' are now implemented too. Key names are still used to recognise keys with special meaning, but not for comparing keys anymore.
2022-06-06 00:23:45 +02:00
_cache.put(k, ks);
Separate handling of modifiers from KeyValue class KeyValue defines an ADT and some of its values, it now contains public final fields and no internal logic. KeyModifier handles modifiers and accents and creates new instances of KeyValue when needed. This operation is now properly cached.
2021-04-18 23:28:49 +02:00
}
return ks;
}
Stop using flags for modifiers There was no free bits left to add new modifiers. Instead of increasing the width of the 'flags' field, refactor the way modifiers are represented and used. Modifers are now represented as independent values and stored in the 'code' field. A flag is added to distinguish between modifiers and keys with a key event. The most notable change is that modifiers can no longer be or-ed into a single value but have to be represented as an array.
2022-06-05 01:38:42 +02:00
Per-script numpad The numeric layout and the optional right hand side numpad are modified to show the digits belonging to the script used in the current layout. The numpads are still defined as it was before. The digits are changed in `modify_numpad` if needed.
2023-09-03 23:38:55 +02:00
public static abstract class Map_char
Refactor: Abstract KeyValue fields The meaning of the public fields of KeyValue was quite complicated and not handled consistently accross the app. Make these fields private and add a more abstract API on top. The meaning of these fields changed recently and it wasn't an easy change. I plan on making more changes in the future.
2022-06-05 17:26:34 +02:00
{
Refactor: Allow combining diacritics modifiers Change the API of `KeyModifier.Map_char` to allow returning a string instead of a single 16 bits char. This allows to return combining diacritics. This also gets rid of `apply_map_or_dead_char`, maps can have their own fallback.
2023-08-20 00:44:22 +02:00
/** Modify a char or return [null] if the modifier do not apply. Return a
[String] that can contains combining diacritics. */
public abstract String apply(char c);
Refactor: Abstract KeyValue fields The meaning of the public fields of KeyValue was quite complicated and not handled consistently accross the app. Make these fields private and add a more abstract API on top. The meaning of these fields changed recently and it wasn't an easy change. I plan on making more changes in the future.
2022-06-05 17:26:34 +02:00
}
Per-script numpad The numeric layout and the optional right hand side numpad are modified to show the digits belonging to the script used in the current layout. The numpads are still defined as it was before. The digits are changed in `modify_numpad` if needed.
2023-09-03 23:38:55 +02:00
private static final Map_char map_char_none =
new Map_char() {
public String apply(char _c) { return null; }
};
Stop using flags for modifiers There was no free bits left to add new modifiers. Instead of increasing the width of the 'flags' field, refactor the way modifiers are represented and used. Modifers are now represented as independent values and stored in the 'code' field. A flag is added to distinguish between modifiers and keys with a key event. The most notable change is that modifiers can no longer be or-ed into a single value but have to be represented as an array.
2022-06-05 01:38:42 +02:00
private static char map_char_shift(char c)
{
switch (c)
{
case '↙': return '⇙';
case '↓': return '⇓';
case '↘': return '⇘';
case '←': return '⇐';
case '→': return '⇒';
case '↖': return '⇖';
case '↑': return '⇑';
case '↗': return '⇗';
case '└': return '╚';
case '┴': return '╩';
case '┘': return '╝';
case '├': return '╠';
case '┼': return '╬';
case '┤': return '╣';
case '┌': return '╔';
case '┬': return '╦';
case '┐': return '╗';
case '─': return '═';
case '│': return '║';
added uppercase ẞ of ß
2022-07-08 03:04:10 +02:00
case 'ß': return 'ẞ';
Allow to type İ on the Turkish layout In Turkish, upper case of 'iı' is 'İI' but Java's toUpperCase will return 'II'. To make 'İ' accessible, make it the shift of 'ı'. This has the inconvenient of swapping i and ı on the keyboard.
2022-10-04 10:10:54 +02:00
/* In Turkish, upper case of 'iı' is 'İI' but Java's toUpperCase will
return 'II'. To make 'İ' accessible, make it the shift of 'ı'. This
has the inconvenient of swapping i and ı on the keyboard. */
case 'ı': return 'İ';
Use '₹' instead of '₨' in Hindi ₨ is Shift+₹.
2022-11-01 21:44:49 +01:00
case '₹': return '₨';
Stop using flags for modifiers There was no free bits left to add new modifiers. Instead of increasing the width of the 'flags' field, refactor the way modifiers are represented and used. Modifers are now represented as independent values and stored in the 'code' field. A flag is added to distinguish between modifiers and keys with a key event. The most notable change is that modifiers can no longer be or-ed into a single value but have to be represented as an array.
2022-06-05 01:38:42 +02:00
default: return c;
}
}
Refactor: Allow combining diacritics modifiers Change the API of `KeyModifier.Map_char` to allow returning a string instead of a single 16 bits char. This allows to return combining diacritics. This also gets rid of `apply_map_or_dead_char`, maps can have their own fallback.
2023-08-20 00:44:22 +02:00
/** Return [null] if the dead char do not apply. */
private static String map_dead_char(char c, char dead_char)
{
char modified = (char)KeyCharacterMap.getDeadChar(dead_char, c);
return (modified == 0 || modified == c) ? null : String.valueOf(modified);
}
Add hardcoded charmaps for most accents `KeyCharacterMap.getDeadChar` may not be aware of the same dead keys in older version of Android. Hardcoded charmaps are more predictable.
2023-06-25 20:00:29 +02:00
private static final Map_char map_char_aigu =
new Map_char() {
Refactor: Allow combining diacritics modifiers Change the API of `KeyModifier.Map_char` to allow returning a string instead of a single 16 bits char. This allows to return combining diacritics. This also gets rid of `apply_map_or_dead_char`, maps can have their own fallback.
2023-08-20 00:44:22 +02:00
public String apply(char c)
Add hardcoded charmaps for most accents `KeyCharacterMap.getDeadChar` may not be aware of the same dead keys in older version of Android. Hardcoded charmaps are more predictable.
2023-06-25 20:00:29 +02:00
{
switch (c)
{
Refactor: Allow combining diacritics modifiers Change the API of `KeyModifier.Map_char` to allow returning a string instead of a single 16 bits char. This allows to return combining diacritics. This also gets rid of `apply_map_or_dead_char`, maps can have their own fallback.
2023-08-20 00:44:22 +02:00
case 'a': return "á";
case 'e': return "é";
case 'i': return "í";
case 'l': return "ĺ";
case 'o': return "ó";
case 'r': return "ŕ";
case 's': return "ś";
case 'u': return "ú";
case 'y': return "ý";
Add missing combining accents Implement the combinations that were previously not possible and were commented out. Also remove `apply_dead_char` and `apply_combining` and make all dead-keys definitions uniform.
2023-08-20 01:01:38 +02:00
// Combining diacritic
case 'j':
return c + "\u0301";
Refactor: Allow combining diacritics modifiers Change the API of `KeyModifier.Map_char` to allow returning a string instead of a single 16 bits char. This allows to return combining diacritics. This also gets rid of `apply_map_or_dead_char`, maps can have their own fallback.
2023-08-20 00:44:22 +02:00
default: return map_dead_char(c, '\u00B4');
Add hardcoded charmaps for most accents `KeyCharacterMap.getDeadChar` may not be aware of the same dead keys in older version of Android. Hardcoded charmaps are more predictable.
2023-06-25 20:00:29 +02:00
}
}
};
private static final Map_char map_char_caron =
new Map_char() {
Refactor: Allow combining diacritics modifiers Change the API of `KeyModifier.Map_char` to allow returning a string instead of a single 16 bits char. This allows to return combining diacritics. This also gets rid of `apply_map_or_dead_char`, maps can have their own fallback.
2023-08-20 00:44:22 +02:00
public String apply(char c)
Add hardcoded charmaps for most accents `KeyCharacterMap.getDeadChar` may not be aware of the same dead keys in older version of Android. Hardcoded charmaps are more predictable.
2023-06-25 20:00:29 +02:00
{
switch (c)
{
Refactor: Allow combining diacritics modifiers Change the API of `KeyModifier.Map_char` to allow returning a string instead of a single 16 bits char. This allows to return combining diacritics. This also gets rid of `apply_map_or_dead_char`, maps can have their own fallback.
2023-08-20 00:44:22 +02:00
case 'c': return "č";
case 'd': return "ď";
case 'e': return "ě";
case 'l': return "ľ";
case 'n': return "ň";
case 'r': return "ř";
case 's': return "š";
case 't': return "ť";
case 'z': return "ž";
default: return map_dead_char(c, '\u02C7');
Add hardcoded charmaps for most accents `KeyCharacterMap.getDeadChar` may not be aware of the same dead keys in older version of Android. Hardcoded charmaps are more predictable.
2023-06-25 20:00:29 +02:00
}
}
};
private static final Map_char map_char_cedille =
new Map_char() {
Refactor: Allow combining diacritics modifiers Change the API of `KeyModifier.Map_char` to allow returning a string instead of a single 16 bits char. This allows to return combining diacritics. This also gets rid of `apply_map_or_dead_char`, maps can have their own fallback.
2023-08-20 00:44:22 +02:00
public String apply(char c)
Add hardcoded charmaps for most accents `KeyCharacterMap.getDeadChar` may not be aware of the same dead keys in older version of Android. Hardcoded charmaps are more predictable.
2023-06-25 20:00:29 +02:00
{
switch (c)
{
Refactor: Allow combining diacritics modifiers Change the API of `KeyModifier.Map_char` to allow returning a string instead of a single 16 bits char. This allows to return combining diacritics. This also gets rid of `apply_map_or_dead_char`, maps can have their own fallback.
2023-08-20 00:44:22 +02:00
case 'c': return "ç";
case 's': return "ş";
case 'g': return "ģ";
default: return map_dead_char(c, '\u00B8');
Add hardcoded charmaps for most accents `KeyCharacterMap.getDeadChar` may not be aware of the same dead keys in older version of Android. Hardcoded charmaps are more predictable.
2023-06-25 20:00:29 +02:00
}
}
};
private static final Map_char map_char_circonflexe =
new Map_char() {
Refactor: Allow combining diacritics modifiers Change the API of `KeyModifier.Map_char` to allow returning a string instead of a single 16 bits char. This allows to return combining diacritics. This also gets rid of `apply_map_or_dead_char`, maps can have their own fallback.
2023-08-20 00:44:22 +02:00
public String apply(char c)
Add hardcoded charmaps for most accents `KeyCharacterMap.getDeadChar` may not be aware of the same dead keys in older version of Android. Hardcoded charmaps are more predictable.
2023-06-25 20:00:29 +02:00
{
switch (c)
{
Refactor: Allow combining diacritics modifiers Change the API of `KeyModifier.Map_char` to allow returning a string instead of a single 16 bits char. This allows to return combining diacritics. This also gets rid of `apply_map_or_dead_char`, maps can have their own fallback.
2023-08-20 00:44:22 +02:00
case 'a': return "â";
case 'e': return "ê";
case 'i': return "î";
case 'o': return "ô";
case 'u': return "û";
default: return map_dead_char(c, '\u02C6');
Add hardcoded charmaps for most accents `KeyCharacterMap.getDeadChar` may not be aware of the same dead keys in older version of Android. Hardcoded charmaps are more predictable.
2023-06-25 20:00:29 +02:00
}
}
};
private static final Map_char map_char_dot_above =
new Map_char() {
Refactor: Allow combining diacritics modifiers Change the API of `KeyModifier.Map_char` to allow returning a string instead of a single 16 bits char. This allows to return combining diacritics. This also gets rid of `apply_map_or_dead_char`, maps can have their own fallback.
2023-08-20 00:44:22 +02:00
public String apply(char c)
Add hardcoded charmaps for most accents `KeyCharacterMap.getDeadChar` may not be aware of the same dead keys in older version of Android. Hardcoded charmaps are more predictable.
2023-06-25 20:00:29 +02:00
{
switch (c)
{
Refactor: Allow combining diacritics modifiers Change the API of `KeyModifier.Map_char` to allow returning a string instead of a single 16 bits char. This allows to return combining diacritics. This also gets rid of `apply_map_or_dead_char`, maps can have their own fallback.
2023-08-20 00:44:22 +02:00
case 'ė': return "ė";
default: return map_dead_char(c, '\u02D9');
Add hardcoded charmaps for most accents `KeyCharacterMap.getDeadChar` may not be aware of the same dead keys in older version of Android. Hardcoded charmaps are more predictable.
2023-06-25 20:00:29 +02:00
}
}
};
private static final Map_char map_char_grave =
new Map_char() {
Refactor: Allow combining diacritics modifiers Change the API of `KeyModifier.Map_char` to allow returning a string instead of a single 16 bits char. This allows to return combining diacritics. This also gets rid of `apply_map_or_dead_char`, maps can have their own fallback.
2023-08-20 00:44:22 +02:00
public String apply(char c)
Add hardcoded charmaps for most accents `KeyCharacterMap.getDeadChar` may not be aware of the same dead keys in older version of Android. Hardcoded charmaps are more predictable.
2023-06-25 20:00:29 +02:00
{
switch (c)
{
Refactor: Allow combining diacritics modifiers Change the API of `KeyModifier.Map_char` to allow returning a string instead of a single 16 bits char. This allows to return combining diacritics. This also gets rid of `apply_map_or_dead_char`, maps can have their own fallback.
2023-08-20 00:44:22 +02:00
case 'a': return "à";
case 'e': return "è";
case 'i': return "ì";
case 'o': return "ò";
case 'u': return "ù";
default: return map_dead_char(c, '\u02CB');
Add hardcoded charmaps for most accents `KeyCharacterMap.getDeadChar` may not be aware of the same dead keys in older version of Android. Hardcoded charmaps are more predictable.
2023-06-25 20:00:29 +02:00
}
}
};
private static final Map_char map_char_macron =
new Map_char() {
Refactor: Allow combining diacritics modifiers Change the API of `KeyModifier.Map_char` to allow returning a string instead of a single 16 bits char. This allows to return combining diacritics. This also gets rid of `apply_map_or_dead_char`, maps can have their own fallback.
2023-08-20 00:44:22 +02:00
public String apply(char c)
Add hardcoded charmaps for most accents `KeyCharacterMap.getDeadChar` may not be aware of the same dead keys in older version of Android. Hardcoded charmaps are more predictable.
2023-06-25 20:00:29 +02:00
{
switch (c)
{
Refactor: Allow combining diacritics modifiers Change the API of `KeyModifier.Map_char` to allow returning a string instead of a single 16 bits char. This allows to return combining diacritics. This also gets rid of `apply_map_or_dead_char`, maps can have their own fallback.
2023-08-20 00:44:22 +02:00
case 'a': return "ā";
case 'e': return "ē";
case 'i': return "ī";
case 'u': return "ū";
default: return map_dead_char(c, '\u00AF');
Add hardcoded charmaps for most accents `KeyCharacterMap.getDeadChar` may not be aware of the same dead keys in older version of Android. Hardcoded charmaps are more predictable.
2023-06-25 20:00:29 +02:00
}
}
};
private static final Map_char map_char_ogonek =
new Map_char() {
Refactor: Allow combining diacritics modifiers Change the API of `KeyModifier.Map_char` to allow returning a string instead of a single 16 bits char. This allows to return combining diacritics. This also gets rid of `apply_map_or_dead_char`, maps can have their own fallback.
2023-08-20 00:44:22 +02:00
public String apply(char c)
Add hardcoded charmaps for most accents `KeyCharacterMap.getDeadChar` may not be aware of the same dead keys in older version of Android. Hardcoded charmaps are more predictable.
2023-06-25 20:00:29 +02:00
{
switch (c)
{
Refactor: Allow combining diacritics modifiers Change the API of `KeyModifier.Map_char` to allow returning a string instead of a single 16 bits char. This allows to return combining diacritics. This also gets rid of `apply_map_or_dead_char`, maps can have their own fallback.
2023-08-20 00:44:22 +02:00
case 'a': return "ą";
case 'e': return "ę";
case 'i': return "į";
case 'k': return "ķ";
case 'l': return "ļ";
case 'n': return "ņ";
case 'u': return "ų";
default: return map_dead_char(c, '\u02DB');
Add hardcoded charmaps for most accents `KeyCharacterMap.getDeadChar` may not be aware of the same dead keys in older version of Android. Hardcoded charmaps are more predictable.
2023-06-25 20:00:29 +02:00
}
}
};
private static final Map_char map_char_ring =
new Map_char() {
Refactor: Allow combining diacritics modifiers Change the API of `KeyModifier.Map_char` to allow returning a string instead of a single 16 bits char. This allows to return combining diacritics. This also gets rid of `apply_map_or_dead_char`, maps can have their own fallback.
2023-08-20 00:44:22 +02:00
public String apply(char c)
Add hardcoded charmaps for most accents `KeyCharacterMap.getDeadChar` may not be aware of the same dead keys in older version of Android. Hardcoded charmaps are more predictable.
2023-06-25 20:00:29 +02:00
{
switch (c)
{
Refactor: Allow combining diacritics modifiers Change the API of `KeyModifier.Map_char` to allow returning a string instead of a single 16 bits char. This allows to return combining diacritics. This also gets rid of `apply_map_or_dead_char`, maps can have their own fallback.
2023-08-20 00:44:22 +02:00
case 'a': return "å";
case 'u': return "ů";
default: return map_dead_char(c, '\u02DA');
Add hardcoded charmaps for most accents `KeyCharacterMap.getDeadChar` may not be aware of the same dead keys in older version of Android. Hardcoded charmaps are more predictable.
2023-06-25 20:00:29 +02:00
}
}
};
Explicitly map dead key for ñ `KeyCharacterMap.getDeadChar` seems to not give the expected result on Android 4.0. This might affect many more dead key combinations that are not fixed by this commit.
2023-06-04 23:07:35 +02:00
private static final Map_char map_char_tilde =
new Map_char() {
Refactor: Allow combining diacritics modifiers Change the API of `KeyModifier.Map_char` to allow returning a string instead of a single 16 bits char. This allows to return combining diacritics. This also gets rid of `apply_map_or_dead_char`, maps can have their own fallback.
2023-08-20 00:44:22 +02:00
public String apply(char c)
Explicitly map dead key for ñ `KeyCharacterMap.getDeadChar` seems to not give the expected result on Android 4.0. This might affect many more dead key combinations that are not fixed by this commit.
2023-06-04 23:07:35 +02:00
{
switch (c)
{
Refactor: Allow combining diacritics modifiers Change the API of `KeyModifier.Map_char` to allow returning a string instead of a single 16 bits char. This allows to return combining diacritics. This also gets rid of `apply_map_or_dead_char`, maps can have their own fallback.
2023-08-20 00:44:22 +02:00
case 'a': return "ã";
case 'o': return "õ";
case 'n': return "ñ";
default: return map_dead_char(c, '\u02DC');
Add hardcoded charmaps for most accents `KeyCharacterMap.getDeadChar` may not be aware of the same dead keys in older version of Android. Hardcoded charmaps are more predictable.
2023-06-25 20:00:29 +02:00
}
}
};
private static final Map_char map_char_trema =
new Map_char() {
Refactor: Allow combining diacritics modifiers Change the API of `KeyModifier.Map_char` to allow returning a string instead of a single 16 bits char. This allows to return combining diacritics. This also gets rid of `apply_map_or_dead_char`, maps can have their own fallback.
2023-08-20 00:44:22 +02:00
public String apply(char c)
Add hardcoded charmaps for most accents `KeyCharacterMap.getDeadChar` may not be aware of the same dead keys in older version of Android. Hardcoded charmaps are more predictable.
2023-06-25 20:00:29 +02:00
{
switch (c)
{
Refactor: Allow combining diacritics modifiers Change the API of `KeyModifier.Map_char` to allow returning a string instead of a single 16 bits char. This allows to return combining diacritics. This also gets rid of `apply_map_or_dead_char`, maps can have their own fallback.
2023-08-20 00:44:22 +02:00
case 'a': return "ä";
case 'e': return "ë";
case 'i': return "ï";
case 'o': return "ö";
case 'u': return "ü";
case 'y': return "ÿ";
default: return map_dead_char(c, '\u00A8');
Explicitly map dead key for ñ `KeyCharacterMap.getDeadChar` seems to not give the expected result on Android 4.0. This might affect many more dead key combinations that are not fixed by this commit.
2023-06-04 23:07:35 +02:00
}
}
};
Add missing combining accents Implement the combinations that were previously not possible and were commented out. Also remove `apply_dead_char` and `apply_combining` and make all dead-keys definitions uniform.
2023-08-20 01:01:38 +02:00
private static final Map_char map_char_breve =
new Map_char() {
public String apply(char c)
{
switch (c)
{
default: return map_dead_char(c, '\u02D8');
}
}
};
Refactor: Abstract KeyValue fields The meaning of the public fields of KeyValue was quite complicated and not handled consistently accross the app. Make these fields private and add a more abstract API on top. The meaning of these fields changed recently and it wasn't an easy change. I plan on making more changes in the future.
2022-06-05 17:26:34 +02:00
private static final Map_char map_char_double_aigu =
new Map_char() {
Refactor: Allow combining diacritics modifiers Change the API of `KeyModifier.Map_char` to allow returning a string instead of a single 16 bits char. This allows to return combining diacritics. This also gets rid of `apply_map_or_dead_char`, maps can have their own fallback.
2023-08-20 00:44:22 +02:00
public String apply(char c)
Refactor: Abstract KeyValue fields The meaning of the public fields of KeyValue was quite complicated and not handled consistently accross the app. Make these fields private and add a more abstract API on top. The meaning of these fields changed recently and it wasn't an easy change. I plan on making more changes in the future.
2022-06-05 17:26:34 +02:00
{
switch (c)
{
Refactor: Allow combining diacritics modifiers Change the API of `KeyModifier.Map_char` to allow returning a string instead of a single 16 bits char. This allows to return combining diacritics. This also gets rid of `apply_map_or_dead_char`, maps can have their own fallback.
2023-08-20 00:44:22 +02:00
case 'o': return "ő";
case 'u': return "ű";
case ' ': return "˝";
Add missing combining accents Implement the combinations that were previously not possible and were commented out. Also remove `apply_dead_char` and `apply_combining` and make all dead-keys definitions uniform.
2023-08-20 01:01:38 +02:00
// Combining diacritic
case 'a':
case 'e':
case 'i':
case 'm':
case 'y':
return c + "\u030b";
Refactor: Allow combining diacritics modifiers Change the API of `KeyModifier.Map_char` to allow returning a string instead of a single 16 bits char. This allows to return combining diacritics. This also gets rid of `apply_map_or_dead_char`, maps can have their own fallback.
2023-08-20 00:44:22 +02:00
default: return null;
Refactor: Abstract KeyValue fields The meaning of the public fields of KeyValue was quite complicated and not handled consistently accross the app. Make these fields private and add a more abstract API on top. The meaning of these fields changed recently and it wasn't an easy change. I plan on making more changes in the future.
2022-06-05 17:26:34 +02:00
}
}
};
Stop using flags for modifiers There was no free bits left to add new modifiers. Instead of increasing the width of the 'flags' field, refactor the way modifiers are represented and used. Modifers are now represented as independent values and stored in the 'code' field. A flag is added to distinguish between modifiers and keys with a key event. The most notable change is that modifiers can no longer be or-ed into a single value but have to be represented as an array.
2022-06-05 01:38:42 +02:00
Refactor: Abstract KeyValue fields The meaning of the public fields of KeyValue was quite complicated and not handled consistently accross the app. Make these fields private and add a more abstract API on top. The meaning of these fields changed recently and it wasn't an easy change. I plan on making more changes in the future.
2022-06-05 17:26:34 +02:00
private static final Map_char map_char_ordinal =
new Map_char() {
Refactor: Allow combining diacritics modifiers Change the API of `KeyModifier.Map_char` to allow returning a string instead of a single 16 bits char. This allows to return combining diacritics. This also gets rid of `apply_map_or_dead_char`, maps can have their own fallback.
2023-08-20 00:44:22 +02:00
public String apply(char c)
Refactor: Abstract KeyValue fields The meaning of the public fields of KeyValue was quite complicated and not handled consistently accross the app. Make these fields private and add a more abstract API on top. The meaning of these fields changed recently and it wasn't an easy change. I plan on making more changes in the future.
2022-06-05 17:26:34 +02:00
{
switch (c)
{
Refactor: Allow combining diacritics modifiers Change the API of `KeyModifier.Map_char` to allow returning a string instead of a single 16 bits char. This allows to return combining diacritics. This also gets rid of `apply_map_or_dead_char`, maps can have their own fallback.
2023-08-20 00:44:22 +02:00
case 'a': return "ª";
case 'o': return "º";
case '1': return "ª";
case '2': return "º";
case '3': return "ⁿ";
case '4': return "ᵈ";
case '5': return "ᵉ";
case '6': return "ʳ";
case '7': return "ˢ";
case '8': return "ᵗ";
case '9': return "ʰ";
case '*': return "°";
default: return null;
Refactor: Abstract KeyValue fields The meaning of the public fields of KeyValue was quite complicated and not handled consistently accross the app. Make these fields private and add a more abstract API on top. The meaning of these fields changed recently and it wasn't an easy change. I plan on making more changes in the future.
2022-06-05 17:26:34 +02:00
}
}
};
Stop using flags for modifiers There was no free bits left to add new modifiers. Instead of increasing the width of the 'flags' field, refactor the way modifiers are represented and used. Modifers are now represented as independent values and stored in the 'code' field. A flag is added to distinguish between modifiers and keys with a key event. The most notable change is that modifiers can no longer be or-ed into a single value but have to be represented as an array.
2022-06-05 01:38:42 +02:00
Refactor: Abstract KeyValue fields The meaning of the public fields of KeyValue was quite complicated and not handled consistently accross the app. Make these fields private and add a more abstract API on top. The meaning of these fields changed recently and it wasn't an easy change. I plan on making more changes in the future.
2022-06-05 17:26:34 +02:00
private static final Map_char map_char_superscript =
new Map_char() {
Refactor: Allow combining diacritics modifiers Change the API of `KeyModifier.Map_char` to allow returning a string instead of a single 16 bits char. This allows to return combining diacritics. This also gets rid of `apply_map_or_dead_char`, maps can have their own fallback.
2023-08-20 00:44:22 +02:00
public String apply(char c)
Refactor: Abstract KeyValue fields The meaning of the public fields of KeyValue was quite complicated and not handled consistently accross the app. Make these fields private and add a more abstract API on top. The meaning of these fields changed recently and it wasn't an easy change. I plan on making more changes in the future.
2022-06-05 17:26:34 +02:00
{
switch (c)
{
Refactor: Allow combining diacritics modifiers Change the API of `KeyModifier.Map_char` to allow returning a string instead of a single 16 bits char. This allows to return combining diacritics. This also gets rid of `apply_map_or_dead_char`, maps can have their own fallback.
2023-08-20 00:44:22 +02:00
case '1': return "¹";
case '2': return "²";
case '3': return "³";
case '4': return "⁴";
case '5': return "⁵";
case '6': return "⁶";
case '7': return "⁷";
case '8': return "⁸";
case '9': return "⁹";
case '0': return "⁰";
case '+': return "⁺";
case '-': return "⁻";
case '=': return "⁼";
case '(': return "⁽";
case ')': return "⁾";
case 'a': return "ᵃ";
case 'b': return "ᵇ";
case 'c': return "ᶜ";
case 'd': return "ᵈ";
case 'e': return "ᵉ";
case 'f': return "ᶠ";
case 'g': return "ᵍ";
case 'h': return "ʰ";
case 'i': return "ⁱ";
case 'j': return "ʲ";
case 'k': return "ᵏ";
case 'l': return "ˡ";
case 'm': return "ᵐ";
case 'n': return "ⁿ";
case 'o': return "ᵒ";
case 'p': return "ᵖ";
case 'r': return "ʳ";
case 's': return "ˢ";
case 't': return "ᵗ";
case 'u': return "ᵘ";
case 'v': return "ᵛ";
case 'w': return "ʷ";
case 'x': return "ˣ";
case 'y': return "ʸ";
case 'z': return "ᶻ";
default: return null;
Refactor: Abstract KeyValue fields The meaning of the public fields of KeyValue was quite complicated and not handled consistently accross the app. Make these fields private and add a more abstract API on top. The meaning of these fields changed recently and it wasn't an easy change. I plan on making more changes in the future.
2022-06-05 17:26:34 +02:00
}
}
};
Stop using flags for modifiers There was no free bits left to add new modifiers. Instead of increasing the width of the 'flags' field, refactor the way modifiers are represented and used. Modifers are now represented as independent values and stored in the 'code' field. A flag is added to distinguish between modifiers and keys with a key event. The most notable change is that modifiers can no longer be or-ed into a single value but have to be represented as an array.
2022-06-05 01:38:42 +02:00
Refactor: Abstract KeyValue fields The meaning of the public fields of KeyValue was quite complicated and not handled consistently accross the app. Make these fields private and add a more abstract API on top. The meaning of these fields changed recently and it wasn't an easy change. I plan on making more changes in the future.
2022-06-05 17:26:34 +02:00
private static final Map_char map_char_subscript =
new Map_char() {
Refactor: Allow combining diacritics modifiers Change the API of `KeyModifier.Map_char` to allow returning a string instead of a single 16 bits char. This allows to return combining diacritics. This also gets rid of `apply_map_or_dead_char`, maps can have their own fallback.
2023-08-20 00:44:22 +02:00
public String apply(char c)
Refactor: Abstract KeyValue fields The meaning of the public fields of KeyValue was quite complicated and not handled consistently accross the app. Make these fields private and add a more abstract API on top. The meaning of these fields changed recently and it wasn't an easy change. I plan on making more changes in the future.
2022-06-05 17:26:34 +02:00
{
switch (c)
{
Refactor: Allow combining diacritics modifiers Change the API of `KeyModifier.Map_char` to allow returning a string instead of a single 16 bits char. This allows to return combining diacritics. This also gets rid of `apply_map_or_dead_char`, maps can have their own fallback.
2023-08-20 00:44:22 +02:00
case '1': return "₁";
case '2': return "₂";
case '3': return "₃";
case '4': return "₄";
case '5': return "₅";
case '6': return "₆";
case '7': return "₇";
case '8': return "₈";
case '9': return "₉";
case '0': return "₀";
case '+': return "₊";
case '-': return "₋";
case '=': return "₌";
case '(': return "₍";
case ')': return "₎";
case 'a': return "ₐ";
case 'e': return "ₑ";
case 'h': return "ₕ";
case 'i': return "ᵢ";
case 'j': return "ⱼ";
case 'k': return "ₖ";
case 'l': return "ₗ";
case 'm': return "ₘ";
case 'n': return "ₙ";
case 'o': return "ₒ";
case 'p': return "ₚ";
case 'r': return "ᵣ";
case 's': return "ₛ";
case 't': return "ₜ";
case 'u': return "ᵤ";
case 'v': return "ᵥ";
case 'x': return "ₓ";
default: return null;
Refactor: Abstract KeyValue fields The meaning of the public fields of KeyValue was quite complicated and not handled consistently accross the app. Make these fields private and add a more abstract API on top. The meaning of these fields changed recently and it wasn't an easy change. I plan on making more changes in the future.
2022-06-05 17:26:34 +02:00
}
}
};
Stop using flags for modifiers There was no free bits left to add new modifiers. Instead of increasing the width of the 'flags' field, refactor the way modifiers are represented and used. Modifers are now represented as independent values and stored in the 'code' field. A flag is added to distinguish between modifiers and keys with a key event. The most notable change is that modifiers can no longer be or-ed into a single value but have to be represented as an array.
2022-06-05 01:38:42 +02:00
Refactor: Abstract KeyValue fields The meaning of the public fields of KeyValue was quite complicated and not handled consistently accross the app. Make these fields private and add a more abstract API on top. The meaning of these fields changed recently and it wasn't an easy change. I plan on making more changes in the future.
2022-06-05 17:26:34 +02:00
private static final Map_char map_char_arrows =
new Map_char() {
Refactor: Allow combining diacritics modifiers Change the API of `KeyModifier.Map_char` to allow returning a string instead of a single 16 bits char. This allows to return combining diacritics. This also gets rid of `apply_map_or_dead_char`, maps can have their own fallback.
2023-08-20 00:44:22 +02:00
public String apply(char c)
Refactor: Abstract KeyValue fields The meaning of the public fields of KeyValue was quite complicated and not handled consistently accross the app. Make these fields private and add a more abstract API on top. The meaning of these fields changed recently and it wasn't an easy change. I plan on making more changes in the future.
2022-06-05 17:26:34 +02:00
{
switch (c)
{
Refactor: Allow combining diacritics modifiers Change the API of `KeyModifier.Map_char` to allow returning a string instead of a single 16 bits char. This allows to return combining diacritics. This also gets rid of `apply_map_or_dead_char`, maps can have their own fallback.
2023-08-20 00:44:22 +02:00
case '1': return "↙";
case '2': return "↓";
case '3': return "↘";
case '4': return "←";
case '6': return "→";
case '7': return "↖";
case '8': return "↑";
case '9': return "↗";
default: return null;
Refactor: Abstract KeyValue fields The meaning of the public fields of KeyValue was quite complicated and not handled consistently accross the app. Make these fields private and add a more abstract API on top. The meaning of these fields changed recently and it wasn't an easy change. I plan on making more changes in the future.
2022-06-05 17:26:34 +02:00
}
}
};
Stop using flags for modifiers There was no free bits left to add new modifiers. Instead of increasing the width of the 'flags' field, refactor the way modifiers are represented and used. Modifers are now represented as independent values and stored in the 'code' field. A flag is added to distinguish between modifiers and keys with a key event. The most notable change is that modifiers can no longer be or-ed into a single value but have to be represented as an array.
2022-06-05 01:38:42 +02:00
Add missing combining accents Implement the combinations that were previously not possible and were commented out. Also remove `apply_dead_char` and `apply_combining` and make all dead-keys definitions uniform.
2023-08-20 01:01:38 +02:00
private static final Map_char map_char_arrow_right =
new Map_char() {
public String apply(char c)
{
switch (c)
{
default: return c + "\u20D7";
}
}
};
Refactor: Abstract KeyValue fields The meaning of the public fields of KeyValue was quite complicated and not handled consistently accross the app. Make these fields private and add a more abstract API on top. The meaning of these fields changed recently and it wasn't an easy change. I plan on making more changes in the future.
2022-06-05 17:26:34 +02:00
private static final Map_char map_char_box =
new Map_char() {
Refactor: Allow combining diacritics modifiers Change the API of `KeyModifier.Map_char` to allow returning a string instead of a single 16 bits char. This allows to return combining diacritics. This also gets rid of `apply_map_or_dead_char`, maps can have their own fallback.
2023-08-20 00:44:22 +02:00
public String apply(char c)
Refactor: Abstract KeyValue fields The meaning of the public fields of KeyValue was quite complicated and not handled consistently accross the app. Make these fields private and add a more abstract API on top. The meaning of these fields changed recently and it wasn't an easy change. I plan on making more changes in the future.
2022-06-05 17:26:34 +02:00
{
switch (c)
{
Refactor: Allow combining diacritics modifiers Change the API of `KeyModifier.Map_char` to allow returning a string instead of a single 16 bits char. This allows to return combining diacritics. This also gets rid of `apply_map_or_dead_char`, maps can have their own fallback.
2023-08-20 00:44:22 +02:00
case '1': return "└";
case '2': return "┴";
case '3': return "┘";
case '4': return "├";
case '5': return "┼";
case '6': return "┤";
case '7': return "┌";
case '8': return "┬";
case '9': return "┐";
case '0': return "─";
case '.': return "│";
default: return null;
Refactor: Abstract KeyValue fields The meaning of the public fields of KeyValue was quite complicated and not handled consistently accross the app. Make these fields private and add a more abstract API on top. The meaning of these fields changed recently and it wasn't an easy change. I plan on making more changes in the future.
2022-06-05 17:26:34 +02:00
}
}
};
Add the 'accent_slash' modifier Might be useful for some math characters.
2022-06-05 12:02:35 +02:00
Refactor: Abstract KeyValue fields The meaning of the public fields of KeyValue was quite complicated and not handled consistently accross the app. Make these fields private and add a more abstract API on top. The meaning of these fields changed recently and it wasn't an easy change. I plan on making more changes in the future.
2022-06-05 17:26:34 +02:00
private static final Map_char map_char_slash =
new Map_char() {
Refactor: Allow combining diacritics modifiers Change the API of `KeyModifier.Map_char` to allow returning a string instead of a single 16 bits char. This allows to return combining diacritics. This also gets rid of `apply_map_or_dead_char`, maps can have their own fallback.
2023-08-20 00:44:22 +02:00
public String apply(char c)
Refactor: Abstract KeyValue fields The meaning of the public fields of KeyValue was quite complicated and not handled consistently accross the app. Make these fields private and add a more abstract API on top. The meaning of these fields changed recently and it wasn't an easy change. I plan on making more changes in the future.
2022-06-05 17:26:34 +02:00
{
switch (c)
{
Refactor: Allow combining diacritics modifiers Change the API of `KeyModifier.Map_char` to allow returning a string instead of a single 16 bits char. This allows to return combining diacritics. This also gets rid of `apply_map_or_dead_char`, maps can have their own fallback.
2023-08-20 00:44:22 +02:00
case 'a': return "ⱥ";
case 'b': return "␢";
case 'c': return "ȼ";
case 'e': return "ɇ";
case 'g': return "ꞡ";
case 'k': return "ꝃ";
case 'l': return "ł";
case 'n': return "ꞥ";
case 'o': return "ø";
case 'r': return "ꞧ";
case 's': return "ꞩ";
case 't': return "ⱦ";
default: return null;
Refactor: Abstract KeyValue fields The meaning of the public fields of KeyValue was quite complicated and not handled consistently accross the app. Make these fields private and add a more abstract API on top. The meaning of these fields changed recently and it wasn't an easy change. I plan on making more changes in the future.
2022-06-05 17:26:34 +02:00
}
}
};
Add the bar diacritic dead key Allows to type many of the "with stroke" or "with bar" latin letters.
2022-11-05 19:26:49 +01:00
private static final Map_char map_char_bar =
new Map_char() {
Refactor: Allow combining diacritics modifiers Change the API of `KeyModifier.Map_char` to allow returning a string instead of a single 16 bits char. This allows to return combining diacritics. This also gets rid of `apply_map_or_dead_char`, maps can have their own fallback.
2023-08-20 00:44:22 +02:00
public String apply(char c)
Add the bar diacritic dead key Allows to type many of the "with stroke" or "with bar" latin letters.
2022-11-05 19:26:49 +01:00
{
switch (c)
{
Refactor: Allow combining diacritics modifiers Change the API of `KeyModifier.Map_char` to allow returning a string instead of a single 16 bits char. This allows to return combining diacritics. This also gets rid of `apply_map_or_dead_char`, maps can have their own fallback.
2023-08-20 00:44:22 +02:00
case 'b': return "ƀ";
case 'c': return "ꞓ";
case 'd': return "đ";
case 'g': return "ǥ";
case 'i': return "ɨ";
case 'j': return "ɉ";
case 'k': return "ꝁ";
case 'l': return "ƚ";
case 'o': return "ɵ";
case 'p': return "ᵽ";
case 'q': return "ꝗ";
case 'r': return "ɍ";
case 't': return "ŧ";
case 'u': return "ʉ";
case 'y': return "ɏ";
case 'z': return "ƶ";
default: return null;
Add the bar diacritic dead key Allows to type many of the "with stroke" or "with bar" latin letters.
2022-11-05 19:26:49 +01:00
}
}
};
Vietnamese keyboard (#291) Added missing accent (horn, hook, dot below) Added layout Added accent font svg (by modified existing accent)
2023-02-09 18:40:48 +01:00
private static final Map_char map_char_dot_below =
Refactor: Allow combining diacritics modifiers Change the API of `KeyModifier.Map_char` to allow returning a string instead of a single 16 bits char. This allows to return combining diacritics. This also gets rid of `apply_map_or_dead_char`, maps can have their own fallback.
2023-08-20 00:44:22 +02:00
new Map_char() {
public String apply(char c)
{
switch (c)
{
case 'a': return "ạ";
case 'ă': return "ặ";
case 'â': return "ậ";
case 'e': return "ẹ";
case 'ê': return "ệ";
case 'i': return "ị";
case 'o': return "ọ";
case 'ô': return "ộ";
case 'ơ': return "ợ";
case 'u': return "ụ";
case 'ư': return "ự";
case 'y': return "ỵ";
default: return null;
}
}
};
Vietnamese keyboard (#291) Added missing accent (horn, hook, dot below) Added layout Added accent font svg (by modified existing accent)
2023-02-09 18:40:48 +01:00
private static final Map_char map_char_horn =
Refactor: Allow combining diacritics modifiers Change the API of `KeyModifier.Map_char` to allow returning a string instead of a single 16 bits char. This allows to return combining diacritics. This also gets rid of `apply_map_or_dead_char`, maps can have their own fallback.
2023-08-20 00:44:22 +02:00
new Map_char() {
public String apply(char c)
{
switch (c)
{
case 'o': return "ơ";
case 'ó': return "ớ";
case 'ò': return "ờ";
case 'ỏ': return "ở";
case 'õ': return "ỡ";
case 'ọ': return "ợ";
case 'u': return "ư";
case 'ú': return "ứ";
case 'ù': return "ừ";
case 'ủ': return "ử";
case 'ũ': return "ữ";
case 'ụ': return "ự";
default: return null;
}
}
};
Vietnamese keyboard (#291) Added missing accent (horn, hook, dot below) Added layout Added accent font svg (by modified existing accent)
2023-02-09 18:40:48 +01:00
private static final Map_char map_char_hook_above =
Refactor: Allow combining diacritics modifiers Change the API of `KeyModifier.Map_char` to allow returning a string instead of a single 16 bits char. This allows to return combining diacritics. This also gets rid of `apply_map_or_dead_char`, maps can have their own fallback.
2023-08-20 00:44:22 +02:00
new Map_char() {
public String apply(char c)
{
switch (c)
{
case 'a': return "ả";
case 'ă': return "ẳ";
case 'â': return "ẩ";
case 'e': return "ẻ";
case 'ê': return "ể";
case 'i': return "ỉ";
case 'o': return "ỏ";
case 'ô': return "ổ";
case 'ơ': return "ở";
case 'u': return "ủ";
case 'ư': return "ử";
case 'y': return "ỷ";
default: return null;
}
}
};
Per-script numpad The numeric layout and the optional right hand side numpad are modified to show the digits belonging to the script used in the current layout. The numpads are still defined as it was before. The digits are changed in `modify_numpad` if needed.
2023-09-03 23:38:55 +02:00
private static final Map_char map_char_numpad_arabic =
new Map_char() {
public String apply(char c)
{
switch (c)
{
case '0': return "٠";
case '1': return "١";
case '2': return "٢";
case '3': return "٣";
case '4': return "٤";
case '5': return "٥";
case '6': return "٦";
case '7': return "٧";
case '8': return "٨";
case '9': return "٩";
default: return null;
}
}
};
private static final Map_char map_char_numpad_bengali =
new Map_char() {
public String apply(char c)
{
switch (c)
{
case '0': return "০";
case '1': return "১";
case '2': return "২";
case '3': return "৩";
case '4': return "৪";
case '5': return "৫";
case '6': return "৬";
case '7': return "৭";
case '8': return "৮";
case '9': return "৯";
default: return null;
}
}
};
private static final Map_char map_char_numpad_devanagari =
new Map_char() {
public String apply(char c)
{
switch (c)
{
case '0': return "०";
case '1': return "१";
case '2': return "२";
case '3': return "३";
case '4': return "४";
case '5': return "५";
case '6': return "६";
case '7': return "७";
case '8': return "८";
case '9': return "९";
default: return null;
}
}
};
private static final Map_char map_char_numpad_persian =
new Map_char() {
public String apply(char c)
{
switch (c)
{
case '0': return "۰";
case '1': return "۱";
case '2': return "۲";
case '3': return "۳";
case '4': return "۴";
case '5': return "۵";
case '6': return "۶";
case '7': return "۷";
case '8': return "۸";
case '9': return "۹";
default: return null;
}
}
};
Separate handling of modifiers from KeyValue class KeyValue defines an ADT and some of its values, it now contains public final fields and no internal logic. KeyModifier handles modifiers and accents and creates new instances of KeyValue when needed. This operation is now properly cached.
2021-04-18 23:28:49 +02:00
}
Copy Permalink