193 lines
7.1 KiB
Python
193 lines
7.1 KiB
Python
"""Native number inputs and scrollbars with usable click targets."""
|
|
from PySide6 import QtCore as C, QtGui as G, QtWidgets as W
|
|
import time
|
|
|
|
|
|
class ComboBox(W.QComboBox):
|
|
"""Size popups for their text, independently of narrow table columns."""
|
|
def __init__(self, parent=None):
|
|
self._text_width = None
|
|
super().__init__(parent)
|
|
self.setSizeAdjustPolicy(W.QComboBox.SizeAdjustPolicy.AdjustToMinimumContentsLengthWithIcon)
|
|
self.setMinimumContentsLength(6)
|
|
self.setMaxVisibleItems(12)
|
|
view = W.QListView(self)
|
|
view.setTextElideMode(C.Qt.TextElideMode.ElideNone)
|
|
view.setHorizontalScrollBarPolicy(C.Qt.ScrollBarPolicy.ScrollBarAsNeeded)
|
|
view.setHorizontalScrollMode(W.QAbstractItemView.ScrollMode.ScrollPerPixel)
|
|
self.setView(view)
|
|
for signal in (self.model().dataChanged, self.model().rowsInserted, self.model().rowsRemoved, self.model().modelReset):
|
|
signal.connect(self.invalidate_width)
|
|
|
|
def invalidate_width(self, *args):
|
|
self._text_width = None
|
|
self.updateGeometry()
|
|
|
|
def text_width(self):
|
|
if self._text_width is None:
|
|
self._text_width = max((self.fontMetrics().horizontalAdvance(self.itemText(i)) for i in range(self.count())), default=0)
|
|
return self._text_width
|
|
|
|
def sizeHint(self):
|
|
hint = super().sizeHint()
|
|
hint.setWidth(max(120, hint.width(), min(360, self.text_width() + 48)))
|
|
return hint
|
|
|
|
def minimumSizeHint(self):
|
|
hint = super().minimumSizeHint()
|
|
hint.setWidth(max(120, hint.width(), min(260, self.text_width() + 48)))
|
|
return hint
|
|
|
|
def changeEvent(self, event):
|
|
if event.type() in (C.QEvent.Type.FontChange, C.QEvent.Type.StyleChange):
|
|
self.invalidate_width()
|
|
super().changeEvent(event)
|
|
|
|
def showPopup(self):
|
|
view = self.view()
|
|
screen = self.screen().availableGeometry()
|
|
scrollbar = view.verticalScrollBar().sizeHint().width()
|
|
content = max(self.text_width() + 16, view.sizeHintForColumn(0))
|
|
width = min(screen.width(), max(self.width(), content + scrollbar + 2 * view.frameWidth() + 8))
|
|
popup = view.window()
|
|
frame = popup.frameWidth() if isinstance(popup, W.QFrame) else 0
|
|
view.setMinimumWidth(max(0, width - 2 * frame))
|
|
super().showPopup()
|
|
# QComboBox resets this policy while opening its popup.
|
|
view.setHorizontalScrollBarPolicy(C.Qt.ScrollBarPolicy.ScrollBarAsNeeded)
|
|
popup.resize(width, popup.height())
|
|
view.doItemsLayout()
|
|
if view.horizontalScrollBar().maximum() > 0:
|
|
popup.resize(width, min(screen.height(), popup.height() + view.horizontalScrollBar().sizeHint().height()))
|
|
popup.move(min(max(popup.x(), screen.left()), screen.right() - popup.width() + 1),
|
|
min(max(popup.y(), screen.top()), screen.bottom() - popup.height() + 1))
|
|
|
|
def event(self, event):
|
|
if event.type() == C.QEvent.Type.ToolTip and self.currentText():
|
|
text = self.currentText()
|
|
if self.toolTip() and self.toolTip() != text:
|
|
text += "\n" + self.toolTip()
|
|
W.QToolTip.showText(event.globalPos(), text, self)
|
|
return True
|
|
return super().event(event)
|
|
|
|
|
|
class RowBatch(C.QObject):
|
|
"""Create Qt rows in short event-loop slices, keeping input responsive."""
|
|
def __init__(self, parent):
|
|
super().__init__(parent)
|
|
self.timer = C.QTimer(self)
|
|
self.timer.setInterval(1)
|
|
self.timer.timeout.connect(self.tick)
|
|
self.running = False
|
|
|
|
def start(self, rows, apply, finished):
|
|
self.stop()
|
|
self.rows, self.apply, self.finished = iter(rows), apply, finished
|
|
self.running = True
|
|
self.tick()
|
|
if self.running:
|
|
self.timer.start()
|
|
|
|
def stop(self):
|
|
self.timer.stop()
|
|
self.running = False
|
|
|
|
@C.Slot()
|
|
def tick(self):
|
|
until = time.perf_counter() + .008
|
|
count = 0
|
|
while self.running and count < 24 and time.perf_counter() < until:
|
|
try:
|
|
row = next(self.rows)
|
|
except StopIteration:
|
|
self.stop()
|
|
self.finished()
|
|
return
|
|
self.apply(row)
|
|
count += 1
|
|
|
|
|
|
class IntegerInput(W.QLineEdit):
|
|
valueChanged = C.Signal(int)
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
self._value, self._minimum, self._maximum = 0, 0, 2147483647
|
|
self.setValidator(G.QIntValidator(self._minimum, self._maximum, self))
|
|
self.setText("0")
|
|
self.setMinimumWidth(76)
|
|
self.textChanged.connect(self.accept_number)
|
|
self.editingFinished.connect(self.finish_number)
|
|
|
|
def value(self):
|
|
return self._value
|
|
|
|
def setValue(self, value):
|
|
value = min(self._maximum, max(self._minimum, int(value)))
|
|
changed = value != self._value
|
|
# Signal blockers must not prevent updates to the stored numeric value.
|
|
self._value = value
|
|
self.setText(str(value))
|
|
if changed:
|
|
self.valueChanged.emit(value)
|
|
|
|
def setRange(self, minimum, maximum):
|
|
self._minimum, self._maximum = int(minimum), int(maximum)
|
|
self.validator().setRange(self._minimum, self._maximum)
|
|
self.setValue(self._value)
|
|
|
|
def setMinimum(self, minimum):
|
|
self.setRange(minimum, self._maximum)
|
|
|
|
def accept_number(self, text):
|
|
if self.hasAcceptableInput():
|
|
value = int(text)
|
|
if value != self._value:
|
|
self._value = value
|
|
self.valueChanged.emit(value)
|
|
|
|
def finish_number(self):
|
|
self.setValue(self._value)
|
|
|
|
|
|
class NativeScrollStyle(W.QProxyStyle):
|
|
def pixelMetric(self, metric, option=None, widget=None):
|
|
value = super().pixelMetric(metric, option, widget)
|
|
if metric == W.QStyle.PixelMetric.PM_ScrollBarExtent:
|
|
return max(22, value)
|
|
if metric == W.QStyle.PixelMetric.PM_ScrollBarSliderMin:
|
|
return max(30, value)
|
|
return value
|
|
|
|
def styleHint(self, hint, option=None, widget=None, returnData=None):
|
|
if hint == W.QStyle.StyleHint.SH_ScrollBar_Transient:
|
|
return 0
|
|
return super().styleHint(hint, option, widget, returnData)
|
|
|
|
|
|
class ScrollbarStyler(C.QObject):
|
|
def __init__(self, app):
|
|
super().__init__(app)
|
|
self.scroll_style = NativeScrollStyle(W.QStyleFactory.create("Fusion"))
|
|
self.scroll_style.setParent(self)
|
|
|
|
def eventFilter(self, widget, event):
|
|
if event.type() == C.QEvent.Type.Polish and isinstance(widget, W.QScrollBar) and not getattr(widget, "_ranch_scrollbar", False):
|
|
widget._ranch_scrollbar = True
|
|
widget.setStyle(self.scroll_style)
|
|
if widget.orientation() == C.Qt.Orientation.Horizontal:
|
|
widget.setFixedHeight(22)
|
|
else:
|
|
widget.setFixedWidth(22)
|
|
return False
|
|
|
|
|
|
def use_native_scrollbars():
|
|
app = W.QApplication.instance()
|
|
if app is None or getattr(app, "_ranch_scrollbar_styler", None) is not None:
|
|
return
|
|
styler = ScrollbarStyler(app)
|
|
app._ranch_scrollbar_styler = styler
|
|
app.installEventFilter(styler)
|