Implemented rangeLimit for input / And NoErase (#151)

* Implemented rangeLimit for input / And NoErase

Issue #149

- implemented rangeLimit as an int parameter for the insert proc
- implemented overWrite as a boolean parameter for the insert proc
- added NoErase to the delete/backspace logic of the input widget
- fixed the updateInput override in tinput2.nim
- ensured all tests pass in ttextboxes.nim

* Added unsaved documentation

* Corrected vertical cursor movement during selection / improved docs

Offset was being calculated relative to one side of the selection rather than the cursorPos.

* Removed dead parameter from findLine / cleaned docs

Author: derek-v-s

src/figuro/ui/textboxes.nim

@@ -92,13 +92,8 @@ proc runeAtCursor*(self: TextBox): Rune =
     return Rune(0)
   result = self.layout.runes[self.clamped(Left, 0, inclusive=false)]
 
-proc findLine*(self: TextBox, down: bool, select: bool = false): int =
-  ## Finds the index of the line in self.layout.lines that contains the
-  ## relevant cursor/selection point.
-  ## - `down`: Indicates the direction of intended cursor movement (true for down, false for up).
-  ##           Used when `select` is false to determine which end of selection to check.
-  ## - `select`: True if the selection is currently being grown (e.g., Shift + Arrow).
-  ##             Defaults to false.
+proc findLine*(self: TextBox): int =
+  ## Returns the line the cursor is on.
 
   result = -1 # Default to -1 if no line is found
 
@@ -108,16 +103,7 @@ proc findLine*(self: TextBox, down: bool, select: bool = false): int =
   if self.layout.lines.len == 0:
     return -1
 
-  var charPosToFind: int
-  if select:
-    charPosToFind = self.cursorPos
-  else:
-    if down:
-      charPosToFind = self.selectionRange.b
-    else:
-      charPosToFind = self.selectionRange.a
-
-  let clampedCharPos = clamp(charPosToFind, 0, self.runes().len())
+  let clampedCharPos = clamp(self.cursorPos, 0, self.runes().len())
 
   for idx, lineSlice in self.layout.lines:
     # Standard case: character position is within the rune indices of the line.
@@ -216,13 +202,14 @@ proc updateSelection*(self: var TextBox) =
     rect.h = (rhs.y + rhs.h) - lhs.y
     self.selectionRects.add rect.descaled()
 
-proc growSelection*(self: var TextBox) =
+proc growSelection(self: var TextBox) =
   self.selectionRange.a = min(self.cursorPos, self.anchor)
   self.selectionRange.b = max(self.cursorPos, self.anchor)
   if not self.selectionExists: self.selectionExists = true
   self.updateSelection()
 
 proc clearSelection*(self: var TextBox) =
+  ## Clears any existing selection.
   self.anchor = self.cursorPos
   self.selectionRange.a = self.cursorPos
   self.selectionRange.b = self.cursorPos
@@ -248,20 +235,20 @@ proc updateCursor*(self: var TextBox) =
   self.cursorRect = cursor.descaled()
 
 proc placeCursor*(self: var TextBox, pos: int, select = false) =
-  # Places the keyboard cursor at the specified position.
-  # Clears the selection and brings the anchor along unless
-  # clearSelection is set to false.
+  # Places the keyboard cursor at the specified position (`pos`).
+  #
+  # If `select` is false (default), then the selection is cleared
+  # and the archor is moved with the cursor. Otherwise, a selection
+  # will be created.
   self.cursorPos = clamp(pos, 0, self.runes().len())
   self.updateCursor()
   if select: self.growSelection()
   else: self.clearSelection()
 
-proc shiftCursorDown*(self: var TextBox, select = false): int =
-  ## Move cursor or selection down one line.
-  ## - `select`: If true, extends the selection downwards.
-  ##             If false, moves the cursor and clears any existing selection.
+proc shiftCursorDown(self: var TextBox): int =
+  ## Returns the target position for a downward movement of the cursor.
 
-  let presentLineIdx = self.findLine(down = true, select = select)
+  let presentLineIdx = self.findLine()
 
   # If findLine returns -1 (e.g., empty layout), do nothing.
   if presentLineIdx == -1:
@@ -282,20 +269,17 @@ proc shiftCursorDown*(self: var TextBox, select = false): int =
     let nextLineSlice = self.layout.lines[nextLineIdx]
 
     # Calculate the horizontal offset (difference in rune indices)
-    # from the start of the current line to the cursor's Right edge.
-    let horizontalOffset = self.clamped(Right) - currentLineStartIdx
+    let horizontalOffset = self.cursorPos - currentLineStartIdx
 
     # Calculate the target rune index on the next line.
     # Add the horizontal offset to the start of the next line.
     # Ensure the target index doesn't go beyond the end index of the next line.
     return min(nextLineSlice.a + horizontalOffset, nextLineSlice.b)
 
-proc shiftCursorUp*(self: var TextBox, select = false): int =
-  ## Move cursor or selection up one line.
-  ## - `select`: If true, extends the selection upwards.
-  ##             If false, moves the cursor and clears any existing selection.
+proc shiftCursorUp(self: var TextBox): int =
+  ## Returns the target position for a upward movement of the cursor.
 
-  let presentLineIdx = self.findLine(down = false, select = select)
+  let presentLineIdx = self.findLine()
   if presentLineIdx == -1:
     return
 
@@ -305,26 +289,27 @@ proc shiftCursorUp*(self: var TextBox, select = false): int =
   else:
     let previousLineIdx = clamp(presentLineIdx - 1, 0, self.layout.lines.high)
     let previousLineSlice = self.layout.lines[previousLineIdx]
-    let horizontalOffset = self.clamped(Left) - currentLineStartIdx
+    let horizontalOffset = self.cursorPos - currentLineStartIdx
     return min(previousLineSlice.a + horizontalOffset, previousLineSlice.b)
 
 proc shiftCursor*(self: var TextBox,
-                              orientation: Orient,
-                              select = false) =
-  # Shifts the keyboard cursor based on an orientation.
-  # Options include: Right, Left, Up, Down,
-  # Beginning, TheEnd, PreviousWord, NextWord.
-  # Clears the selection and brings the anchor along unless
-  # select is set to true.
+                  orientation: Orient,
+                  select = false) =
+  ## Shifts the keyboard cursor based on an `orientation`.
+  ##
+  ## Orientations include: Right, Left, Up, Down,
+  ## Beginning, TheEnd, PreviousWord, NextWord.
+  ## If `select` is true, the selection is extended.
+  ## Otherwise, any existing selection is cleared.
   let pos: int = case orientation
     of Right: self.cursorPos + 1
     of Left: self.cursorPos - 1
     of NextWord: self.findNextWord()
     of PreviousWord: self.findPrevWord()
     of Beginning: 0
     of TheEnd: self.runes().len()
-    of Up: self.shiftCursorUp(select)
-    of Down: self.shiftCursorDown(select)
+    of Up: self.shiftCursorUp()
+    of Down: self.shiftCursorDown()
   self.cursorPos = clamp(pos, 0, self.runes().len())
   self.updateCursor()
   if select: self.growSelection()
@@ -386,28 +371,50 @@ proc delete*(self: var TextBox, orientation: Orient) =
       self.placeCursor(idx)
     else: discard
 
-proc insert*(self: var TextBox, rune: Rune) =
-
+proc insert*(self: var TextBox,
+            rune: Rune,
+            overWrite = false,
+            rangeLimit = 0) =
+  ## Inserts a rune at the current cursor position.
+  ##
+  ## overWrite: If set to true, then replace the rune in front of cursorPos.
+  ## rangeLimit: If set to a number larger than 0,
+  ## then this function will not insert a rune once there are that many runes.
   if self.selectionExists:
     self.deleteSelected()
 
-  if Overwrite in self.opts:
+  # 1. no overWrite, no rangeLimit
+  if not overWrite and rangeLimit == 0:
+    self.runes.insert(rune, self.cursorPos)
+  # 2. no overWrite, yes rangeLimit
+  elif not overWrite and rangeLimit > 0:
+    if rangeLimit > self.runes.len:
+     self.runes.insert(rune, self.cursorPos)
+  # 3. yes overWrite, no rangeLimit
+  elif overWrite and rangeLimit == 0:
     if self.cursorPos < self.runes.len():
       self.runes[self.cursorPos] = rune
     else:
       self.runes.insert(rune, self.cursorPos)
-  else:
-    self.runes.insert(rune, self.cursorPos)
+  # 4. yes overWrite, yes rangeLimit
+  elif overWrite and rangeLimit > 0:
+    if self.cursorPos <= rangeLimit - 1:
+      if self.cursorPos < self.runes.len():
+        self.runes[self.cursorPos] = rune
+      else:
+        self.runes.insert(rune, self.cursorPos)
 
   self.updateLayout()
   self.shiftCursor(Right)
 
-proc insert*(self: var TextBox, runes: seq[Rune]) =
+proc insert*(self: var TextBox,
+            runes: seq[Rune],
+            overWrite = false) =
 
-  if self.hasSelection():
+  if self.selectionExists:
     self.deleteSelected()
 
-  if Overwrite in self.opts:
+  if overWrite:
     for i in 0..<runes.len():
       if self.cursorPos < self.runes.len():
         self.runes[self.cursorPos] = runes[i]

src/figuro/widgets/input.nim

@@ -22,15 +22,14 @@ type
     cursorTick: int
     cursorCnt: int
     skipOnInput*: HashSet[Rune]
+    rangeLimit*: int = 0
 
   Cursor* = ref object of Figuro
   Selection* = ref object of Figuro
 
 proc setOptions*(self: Input, opt: set[InputOptions], state = true) {.thisWrapper.} =
   if state: self.opts.incl opt
   else: self.opts.excl opt
-  if OverwriteMode in opt:
-    self.text.options({TextOptions.Overwrite}, state)
 
 proc skipOnInput*(self: Input, runes: HashSet[Rune]) =
   ## skips the given runes and advances the cursor to the
@@ -118,7 +117,10 @@ proc keyInput*(self: Input, rune: Rune) {.slot.} =
 
 proc updateInput*(self: Input, rune: Rune) {.slot.} =
   self.skipSelectedRune()
-  self.text.insert(rune)
+  if OverwriteMode in self.opts:
+    self.text.insert(rune, overWrite = true, self.rangeLimit)
+  else:
+    self.text.insert(rune, overWrite = false, self.rangeLimit)
   self.text.update(self.box)
   refresh(self)
 
@@ -144,11 +146,13 @@ proc keyCommand*(self: Input, pressed: set[UiKey], down: set[UiKey]) {.slot.} =
     var update = true
     case pressed.getKey()
     of KeyBackspace:
-      self.text.delete(Left)
-      self.text.update(self.box)
+      if NoErase notin self.opts:
+        self.text.delete(Left)
+        self.text.update(self.box)
     of KeyDelete:
-      self.text.delete(Right)
-      self.text.update(self.box)
+      if NoErase notin self.opts:
+        self.text.delete(Right)
+        self.text.update(self.box)
     of KeyLeft:
       self.text.shiftCursor(Left)
     of KeyRight:

tests/tinput.nim

@@ -37,7 +37,6 @@ proc draw*(self: Main) {.slot.} =
           this.text.shiftCursor(TheEnd)
           this.activate()
 
-
 var main = Main.new()
 var frame = newAppFrame(main, size=(720'ui, 140'ui), saveWindowState = false)
 startFiguro(frame)

tests/tinput2.nim

@@ -82,12 +82,15 @@ proc draw*(self: Main) {.slot.} =
             proc overrideUpdateInput(this: Input, rune: Rune) {.slot.} =
               let isDigit = rune <=% Rune('9') and rune.char in {'0'..'9'}
               template currCharColon(): bool = this.text.runeAtCursor() == Rune(':')
+              this.skipSelectedRune()
               if isDigit:
-                this.updateInput(rune)
+                this.text.insert(rune, overWrite = true, rangeLimit = 8)
             onInit:
               this.activate()
 
+            disconnect(this, doUpdateInput, this, updateInput)
             connect(this, doUpdateInput, this, overrideUpdateInput)
+
             if not this.textChanged(""):
               # set default
               this.setText("00:00:00")

tests/unittests/ttextboxes.nim

@@ -172,66 +172,53 @@ suite "text boxes (single line)":
     check tx.runes == "alpha".toRunes()
 
   test "set text overwrite":
-    text.opts.incl Overwrite
-
     text.placeCursor(0)
-    text.insert("o".runeAt(0))
+    text.insert("o".runeAt(0), overWrite = true)
     check text.runes == "obcd".toRunes()
     text.placeCursor(0)
-    text.insert("u".runeAt(0))
+    text.insert("u".runeAt(0), true)
     check text.runes == "ubcd".toRunes()
 
     text.placeCursor(1)
-    text.insert("x".runeAt(0))
+    text.insert("x".runeAt(0), true)
     check text.runes == "uxcd".toRunes()
     text.placeCursor(1)
-    text.insert("y".runeAt(0))
+    text.insert("y".runeAt(0), true)
     check text.runes == "uycd".toRunes()
 
+  test "set text overwrite end, with rangelimit":
+    text.selection = 4..4
+    text.insert("x".runeAt(0), true, rangeLimit = 4)
+    check text.runes == "abcd".toRunes()
 
-  # The insert proc needs another option like RangeLimit;
-  # otherwise, Overwrite can't be used as a general purpose toggle.
-  # test "set text overwrite end":
-  #   text.opts.incl Overwrite
-
-  #   text.selection = 4..4
-  #   text.insert("x".runeAt(0))
-  #   check text.runes == "abcd".toRunes()
-
-  #   text.selection = 3..3
-  #   text.insert("x".runeAt(0))
-  #   check text.runes == "abcx".toRunes()
+    text.selection = 3..3
+    text.insert("x".runeAt(0), true, 4)
+    check text.runes == "abcx".toRunes()
 
   test "set text overwrite selected":
-    text.opts.incl Overwrite
     text.selection = 2..3
-    text.insert("o".runeAt(0))
+    text.insert("o".runeAt(0), true)
     check text.runes == "abo".toRunes()
 
   test "set text overwrite many selected":
-    text.opts.incl Overwrite
     text.selection = 2..4
     text.placeCursor(2)
-    text.insert("xy".toRunes())
+    text.insert("xy".toRunes(), true)
     check text.runes == "abxy".toRunes()
 
   test "set text overwrite many selected":
-    text.opts.incl Overwrite
     text.selection = 4..4
-    text.insert("x".toRunes())
+    text.insert("x".toRunes(), true)
     check text.runes == "abcd".toRunes()
 
   test "set text overwrite single":
-    text.opts.incl Overwrite
     text.selection = 0..0
-    text.insert("x".toRunes())
+    text.insert("x".toRunes(), true)
     check text.runes == "xbcd".toRunes()
 
   test "set text overwrite multiple":
-    text.opts.incl Overwrite
-
     text.selection = 0..0
-    text.insert("xy".toRunes())
+    text.insert("xy".toRunes(), true)
     check text.runes == "xycd".toRunes()
 
   test "set text with longer selected text":