# The functions in this module are used to connect callback properties to Qt # widgets. from datetime import datetime import math from qtpy import QtGui, QtWidgets from qtpy.QtCore import Qt, QDateTime import numpy as np from ..core import add_callback, remove_callback from ..selection import SelectionCallbackProperty, ChoiceSeparator __all__ = ['connect_checkable_button', 'connect_text', 'connect_combo_data', 'connect_combo_text', 'connect_float_text', 'connect_value', 'connect_combo_selection', 'connect_list_selection', 'connect_datetime', 'BaseConnection'] class UserDataWrapper(object): def __init__(self, data): self.data = data class BaseConnection(object): def __init__(self, instance, prop, widget): self._instance = instance self._prop = prop self._widget = widget class connect_checkable_button(BaseConnection): """ Connect a boolean callback property with a Qt button widget. Parameters ---------- instance : object The class instance that the callback property is attached to prop : str The name of the callback property widget : QtWidget The Qt widget to connect. This should implement the ``setChecked`` method and the ``toggled`` signal. """ def __init__(self, instance, prop, widget): super(connect_checkable_button, self).__init__(instance, prop, widget) self.connect() def update_widget(self, value): self._widget.setChecked(value) def update_prop(self, value): setattr(self._instance, self._prop, value) def connect(self): add_callback(self._instance, self._prop, self.update_widget) self._widget.toggled.connect(self.update_prop) self._widget.setChecked(getattr(self._instance, self._prop) or False) def disconnect(self): remove_callback(self._instance, self._prop, self.update_widget) self._widget.toggled.disconnect(self.update_prop) class connect_text(BaseConnection): """ Connect a string callback property with a Qt widget containing text. Parameters ---------- instance : object The class instance that the callback property is attached to prop : str The name of the callback property widget : QtWidget The Qt widget to connect. This should implement the ``setText`` and ``text`` methods as well optionally the ``editingFinished`` signal. """ def __init__(self, instance, prop, widget): super(connect_text, self).__init__(instance, prop, widget) self.connect() def update_prop(self): value = self._widget.text() setattr(self._instance, self._prop, value) def update_widget(self, value): if hasattr(self._widget, 'editingFinished'): self._widget.blockSignals(True) self._widget.setText(value) self._widget.blockSignals(False) self._widget.editingFinished.emit() else: self._widget.setText(value) def connect(self): add_callback(self._instance, self._prop, self.update_widget) try: self._widget.editingFinished.connect(self.update_prop) except AttributeError: pass self.update_widget(getattr(self._instance, self._prop)) def disconnect(self): remove_callback(self._instance, self._prop, self.update_widget) try: self._widget.editingFinished.disconnect(self.update_prop) except AttributeError: pass class connect_combo_data(BaseConnection): """ Connect a callback property with a QComboBox widget based on the userData. Parameters ---------- instance : object The class instance that the callback property is attached to prop : str The name of the callback property widget : QComboBox The combo box to connect. See Also -------- connect_combo_text: connect a callback property with a QComboBox widget based on the text. """ def __init__(self, instance, prop, widget): super(connect_combo_data, self).__init__(instance, prop, widget) self.connect() def update_widget(self, value): try: idx = _find_combo_data(self._widget, value) except ValueError: if value is None: idx = -1 else: raise self._widget.setCurrentIndex(idx) def update_prop(self, idx): if idx == -1: setattr(self._instance, self._prop, None) else: data_wrapper = self._widget.itemData(idx) if data_wrapper is None: setattr(self._instance, self._prop, None) else: setattr(self._instance, self._prop, data_wrapper.data) def connect(self): add_callback(self._instance, self._prop, self.update_widget) self._widget.currentIndexChanged.connect(self.update_prop) self.update_widget(getattr(self._instance, self._prop)) def disconnect(self): remove_callback(self._instance, self._prop, self.update_widget) self._widget.currentIndexChanged.disconnect(self.update_prop) class connect_combo_text(BaseConnection): """ Connect a callback property with a QComboBox widget based on the text. Parameters ---------- instance : object The class instance that the callback property is attached to prop : str The name of the callback property widget : QComboBox The combo box to connect. See Also -------- connect_combo_data: connect a callback property with a QComboBox widget based on the userData. """ def __init__(self, instance, prop, widget): super(connect_combo_text, self).__init__(instance, prop, widget) self.connect() def update_widget(self, value): try: idx = _find_combo_text(self._widget, value) except ValueError: if value is None: idx = -1 else: raise self._widget.setCurrentIndex(idx) def update_prop(self, idx): if idx == -1: setattr(self._instance, self._prop, None) else: setattr(self._instance, self._prop, self._widget.itemText(idx)) def connect(self): add_callback(self._instance, self._prop, self.update_widget) self._widget.currentIndexChanged.connect(self.update_prop) self.update_widget(getattr(self._instance, self._prop)) def disconnect(self): remove_callback(self._instance, self._prop, self.update_widget) self._widget.currentIndexChanged.disconnect(self.update_prop) class connect_float_text(BaseConnection): """ Connect a numerical callback property with a Qt widget containing text. Parameters ---------- instance : object The class instance that the callback property is attached to prop : str The name of the callback property widget : QtWidget The Qt widget to connect. This should implement the ``setText`` and ``text`` methods as well optionally the ``editingFinished`` signal. fmt : str or func This should be either a format string (in the ``{}`` notation), or a function that takes a number and returns a string. """ def __init__(self, instance, prop, widget, fmt="{:g}"): super(connect_float_text, self).__init__(instance, prop, widget) if callable(fmt): format_func = fmt else: def format_func(x): try: return fmt.format(x) except ValueError: return str(x) self._format_func = format_func self.connect() def update_prop(self): value = self._widget.text() try: value = float(value) except ValueError: try: value = np.datetime64(value) except Exception: value = 0 setattr(self._instance, self._prop, value) def update_widget(self, value): if value is None: value = 0. self._widget.setText(self._format_func(value)) def connect(self): add_callback(self._instance, self._prop, self.update_widget) try: self._widget.editingFinished.connect(self.update_prop) except AttributeError: pass self.update_widget(getattr(self._instance, self._prop)) def disconnect(self): remove_callback(self._instance, self._prop, self.update_widget) try: self._widget.editingFinished.disconnect(self.update_prop) except AttributeError: pass class connect_value(BaseConnection): """ Connect a numerical callback property with a Qt widget representing a value. Parameters ---------- instance : object The class instance that the callback property is attached to prop : str The name of the callback property widget : QtWidget The Qt widget to connect. This should implement the ``setText`` and ``text`` methods as well optionally the ``editingFinished`` signal. value_range : iterable, optional A pair of two values representing the true range of values (since Qt widgets such as sliders can only have values in certain ranges). log : bool, optional Whether the Qt widget value should be mapped to the log of the callback property. """ def __init__(self, instance, prop, widget, value_range=None, log=False): super(connect_value, self).__init__(instance, prop, widget) if log: if value_range is None: raise ValueError("log option can only be set if value_range is given") else: self._value_range = math.log10(value_range[0]), math.log10(value_range[1]) else: self._value_range = value_range self._log = log self.connect() def update_prop(self): value = self._widget.value() if self._value_range is not None: imin, imax = self._widget.minimum(), self._widget.maximum() value = ((value - imin) / (imax - imin) * (self._value_range[1] - self._value_range[0]) + self._value_range[0]) if self._log: value = 10 ** value setattr(self._instance, self._prop, value) def update_widget(self, value): if value is None: self._widget.setValue(0) return if self._log: value = math.log10(value) if self._value_range is not None: imin, imax = self._widget.minimum(), self._widget.maximum() value = ((value - self._value_range[0]) / (self._value_range[1] - self._value_range[0]) * (imax - imin) + imin) if isinstance(self._widget, (QtWidgets.QSlider, QtWidgets.QSpinBox)): self._widget.setValue(int(value)) else: self._widget.setValue(value) def connect(self): add_callback(self._instance, self._prop, self.update_widget) self._widget.valueChanged.connect(self.update_prop) self.update_widget(getattr(self._instance, self._prop)) def disconnect(self): remove_callback(self._instance, self._prop, self.update_widget) self._widget.valueChanged.disconnect(self.update_prop) class connect_button(BaseConnection): """ Connect a button with a callback method Parameters ---------- instance : object The class instance that the callback method is attached to prop : str The name of the callback method widget : QtWidget The Qt widget to connect. This should implement the ``clicked`` method """ def __init__(self, instance, prop, widget): super(connect_button, self).__init__(instance, prop, widget) self.connect() def connect(self): self._widget.clicked.connect(getattr(self._instance, self._prop)) def disconnect(self): self._widget.clicked.disconnect(self.update_prop) def _find_combo_data(widget, value): """ Returns the index in a combo box where itemData == value Raises a ValueError if data is not found """ # Here we check that the result is True, because some classes may overload # == and return other kinds of objects whether true or false. for idx in range(widget.count()): if widget.itemData(idx) is not None: if isinstance(widget.itemData(idx), UserDataWrapper): if widget.itemData(idx).data is value or (widget.itemData(idx).data == value) is True: return idx else: if widget.itemData(idx) is value or (widget.itemData(idx) == value) is True: return idx else: raise ValueError("%s not found in combo box" % (value,)) def _find_combo_text(widget, value): """ Returns the index in a combo box where text == value Raises a ValueError if data is not found """ i = widget.findText(value) if i == -1: raise ValueError("%s not found in combo box" % value) else: return i class connect_combo_selection(BaseConnection): def __init__(self, instance, prop, widget): if not isinstance(getattr(type(instance), prop), SelectionCallbackProperty): raise TypeError('connect_combo_selection requires a SelectionCallbackProperty') super(connect_combo_selection, self).__init__(instance, prop, widget) self.connect() def update_widget(self, value): # Update choices in the combo box combo_data = [self._widget.itemData(idx) for idx in range(self._widget.count())] combo_text = [self._widget.itemText(idx) for idx in range(self._widget.count())] choices = getattr(type(self._instance), self._prop).get_choices(self._instance) choice_labels = getattr(type(self._instance), self._prop).get_choice_labels(self._instance) if combo_data == choices and combo_text == choice_labels: choices_updated = False else: self._widget.blockSignals(True) self._widget.clear() if len(choices) == 0: return combo_model = self._widget.model() for index, (label, choice) in enumerate(zip(choice_labels, choices)): self._widget.addItem(label, userData=UserDataWrapper(choice)) # We interpret None data as being disabled rows (used for headers) if isinstance(choice, ChoiceSeparator): item = combo_model.item(index) palette = self._widget.palette() item.setFlags(item.flags() & ~(Qt.ItemIsSelectable | Qt.ItemIsEnabled)) item.setData(palette.color(QtGui.QPalette.Disabled, QtGui.QPalette.Text)) choices_updated = True # Update current selection try: idx = _find_combo_data(self._widget, value) except ValueError: if value is None: idx = -1 else: raise if idx == self._widget.currentIndex() and not choices_updated: return self._widget.setCurrentIndex(idx) self._widget.blockSignals(False) self._widget.currentIndexChanged.emit(idx) def update_prop(self, idx): if idx == -1: setattr(self._instance, self._prop, None) else: data_wrapper = self._widget.itemData(idx) if data_wrapper is None: setattr(self._instance, self._prop, None) else: setattr(self._instance, self._prop, data_wrapper.data) def connect(self): add_callback(self._instance, self._prop, self.update_widget) self._widget.currentIndexChanged.connect(self.update_prop) self.update_widget(getattr(self._instance, self._prop)) def disconnect(self): remove_callback(self._instance, self._prop, self.update_widget) self._widget.currentIndexChanged.disconnect(self.update_prop) class connect_list_selection(BaseConnection): def __init__(self, instance, prop, widget): """ Connect a SelectionCallbackProperty with a QListWidget that supports single-item selection. """ if not isinstance(getattr(type(instance), prop), SelectionCallbackProperty): raise TypeError('connect_list_selection requires a SelectionCallbackProperty') super(connect_list_selection, self).__init__(instance, prop, widget) self.connect() def update_widget(self, value, force=False): items = [self._widget.item(idx) for idx in range(self._widget.count())] list_text = [item.text() for item in items] list_data = [item.data(Qt.UserRole) for item in items] list_data = [d.data if d is not None else d for d in list_data] choices = getattr(type(self._instance), self._prop).get_choices(self._instance) choice_labels = getattr(type(self._instance), self._prop).get_choice_labels(self._instance) for idx in range(len(choices)): if choices[idx] is value or (choices[idx] == value) is True: break else: idx = -1 self._widget.blockSignals(True) choices_match = list_data == choices and list_text == choice_labels if force or not choices_match: self._widget.clear() if len(choices) == 0: self._widget.blockSignals(False) return for index, (label, choice) in enumerate(zip(choice_labels, choices)): item = QtWidgets.QListWidgetItem(label) item.setData(Qt.UserRole, UserDataWrapper(choice)) self._widget.addItem(item) # We interpret None data as being disabled rows (used for headers) if isinstance(choice, ChoiceSeparator): item.setFlags(item.flags() & ~(Qt.ItemIsSelectable | Qt.ItemIsEnabled)) if len(self._widget.selectedItems()) == 0: current_index = -1 else: selected_item = self._widget.selectedItems()[0] for current_index, item in enumerate(items): if item is selected_item: break else: current_index = -1 if idx == current_index and choices_match: self._widget.blockSignals(False) return self._widget.setCurrentItem(self._widget.item(idx)) self._widget.blockSignals(False) self._widget.itemSelectionChanged.emit() def update_prop(self): if len(self._widget.selectedItems()) == 0: setattr(self._instance, self._prop, None) else: data_wrapper = self._widget.selectedItems()[0].data(Qt.UserRole) if data_wrapper is None: setattr(self._instance, self._prop, None) else: setattr(self._instance, self._prop, data_wrapper.data) def connect(self): add_callback(self._instance, self._prop, self.update_widget) self._widget.itemSelectionChanged.connect(self.update_prop) self.update_widget(getattr(self._instance, self._prop)) def disconnect(self): remove_callback(self._instance, self._prop, self.update_widget) self._widget.itemSelectionChanged.disconnect(self.update_prop) class connect_datetime(BaseConnection): """ Connect a CallbackProperty to a QDateTimeEdit. Since QDateEdit and QTimeEdit are subclasses of QDateTimeEdit, this connection will work for those more specific widgets as well. """ def __init__(self, instance, prop, widget): super(connect_datetime, self).__init__(instance, prop, widget) self.connect() def update_prop(self): qdatetime = self._widget.dateTime().toUTC() value = np.datetime64(qdatetime.toPython()) setattr(self._instance, self._prop, value) def update_widget(self, value): if value is None: value = np.datetime64('now') dt = value.item() # datetime64::item can return a date # If this happens, we use midnight as our time # (datetime is a subclass of date so we need to check this way) if not isinstance(dt, datetime): date = dt time = datetime.min.time() else: date = dt.date() time = dt.time() qdatetime = QDateTime(date, time, Qt.TimeSpec.UTC).toTimeSpec(self._widget.timeSpec()) self._widget.setDateTime(qdatetime) def connect(self): add_callback(self._instance, self._prop, self.update_widget) self._widget.dateTimeChanged.connect(self.update_prop) self._widget.dateChanged.connect(self.update_prop) self._widget.timeChanged.connect(self.update_prop) self.update_widget(getattr(self._instance, self._prop)) def disconnect(self): remove_callback(self._instance, self._prop, self.update_widget) self._widget.dateTimeChanged.disconnect(self.update_prop) self._widget.dateChanged.disconnect(self.update_prop) self._widget.timeChanged.disconnect(self.update_prop)