fix: improve streaming UX, stop button, and scroll synchronization

Streaming Text Insertion:
- Disable widget updates during text insertion to prevent auto-scroll
- Append using separate QTextCursor on document (doesn't affect visible cursor)
- Only auto-scroll to bottom if user was already at bottom (watching stream)
- Preserve user's scroll position when they scroll up to read earlier content
- Qt version compatibility for QTextCursor.End enum (Qt5/Qt6)

Stop Button Fix:
- Add cancellation check inside streaming generator consumption loop
- Check cancel_request() on each character/chunk during streaming
- Raise TranslationCanceled immediately when stop is requested
- Apply to both single translation and batch mode streaming
- Fixes infinite 'Stopping...' state with large merged translations

Scroll Synchronization:
- Replace pixel-based scroll sync with line-number (block) synchronization
- Get firstVisibleBlock() number and sync to same block in other editors
- Calculate exact scroll position using block geometry and cursorRect()
- Block scrollbar signals during sync to prevent feedback loop
- Works correctly during streaming when translation is incomplete
- Works with word wrap enabled/disabled
- Eliminates lag/gap between original and translation scroll positions

Author: seidnerj

advanced.py

@@ -6,7 +6,7 @@
     QPlainTextEdit, QPushButton, QSplitter, QLabel, QThread, QLineEdit,
     QGridLayout, QProgressBar, pyqtSignal, pyqtSlot, QPixmap, QEvent,
     QStackedWidget, QSpacerItem, QTabWidget, QCheckBox,
-    QComboBox, QSizePolicy)
+    QComboBox, QSizePolicy, QTextCursor)
 from calibre.constants import __version__  # type: ignore
 from calibre.gui2 import I  # type: ignore
 from calibre.utils.localization import _  # type: ignore
@@ -973,11 +973,44 @@ def layout_review(self):
         self.review_splitter.setSizes(_size)
 
         def synchronizeScrollbars(editors):
+            """Sync scroll position by line number, not pixels or percentage.
+            Works correctly during streaming and with word wrap."""
             for editor in editors:
                 for other_editor in editors:
                     if editor != other_editor:
+                        def create_sync_handler(source, target):
+                            def sync_by_line_number():
+                                # Get first visible line number in source
+                                source_block = source.firstVisibleBlock()
+                                line_number = source_block.blockNumber()
+
+                                # Block signals to prevent feedback loop
+                                target_scrollbar = target.verticalScrollBar()
+                                target_scrollbar.blockSignals(True)
+
+                                # Get the block at same line number in target
+                                target_doc = target.document()
+                                target_block = target_doc.findBlockByNumber(line_number)
+
+                                if target_block.isValid():
+                                    # Calculate exact scroll position for the block
+                                    # Use block's vertical position to set scrollbar directly
+                                    target_cursor = QTextCursor(target_block)
+                                    target_rect = target.cursorRect(target_cursor)
+
+                                    # Get the current top position of the block
+                                    block_top = target_rect.top()
+
+                                    # Set scrollbar to show this block at top of viewport
+                                    current_scroll = target.verticalScrollBar().value()
+                                    target.verticalScrollBar().setValue(current_scroll + block_top)
+
+                                # Re-enable signals
+                                target_scrollbar.blockSignals(False)
+                            return sync_by_line_number
+
                         editor.verticalScrollBar().valueChanged.connect(
-                            other_editor.verticalScrollBar().setValue)
+                            create_sync_handler(editor, other_editor))
         synchronizeScrollbars((raw_text, original_text, translation_text))
 
         translation_text.cursorPositionChanged.connect(
@@ -1139,7 +1172,31 @@ def streaming_translation(data):
             elif isinstance(data, Paragraph):
                 self.table.setCurrentItem(self.table.item(data.row, 0))
             else:
-                translation_text.insertPlainText(data)
+                # Check if user is at bottom (watching stream)
+                scrollbar = translation_text.verticalScrollBar()
+                was_at_bottom = scrollbar.value() >= scrollbar.maximum() - 10
+
+                # Disable updates to prevent auto-scroll/flicker
+                translation_text.setUpdatesEnabled(False)
+                saved_position = scrollbar.value()
+
+                # Append to document using cursor at end
+                doc = translation_text.document()
+                cursor = QTextCursor(doc)
+                end_position = getattr(QTextCursor.MoveOperation, 'End', None) or QTextCursor.End
+                cursor.movePosition(end_position)
+                cursor.insertText(data)
+
+                # Restore scroll position before re-enabling updates
+                if not was_at_bottom:
+                    scrollbar.setValue(saved_position)
+
+                # Re-enable updates - this triggers repaint
+                translation_text.setUpdatesEnabled(True)
+
+                # Scroll to bottom only if user was watching
+                if was_at_bottom:
+                    scrollbar.setValue(scrollbar.maximum())
         self.trans_worker.streaming.connect(streaming_translation)
 
         def modify_translation():

lib/translation.py

@@ -169,14 +169,23 @@ def translate_paragraph(self, paragraph):
                 temp = ''
                 clear = True
                 for char in translation:
+                    # Check for cancellation during streaming
+                    if self.cancel_request():
+                        raise TranslationCanceled(_('Translation canceled.'))
                     if clear:
                         self.streaming('')
                         clear = False
                     self.streaming(char)
                     time.sleep(0.05)
                     temp += char
             else:
-                temp = ''.join([char for char in translation])
+                # For batch mode, still check cancellation periodically
+                temp_chars = []
+                for char in translation:
+                    if self.cancel_request():
+                        raise TranslationCanceled(_('Translation canceled.'))
+                    temp_chars.append(char)
+                temp = ''.join(temp_chars)
             translation = temp
         translation = self.glossary.restore(translation)
         paragraph.translation = translation.strip()