Fix inverted RTL word navigation in the subtitle edit box

In a right-to-left subtitle, Ctrl+Left / Ctrl+Right jumped the wrong way.
Avalonia's TextBox moves the caret one character visually (bidi-aware) but
moves whole words by logical text offset, so word steps run opposite to the
visual direction in RTL text (single-character steps were already correct).
Ctrl+Up / Ctrl+Down also did nothing useful.

Add a tunnel-phase key handler on the main and original edit text boxes that
runs only when the box is in RTL flow:
- Ctrl+Left / Ctrl+Right move a word in the visually-correct direction.
- Ctrl+Up / Ctrl+Down move to the start / end of the current line.
- Shift extends the selection.

It no-ops for left-to-right editing, so LTR behaviour and any global
Ctrl+Arrow shortcuts are unchanged.

Author: Muaz

src/ui/Features/Main/Layout/InitListViewAndEditBox.cs

@@ -1711,6 +1711,7 @@ private static Avalonia.Controls.Control MakeTextBox(MainViewModel vm)
             textBox.AddHandler(InputElement.PointerPressedEvent, (_, e) => vm.StoreTextEditorPointerArgs(e), RoutingStrategies.Tunnel);
 
             SetupMacContextMenuForTextBox(textBox, vm);
+            AttachRightToLeftCaretNavigation(textBox);
 
             vm.EditTextBox = new TextBoxWrapper(textBox);
             return textBox;
@@ -1821,6 +1822,7 @@ private static Avalonia.Controls.Control MakeTextBoxOriginal(MainViewModel vm)
             }
 
             SetupMacContextMenuForTextBox(textBox, vm);
+            AttachRightToLeftCaretNavigation(textBox);
 
             vm.EditTextBoxOriginal = new TextBoxWrapper(textBox);
             return textBox;
@@ -1945,4 +1947,117 @@ private static void SetupMacContextMenu(TextEditor textEditor, MainViewModel vm)
             },
             RoutingStrategies.Tunnel);
     }
+
+    /// <summary>
+    /// Avalonia's TextBox moves the caret one character visually (bidi-aware) but moves whole words
+    /// by logical text offset. For a right-to-left subtitle that makes Ctrl+Left / Ctrl+Right jump
+    /// the wrong way (single-character steps are fine). This handler reimplements word movement in
+    /// the visually-correct direction for RTL text and adds Ctrl+Up / Ctrl+Down = start / end of the
+    /// current line. It only acts when the box is in RTL flow, so left-to-right editing and any global
+    /// Ctrl+Arrow shortcuts are left untouched.
+    /// </summary>
+    private static void AttachRightToLeftCaretNavigation(TextBox textBox)
+    {
+        textBox.AddHandler(
+            InputElement.KeyDownEvent,
+            (_, e) =>
+            {
+                if (textBox.FlowDirection != FlowDirection.RightToLeft ||
+                    !e.KeyModifiers.HasFlag(KeyModifiers.Control))
+                {
+                    return;
+                }
+
+                var text = textBox.Text ?? string.Empty;
+                var caret = Math.Clamp(textBox.CaretIndex, 0, text.Length);
+                int target;
+                switch (e.Key)
+                {
+                    case Key.Left:  // visually left in RTL == later in the logical string
+                        target = NextWordBoundary(text, caret, forward: true);
+                        break;
+                    case Key.Right: // visually right in RTL == earlier in the logical string
+                        target = NextWordBoundary(text, caret, forward: false);
+                        break;
+                    case Key.Up:    // head of the current line
+                        target = CurrentLineStart(text, caret);
+                        break;
+                    case Key.Down:  // end of the current line
+                        target = CurrentLineEnd(text, caret);
+                        break;
+                    default:
+                        return;
+                }
+
+                MoveCaret(textBox, target, e.KeyModifiers.HasFlag(KeyModifiers.Shift));
+                e.Handled = true;
+            },
+            RoutingStrategies.Tunnel);
+    }
+
+    private static bool IsWordSeparator(char c) => char.IsWhiteSpace(c) || char.IsPunctuation(c) || char.IsSymbol(c);
+
+    // Mirrors the usual "Ctrl+Arrow" word stop: forward stops at the start of the next word,
+    // backward stops at the start of the current/previous word.
+    private static int NextWordBoundary(string text, int index, bool forward)
+    {
+        if (forward)
+        {
+            var i = index;
+            while (i < text.Length && !IsWordSeparator(text[i])) i++;
+            while (i < text.Length && IsWordSeparator(text[i])) i++;
+            return i;
+        }
+        else
+        {
+            var i = index;
+            while (i > 0 && IsWordSeparator(text[i - 1])) i--;
+            while (i > 0 && !IsWordSeparator(text[i - 1])) i--;
+            return i;
+        }
+    }
+
+    private static int CurrentLineStart(string text, int index)
+    {
+        var i = index;
+        while (i > 0 && text[i - 1] != '\n' && text[i - 1] != '\r') i--;
+        return i;
+    }
+
+    private static int CurrentLineEnd(string text, int index)
+    {
+        var i = index;
+        while (i < text.Length && text[i] != '\n' && text[i] != '\r') i++;
+        return i;
+    }
+
+    private static void MoveCaret(TextBox textBox, int target, bool extendSelection)
+    {
+        var length = (textBox.Text ?? string.Empty).Length;
+        target = Math.Clamp(target, 0, length);
+
+        if (extendSelection)
+        {
+            // Keep the fixed end of the existing selection as the anchor; the caret follows
+            // SelectionEnd, so don't touch CaretIndex here (its setter can collapse the selection).
+            int anchor;
+            if (textBox.SelectionStart != textBox.SelectionEnd)
+            {
+                anchor = textBox.CaretIndex == textBox.SelectionEnd ? textBox.SelectionStart : textBox.SelectionEnd;
+            }
+            else
+            {
+                anchor = textBox.CaretIndex;
+            }
+
+            textBox.SelectionStart = anchor;
+            textBox.SelectionEnd = target;
+        }
+        else
+        {
+            textBox.CaretIndex = target;
+            textBox.SelectionStart = target;
+            textBox.SelectionEnd = target;
+        }
+    }
 }