holm/Unexpected-Keyboard
1
0
Fork 0
forked from extern/Unexpected-Keyboard
Code Pull Requests Activity
773147ab9c
Unexpected-Keyboard/srcs/juloo.keyboard2/Pointers.java

795 lines
22 KiB
Java
Raw Normal View History

Move pointer handling code to its own class Separate the concerns and have a clearer interface between the two parts of the code.
2022-02-20 13:09:39 +01:00
package juloo.keyboard2;
import android.os.Handler;
import android.os.Message;
import java.util.ArrayList;
Send down event for modifiers on time This allows to use modifiers in combination with other inputs like a mouse click, for example under termux-x11. The key down event and notification about modifiers changing are sent down to KeyEventHandler. A mutable state remember for which modifier down events have been sent. When pressing down a modifier with one finger and typing with the other, it might appear that the modifier is released after the first time an other key is pressed and then pressed and released for the following keys. This prevents unintentionally type two modified keys instead of one when the second key is pressed while the other is not yet released.
2024-01-26 00:17:51 +01:00
import java.util.Arrays;
import java.util.Iterator;
import java.util.NoSuchElementException;
Move pointer handling code to its own class Separate the concerns and have a clearer interface between the two parts of the code.
2022-02-20 13:09:39 +01:00
/**
* Manage pointers (fingers) on the screen and long presses.
* Call back to IPointerEventHandler.
*/
public final class Pointers implements Handler.Callback
{
refactor: Use internal flags in Pointers 'FLAG_LOCKED' and 'FLAG_FAKE_PTR' are only used within Pointers. Define new flags in Pointers and remove these from KeyValue. Also allows to define new flags.
2024-03-11 00:10:12 +01:00
public static final int FLAG_P_LATCHABLE = 1;
public static final int FLAG_P_LATCHED = (1 << 1);
public static final int FLAG_P_FAKE = (1 << 2);
public static final int FLAG_P_LOCKABLE = (1 << 3);
public static final int FLAG_P_LOCKED = (1 << 4);
refactor: Pointers: Flag for sliding state
2024-03-11 00:38:37 +01:00
public static final int FLAG_P_SLIDING = (1 << 5);
refactor: Implement Compose without global state Thanks to the previous commit, a modifier key can now be more complex than just a KeyValue.Modifier. This allows a more elegant implementation of the compose key, that could be taken as a base for other features (eg. unicode hex entry, hangul) The COMPOSE_PENDING modifier is removed as keys of kind Compose_pending can act as a modifier. This has the advantage of highlighting the key that was last pressed in the sequence. Rules are added to Pointers: Non-special but latchable keys must clear latches and cannot be locked with a long press. These rules were not needed before but were intended.
2024-03-18 01:00:22 +01:00
/** Clear latched (only if also FLAG_P_LATCHABLE set). */
public static final int FLAG_P_CLEAR_LATCHED = (1 << 6);
/** Can't be locked, even when long pressing. */
public static final int FLAG_P_CANT_LOCK = (1 << 7);
refactor: Use internal flags in Pointers 'FLAG_LOCKED' and 'FLAG_FAKE_PTR' are only used within Pointers. Define new flags in Pointers and remove these from KeyValue. Also allows to define new flags.
2024-03-11 00:10:12 +01:00
Move pointer handling code to its own class Separate the concerns and have a clearer interface between the two parts of the code.
2022-02-20 13:09:39 +01:00
private Handler _keyrepeat_handler;
private ArrayList<Pointer> _ptrs = new ArrayList<Pointer>();
private IPointerEventHandler _handler;
private Config _config;
public Pointers(IPointerEventHandler h, Config c)
{
_keyrepeat_handler = new Handler(this);
_handler = h;
_config = c;
}
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
/** Return the list of modifiers currently activated. */
public Modifiers getModifiers()
Fix modifiers not cleared when presses overlap When typing fast, a second key might be pressed before the first is released. Clearing modifiers earlier would prevent this but would break modifiers placed in corners (especially the accent keys). Instead, don't take latched modifiers into account when registering the second press. A new flag is needed to not interfere with holding modifers, which is merged with the norepeat flag.
2022-04-30 23:36:17 +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
return getModifiers(false);
Fix modifiers not cleared when presses overlap When typing fast, a second key might be pressed before the first is released. Clearing modifiers earlier would prevent this but would break modifiers placed in corners (especially the accent keys). Instead, don't take latched modifiers into account when registering the second press. A new flag is needed to not interfere with holding modifers, which is merged with the norepeat flag.
2022-04-30 23:36:17 +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
/** When [skip_latched] is true, don't take flags of latched keys into account. */
private Modifiers getModifiers(boolean skip_latched)
Move pointer handling code to its own class Separate the concerns and have a clearer interface between the two parts of the code.
2022-02-20 13:09:39 +01: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
int n_ptrs = _ptrs.size();
refactor: Allow modifier of other key kinds Allow keys of a kind other than Modifier to be a modifier. This requires writing a compareTo function for KeyValue. Fields are compared in this order: Kind, value, flags, symbol.
2024-03-18 00:14:19 +01:00
KeyValue[] mods = new KeyValue[n_ptrs];
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
int n_mods = 0;
for (int i = 0; i < n_ptrs; i++)
Fix modifiers not cleared when presses overlap When typing fast, a second key might be pressed before the first is released. Clearing modifiers earlier would prevent this but would break modifiers placed in corners (especially the accent keys). Instead, don't take latched modifiers into account when registering the second press. A new flag is needed to not interfere with holding modifers, which is merged with the norepeat flag.
2022-04-30 23:36:17 +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
Pointer p = _ptrs.get(i);
refactor: Allow modifier of other key kinds Allow keys of a kind other than Modifier to be a modifier. This requires writing a compareTo function for KeyValue. Fields are compared in this order: Kind, value, flags, symbol.
2024-03-18 00:14:19 +01:00
if (p.value != null
refactor: Add latched flag to Pointers
2024-03-11 00:29:12 +01:00
&& !(skip_latched && p.hasFlagsAny(FLAG_P_LATCHED)
refactor: Use internal flags in Pointers 'FLAG_LOCKED' and 'FLAG_FAKE_PTR' are only used within Pointers. Define new flags in Pointers and remove these from KeyValue. Also allows to define new flags.
2024-03-11 00:10:12 +01:00
&& (p.flags & FLAG_P_LOCKED) == 0))
refactor: Allow modifier of other key kinds Allow keys of a kind other than Modifier to be a modifier. This requires writing a compareTo function for KeyValue. Fields are compared in this order: Kind, value, flags, symbol.
2024-03-18 00:14:19 +01:00
mods[n_mods++] = p.value;
Fix modifiers not cleared when presses overlap When typing fast, a second key might be pressed before the first is released. Clearing modifiers earlier would prevent this but would break modifiers placed in corners (especially the accent keys). Instead, don't take latched modifiers into account when registering the second press. A new flag is needed to not interfere with holding modifers, which is merged with the norepeat flag.
2022-04-30 23:36:17 +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
return Modifiers.ofArray(mods, n_mods);
Move pointer handling code to its own class Separate the concerns and have a clearer interface between the two parts of the code.
2022-02-20 13:09:39 +01:00
}
public void clear()
{
Correctly handle pointer cancel events The cancel event ends the motion, it doesn't apply to a single pointer like it was previously expected.
2022-12-04 18:21:59 +01:00
for (Pointer p : _ptrs)
stopKeyRepeat(p);
Move pointer handling code to its own class Separate the concerns and have a clearer interface between the two parts of the code.
2022-02-20 13:09:39 +01:00
_ptrs.clear();
}
public boolean isKeyDown(KeyboardData.Key k)
{
for (Pointer p : _ptrs)
if (p.key == k)
return true;
return false;
}
refactor: Use internal flags in Pointers 'FLAG_LOCKED' and 'FLAG_FAKE_PTR' are only used within Pointers. Define new flags in Pointers and remove these from KeyValue. Also allows to define new flags.
2024-03-11 00:10:12 +01:00
/** See [FLAG_P_*] flags. Returns [-1] if the key is not pressed. */
Move pointer handling code to its own class Separate the concerns and have a clearer interface between the two parts of the code.
2022-02-20 13:09:39 +01:00
public int getKeyFlags(KeyValue kv)
{
for (Pointer p : _ptrs)
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
if (p.value != null && p.value.equals(kv))
Move pointer handling code to its own class Separate the concerns and have a clearer interface between the two parts of the code.
2022-02-20 13:09:39 +01:00
return p.flags;
return -1;
}
Fix auto-capitalisation disabling locked shift Shift locked via the "caps lock" key use the "fake pointer" mechanism that is also used by auto-capitalisation. Make sure that unlatching a fake pointer do not disabled a locked modifier. The implementation is moved into the Pointers class for a safer API and easier implementation.
2024-03-03 17:08:25 +01:00
/** The key must not be already latched . */
void add_fake_pointer(KeyboardData.Key key, KeyValue kv, boolean locked)
Automatic capitalisation at beginning of sentences Keep track of end-of-sentence characters while typing and automatically enable shift when appropriate. The last few characters just before the cursor need to be queried in some cases: Begin of input, cursor has moved or text is deleted. This might have a performance cost. This normally only enable shift but it also needs to disable shift when the cursor moves.
2022-07-24 20:02:48 +02:00
{
Fix auto-capitalisation disabling locked shift Shift locked via the "caps lock" key use the "fake pointer" mechanism that is also used by auto-capitalisation. Make sure that unlatching a fake pointer do not disabled a locked modifier. The implementation is moved into the Pointers class for a safer API and easier implementation.
2024-03-03 17:08:25 +01:00
Pointer ptr = new Pointer(-1, key, kv, 0.f, 0.f, Modifiers.EMPTY);
refactor: Add latched flag to Pointers
2024-03-11 00:29:12 +01:00
ptr.flags = FLAG_P_FAKE | FLAG_P_LATCHED;
Add the capslock key The key enable caps lock immediately. It does nothing if caps lock is already enabled. It is not present on the keyboard by default but a place is defined on every layout, top-right of the shift key. It can be enabled in the settings. The icon is from materialdesignicons.com.
2022-10-23 21:34:05 +02:00
if (locked)
refactor: Use internal flags in Pointers 'FLAG_LOCKED' and 'FLAG_FAKE_PTR' are only used within Pointers. Define new flags in Pointers and remove these from KeyValue. Also allows to define new flags.
2024-03-11 00:10:12 +01:00
ptr.flags |= FLAG_P_LOCKED;
Automatic capitalisation at beginning of sentences Keep track of end-of-sentence characters while typing and automatically enable shift when appropriate. The last few characters just before the cursor need to be queried in some cases: Begin of input, cursor has moved or text is deleted. This might have a performance cost. This normally only enable shift but it also needs to disable shift when the cursor moves.
2022-07-24 20:02:48 +02:00
_ptrs.add(ptr);
Send down event for modifiers on time This allows to use modifiers in combination with other inputs like a mouse click, for example under termux-x11. The key down event and notification about modifiers changing are sent down to KeyEventHandler. A mutable state remember for which modifier down events have been sent. When pressing down a modifier with one finger and typing with the other, it might appear that the modifier is released after the first time an other key is pressed and then pressed and released for the following keys. This prevents unintentionally type two modified keys instead of one when the second key is pressed while the other is not yet released.
2024-01-26 00:17:51 +01:00
_handler.onPointerFlagsChanged(false);
Automatic capitalisation at beginning of sentences Keep track of end-of-sentence characters while typing and automatically enable shift when appropriate. The last few characters just before the cursor need to be queried in some cases: Begin of input, cursor has moved or text is deleted. This might have a performance cost. This normally only enable shift but it also needs to disable shift when the cursor moves.
2022-07-24 20:02:48 +02:00
}
Fix auto-capitalisation disabling locked shift Shift locked via the "caps lock" key use the "fake pointer" mechanism that is also used by auto-capitalisation. Make sure that unlatching a fake pointer do not disabled a locked modifier. The implementation is moved into the Pointers class for a safer API and easier implementation.
2024-03-03 17:08:25 +01:00
/** Set whether a key is latched or locked by adding a "fake" pointer, a
pointer that is not due to user interaction.
This is used by auto-capitalisation.
When [lock] is true, [latched] control whether the modifier is locked or disabled.
When [lock] is false, an existing locked pointer is not affected. */
public void set_fake_pointer_state(KeyboardData.Key key, KeyValue kv,
boolean latched, boolean lock)
Automatic capitalisation at beginning of sentences Keep track of end-of-sentence characters while typing and automatically enable shift when appropriate. The last few characters just before the cursor need to be queried in some cases: Begin of input, cursor has moved or text is deleted. This might have a performance cost. This normally only enable shift but it also needs to disable shift when the cursor moves.
2022-07-24 20:02:48 +02:00
{
Pointer ptr = getLatched(key, kv);
Fix auto-capitalisation disabling locked shift Shift locked via the "caps lock" key use the "fake pointer" mechanism that is also used by auto-capitalisation. Make sure that unlatching a fake pointer do not disabled a locked modifier. The implementation is moved into the Pointers class for a safer API and easier implementation.
2024-03-03 17:08:25 +01:00
if (ptr == null)
{
// No existing pointer, latch the key.
if (latched)
add_fake_pointer(key, kv, lock);
}
refactor: Use internal flags in Pointers 'FLAG_LOCKED' and 'FLAG_FAKE_PTR' are only used within Pointers. Define new flags in Pointers and remove these from KeyValue. Also allows to define new flags.
2024-03-11 00:10:12 +01:00
else if ((ptr.flags & FLAG_P_FAKE) != 0)
Fix auto-capitalisation disabling locked shift Shift locked via the "caps lock" key use the "fake pointer" mechanism that is also used by auto-capitalisation. Make sure that unlatching a fake pointer do not disabled a locked modifier. The implementation is moved into the Pointers class for a safer API and easier implementation.
2024-03-03 17:08:25 +01:00
{} // Key already latched but not by a fake ptr, do nothing.
else if (lock)
{
// Acting on locked modifiers, replace the pointer each time.
Automatic capitalisation at beginning of sentences Keep track of end-of-sentence characters while typing and automatically enable shift when appropriate. The last few characters just before the cursor need to be queried in some cases: Begin of input, cursor has moved or text is deleted. This might have a performance cost. This normally only enable shift but it also needs to disable shift when the cursor moves.
2022-07-24 20:02:48 +02:00
removePtr(ptr);
Fix auto-capitalisation disabling locked shift Shift locked via the "caps lock" key use the "fake pointer" mechanism that is also used by auto-capitalisation. Make sure that unlatching a fake pointer do not disabled a locked modifier. The implementation is moved into the Pointers class for a safer API and easier implementation.
2024-03-03 17:08:25 +01:00
if (latched)
add_fake_pointer(key, kv, lock);
}
refactor: Use internal flags in Pointers 'FLAG_LOCKED' and 'FLAG_FAKE_PTR' are only used within Pointers. Define new flags in Pointers and remove these from KeyValue. Also allows to define new flags.
2024-03-11 00:10:12 +01:00
else if ((ptr.flags & FLAG_P_LOCKED) != 0)
Fix auto-capitalisation disabling locked shift Shift locked via the "caps lock" key use the "fake pointer" mechanism that is also used by auto-capitalisation. Make sure that unlatching a fake pointer do not disabled a locked modifier. The implementation is moved into the Pointers class for a safer API and easier implementation.
2024-03-03 17:08:25 +01:00
{} // Existing ptr is locked but [lock] is false, do not continue.
else if (!latched)
{
// Key is latched by a fake ptr. Unlatch if requested.
removePtr(ptr);
_handler.onPointerFlagsChanged(false);
}
Automatic capitalisation at beginning of sentences Keep track of end-of-sentence characters while typing and automatically enable shift when appropriate. The last few characters just before the cursor need to be queried in some cases: Begin of input, cursor has moved or text is deleted. This might have a performance cost. This normally only enable shift but it also needs to disable shift when the cursor moves.
2022-07-24 20:02:48 +02:00
}
Move pointer handling code to its own class Separate the concerns and have a clearer interface between the two parts of the code.
2022-02-20 13:09:39 +01:00
// Receiving events
public void onTouchUp(int pointerId)
{
Pointer ptr = getPtr(pointerId);
if (ptr == null)
return;
refactor: Pointers: Flag for sliding state
2024-03-11 00:38:37 +01:00
if (ptr.hasFlagsAny(FLAG_P_SLIDING))
Don't send event at end of sliding A sliding pointer going up must not cause a key event to be sent. This caused an extra cursor movement and cleared the latched modifiers.
2023-01-29 18:49:44 +01:00
{
Do not lock modifiers if sliding a key This unconditionally removes all pointers (touches) pressing modifiers which are not already locked, avoiding that the (currently) latched modifier will be locked aventually. This can be verfified while sliding the space bar to move the cursor left or right. Closes #319.
2023-04-08 20:10:41 +02:00
clearLatched();
More precise and faster spacebar slider (#593) * Make slider speed independent from swipe distance Swipe distances other than the default resulted in a slider that were not easy to control. * refactor: Add class Pointers.Sliding It holds the states and the code needed to make the slider work. 'Pointer.sliding' is set to [null] when sliding is not in progress. The implementation is changed not to depend on [downX] and [dx] but instead use the pointer's [x] coordinate directly. * Move the cursor further for faster slides In sliding mode, compute the speed of the pointer and use it to increase at which the cursor moves. * refactor: Separate kind for cursor movement keys This allows to define a key that moves the cursor more than one position at a time. This will be used to avoid lag during fast slider movements. * Reduce lag when sliding quickly on the spacebar Avoid sending key events in a loop while sliding quickly in a cursor movement key. Key of kind Cursor_move are "multiplied", meaning a single key event represents a movement of more than one position, reducing the number of key events sent. This is only for cursor move keys.
2024-05-02 19:31:48 +02:00
ptr.sliding.onTouchUp(ptr);
Don't send event at end of sliding A sliding pointer going up must not cause a key event to be sent. This caused an extra cursor movement and cleared the latched modifiers.
2023-01-29 18:49:44 +01:00
return;
}
Move pointer handling code to its own class Separate the concerns and have a clearer interface between the two parts of the code.
2022-02-20 13:09:39 +01:00
stopKeyRepeat(ptr);
Circle and round trip gestures (#640) This implements clockwise/anticlockwise circle and round trip gestures inspired by Messagease. The circle gestures start after a small threshold to avoid making the regular swipe too hard to aim. The gestures do: - circle: The center symbol with Shift applied, with a fallback on Fn - round trip: Same as the circle gesture but applied to a side symbol - anticlockwise circle: Nothing currently. It is intended to be made configurable per-layout in the future. The new Gesture class keeps track of what the pointer is doing while it moves on a key. It replaces the 'selected_direction' integer.
2024-05-25 21:19:44 +02:00
KeyValue ptr_value = ptr.value;
if (ptr.gesture != null && ptr.gesture.is_in_progress())
{
// A gesture was in progress
ptr.gesture.pointer_up();
}
Allow modifiers to hide keys Modifiers can temporarily remove a key from the layout by returning 'null'. Make sure pointer handling code handle these modified keys gracefully and doesn't trigger a key event and a vibration for the removed key.
2022-03-19 15:39:20 +01:00
Pointer latched = getLatched(ptr);
Move pointer handling code to its own class Separate the concerns and have a clearer interface between the two parts of the code.
2022-02-20 13:09:39 +01:00
if (latched != null) // Already latched
{
removePtr(ptr); // Remove dupplicate
refactor: Use internal flags in Pointers 'FLAG_LOCKED' and 'FLAG_FAKE_PTR' are only used within Pointers. Define new flags in Pointers and remove these from KeyValue. Also allows to define new flags.
2024-03-11 00:10:12 +01:00
if ((latched.flags & FLAG_P_LOCKABLE) != 0) // Toggle lockable key
Hold any modifier to lock Modifiers can be locked with a long press. The key repeat mechanism is re-used and the press timeout is the same. Every modifiers can be locked that way, not only the "lockable" ones. The previous behavior can be enabled in the settings (for shift only) but the default is changed.
2022-07-24 23:55:00 +02:00
lockPointer(latched, false);
Move pointer handling code to its own class Separate the concerns and have a clearer interface between the two parts of the code.
2022-02-20 13:09:39 +01:00
else // Otherwise, unlatch
{
removePtr(latched);
Circle and round trip gestures (#640) This implements clockwise/anticlockwise circle and round trip gestures inspired by Messagease. The circle gestures start after a small threshold to avoid making the regular swipe too hard to aim. The gestures do: - circle: The center symbol with Shift applied, with a fallback on Fn - round trip: Same as the circle gesture but applied to a side symbol - anticlockwise circle: Nothing currently. It is intended to be made configurable per-layout in the future. The new Gesture class keeps track of what the pointer is doing while it moves on a key. It replaces the 'selected_direction' integer.
2024-05-25 21:19:44 +02:00
_handler.onPointerUp(ptr_value, ptr.modifiers);
Move pointer handling code to its own class Separate the concerns and have a clearer interface between the two parts of the code.
2022-02-20 13:09:39 +01:00
}
}
refactor: Use internal flags in Pointers 'FLAG_LOCKED' and 'FLAG_FAKE_PTR' are only used within Pointers. Define new flags in Pointers and remove these from KeyValue. Also allows to define new flags.
2024-03-11 00:10:12 +01:00
else if ((ptr.flags & FLAG_P_LATCHABLE) != 0)
Move pointer handling code to its own class Separate the concerns and have a clearer interface between the two parts of the code.
2022-02-20 13:09:39 +01:00
{
refactor: Implement Compose without global state Thanks to the previous commit, a modifier key can now be more complex than just a KeyValue.Modifier. This allows a more elegant implementation of the compose key, that could be taken as a base for other features (eg. unicode hex entry, hangul) The COMPOSE_PENDING modifier is removed as keys of kind Compose_pending can act as a modifier. This has the advantage of highlighting the key that was last pressed in the sequence. Rules are added to Pointers: Non-special but latchable keys must clear latches and cannot be locked with a long press. These rules were not needed before but were intended.
2024-03-18 01:00:22 +01:00
// Latchable but non-special keys must clear latched.
if ((ptr.flags & FLAG_P_CLEAR_LATCHED) != 0)
clearLatched();
refactor: Add latched flag to Pointers
2024-03-11 00:29:12 +01:00
ptr.flags |= FLAG_P_LATCHED;
ptr.pointerId = -1;
Hold any modifier to lock Modifiers can be locked with a long press. The key repeat mechanism is re-used and the press timeout is the same. Every modifiers can be locked that way, not only the "lockable" ones. The previous behavior can be enabled in the settings (for shift only) but the default is changed.
2022-07-24 23:55:00 +02:00
_handler.onPointerFlagsChanged(false);
Move pointer handling code to its own class Separate the concerns and have a clearer interface between the two parts of the code.
2022-02-20 13:09:39 +01:00
}
else
{
clearLatched();
removePtr(ptr);
Circle and round trip gestures (#640) This implements clockwise/anticlockwise circle and round trip gestures inspired by Messagease. The circle gestures start after a small threshold to avoid making the regular swipe too hard to aim. The gestures do: - circle: The center symbol with Shift applied, with a fallback on Fn - round trip: Same as the circle gesture but applied to a side symbol - anticlockwise circle: Nothing currently. It is intended to be made configurable per-layout in the future. The new Gesture class keeps track of what the pointer is doing while it moves on a key. It replaces the 'selected_direction' integer.
2024-05-25 21:19:44 +02:00
_handler.onPointerUp(ptr_value, ptr.modifiers);
Move pointer handling code to its own class Separate the concerns and have a clearer interface between the two parts of the code.
2022-02-20 13:09:39 +01:00
}
}
Correctly handle pointer cancel events The cancel event ends the motion, it doesn't apply to a single pointer like it was previously expected.
2022-12-04 18:21:59 +01:00
public void onTouchCancel()
Handle CANCEL touch events Handling this event is part of the API but was never done. This caused unstoppable key-repeat. This event isn't common, the only way I found on Android 10 is to switch to the emoji keyboard while holding a key. Some apps might cause this event more often.
2022-03-15 20:44:02 +01:00
{
Correctly handle pointer cancel events The cancel event ends the motion, it doesn't apply to a single pointer like it was previously expected.
2022-12-04 18:21:59 +01:00
clear();
Hold any modifier to lock Modifiers can be locked with a long press. The key repeat mechanism is re-used and the press timeout is the same. Every modifiers can be locked that way, not only the "lockable" ones. The previous behavior can be enabled in the settings (for shift only) but the default is changed.
2022-07-24 23:55:00 +02:00
_handler.onPointerFlagsChanged(true);
Handle CANCEL touch events Handling this event is part of the API but was never done. This caused unstoppable key-repeat. This event isn't common, the only way I found on Android 10 is to switch to the emoji keyboard while holding a key. Some apps might cause this event more often.
2022-03-15 20:44:02 +01:00
}
Fix modifiers not cleared when presses overlap When typing fast, a second key might be pressed before the first is released. Clearing modifiers earlier would prevent this but would break modifiers placed in corners (especially the accent keys). Instead, don't take latched modifiers into account when registering the second press. A new flag is needed to not interfere with holding modifers, which is merged with the norepeat flag.
2022-04-30 23:36:17 +02:00
/* Whether an other pointer is down on a non-special key. */
private boolean isOtherPointerDown()
{
for (Pointer p : _ptrs)
refactor: Add latched flag to Pointers
2024-03-11 00:29:12 +01:00
if (!p.hasFlagsAny(FLAG_P_LATCHED) &&
refactor: Use internal flags in Pointers 'FLAG_LOCKED' and 'FLAG_FAKE_PTR' are only used within Pointers. Define new flags in Pointers and remove these from KeyValue. Also allows to define new flags.
2024-03-11 00:10:12 +01:00
(p.value == null || !p.value.hasFlagsAny(KeyValue.FLAG_SPECIAL)))
Fix modifiers not cleared when presses overlap When typing fast, a second key might be pressed before the first is released. Clearing modifiers earlier would prevent this but would break modifiers placed in corners (especially the accent keys). Instead, don't take latched modifiers into account when registering the second press. A new flag is needed to not interfere with holding modifers, which is merged with the norepeat flag.
2022-04-30 23:36:17 +02:00
return true;
return false;
}
Move pointer handling code to its own class Separate the concerns and have a clearer interface between the two parts of the code.
2022-02-20 13:09:39 +01:00
public void onTouchDown(float x, float y, int pointerId, KeyboardData.Key key)
{
Move cursor by sliding on the space bar Send key events for the left or right arrow as the finger slides on the space bar. Can be used to select text by holding shift. Works under Termux. Events are sent linearly as the finger travels. The distance between each events is defined from the swiping distance divided by 4. 'slider="true"' can be set on a key that have 'edgekeys="true"'. 'key2' and 'key3' represent the right and left keys.
2023-01-22 23:03:30 +01:00
// Ignore new presses while a sliding key is active. On some devices, ghost
// touch events can happen while the pointer travels on top of other keys.
if (isSliding())
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
// Don't take latched modifiers into account if an other key is pressed.
// The other key already "own" the latched modifiers and will clear them.
Modifiers mods = getModifiers(isOtherPointerDown());
Refactor: Remove KeyboardData.Corner The Corner class is removed. The "localized" flag for all the corners is held in a bitfield.
2023-03-05 23:08:35 +01:00
KeyValue value = _handler.modifyKey(key.keys[0], mods);
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
Pointer ptr = new Pointer(pointerId, key, value, x, y, mods);
Move pointer handling code to its own class Separate the concerns and have a clearer interface between the two parts of the code.
2022-02-20 13:09:39 +01:00
_ptrs.add(ptr);
Hold any modifier to lock Modifiers can be locked with a long press. The key repeat mechanism is re-used and the press timeout is the same. Every modifiers can be locked that way, not only the "lockable" ones. The previous behavior can be enabled in the settings (for shift only) but the default is changed.
2022-07-24 23:55:00 +02:00
startKeyRepeat(ptr);
Disable automatically Shift when pressing Ctrl Automatic capitalisation might interferes with keyboard shortcuts.
2023-08-26 23:37:22 +02:00
_handler.onPointerDown(value, false);
Move pointer handling code to its own class Separate the concerns and have a clearer interface between the two parts of the code.
2022-02-20 13:09:39 +01:00
}
Allow 8 symbols per key 'Keyboard.Key' now contains an array of size 9, giving each keyvalue an index. The algorithm for finding the nearest key during a swipe now needs 16 segments, which are now calculated as an angle. The algorithm does one more interation instead of 2 more, slightly reducing the sensitivity of corner values. The 'getAtDirection' function is moved into the Pointers class to clearly separate the two systems. The 'edgekey' attribute is now obsolete but is kept for compatibility. The flag is removed internally, key index are simply translated. Similarly, the 'slider' attribute now act on keys at index 5 and 6 instead of 2 and 3.
2023-03-03 19:44:05 +01:00
static final int[] DIRECTION_TO_INDEX = new int[]{
7, 2, 2, 6, 6, 4, 4, 8, 8, 3, 3, 5, 5, 1, 1, 7
};
/**
* [direction] is an int between [0] and [15] that represent 16 sections of a
* circle, clockwise, starting at the top.
*/
KeyValue getKeyAtDirection(KeyboardData.Key k, int direction)
{
Refactor: Remove KeyboardData.Corner The Corner class is removed. The "localized" flag for all the corners is held in a bitfield.
2023-03-05 23:08:35 +01:00
return k.keys[DIRECTION_TO_INDEX[direction]];
Allow 8 symbols per key 'Keyboard.Key' now contains an array of size 9, giving each keyvalue an index. The algorithm for finding the nearest key during a swipe now needs 16 segments, which are now calculated as an angle. The algorithm does one more interation instead of 2 more, slightly reducing the sensitivity of corner values. The 'getAtDirection' function is moved into the Pointers class to clearly separate the two systems. The 'edgekey' attribute is now obsolete but is kept for compatibility. The flag is removed internally, key index are simply translated. Similarly, the 'slider' attribute now act on keys at index 5 and 6 instead of 2 and 3.
2023-03-03 19:44:05 +01:00
}
Circle and round trip gestures (#640) This implements clockwise/anticlockwise circle and round trip gestures inspired by Messagease. The circle gestures start after a small threshold to avoid making the regular swipe too hard to aim. The gestures do: - circle: The center symbol with Shift applied, with a fallback on Fn - round trip: Same as the circle gesture but applied to a side symbol - anticlockwise circle: Nothing currently. It is intended to be made configurable per-layout in the future. The new Gesture class keeps track of what the pointer is doing while it moves on a key. It replaces the 'selected_direction' integer.
2024-05-25 21:19:44 +02:00
/**
* Get the key nearest to [direction] that is not key0. Take care
* of applying [_handler.modifyKey] to the selected key in the same
* operation to be sure to treat removed keys correctly.
* Return [null] if no key could be found in the given direction or
* if the selected key didn't change.
Better handling of removed keys and swipe geture The "closest key" logic must be careful not to reveal keys removed by a modifier. Must check [_handler.onPointerSwipe] for every candidate values. [selected_value] is changed back to [selected_direction]. This adds a new bug: When the direction change, the selected value might not change but a vibration will be triggered anyway.
2022-05-08 16:38:44 +02:00
*/
Circle and round trip gestures (#640) This implements clockwise/anticlockwise circle and round trip gestures inspired by Messagease. The circle gestures start after a small threshold to avoid making the regular swipe too hard to aim. The gestures do: - circle: The center symbol with Shift applied, with a fallback on Fn - round trip: Same as the circle gesture but applied to a side symbol - anticlockwise circle: Nothing currently. It is intended to be made configurable per-layout in the future. The new Gesture class keeps track of what the pointer is doing while it moves on a key. It replaces the 'selected_direction' integer.
2024-05-25 21:19:44 +02:00
private KeyValue getNearestKeyAtDirection(Pointer ptr, int direction)
Better handling of removed keys and swipe geture The "closest key" logic must be careful not to reveal keys removed by a modifier. Must check [_handler.onPointerSwipe] for every candidate values. [selected_value] is changed back to [selected_direction]. This adds a new bug: When the direction change, the selected value might not change but a vibration will be triggered anyway.
2022-05-08 16:38:44 +02:00
{
KeyValue k;
Allow 8 symbols per key 'Keyboard.Key' now contains an array of size 9, giving each keyvalue an index. The algorithm for finding the nearest key during a swipe now needs 16 segments, which are now calculated as an angle. The algorithm does one more interation instead of 2 more, slightly reducing the sensitivity of corner values. The 'getAtDirection' function is moved into the Pointers class to clearly separate the two systems. The 'edgekey' attribute is now obsolete but is kept for compatibility. The flag is removed internally, key index are simply translated. Similarly, the 'slider' attribute now act on keys at index 5 and 6 instead of 2 and 3.
2023-03-03 19:44:05 +01:00
// [i] is [0, -1, 1, -2, 2, ...]
for (int i = 0; i > -4; i = (~i>>31) - i)
Better handling of removed keys and swipe geture The "closest key" logic must be careful not to reveal keys removed by a modifier. Must check [_handler.onPointerSwipe] for every candidate values. [selected_value] is changed back to [selected_direction]. This adds a new bug: When the direction change, the selected value might not change but a vibration will be triggered anyway.
2022-05-08 16:38:44 +02:00
{
Correct pointer direction The previous algorithm did not cut the circle into 16 equal parts. The division by 2pi yielded numbers smaller than 16, which no longer made sense after the cast to int.
2023-03-13 03:06:43 +01:00
int d = (direction + i + 16) % 16;
Better handling of removed keys and swipe geture The "closest key" logic must be careful not to reveal keys removed by a modifier. Must check [_handler.onPointerSwipe] for every candidate values. [selected_value] is changed back to [selected_direction]. This adds a new bug: When the direction change, the selected value might not change but a vibration will be triggered anyway.
2022-05-08 16:38:44 +02:00
// Don't make the difference between a key that doesn't exist and a key
// that is removed by [_handler]. Triggers side effects.
Allow 8 symbols per key 'Keyboard.Key' now contains an array of size 9, giving each keyvalue an index. The algorithm for finding the nearest key during a swipe now needs 16 segments, which are now calculated as an angle. The algorithm does one more interation instead of 2 more, slightly reducing the sensitivity of corner values. The 'getAtDirection' function is moved into the Pointers class to clearly separate the two systems. The 'edgekey' attribute is now obsolete but is kept for compatibility. The flag is removed internally, key index are simply translated. Similarly, the 'slider' attribute now act on keys at index 5 and 6 instead of 2 and 3.
2023-03-03 19:44:05 +01:00
k = _handler.modifyKey(getKeyAtDirection(ptr.key, d), ptr.modifiers);
Better handling of removed keys and swipe geture The "closest key" logic must be careful not to reveal keys removed by a modifier. Must check [_handler.onPointerSwipe] for every candidate values. [selected_value] is changed back to [selected_direction]. This adds a new bug: When the direction change, the selected value might not change but a vibration will be triggered anyway.
2022-05-08 16:38:44 +02:00
if (k != null)
return k;
}
return null;
}
Move pointer handling code to its own class Separate the concerns and have a clearer interface between the two parts of the code.
2022-02-20 13:09:39 +01:00
public void onTouchMove(float x, float y, int pointerId)
{
Pointer ptr = getPtr(pointerId);
if (ptr == null)
return;
More precise and faster spacebar slider (#593) * Make slider speed independent from swipe distance Swipe distances other than the default resulted in a slider that were not easy to control. * refactor: Add class Pointers.Sliding It holds the states and the code needed to make the slider work. 'Pointer.sliding' is set to [null] when sliding is not in progress. The implementation is changed not to depend on [downX] and [dx] but instead use the pointer's [x] coordinate directly. * Move the cursor further for faster slides In sliding mode, compute the speed of the pointer and use it to increase at which the cursor moves. * refactor: Separate kind for cursor movement keys This allows to define a key that moves the cursor more than one position at a time. This will be used to avoid lag during fast slider movements. * Reduce lag when sliding quickly on the spacebar Avoid sending key events in a loop while sliding quickly in a cursor movement key. Key of kind Cursor_move are "multiplied", meaning a single key event represents a movement of more than one position, reducing the number of key events sent. This is only for cursor move keys.
2024-05-02 19:31:48 +02:00
if (ptr.hasFlagsAny(FLAG_P_SLIDING))
{
ptr.sliding.onTouchMove(ptr, x);
return;
}
use the closest swipe key on swipe fix a direction
2022-05-06 18:38:43 +02:00
// The position in a IME windows is clampled to view.
// For a better up swipe behaviour, set the y position to a negative value when clamped.
if (y == 0.0) y = -400;
Move pointer handling code to its own class Separate the concerns and have a clearer interface between the two parts of the code.
2022-02-20 13:09:39 +01:00
float dx = x - ptr.downX;
float dy = y - ptr.downY;
only vibrate when the swipe key changes
2022-05-07 00:08:20 +02:00
Move cursor by sliding on the space bar Send key events for the left or right arrow as the finger slides on the space bar. Can be used to select text by holding shift. Works under Termux. Events are sent linearly as the finger travels. The distance between each events is defined from the swiping distance divided by 4. 'slider="true"' can be set on a key that have 'edgekeys="true"'. 'key2' and 'key3' represent the right and left keys.
2023-01-22 23:03:30 +01:00
float dist = Math.abs(dx) + Math.abs(dy);
Move pointer handling code to its own class Separate the concerns and have a clearer interface between the two parts of the code.
2022-02-20 13:09:39 +01:00
if (dist < _config.swipe_dist_px)
{
Circle and round trip gestures (#640) This implements clockwise/anticlockwise circle and round trip gestures inspired by Messagease. The circle gestures start after a small threshold to avoid making the regular swipe too hard to aim. The gestures do: - circle: The center symbol with Shift applied, with a fallback on Fn - round trip: Same as the circle gesture but applied to a side symbol - anticlockwise circle: Nothing currently. It is intended to be made configurable per-layout in the future. The new Gesture class keeps track of what the pointer is doing while it moves on a key. It replaces the 'selected_direction' integer.
2024-05-25 21:19:44 +02:00
// Pointer is still on the center.
if (ptr.gesture == null || !ptr.gesture.is_in_progress())
return;
// Gesture ended
ptr.gesture.moved_to_center();
ptr.value = apply_gesture(ptr, ptr.gesture.get_gesture());
ptr.flags = 0;
Move pointer handling code to its own class Separate the concerns and have a clearer interface between the two parts of the code.
2022-02-20 13:09:39 +01:00
}
only vibrate when the swipe key changes
2022-05-07 00:08:20 +02:00
else
Circle and round trip gestures (#640) This implements clockwise/anticlockwise circle and round trip gestures inspired by Messagease. The circle gestures start after a small threshold to avoid making the regular swipe too hard to aim. The gestures do: - circle: The center symbol with Shift applied, with a fallback on Fn - round trip: Same as the circle gesture but applied to a side symbol - anticlockwise circle: Nothing currently. It is intended to be made configurable per-layout in the future. The new Gesture class keeps track of what the pointer is doing while it moves on a key. It replaces the 'selected_direction' integer.
2024-05-25 21:19:44 +02:00
{ // Pointer is on a quadrant.
Allow 8 symbols per key 'Keyboard.Key' now contains an array of size 9, giving each keyvalue an index. The algorithm for finding the nearest key during a swipe now needs 16 segments, which are now calculated as an angle. The algorithm does one more interation instead of 2 more, slightly reducing the sensitivity of corner values. The 'getAtDirection' function is moved into the Pointers class to clearly separate the two systems. The 'edgekey' attribute is now obsolete but is kept for compatibility. The flag is removed internally, key index are simply translated. Similarly, the 'slider' attribute now act on keys at index 5 and 6 instead of 2 and 3.
2023-03-03 19:44:05 +01:00
// See [getKeyAtDirection()] for the meaning. The starting point on the
// circle is the top direction.
Correct pointer direction The previous algorithm did not cut the circle into 16 equal parts. The division by 2pi yielded numbers smaller than 16, which no longer made sense after the cast to int.
2023-03-13 03:06:43 +01:00
double a = Math.atan2(dy, dx) + Math.PI;
// a is between 0 and 2pi, 0 is pointing to the left
// add 12 to align 0 to the top
Circle and round trip gestures (#640) This implements clockwise/anticlockwise circle and round trip gestures inspired by Messagease. The circle gestures start after a small threshold to avoid making the regular swipe too hard to aim. The gestures do: - circle: The center symbol with Shift applied, with a fallback on Fn - round trip: Same as the circle gesture but applied to a side symbol - anticlockwise circle: Nothing currently. It is intended to be made configurable per-layout in the future. The new Gesture class keeps track of what the pointer is doing while it moves on a key. It replaces the 'selected_direction' integer.
2024-05-25 21:19:44 +02:00
int direction = ((int)(a * 8 / Math.PI) + 12) % 16;
if (ptr.gesture == null)
{ // Gesture starts
ptr.gesture = new Gesture(direction);
KeyValue new_value = getNearestKeyAtDirection(ptr, direction);
if (new_value != null)
{ // Pointer is swiping into a side key.
ptr.value = new_value;
ptr.flags = pointer_flags_of_kv(new_value);
// Sliding mode is entered when key5 or key6 is down on a slider key.
if (ptr.key.slider &&
(new_value.equals(ptr.key.getKeyValue(5))
|| new_value.equals(ptr.key.getKeyValue(6))))
{
startSliding(ptr, x);
}
_handler.onPointerDown(new_value, true);
}
only vibrate when the swipe key changes
2022-05-07 00:08:20 +02:00
Circle and round trip gestures (#640) This implements clockwise/anticlockwise circle and round trip gestures inspired by Messagease. The circle gestures start after a small threshold to avoid making the regular swipe too hard to aim. The gestures do: - circle: The center symbol with Shift applied, with a fallback on Fn - round trip: Same as the circle gesture but applied to a side symbol - anticlockwise circle: Nothing currently. It is intended to be made configurable per-layout in the future. The new Gesture class keeps track of what the pointer is doing while it moves on a key. It replaces the 'selected_direction' integer.
2024-05-25 21:19:44 +02:00
}
else if (ptr.gesture.changed_direction(direction))
{ // Gesture changed state
if (!ptr.gesture.is_in_progress())
{ // Gesture ended
stopKeyRepeat(ptr);
_handler.onPointerFlagsChanged(true);
}
else
Move cursor by sliding on the space bar Send key events for the left or right arrow as the finger slides on the space bar. Can be used to select text by holding shift. Works under Termux. Events are sent linearly as the finger travels. The distance between each events is defined from the swiping distance divided by 4. 'slider="true"' can be set on a key that have 'edgekeys="true"'. 'key2' and 'key3' represent the right and left keys.
2023-01-22 23:03:30 +01:00
{
Circle and round trip gestures (#640) This implements clockwise/anticlockwise circle and round trip gestures inspired by Messagease. The circle gestures start after a small threshold to avoid making the regular swipe too hard to aim. The gestures do: - circle: The center symbol with Shift applied, with a fallback on Fn - round trip: Same as the circle gesture but applied to a side symbol - anticlockwise circle: Nothing currently. It is intended to be made configurable per-layout in the future. The new Gesture class keeps track of what the pointer is doing while it moves on a key. It replaces the 'selected_direction' integer.
2024-05-25 21:19:44 +02:00
ptr.value = apply_gesture(ptr, ptr.gesture.get_gesture());
restartKeyRepeat(ptr);
ptr.flags = 0; // Special behaviors are ignored during a gesture.
Move cursor by sliding on the space bar Send key events for the left or right arrow as the finger slides on the space bar. Can be used to select text by holding shift. Works under Termux. Events are sent linearly as the finger travels. The distance between each events is defined from the swiping distance divided by 4. 'slider="true"' can be set on a key that have 'edgekeys="true"'. 'key2' and 'key3' represent the right and left keys.
2023-01-22 23:03:30 +01:00
}
Improve modulated key repeat Change the formula: don't use an external constant, add a state. It's now the ratio between where the finger is at the first repeat and where it is now. Keep the repeat going when swiping into an other key. Currently only for arrows: It's now possible to go from an arrow to an other without waiting again for the key repeat timeout. The backspace and delete keys don't work well with this.
2022-02-21 00:24:57 +01:00
}
Move pointer handling code to its own class Separate the concerns and have a clearer interface between the two parts of the code.
2022-02-20 13:09:39 +01:00
}
}
// Pointers management
private Pointer getPtr(int pointerId)
{
for (Pointer p : _ptrs)
if (p.pointerId == pointerId)
return p;
return null;
}
private void removePtr(Pointer ptr)
{
_ptrs.remove(ptr);
}
Allow modifiers to hide keys Modifiers can temporarily remove a key from the layout by returning 'null'. Make sure pointer handling code handle these modified keys gracefully and doesn't trigger a key event and a vibration for the removed key.
2022-03-19 15:39:20 +01:00
private Pointer getLatched(Pointer target)
Move pointer handling code to its own class Separate the concerns and have a clearer interface between the two parts of the code.
2022-02-20 13:09:39 +01:00
{
Automatic capitalisation at beginning of sentences Keep track of end-of-sentence characters while typing and automatically enable shift when appropriate. The last few characters just before the cursor need to be queried in some cases: Begin of input, cursor has moved or text is deleted. This might have a performance cost. This normally only enable shift but it also needs to disable shift when the cursor moves.
2022-07-24 20:02:48 +02:00
return getLatched(target.key, target.value);
}
private Pointer getLatched(KeyboardData.Key k, KeyValue v)
{
Fix latched pointers accumulating on the same key It was possible to latch and lock the same modifier several time at the same time independently. Remove that.
2022-05-01 00:11:52 +02:00
if (v == null)
return null;
Move pointer handling code to its own class Separate the concerns and have a clearer interface between the two parts of the code.
2022-02-20 13:09:39 +01:00
for (Pointer p : _ptrs)
refactor: Add latched flag to Pointers
2024-03-11 00:29:12 +01:00
if (p.key == k && p.hasFlagsAny(FLAG_P_LATCHED)
&& p.value != null && p.value.equals(v))
Move pointer handling code to its own class Separate the concerns and have a clearer interface between the two parts of the code.
2022-02-20 13:09:39 +01:00
return p;
return null;
}
private void clearLatched()
{
for (int i = _ptrs.size() - 1; i >= 0; i--)
{
Pointer ptr = _ptrs.get(i);
// Latched and not locked, remove
refactor: Add latched flag to Pointers
2024-03-11 00:29:12 +01:00
if (ptr.hasFlagsAny(FLAG_P_LATCHED) && (ptr.flags & FLAG_P_LOCKED) == 0)
Move pointer handling code to its own class Separate the concerns and have a clearer interface between the two parts of the code.
2022-02-20 13:09:39 +01:00
_ptrs.remove(i);
Hold any modifier to lock Modifiers can be locked with a long press. The key repeat mechanism is re-used and the press timeout is the same. Every modifiers can be locked that way, not only the "lockable" ones. The previous behavior can be enabled in the settings (for shift only) but the default is changed.
2022-07-24 23:55:00 +02:00
// Not latched but pressed, don't latch once released and stop long press.
refactor: Use internal flags in Pointers 'FLAG_LOCKED' and 'FLAG_FAKE_PTR' are only used within Pointers. Define new flags in Pointers and remove these from KeyValue. Also allows to define new flags.
2024-03-11 00:10:12 +01:00
else if ((ptr.flags & FLAG_P_LATCHABLE) != 0)
ptr.flags &= ~FLAG_P_LATCHABLE;
Move pointer handling code to its own class Separate the concerns and have a clearer interface between the two parts of the code.
2022-02-20 13:09:39 +01:00
}
}
Hold any modifier to lock Modifiers can be locked with a long press. The key repeat mechanism is re-used and the press timeout is the same. Every modifiers can be locked that way, not only the "lockable" ones. The previous behavior can be enabled in the settings (for shift only) but the default is changed.
2022-07-24 23:55:00 +02:00
/** Make a pointer into the locked state. */
private void lockPointer(Pointer ptr, boolean shouldVibrate)
{
refactor: Use internal flags in Pointers 'FLAG_LOCKED' and 'FLAG_FAKE_PTR' are only used within Pointers. Define new flags in Pointers and remove these from KeyValue. Also allows to define new flags.
2024-03-11 00:10:12 +01:00
ptr.flags = (ptr.flags & ~FLAG_P_LOCKABLE) | FLAG_P_LOCKED;
Hold any modifier to lock Modifiers can be locked with a long press. The key repeat mechanism is re-used and the press timeout is the same. Every modifiers can be locked that way, not only the "lockable" ones. The previous behavior can be enabled in the settings (for shift only) but the default is changed.
2022-07-24 23:55:00 +02:00
_handler.onPointerFlagsChanged(shouldVibrate);
}
Move cursor by sliding on the space bar Send key events for the left or right arrow as the finger slides on the space bar. Can be used to select text by holding shift. Works under Termux. Events are sent linearly as the finger travels. The distance between each events is defined from the swiping distance divided by 4. 'slider="true"' can be set on a key that have 'edgekeys="true"'. 'key2' and 'key3' represent the right and left keys.
2023-01-22 23:03:30 +01:00
boolean isSliding()
{
for (Pointer ptr : _ptrs)
refactor: Pointers: Flag for sliding state
2024-03-11 00:38:37 +01:00
if (ptr.hasFlagsAny(FLAG_P_SLIDING))
Move cursor by sliding on the space bar Send key events for the left or right arrow as the finger slides on the space bar. Can be used to select text by holding shift. Works under Termux. Events are sent linearly as the finger travels. The distance between each events is defined from the swiping distance divided by 4. 'slider="true"' can be set on a key that have 'edgekeys="true"'. 'key2' and 'key3' represent the right and left keys.
2023-01-22 23:03:30 +01:00
return true;
return false;
}
Move pointer handling code to its own class Separate the concerns and have a clearer interface between the two parts of the code.
2022-02-20 13:09:39 +01:00
// Key repeat
/** Message from [_keyrepeat_handler]. */
@Override
public boolean handleMessage(Message msg)
{
for (Pointer ptr : _ptrs)
{
if (ptr.timeoutWhat == msg.what)
{
Hold any modifier to lock Modifiers can be locked with a long press. The key repeat mechanism is re-used and the press timeout is the same. Every modifiers can be locked that way, not only the "lockable" ones. The previous behavior can be enabled in the settings (for shift only) but the default is changed.
2022-07-24 23:55:00 +02:00
if (handleKeyRepeat(ptr))
Remove the modulated repeat It allowed to modulate the repeat speed of some keys (arrow, backspace, delete) by move the finger farther or closer to the key. In practice, this wasn't pratical and doesn't seem popular. It is removed in favor of a better mechanism for moving the cursor.
2023-01-22 23:13:30 +01:00
_keyrepeat_handler.sendEmptyMessageDelayed(msg.what,
_config.longPressInterval);
Hold any modifier to lock Modifiers can be locked with a long press. The key repeat mechanism is re-used and the press timeout is the same. Every modifiers can be locked that way, not only the "lockable" ones. The previous behavior can be enabled in the settings (for shift only) but the default is changed.
2022-07-24 23:55:00 +02:00
else
ptr.timeoutWhat = -1;
return true;
Move pointer handling code to its own class Separate the concerns and have a clearer interface between the two parts of the code.
2022-02-20 13:09:39 +01:00
}
}
Hold any modifier to lock Modifiers can be locked with a long press. The key repeat mechanism is re-used and the press timeout is the same. Every modifiers can be locked that way, not only the "lockable" ones. The previous behavior can be enabled in the settings (for shift only) but the default is changed.
2022-07-24 23:55:00 +02:00
return false;
}
Move pointer handling code to its own class Separate the concerns and have a clearer interface between the two parts of the code.
2022-02-20 13:09:39 +01:00
private static int uniqueTimeoutWhat = 0;
private void startKeyRepeat(Pointer ptr)
{
int what = (uniqueTimeoutWhat++);
ptr.timeoutWhat = what;
Remove the modulated repeat It allowed to modulate the repeat speed of some keys (arrow, backspace, delete) by move the finger farther or closer to the key. In practice, this wasn't pratical and doesn't seem popular. It is removed in favor of a better mechanism for moving the cursor.
2023-01-22 23:13:30 +01:00
_keyrepeat_handler.sendEmptyMessageDelayed(what, _config.longPressTimeout);
Move pointer handling code to its own class Separate the concerns and have a clearer interface between the two parts of the code.
2022-02-20 13:09:39 +01:00
}
private void stopKeyRepeat(Pointer ptr)
{
if (ptr.timeoutWhat != -1)
{
_keyrepeat_handler.removeMessages(ptr.timeoutWhat);
ptr.timeoutWhat = -1;
}
}
Circle and round trip gestures (#640) This implements clockwise/anticlockwise circle and round trip gestures inspired by Messagease. The circle gestures start after a small threshold to avoid making the regular swipe too hard to aim. The gestures do: - circle: The center symbol with Shift applied, with a fallback on Fn - round trip: Same as the circle gesture but applied to a side symbol - anticlockwise circle: Nothing currently. It is intended to be made configurable per-layout in the future. The new Gesture class keeps track of what the pointer is doing while it moves on a key. It replaces the 'selected_direction' integer.
2024-05-25 21:19:44 +02:00
private void restartKeyRepeat(Pointer ptr)
{
stopKeyRepeat(ptr);
startKeyRepeat(ptr);
}
Hold any modifier to lock Modifiers can be locked with a long press. The key repeat mechanism is re-used and the press timeout is the same. Every modifiers can be locked that way, not only the "lockable" ones. The previous behavior can be enabled in the settings (for shift only) but the default is changed.
2022-07-24 23:55:00 +02:00
/** A pointer is repeating. Returns [true] if repeat should continue. */
private boolean handleKeyRepeat(Pointer ptr)
{
// Long press toggle lock on modifiers
refactor: Use internal flags in Pointers 'FLAG_LOCKED' and 'FLAG_FAKE_PTR' are only used within Pointers. Define new flags in Pointers and remove these from KeyValue. Also allows to define new flags.
2024-03-11 00:10:12 +01:00
if ((ptr.flags & FLAG_P_LATCHABLE) != 0)
Hold any modifier to lock Modifiers can be locked with a long press. The key repeat mechanism is re-used and the press timeout is the same. Every modifiers can be locked that way, not only the "lockable" ones. The previous behavior can be enabled in the settings (for shift only) but the default is changed.
2022-07-24 23:55:00 +02:00
{
refactor: Implement Compose without global state Thanks to the previous commit, a modifier key can now be more complex than just a KeyValue.Modifier. This allows a more elegant implementation of the compose key, that could be taken as a base for other features (eg. unicode hex entry, hangul) The COMPOSE_PENDING modifier is removed as keys of kind Compose_pending can act as a modifier. This has the advantage of highlighting the key that was last pressed in the sequence. Rules are added to Pointers: Non-special but latchable keys must clear latches and cannot be locked with a long press. These rules were not needed before but were intended.
2024-03-18 01:00:22 +01:00
if (!ptr.hasFlagsAny(FLAG_P_CANT_LOCK))
lockPointer(ptr, true);
Hold any modifier to lock Modifiers can be locked with a long press. The key repeat mechanism is re-used and the press timeout is the same. Every modifiers can be locked that way, not only the "lockable" ones. The previous behavior can be enabled in the settings (for shift only) but the default is changed.
2022-07-24 23:55:00 +02:00
return false;
}
Modify keys after a long press
2023-02-12 23:14:57 +01:00
// Stop repeating: Latched key, no key
refactor: Add latched flag to Pointers
2024-03-11 00:29:12 +01:00
if (ptr.hasFlagsAny(FLAG_P_LATCHED) || ptr.value == null)
Hold any modifier to lock Modifiers can be locked with a long press. The key repeat mechanism is re-used and the press timeout is the same. Every modifiers can be locked that way, not only the "lockable" ones. The previous behavior can be enabled in the settings (for shift only) but the default is changed.
2022-07-24 23:55:00 +02:00
return false;
Modify keys after a long press
2023-02-12 23:14:57 +01:00
KeyValue kv = KeyModifier.modify_long_press(ptr.value);
if (!kv.equals(ptr.value))
{
ptr.value = kv;
Disable automatically Shift when pressing Ctrl Automatic capitalisation might interferes with keyboard shortcuts.
2023-08-26 23:37:22 +02:00
_handler.onPointerDown(kv, true);
Modify keys after a long press
2023-02-12 23:14:57 +01:00
return true;
}
// Stop repeating: Special keys
compose: Grey out keys that are not in sequence Keys that are not in the pending compose sequence are greyed out with the new 'FLAG_GREYED' flag.
2024-02-17 19:31:52 +01:00
if (kv.hasFlagsAny(KeyValue.FLAG_SPECIAL))
Modify keys after a long press
2023-02-12 23:14:57 +01:00
return false;
_handler.onPointerHold(kv, ptr.modifiers);
Hold any modifier to lock Modifiers can be locked with a long press. The key repeat mechanism is re-used and the press timeout is the same. Every modifiers can be locked that way, not only the "lockable" ones. The previous behavior can be enabled in the settings (for shift only) but the default is changed.
2022-07-24 23:55:00 +02:00
return true;
}
Move cursor by sliding on the space bar Send key events for the left or right arrow as the finger slides on the space bar. Can be used to select text by holding shift. Works under Termux. Events are sent linearly as the finger travels. The distance between each events is defined from the swiping distance divided by 4. 'slider="true"' can be set on a key that have 'edgekeys="true"'. 'key2' and 'key3' represent the right and left keys.
2023-01-22 23:03:30 +01:00
// Sliding
More precise and faster spacebar slider (#593) * Make slider speed independent from swipe distance Swipe distances other than the default resulted in a slider that were not easy to control. * refactor: Add class Pointers.Sliding It holds the states and the code needed to make the slider work. 'Pointer.sliding' is set to [null] when sliding is not in progress. The implementation is changed not to depend on [downX] and [dx] but instead use the pointer's [x] coordinate directly. * Move the cursor further for faster slides In sliding mode, compute the speed of the pointer and use it to increase at which the cursor moves. * refactor: Separate kind for cursor movement keys This allows to define a key that moves the cursor more than one position at a time. This will be used to avoid lag during fast slider movements. * Reduce lag when sliding quickly on the spacebar Avoid sending key events in a loop while sliding quickly in a cursor movement key. Key of kind Cursor_move are "multiplied", meaning a single key event represents a movement of more than one position, reducing the number of key events sent. This is only for cursor move keys.
2024-05-02 19:31:48 +02:00
void startSliding(Pointer ptr, float x)
Move cursor by sliding on the space bar Send key events for the left or right arrow as the finger slides on the space bar. Can be used to select text by holding shift. Works under Termux. Events are sent linearly as the finger travels. The distance between each events is defined from the swiping distance divided by 4. 'slider="true"' can be set on a key that have 'edgekeys="true"'. 'key2' and 'key3' represent the right and left keys.
2023-01-22 23:03:30 +01:00
{
stopKeyRepeat(ptr);
refactor: Pointers: Flag for sliding state
2024-03-11 00:38:37 +01:00
ptr.flags |= FLAG_P_SLIDING;
More precise and faster spacebar slider (#593) * Make slider speed independent from swipe distance Swipe distances other than the default resulted in a slider that were not easy to control. * refactor: Add class Pointers.Sliding It holds the states and the code needed to make the slider work. 'Pointer.sliding' is set to [null] when sliding is not in progress. The implementation is changed not to depend on [downX] and [dx] but instead use the pointer's [x] coordinate directly. * Move the cursor further for faster slides In sliding mode, compute the speed of the pointer and use it to increase at which the cursor moves. * refactor: Separate kind for cursor movement keys This allows to define a key that moves the cursor more than one position at a time. This will be used to avoid lag during fast slider movements. * Reduce lag when sliding quickly on the spacebar Avoid sending key events in a loop while sliding quickly in a cursor movement key. Key of kind Cursor_move are "multiplied", meaning a single key event represents a movement of more than one position, reducing the number of key events sent. This is only for cursor move keys.
2024-05-02 19:31:48 +02:00
ptr.sliding = new Sliding(x);
Move cursor by sliding on the space bar Send key events for the left or right arrow as the finger slides on the space bar. Can be used to select text by holding shift. Works under Termux. Events are sent linearly as the finger travels. The distance between each events is defined from the swiping distance divided by 4. 'slider="true"' can be set on a key that have 'edgekeys="true"'. 'key2' and 'key3' represent the right and left keys.
2023-01-22 23:03:30 +01:00
}
Improve modulated key repeat Change the formula: don't use an external constant, add a state. It's now the ratio between where the finger is at the first repeat and where it is now. Keep the repeat going when swiping into an other key. Currently only for arrows: It's now possible to go from an arrow to an other without waiting again for the key repeat timeout. The backspace and delete keys don't work well with this.
2022-02-21 00:24:57 +01:00
refactor: Use internal flags in Pointers 'FLAG_LOCKED' and 'FLAG_FAKE_PTR' are only used within Pointers. Define new flags in Pointers and remove these from KeyValue. Also allows to define new flags.
2024-03-11 00:10:12 +01:00
/** Return the [FLAG_P_*] flags that correspond to pressing [kv]. */
static int pointer_flags_of_kv(KeyValue kv)
{
int flags = 0;
if (kv.hasFlagsAny(KeyValue.FLAG_LATCH))
refactor: Implement Compose without global state Thanks to the previous commit, a modifier key can now be more complex than just a KeyValue.Modifier. This allows a more elegant implementation of the compose key, that could be taken as a base for other features (eg. unicode hex entry, hangul) The COMPOSE_PENDING modifier is removed as keys of kind Compose_pending can act as a modifier. This has the advantage of highlighting the key that was last pressed in the sequence. Rules are added to Pointers: Non-special but latchable keys must clear latches and cannot be locked with a long press. These rules were not needed before but were intended.
2024-03-18 01:00:22 +01:00
{
// Non-special latchable key must clear modifiers and can't be locked
if (!kv.hasFlagsAny(KeyValue.FLAG_SPECIAL))
flags |= FLAG_P_CLEAR_LATCHED | FLAG_P_CANT_LOCK;
refactor: Use internal flags in Pointers 'FLAG_LOCKED' and 'FLAG_FAKE_PTR' are only used within Pointers. Define new flags in Pointers and remove these from KeyValue. Also allows to define new flags.
2024-03-11 00:10:12 +01:00
flags |= FLAG_P_LATCHABLE;
refactor: Implement Compose without global state Thanks to the previous commit, a modifier key can now be more complex than just a KeyValue.Modifier. This allows a more elegant implementation of the compose key, that could be taken as a base for other features (eg. unicode hex entry, hangul) The COMPOSE_PENDING modifier is removed as keys of kind Compose_pending can act as a modifier. This has the advantage of highlighting the key that was last pressed in the sequence. Rules are added to Pointers: Non-special but latchable keys must clear latches and cannot be locked with a long press. These rules were not needed before but were intended.
2024-03-18 01:00:22 +01:00
}
refactor: Use internal flags in Pointers 'FLAG_LOCKED' and 'FLAG_FAKE_PTR' are only used within Pointers. Define new flags in Pointers and remove these from KeyValue. Also allows to define new flags.
2024-03-11 00:10:12 +01:00
if (kv.hasFlagsAny(KeyValue.FLAG_LOCK))
flags |= FLAG_P_LOCKABLE;
return flags;
}
Circle and round trip gestures (#640) This implements clockwise/anticlockwise circle and round trip gestures inspired by Messagease. The circle gestures start after a small threshold to avoid making the regular swipe too hard to aim. The gestures do: - circle: The center symbol with Shift applied, with a fallback on Fn - round trip: Same as the circle gesture but applied to a side symbol - anticlockwise circle: Nothing currently. It is intended to be made configurable per-layout in the future. The new Gesture class keeps track of what the pointer is doing while it moves on a key. It replaces the 'selected_direction' integer.
2024-05-25 21:19:44 +02:00
// Gestures
/** Apply a gesture to the current key. */
KeyValue apply_gesture(Pointer ptr, Gesture.Name gesture)
{
switch (gesture)
{
case None:
return ptr.value;
case Swipe:
return ptr.value;
case Roundtrip:
return
modify_key_with_extra_modifier(
ptr,
getNearestKeyAtDirection(ptr, ptr.gesture.current_direction()),
KeyValue.Modifier.GESTURE);
case Circle:
return
modify_key_with_extra_modifier(ptr, ptr.key.keys[0],
KeyValue.Modifier.GESTURE);
case Anticircle:
Configure anticircle gesture per-key (#644) This adds the new 'anticircle' attribute to layouts '<key>' elements that configure the key to send when doing a anti-clockwise circle gesture on it. Labels are drawn the same way as indication. Updated docs.
2024-05-29 11:59:54 +02:00
return _handler.modifyKey(ptr.key.anticircle, ptr.modifiers);
Circle and round trip gestures (#640) This implements clockwise/anticlockwise circle and round trip gestures inspired by Messagease. The circle gestures start after a small threshold to avoid making the regular swipe too hard to aim. The gestures do: - circle: The center symbol with Shift applied, with a fallback on Fn - round trip: Same as the circle gesture but applied to a side symbol - anticlockwise circle: Nothing currently. It is intended to be made configurable per-layout in the future. The new Gesture class keeps track of what the pointer is doing while it moves on a key. It replaces the 'selected_direction' integer.
2024-05-25 21:19:44 +02:00
}
return ptr.value; // Unreachable
}
KeyValue modify_key_with_extra_modifier(Pointer ptr, KeyValue kv,
KeyValue.Modifier extra_mod)
{
return
_handler.modifyKey(kv,
ptr.modifiers.with_extra_mod(KeyValue.makeInternalModifier(extra_mod)));
}
// Pointers
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 final class Pointer
Move pointer handling code to its own class Separate the concerns and have a clearer interface between the two parts of the code.
2022-02-20 13:09:39 +01:00
{
/** -1 when latched. */
public int pointerId;
only vibrate when the swipe key changes
2022-05-07 00:08:20 +02:00
/** The Key pressed by this Pointer */
Allow modifiers to hide keys Modifiers can temporarily remove a key from the layout by returning 'null'. Make sure pointer handling code handle these modified keys gracefully and doesn't trigger a key event and a vibration for the removed key.
2022-03-19 15:39:20 +01:00
public final KeyboardData.Key key;
Circle and round trip gestures (#640) This implements clockwise/anticlockwise circle and round trip gestures inspired by Messagease. The circle gestures start after a small threshold to avoid making the regular swipe too hard to aim. The gestures do: - circle: The center symbol with Shift applied, with a fallback on Fn - round trip: Same as the circle gesture but applied to a side symbol - anticlockwise circle: Nothing currently. It is intended to be made configurable per-layout in the future. The new Gesture class keeps track of what the pointer is doing while it moves on a key. It replaces the 'selected_direction' integer.
2024-05-25 21:19:44 +02:00
/** Gesture state, see [Gesture]. [null] means the pointer has not moved out of the center region. */
public Gesture gesture;
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
/** Selected value with [modifiers] applied. */
Move pointer handling code to its own class Separate the concerns and have a clearer interface between the two parts of the code.
2022-02-20 13:09:39 +01:00
public KeyValue value;
public float downX;
public float downY;
Record activated modifiers on key down The View no longer keeps flags for something other than rendering.
2022-04-30 23:17:20 +02:00
/** Modifier flags at the time the key was pressed. */
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 Modifiers modifiers;
refactor: Use internal flags in Pointers 'FLAG_LOCKED' and 'FLAG_FAKE_PTR' are only used within Pointers. Define new flags in Pointers and remove these from KeyValue. Also allows to define new flags.
2024-03-11 00:10:12 +01:00
/** See [FLAG_P_*] flags. */
Move pointer handling code to its own class Separate the concerns and have a clearer interface between the two parts of the code.
2022-02-20 13:09:39 +01:00
public int flags;
/** Identify timeout messages. */
public int timeoutWhat;
More precise and faster spacebar slider (#593) * Make slider speed independent from swipe distance Swipe distances other than the default resulted in a slider that were not easy to control. * refactor: Add class Pointers.Sliding It holds the states and the code needed to make the slider work. 'Pointer.sliding' is set to [null] when sliding is not in progress. The implementation is changed not to depend on [downX] and [dx] but instead use the pointer's [x] coordinate directly. * Move the cursor further for faster slides In sliding mode, compute the speed of the pointer and use it to increase at which the cursor moves. * refactor: Separate kind for cursor movement keys This allows to define a key that moves the cursor more than one position at a time. This will be used to avoid lag during fast slider movements. * Reduce lag when sliding quickly on the spacebar Avoid sending key events in a loop while sliding quickly in a cursor movement key. Key of kind Cursor_move are "multiplied", meaning a single key event represents a movement of more than one position, reducing the number of key events sent. This is only for cursor move keys.
2024-05-02 19:31:48 +02:00
/** [null] when not in sliding mode. */
public Sliding sliding;
Move pointer handling code to its own class Separate the concerns and have a clearer interface between the two parts of the code.
2022-02-20 13:09:39 +01: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
public Pointer(int p, KeyboardData.Key k, KeyValue v, float x, float y, Modifiers m)
Move pointer handling code to its own class Separate the concerns and have a clearer interface between the two parts of the code.
2022-02-20 13:09:39 +01:00
{
pointerId = p;
key = k;
Circle and round trip gestures (#640) This implements clockwise/anticlockwise circle and round trip gestures inspired by Messagease. The circle gestures start after a small threshold to avoid making the regular swipe too hard to aim. The gestures do: - circle: The center symbol with Shift applied, with a fallback on Fn - round trip: Same as the circle gesture but applied to a side symbol - anticlockwise circle: Nothing currently. It is intended to be made configurable per-layout in the future. The new Gesture class keeps track of what the pointer is doing while it moves on a key. It replaces the 'selected_direction' integer.
2024-05-25 21:19:44 +02:00
gesture = null;
Move pointer handling code to its own class Separate the concerns and have a clearer interface between the two parts of the code.
2022-02-20 13:09:39 +01:00
value = v;
downX = x;
downY = y;
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
modifiers = m;
refactor: Use internal flags in Pointers 'FLAG_LOCKED' and 'FLAG_FAKE_PTR' are only used within Pointers. Define new flags in Pointers and remove these from KeyValue. Also allows to define new flags.
2024-03-11 00:10:12 +01:00
flags = (v == null) ? 0 : pointer_flags_of_kv(v);
Move pointer handling code to its own class Separate the concerns and have a clearer interface between the two parts of the code.
2022-02-20 13:09:39 +01:00
timeoutWhat = -1;
More precise and faster spacebar slider (#593) * Make slider speed independent from swipe distance Swipe distances other than the default resulted in a slider that were not easy to control. * refactor: Add class Pointers.Sliding It holds the states and the code needed to make the slider work. 'Pointer.sliding' is set to [null] when sliding is not in progress. The implementation is changed not to depend on [downX] and [dx] but instead use the pointer's [x] coordinate directly. * Move the cursor further for faster slides In sliding mode, compute the speed of the pointer and use it to increase at which the cursor moves. * refactor: Separate kind for cursor movement keys This allows to define a key that moves the cursor more than one position at a time. This will be used to avoid lag during fast slider movements. * Reduce lag when sliding quickly on the spacebar Avoid sending key events in a loop while sliding quickly in a cursor movement key. Key of kind Cursor_move are "multiplied", meaning a single key event represents a movement of more than one position, reducing the number of key events sent. This is only for cursor move keys.
2024-05-02 19:31:48 +02:00
sliding = null;
Move pointer handling code to its own class Separate the concerns and have a clearer interface between the two parts of the code.
2022-02-20 13:09:39 +01:00
}
refactor: Add latched flag to Pointers
2024-03-11 00:29:12 +01:00
public boolean hasFlagsAny(int has)
{
return ((flags & has) != 0);
}
Move pointer handling code to its own class Separate the concerns and have a clearer interface between the two parts of the code.
2022-02-20 13:09:39 +01:00
}
More precise and faster spacebar slider (#593) * Make slider speed independent from swipe distance Swipe distances other than the default resulted in a slider that were not easy to control. * refactor: Add class Pointers.Sliding It holds the states and the code needed to make the slider work. 'Pointer.sliding' is set to [null] when sliding is not in progress. The implementation is changed not to depend on [downX] and [dx] but instead use the pointer's [x] coordinate directly. * Move the cursor further for faster slides In sliding mode, compute the speed of the pointer and use it to increase at which the cursor moves. * refactor: Separate kind for cursor movement keys This allows to define a key that moves the cursor more than one position at a time. This will be used to avoid lag during fast slider movements. * Reduce lag when sliding quickly on the spacebar Avoid sending key events in a loop while sliding quickly in a cursor movement key. Key of kind Cursor_move are "multiplied", meaning a single key event represents a movement of more than one position, reducing the number of key events sent. This is only for cursor move keys.
2024-05-02 19:31:48 +02:00
public final class Sliding
{
/** Accumulated distance since last event. */
float d = 0.f;
/** The slider speed changes depending on the pointer speed. */
float speed = 1.f;
/** Coordinate of the last move. */
float last_x;
/** [System.currentTimeMillis()] at the time of the last move. */
long last_move_ms;
public Sliding(float x)
{
last_x = x;
last_move_ms = System.currentTimeMillis();
}
static final float SPEED_SMOOTHING = 0.7f;
/** Avoid absurdly large values. */
static final float SPEED_MAX = 4.f;
public void onTouchMove(Pointer ptr, float x)
{
d += (x - last_x) * speed / _config.slide_step_px;
update_speed(x);
// Send an event when [abs(d)] exceeds [1].
int d_ = (int)d;
if (d_ != 0)
{
d -= d_;
int key_index = (d_ < 0) ? 5 : 6;
ptr.value = _handler.modifyKey(ptr.key.keys[key_index], ptr.modifiers);
send_key(ptr, Math.abs(d_));
}
}
/** Handle a sliding pointer going up. Latched modifiers are not
cleared to allow easy adjustments to the cursors. The pointer is
cancelled. */
public void onTouchUp(Pointer ptr)
{
removePtr(ptr);
_handler.onPointerFlagsChanged(false);
}
/** Send the pressed key [n] times. */
void send_key(Pointer ptr, int n)
{
if (ptr.value == null)
return;
// Avoid looping if possible to avoid lag while sliding fast
KeyValue multiplied = multiply_key(ptr.value, n);
if (multiplied != null)
_handler.onPointerHold(multiplied, ptr.modifiers);
else
for (int i = 0; i < n; i++)
_handler.onPointerHold(ptr.value, ptr.modifiers);
}
/** Return a key performing the same action as [kv] but [n] times. Returns
[null] if [kv] cannot be multiplied. */
KeyValue multiply_key(KeyValue kv, int n)
{
switch (kv.getKind())
{
case Cursor_move:
return KeyValue.cursorMoveKey(kv.getCursorMove() * n);
}
return null;
}
/** [speed] is computed from the elapsed time and distance traveled
between two move events. Exponential smoothing is used to smooth out
the noise. Sets [last_move_ms] and [last_x]. */
void update_speed(float x)
{
long now = System.currentTimeMillis();
float instant_speed = Math.min(SPEED_MAX,
Math.abs(x - last_x) / (float)(now - last_move_ms) + 1.f);
speed = speed + (instant_speed - speed) * SPEED_SMOOTHING;
last_move_ms = now;
last_x = x;
}
}
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
/** Represent modifiers currently activated.
Sorted in the order they should be evaluated. */
public static final class Modifiers
{
refactor: Allow modifier of other key kinds Allow keys of a kind other than Modifier to be a modifier. This requires writing a compareTo function for KeyValue. Fields are compared in this order: Kind, value, flags, symbol.
2024-03-18 00:14:19 +01:00
private final KeyValue[] _mods;
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 final int _size;
refactor: Allow modifier of other key kinds Allow keys of a kind other than Modifier to be a modifier. This requires writing a compareTo function for KeyValue. Fields are compared in this order: Kind, value, flags, symbol.
2024-03-18 00:14:19 +01:00
private Modifiers(KeyValue[] m, int s)
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
{
_mods = m; _size = s;
}
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: Allow modifier of other key kinds Allow keys of a kind other than Modifier to be a modifier. This requires writing a compareTo function for KeyValue. Fields are compared in this order: Kind, value, flags, symbol.
2024-03-18 00:14:19 +01:00
public KeyValue get(int i) { return _mods[_size - 1 - i]; }
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 int size() { return _size; }
Per-layout shift modmap Specify the behavior of shift for a layout. This is intended for locales that use the same alphabet but have different capital letters (eg. Bengali). The modmap is defined like this: <keyboard> <modmap> <shift a="a" b="A"/> </modmap> </keyboard>
2023-06-03 09:37:59 +02:00
public boolean has(KeyValue.Modifier m)
{
refactor: Allow modifier of other key kinds Allow keys of a kind other than Modifier to be a modifier. This requires writing a compareTo function for KeyValue. Fields are compared in this order: Kind, value, flags, symbol.
2024-03-18 00:14:19 +01:00
for (int i = 0; i < _size; i++)
{
KeyValue kv = _mods[i];
switch (kv.getKind())
{
case Modifier:
if (kv.getModifier().equals(m))
return true;
}
}
return false;
Per-layout shift modmap Specify the behavior of shift for a layout. This is intended for locales that use the same alphabet but have different capital letters (eg. Bengali). The modmap is defined like this: <keyboard> <modmap> <shift a="a" b="A"/> </modmap> </keyboard>
2023-06-03 09:37:59 +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
Circle and round trip gestures (#640) This implements clockwise/anticlockwise circle and round trip gestures inspired by Messagease. The circle gestures start after a small threshold to avoid making the regular swipe too hard to aim. The gestures do: - circle: The center symbol with Shift applied, with a fallback on Fn - round trip: Same as the circle gesture but applied to a side symbol - anticlockwise circle: Nothing currently. It is intended to be made configurable per-layout in the future. The new Gesture class keeps track of what the pointer is doing while it moves on a key. It replaces the 'selected_direction' integer.
2024-05-25 21:19:44 +02:00
/** Return a copy of this object with an extra modifier added. */
public Modifiers with_extra_mod(KeyValue m)
{
KeyValue[] newmods = Arrays.copyOf(_mods, _size + 1);
newmods[_size] = m;
return ofArray(newmods, newmods.length);
}
Send down event for modifiers on time This allows to use modifiers in combination with other inputs like a mouse click, for example under termux-x11. The key down event and notification about modifiers changing are sent down to KeyEventHandler. A mutable state remember for which modifier down events have been sent. When pressing down a modifier with one finger and typing with the other, it might appear that the modifier is released after the first time an other key is pressed and then pressed and released for the following keys. This prevents unintentionally type two modified keys instead of one when the second key is pressed while the other is not yet released.
2024-01-26 00:17:51 +01:00
/** Returns the activated modifiers that are not in [m2]. */
refactor: Allow modifier of other key kinds Allow keys of a kind other than Modifier to be a modifier. This requires writing a compareTo function for KeyValue. Fields are compared in this order: Kind, value, flags, symbol.
2024-03-18 00:14:19 +01:00
public Iterator<KeyValue> diff(Modifiers m2)
Send down event for modifiers on time This allows to use modifiers in combination with other inputs like a mouse click, for example under termux-x11. The key down event and notification about modifiers changing are sent down to KeyEventHandler. A mutable state remember for which modifier down events have been sent. When pressing down a modifier with one finger and typing with the other, it might appear that the modifier is released after the first time an other key is pressed and then pressed and released for the following keys. This prevents unintentionally type two modified keys instead of one when the second key is pressed while the other is not yet released.
2024-01-26 00:17:51 +01:00
{
return new ModifiersDiffIterator(this, m2);
}
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
@Override
public int hashCode() { return Arrays.hashCode(_mods); }
@Override
public boolean equals(Object obj)
{
return Arrays.equals(_mods, ((Modifiers)obj)._mods);
}
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 final Modifiers EMPTY =
refactor: Allow modifier of other key kinds Allow keys of a kind other than Modifier to be a modifier. This requires writing a compareTo function for KeyValue. Fields are compared in this order: Kind, value, flags, symbol.
2024-03-18 00:14:19 +01:00
new Modifiers(new KeyValue[0], 0);
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: Allow modifier of other key kinds Allow keys of a kind other than Modifier to be a modifier. This requires writing a compareTo function for KeyValue. Fields are compared in this order: Kind, value, flags, symbol.
2024-03-18 00:14:19 +01:00
protected static Modifiers ofArray(KeyValue[] mods, int size)
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: 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
// Sort and remove duplicates and nulls.
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
if (size > 1)
{
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
Arrays.sort(mods, 0, size);
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 j = 0;
for (int i = 0; i < size; i++)
{
refactor: Allow modifier of other key kinds Allow keys of a kind other than Modifier to be a modifier. This requires writing a compareTo function for KeyValue. Fields are compared in this order: Kind, value, flags, symbol.
2024-03-18 00:14:19 +01:00
KeyValue m = mods[i];
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
if (m != null && (i + 1 >= size || m != mods[i + 1]))
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
{
mods[j] = m;
j++;
}
}
size = j;
}
return new Modifiers(mods, size);
}
Send down event for modifiers on time This allows to use modifiers in combination with other inputs like a mouse click, for example under termux-x11. The key down event and notification about modifiers changing are sent down to KeyEventHandler. A mutable state remember for which modifier down events have been sent. When pressing down a modifier with one finger and typing with the other, it might appear that the modifier is released after the first time an other key is pressed and then pressed and released for the following keys. This prevents unintentionally type two modified keys instead of one when the second key is pressed while the other is not yet released.
2024-01-26 00:17:51 +01:00
/** Returns modifiers that are in [m1_] but not in [m2_]. */
static final class ModifiersDiffIterator
refactor: Allow modifier of other key kinds Allow keys of a kind other than Modifier to be a modifier. This requires writing a compareTo function for KeyValue. Fields are compared in this order: Kind, value, flags, symbol.
2024-03-18 00:14:19 +01:00
implements Iterator<KeyValue>
Send down event for modifiers on time This allows to use modifiers in combination with other inputs like a mouse click, for example under termux-x11. The key down event and notification about modifiers changing are sent down to KeyEventHandler. A mutable state remember for which modifier down events have been sent. When pressing down a modifier with one finger and typing with the other, it might appear that the modifier is released after the first time an other key is pressed and then pressed and released for the following keys. This prevents unintentionally type two modified keys instead of one when the second key is pressed while the other is not yet released.
2024-01-26 00:17:51 +01:00
{
Modifiers m1;
int i1 = 0;
Modifiers m2;
int i2 = 0;
public ModifiersDiffIterator(Modifiers m1_, Modifiers m2_)
{
m1 = m1_;
m2 = m2_;
advance();
}
public boolean hasNext()
{
return i1 < m1._size;
}
refactor: Allow modifier of other key kinds Allow keys of a kind other than Modifier to be a modifier. This requires writing a compareTo function for KeyValue. Fields are compared in this order: Kind, value, flags, symbol.
2024-03-18 00:14:19 +01:00
public KeyValue next()
Send down event for modifiers on time This allows to use modifiers in combination with other inputs like a mouse click, for example under termux-x11. The key down event and notification about modifiers changing are sent down to KeyEventHandler. A mutable state remember for which modifier down events have been sent. When pressing down a modifier with one finger and typing with the other, it might appear that the modifier is released after the first time an other key is pressed and then pressed and released for the following keys. This prevents unintentionally type two modified keys instead of one when the second key is pressed while the other is not yet released.
2024-01-26 00:17:51 +01:00
{
if (i1 >= m1._size)
throw new NoSuchElementException();
refactor: Allow modifier of other key kinds Allow keys of a kind other than Modifier to be a modifier. This requires writing a compareTo function for KeyValue. Fields are compared in this order: Kind, value, flags, symbol.
2024-03-18 00:14:19 +01:00
KeyValue m = m1._mods[i1];
Send down event for modifiers on time This allows to use modifiers in combination with other inputs like a mouse click, for example under termux-x11. The key down event and notification about modifiers changing are sent down to KeyEventHandler. A mutable state remember for which modifier down events have been sent. When pressing down a modifier with one finger and typing with the other, it might appear that the modifier is released after the first time an other key is pressed and then pressed and released for the following keys. This prevents unintentionally type two modified keys instead of one when the second key is pressed while the other is not yet released.
2024-01-26 00:17:51 +01:00
i1++;
advance();
return m;
}
/** Advance to the next element if [i1] is not a valid element. The end
is reached when [i1 = m1.size()]. */
void advance()
{
while (i1 < m1.size())
{
refactor: Allow modifier of other key kinds Allow keys of a kind other than Modifier to be a modifier. This requires writing a compareTo function for KeyValue. Fields are compared in this order: Kind, value, flags, symbol.
2024-03-18 00:14:19 +01:00
KeyValue m = m1._mods[i1];
Send down event for modifiers on time This allows to use modifiers in combination with other inputs like a mouse click, for example under termux-x11. The key down event and notification about modifiers changing are sent down to KeyEventHandler. A mutable state remember for which modifier down events have been sent. When pressing down a modifier with one finger and typing with the other, it might appear that the modifier is released after the first time an other key is pressed and then pressed and released for the following keys. This prevents unintentionally type two modified keys instead of one when the second key is pressed while the other is not yet released.
2024-01-26 00:17:51 +01:00
while (true)
{
if (i2 >= m2._size)
return;
int d = m.compareTo(m2._mods[i2]);
if (d < 0)
return;
i2++;
if (d == 0)
break;
}
i1++;
}
}
}
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
}
Move pointer handling code to its own class Separate the concerns and have a clearer interface between the two parts of the code.
2022-02-20 13:09:39 +01:00
public interface IPointerEventHandler
{
Fix vibration when pointer move slightly Fix the bug introduced in the parent commit.
2022-05-08 16:53:33 +02:00
/** Key can be modified or removed by returning [null]. */
refactor: Use internal flags in Pointers 'FLAG_LOCKED' and 'FLAG_FAKE_PTR' are only used within Pointers. Define new flags in Pointers and remove these from KeyValue. Also allows to define new flags.
2024-03-11 00:10:12 +01:00
public KeyValue modifyKey(KeyValue k, Modifiers mods);
Allow modifiers to hide keys Modifiers can temporarily remove a key from the layout by returning 'null'. Make sure pointer handling code handle these modified keys gracefully and doesn't trigger a key event and a vibration for the removed key.
2022-03-19 15:39:20 +01: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
/** A key is pressed. [getModifiers()] is uptodate. Might be called after a
Disable automatically Shift when pressing Ctrl Automatic capitalisation might interferes with keyboard shortcuts.
2023-08-26 23:37:22 +02:00
press or a swipe to a different value. Down events are not paired with
up events. */
public void onPointerDown(KeyValue k, boolean isSwipe);
Allow modifiers to hide keys Modifiers can temporarily remove a key from the layout by returning 'null'. Make sure pointer handling code handle these modified keys gracefully and doesn't trigger a key event and a vibration for the removed key.
2022-03-19 15:39:20 +01:00
Fix vibration when pointer move slightly Fix the bug introduced in the parent commit.
2022-05-08 16:53:33 +02:00
/** Key is released. [k] is the key that was returned by
[modifySelectedKey] or [modifySelectedKey]. */
refactor: Use internal flags in Pointers 'FLAG_LOCKED' and 'FLAG_FAKE_PTR' are only used within Pointers. Define new flags in Pointers and remove these from KeyValue. Also allows to define new flags.
2024-03-11 00:10:12 +01:00
public void onPointerUp(KeyValue k, Modifiers mods);
Allow modifiers to hide keys Modifiers can temporarily remove a key from the layout by returning 'null'. Make sure pointer handling code handle these modified keys gracefully and doesn't trigger a key event and a vibration for the removed key.
2022-03-19 15:39:20 +01:00
/** Flags changed because latched or locked keys or cancelled pointers. */
Hold any modifier to lock Modifiers can be locked with a long press. The key repeat mechanism is re-used and the press timeout is the same. Every modifiers can be locked that way, not only the "lockable" ones. The previous behavior can be enabled in the settings (for shift only) but the default is changed.
2022-07-24 23:55:00 +02:00
public void onPointerFlagsChanged(boolean shouldVibrate);
Allow modifiers to hide keys Modifiers can temporarily remove a key from the layout by returning 'null'. Make sure pointer handling code handle these modified keys gracefully and doesn't trigger a key event and a vibration for the removed key.
2022-03-19 15:39:20 +01:00
/** Key is repeating. */
refactor: Use internal flags in Pointers 'FLAG_LOCKED' and 'FLAG_FAKE_PTR' are only used within Pointers. Define new flags in Pointers and remove these from KeyValue. Also allows to define new flags.
2024-03-11 00:10:12 +01:00
public void onPointerHold(KeyValue k, Modifiers mods);
Move pointer handling code to its own class Separate the concerns and have a clearer interface between the two parts of the code.
2022-02-20 13:09:39 +01:00
}
}
Copy Permalink