From ff3d3ddc27cc80efd02eb9c7ffe791afc72ada35 Mon Sep 17 00:00:00 2001
From: Andreas Huber <andreas.huber@lucares.de>
Date: Sat, 23 Mar 2024 17:31:28 +0100
Subject: [PATCH] simplified ScaledScrollbar to (hopefully) fix the issue that
 the scrollbar became invalid for huge files when used in tandem with the
 range slider

---
 src/ui/ScaledScrollBar.py | 53 +++++++++++++++++++--------------------
 src/ui/bigtext/bigtext.py |  6 ++---
 2 files changed, 29 insertions(+), 30 deletions(-)

diff --git a/src/ui/ScaledScrollBar.py b/src/ui/ScaledScrollBar.py
index 44aaaba..0463276 100644
--- a/src/ui/ScaledScrollBar.py
+++ b/src/ui/ScaledScrollBar.py
@@ -1,5 +1,3 @@
-import math
-
 from PySide6.QtWidgets import QScrollBar
 from PySide6.QtCore import Signal
 import logging
@@ -21,38 +19,39 @@ class ScaledScrollBar(QScrollBar):
     scrolled_to_end = Signal(bool)
     """Signal emitted when the scroll bar value is set."""
 
+    real_minimum = 0
+    real_maximum = 1
+
     def __init__(self):
         super(ScaledScrollBar, self).__init__()
-        self.real_maximum = self.maximum()
+        super().setMinimum(0)
+        super().setMaximum(10000)
         super().valueChanged.connect(self._valueChanged)
 
+    def setMinimum(self, minimum: int) -> None:
+        self.real_minimum = minimum
+        if self._get_real_value() < minimum:
+            self.setValue(minimum)
+
     def setValue(self, value: int) -> None:
-        if self.is_huge:
-            real_position = value / self.real_maximum
-            super().setValue(round(self.maximum() * real_position))
-        else:
-            super().setValue(value)
+        position_in_percent = (value - self.real_minimum) / self.real_maximum
+        # print(f"set value {value} position_in_percent {position_in_percent}")
+        super().setValue(round(self.maximum() * position_in_percent))
 
     def setMaximum(self, maximum: int) -> None:
-        if maximum > 2 ** 31:
-            new_maximum = 1000 * math.log2(maximum)
-            super().setMaximum(math.ceil(new_maximum))
-            self.real_maximum = maximum
+        self.real_maximum = maximum
+        if self._get_real_value() > maximum:
+            # print(f"setValue because it was greater than max - old value {self._get_real_value()} new value: {maximum}")
+            self.setValue(maximum)
 
-            if not self.is_huge:
-                old_position = self.value() / self.maximum()
-                self.setValue(round(new_maximum * old_position))
-
-            self.is_huge = True
-        else:
-            self.is_huge = False
-            super().setMaximum(maximum)
+    def _get_real_value(self) -> int:
+        return (self.value() / self.maximum()) * (self.real_maximum - self.real_minimum) + self.real_minimum
 
     def _valueChanged(self, value: int):
-        self.scrolled_to_end.emit(value == self.maximum() and value > 0)
-        if self.is_huge:
-            real_value = (value / self.maximum()) * self.real_maximum
-            # print("scaled value changed: %d -> %d (%f)" % (value, real_value, value / self.maximum()))
-            self.scaledValueChanged.emit(str(int(real_value)))
-        else:
-            self.scaledValueChanged.emit(str(int(value)))
+        self.scrolled_to_end.emit(
+            value == self.maximum() and value > 0)  # TOOD remove this event. I will do the 'follow tail' feature with a dedicated button like Webstorm
+
+        real_value = self._get_real_value()
+        # print("scaled value changed: %d -> %d (%f)" % (value, real_value, value / self.maximum()))
+        # print(f"min: {self.minimum()} value: {value} max: {self.maximum()} - real_value: {str(int(real_value))} real_max: {self.real_maximum}")
+        self.scaledValueChanged.emit(str(int(real_value)))
diff --git a/src/ui/bigtext/bigtext.py b/src/ui/bigtext/bigtext.py
index 4ccbef2..37aaaa8 100644
--- a/src/ui/bigtext/bigtext.py
+++ b/src/ui/bigtext/bigtext.py
@@ -116,7 +116,7 @@ class BigText(QWidget):
         byte_count = self.model.byte_count()
         range_start = int(byte_count * (lower_value / 100.0))
         range_end = int(byte_count * (upper_value / 100.0))
-        print(f"-> {lower_value}, {upper_value}, {range_start}, {range_end}")
+        print(f"-> {lower_value}, {upper_value}, {range_start}, {range_end} -- range limit event")
         self.big_text.set_range(range_start, range_end)
 
     def get_file(self):
@@ -184,8 +184,8 @@ class InnerBigText(QWidget):
 
         self.model.setRange(range_start, range_end)
 
-        self._v_scaled_scrollbar.setMinimum(max(0, self._range_start))
-        self._v_scaled_scrollbar.setMaximum(min(self._v_scaled_scrollbar.maximum(), range_end))
+        self._v_scaled_scrollbar.setMinimum(range_start)
+        self._v_scaled_scrollbar.setMaximum(range_end)
 
         self._set_byte_offset(self._byte_offset)