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.

3 files changed, 8 insertions, 63 deletions

diff --git a/srcs/juloo.keyboard2/Config.java b/srcs/juloo.keyboard2/Config.java
index fbb542a..b8580e6 100644
--- a/srcs/juloo.keyboard2/Config.java
+++ b/srcs/juloo.keyboard2/Config.java
@@ -41,7 +41,6 @@ final class Config
   public int keyboardOpacity; // 0 - 255
   public int keyOpacity; // 0 - 255
   public int keyActivatedOpacity; // 0 - 255
-  public boolean preciseRepeat;
   public boolean double_tap_lock_shift;
   public float characterSize; // Ratio
   public int accents; // Values are R.values.pref_accents_v_*
@@ -142,7 +141,6 @@ final class Config
     horizontal_margin =
       get_dip_pref(dm, oriented_pref("horizontal_margin"),
           res.getDimension(R.dimen.horizontal_margin));
-    preciseRepeat = _prefs.getBoolean("precise_repeat", true);
     double_tap_lock_shift = _prefs.getBoolean("lock_double_tap", false);
     characterSize =
       _prefs.getFloat("character_size", 1.f)
diff --git a/srcs/juloo.keyboard2/KeyValue.java b/srcs/juloo.keyboard2/KeyValue.java
index b7a0593..8d12518 100644
--- a/srcs/juloo.keyboard2/KeyValue.java
+++ b/srcs/juloo.keyboard2/KeyValue.java
@@ -78,7 +78,7 @@ final class KeyValue
   public static final int FLAG_LOCK = (1 << 21);
   // Special keys are not repeated and don't clear latched modifiers.
   public static final int FLAG_SPECIAL = (1 << 22);
-  public static final int FLAG_PRECISE_REPEAT = (1 << 23);
+  // Free flag: (1 << 23);
   // Rendering flags.
   public static final int FLAG_KEY_FONT = (1 << 24); // special font file
   public static final int FLAG_SMALLER_FONT = (1 << 25); // 25% smaller symbols
@@ -328,10 +328,10 @@ final class KeyValue
 
     addKeyeventKey("esc", "Esc", KeyEvent.KEYCODE_ESCAPE, FLAG_SMALLER_FONT);
     addKeyeventKey("enter", 0x0E, KeyEvent.KEYCODE_ENTER, 0);
-    addKeyeventKey("up", 0x05, KeyEvent.KEYCODE_DPAD_UP, FLAG_PRECISE_REPEAT);
-    addKeyeventKey("right", 0x06, KeyEvent.KEYCODE_DPAD_RIGHT, FLAG_PRECISE_REPEAT);
-    addKeyeventKey("down", 0x07, KeyEvent.KEYCODE_DPAD_DOWN, FLAG_PRECISE_REPEAT);
-    addKeyeventKey("left", 0x08, KeyEvent.KEYCODE_DPAD_LEFT, FLAG_PRECISE_REPEAT);
+    addKeyeventKey("up", 0x05, KeyEvent.KEYCODE_DPAD_UP, 0);
+    addKeyeventKey("right", 0x06, KeyEvent.KEYCODE_DPAD_RIGHT, 0);
+    addKeyeventKey("down", 0x07, KeyEvent.KEYCODE_DPAD_DOWN, 0);
+    addKeyeventKey("left", 0x08, KeyEvent.KEYCODE_DPAD_LEFT, 0);
     addKeyeventKey("page_up", 0x02, KeyEvent.KEYCODE_PAGE_UP, 0);
     addKeyeventKey("page_down", 0x03, KeyEvent.KEYCODE_PAGE_DOWN, 0);
     addKeyeventKey("home", 0x0B, KeyEvent.KEYCODE_MOVE_HOME, 0);
diff --git a/srcs/juloo.keyboard2/Pointers.java b/srcs/juloo.keyboard2/Pointers.java
index 46b76fc..448fd4c 100644
--- a/srcs/juloo.keyboard2/Pointers.java
+++ b/srcs/juloo.keyboard2/Pointers.java
@@ -147,11 +147,6 @@ public final class Pointers implements Handler.Callback
 
   public void onTouchDown(float x, float y, int pointerId, KeyboardData.Key key)
   {
-    // Ignore new presses while a modulated key is active. On some devices,
-    // ghost touch events can happen while the pointer travels on top of other
-    // keys.
-    if (isModulatedKeyPressed())
-      return;
     // 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());
@@ -207,7 +202,6 @@ public final class Pointers implements Handler.Callback
     float dx = x - ptr.downX;
     float dy = y - ptr.downY;
     float dist = Math.abs(dx) + Math.abs(dy);
-    ptr.ptrDist = dist;
 
     int direction;
     if (dist < _config.swipe_dist_px)
@@ -237,12 +231,6 @@ public final class Pointers implements Handler.Callback
         int old_flags = ptr.flags;
         ptr.value = newValue;
         ptr.flags = newValue.getFlags();
-        // Keep the keyrepeat going between modulated keys.
-        if ((old_flags & ptr.flags & KeyValue.FLAG_PRECISE_REPEAT) == 0)
-        {
-          stopKeyRepeat(ptr);
-          startKeyRepeat(ptr);
-        }
         _handler.onPointerDown(true);
       }
     }
@@ -299,16 +287,6 @@ public final class Pointers implements Handler.Callback
     _handler.onPointerFlagsChanged(shouldVibrate);
   }
 
-  private boolean isModulatedKeyPressed()
-  {
-    for (Pointer ptr : _ptrs)
-    {
-      if ((ptr.flags & KeyValue.FLAG_PRECISE_REPEAT) != 0)
-        return true;
-    }
-    return false;
-  }
-
   // Key repeat
 
   /** Message from [_keyrepeat_handler]. */
@@ -320,7 +298,8 @@ public final class Pointers implements Handler.Callback
       if (ptr.timeoutWhat == msg.what)
       {
         if (handleKeyRepeat(ptr))
-          _keyrepeat_handler.sendEmptyMessageDelayed(msg.what, nextRepeatInterval(ptr));
+          _keyrepeat_handler.sendEmptyMessageDelayed(msg.what,
+              _config.longPressInterval);
         else
           ptr.timeoutWhat = -1;
         return true;
@@ -329,17 +308,6 @@ public final class Pointers implements Handler.Callback
     return false;
   }
 
-  private long nextRepeatInterval(Pointer ptr)
-  {
-    long t = _config.longPressInterval;
-    if (_config.preciseRepeat && (ptr.flags & KeyValue.FLAG_PRECISE_REPEAT) != 0)
-    {
-      // Modulate repeat interval depending on the distance of the pointer
-      t = (long)((float)t * 2.f / modulatePreciseRepeat(ptr));
-    }
-    return t;
-  }
-
   private static int uniqueTimeoutWhat = 0;
 
   private void startKeyRepeat(Pointer ptr)
@@ -348,11 +316,7 @@ public final class Pointers implements Handler.Callback
       return;
     int what = (uniqueTimeoutWhat++);
     ptr.timeoutWhat = what;
-    long timeout = _config.longPressTimeout;
-    // Faster repeat timeout for modulated keys
-    if ((ptr.flags & KeyValue.FLAG_PRECISE_REPEAT) != 0)
-      timeout /= 2;
-    _keyrepeat_handler.sendEmptyMessageDelayed(what, timeout);
+    _keyrepeat_handler.sendEmptyMessageDelayed(what, _config.longPressTimeout);
   }
 
   private void stopKeyRepeat(Pointer ptr)
@@ -361,7 +325,6 @@ public final class Pointers implements Handler.Callback
     {
       _keyrepeat_handler.removeMessages(ptr.timeoutWhat);
       ptr.timeoutWhat = -1;
-      ptr.repeatingPtrDist = -1.f;
     }
   }
 
@@ -381,16 +344,6 @@ public final class Pointers implements Handler.Callback
     return true;
   }
 
-  private float modulatePreciseRepeat(Pointer ptr)
-  {
-    if (ptr.repeatingPtrDist < 0.f)
-      ptr.repeatingPtrDist = ptr.ptrDist; // First repeat
-    if (ptr.ptrDist > ptr.repeatingPtrDist * 2.f)
-      ptr.repeatingPtrDist = ptr.ptrDist / 2.f; // Large swipe, move the middle point
-    float left = ptr.repeatingPtrDist / 2.f;
-    float accel = (ptr.ptrDist - left) / (ptr.repeatingPtrDist - left);
-    return Math.min(8.f, Math.max(0.1f, accel));
-  }
 
   private static final class Pointer
   {
@@ -404,16 +357,12 @@ public final class Pointers implements Handler.Callback
     public KeyValue value;
     public float downX;
     public float downY;
-    /** Distance of the pointer to the initial press. */
-    public float ptrDist;
     /** Modifier flags at the time the key was pressed. */
     public Modifiers modifiers;
     /** Flags of the value. Latch, lock and locked flags are updated. */
     public int flags;
     /** Identify timeout messages. */
     public int timeoutWhat;
-    /** ptrDist at the first repeat, -1 otherwise. */
-    public float repeatingPtrDist;
 
     public Pointer(int p, KeyboardData.Key k, KeyValue v, float x, float y, Modifiers m)
     {
@@ -423,11 +372,9 @@ public final class Pointers implements Handler.Callback
       value = v;
       downX = x;
       downY = y;
-      ptrDist = 0.f;
       modifiers = m;
       flags = (v == null) ? 0 : v.getFlags();
       timeoutWhat = -1;
-      repeatingPtrDist = -1.f;
     }
   }