dcscope 2.22.1__py3-none-any.whl

dcscope/gui/widgets/feature_combobox.py

@@ -0,0 +1,140 @@
+import dclab
+from PyQt6 import QtCore, QtGui, QtWidgets
+
+#: These are features only visible in developer mode
+HIDDEN_FEATURES = []
+for ii in range(10):
+    HIDDEN_FEATURES.append(f"basinmap{ii}")
+
+
+class FeatureComboBox(QtWidgets.QComboBox):
+    def __init__(self, *args, **kwargs):
+        """A DC data aware combobox for displaying DC features
+
+        The combobox uses different colors do indicate the
+        availability of features. Features can be ancillary,
+        innate, basin-based, etc.
+
+        This class serves as a drop-in replacement for QComboBox
+        with a few special properties:
+
+        - Call `set_dataset` with an instance of RTDCBase and the
+          list of options is automatically populated with the values
+          for this dataset, including coloring based on feature origin.
+        - Features defined in :const:`HIDDEN_FEATURES` are not shown in
+          the combobox if "advanced/developer mode" is not set in the
+          settings.
+        - Make sure to use `findData` and don't rely on any external
+          lists when using `addItem`, because some of the items may
+          not be added as explained in the previous point.
+        """
+        super(FeatureComboBox, self).__init__(*args, **kwargs)
+        self.rtdc_ds = None
+        self.default_choices = []
+
+        # determine whether we should hide certain features
+        settings = QtCore.QSettings()
+        devmode = bool(int(settings.value("advanced/developer mode", 0)))
+        self.hidden_feats = HIDDEN_FEATURES if not devmode else []
+
+        # where the data at
+        self.data_role = QtCore.Qt.ItemDataRole.UserRole
+
+        # Set background color to white
+        pal = self.palette()
+        pal.setColor(self.backgroundRole(), QtGui.QColor(255, 255, 255))
+
+    def addItem(self, text, userData=None):
+        if userData not in self.hidden_feats:
+            super(FeatureComboBox, self).addItem(text, userData)
+
+    def currentData(self, role=None):
+        if role is None:
+            role = self.data_role
+        return super(FeatureComboBox, self).currentData(role)
+
+    def findData(self, data, role=None, *args, **kwargs):
+        if role is None:
+            role = self.data_role
+        return super(FeatureComboBox, self).findData(data, role=role,
+                                                     *args, **kwargs)
+
+    def set_dataset(self, rtdc_ds):
+        self.rtdc_ds = rtdc_ds
+        self.update_feature_list()
+
+    @QtCore.pyqtSlot()
+    def update_feature_list(self):
+        """Update the colors of all features in the combobox"""
+        if self.rtdc_ds is None:
+            raise ValueError("Please call `set_dataset` first!")
+        # axes combobox choices
+        ds_feats = self.rtdc_ds.features_scalar
+        # remove hidden features
+        [ds_feats.remove(f) for f in self.hidden_feats if f in ds_feats]
+        ds_labels = [dclab.dfn.get_feature_label(f) for f in ds_feats]
+        ds_colors = []
+        ds_tips = []
+        feats_loaded = self.rtdc_ds.features_loaded
+        feats_ancillary = self.rtdc_ds.features_ancillary
+        feats_basin = self.rtdc_ds.features_basin
+        for feat in ds_feats:
+            if feat in feats_loaded:
+                ds_colors.append("#D2FFC8")
+                ds_tips.append("feature data loaded")
+            elif feat in feats_basin:
+                ds_colors.append("#C0E8FF")
+                ds_tips.append("feature data located in basin")
+            elif feat in feats_ancillary:
+                ds_colors.append("#FFD9C1")
+                ds_tips.append("feature data needs to be computed")
+            else:
+                # fall-back
+                ds_colors.append("#A9A9A9")
+                ds_tips.append("unknown location of feature data")
+
+        ds_fl = sorted(zip(ds_labels, ds_feats, ds_colors, ds_tips))
+
+        # Remember current index. If it is -1, we can select a best feature
+        # based on self.default_choices in the end.
+        idx_cur = self.currentIndex()
+
+        # Remember user selection. If it exists in ds_feats, the selection
+        # will persist even if the user switches the dataset.
+        feat_cur = self.currentData(self.data_role)
+
+        blocked = self.signalsBlocked()  # remember block state
+        self.blockSignals(True)
+
+        # set features
+        self.clear()
+        model = self.model()
+        for (label, feat, color, tip) in ds_fl:
+            item = QtGui.QStandardItem(label)
+            item.setData(feat, self.data_role)
+            item.setBackground(QtGui.QColor(color))
+            item.setForeground(QtGui.QColor("black"))
+            item.setToolTip(tip)
+            model.appendRow(item)
+
+        if feat_cur and feat_cur in ds_feats:
+            # If the previous selection exists in the new feature list, set it.
+            idx_cur = self.findData(feat_cur)
+        else:
+            # If the previous selection does not exist in the new feature list,
+            # select the first available feature in `default_choices`
+            idx_cur = -1
+
+        if idx_cur < 0:
+            # If no selection made by user, select the first available feature
+            # in `default_choices`
+            for choice in self.default_choices:
+                idx_choice = self.findData(choice)
+                if idx_choice >= 0:
+                    idx_cur = idx_choice
+                    break
+
+        self.setCurrentIndex(idx_cur)
+
+        # set previous selection
+        self.blockSignals(blocked)

dcscope/gui/widgets/get_path.py

@@ -0,0 +1,42 @@
+import pathlib
+
+from PyQt6 import QtCore, QtWidgets
+
+
+def get_directory(
+        parent: QtWidgets.QWidget,
+        identifier: str,
+        caption: str = "Select directory",
+        force_dialog: bool = True,
+):
+    """Retrieve the path for a given identifier
+
+    When called for the first time, a directory dialog is opened and
+    the user can select the target directory. The directory is then stored
+    in the settings.
+    When called for the second time, a dialog will only pop up when
+    `show_dialog` is set to `True`, otherwise the value from the settings
+    is returned.
+    """
+    path = ""  # default value
+    settings = QtCore.QSettings()
+    if not force_dialog:
+        # attempt to get the directory from the settings
+        dir_settings = settings.value(f"paths/{identifier}", path)
+        if dir_settings and pathlib.Path(dir_settings).exists():
+            path = dir_settings
+        else:
+            # we *have* to ask the user for the directory
+            force_dialog = True
+
+    if force_dialog:
+        dir_user = QtWidgets.QFileDialog.getExistingDirectory(
+            parent=parent,
+            caption=caption,
+            directory=settings.value(f"paths/{identifier}", path)
+        )
+        if dir_user:
+            path = dir_user
+            settings.setValue(f"paths/{identifier}", path)
+
+    return path

dcscope/gui/widgets/key_value_table_widget.css

@@ -0,0 +1,12 @@
+/* This did not work (overlap with grid line). I used spaced for padding instead. */
+/*
+QTableView::item
+{
+  border: 0px;
+  padding: 5px;
+}
+*/
+
+QTableView {
+  gridline-color: white;
+}

dcscope/gui/widgets/key_value_table_widget.py

@@ -0,0 +1,75 @@
+import pathlib
+import importlib.resources
+
+import numpy as np
+from PyQt6 import QtCore, QtWidgets
+
+
+class KeyValueTableWidget(QtWidgets.QTableWidget):
+    def __init__(self, *args, **kwargs):
+        """A table widgets with two columns for key-value visualization"""
+        super(KeyValueTableWidget, self).__init__(*args, **kwargs)
+        ref = importlib.resources.files(
+            "dcscope.gui.widgets") / "key_value_table_widget.css"
+        with importlib.resources.as_file(ref) as path_css:
+            stylesheet = pathlib.Path(path_css).read_text()
+        self.setStyleSheet(stylesheet)
+        self.horizontalHeader().hide()
+        self.verticalHeader().hide()
+        self.setAlternatingRowColors(True)
+        self.setSelectionMode(
+            QtWidgets.QAbstractItemView.SelectionMode.NoSelection)
+        # For some reason this does not work here.
+        # self.setColumnCount(2)
+        # header = self.horizontalHeader()
+        # header.setSectionResizeMode(0,
+        #                             QtWidgets.QHeaderView.ResizeToContents)
+        # header.setSectionResizeMode(1, QtWidgets.QHeaderView.Stretch)
+
+    def set_key_vals(self, keys, vals, max_key_len=23):
+        """Convenience function for setting key-value pairs in this table"""
+        # disable updates
+        self.setUpdatesEnabled(False)
+        # rows'n'cols
+        self.setRowCount(len(keys))
+        self.setColumnCount(2)
+        # populate
+        for ii, (hi, vi) in enumerate(zip(keys, vals)):
+            # name
+            if len(hi) < max_key_len:
+                name_vis = hi
+            else:
+                name_vis = hi[:max_key_len-3] + "..."
+            # pad with spaces (b/c css padding caused overlap)
+            name_vis = " " + name_vis + " "
+            label_name = self.item(ii, 0)
+            if label_name is None:
+                label_name = QtWidgets.QTableWidgetItem(name_vis)
+                label_name.setFlags(QtCore.Qt.ItemFlag.ItemIsEnabled)
+                self.setItem(ii, 0, label_name)
+            else:
+                if label_name.text() != name_vis:
+                    label_name.setText(name_vis)
+            label_name.setToolTip(hi)
+            # value
+            if np.isnan(vi) or np.isinf(vi):
+                fmt = "{}"
+            else:
+                fmt = "{:.7g}"
+            value_vis = fmt.format(vi)
+            label_value = self.item(ii, 1)
+            if label_value is None:
+                label_value = QtWidgets.QTableWidgetItem(value_vis)
+                label_value.setFlags(QtCore.Qt.ItemFlag.ItemIsEnabled)
+                self.setItem(ii, 1, label_value)
+            else:
+                label_value.setText(value_vis)
+            label_value.setToolTip(hi)
+        # spacing (did not work in __init__)
+        header = self.horizontalHeader()
+        header.setSectionResizeMode(
+            0, QtWidgets.QHeaderView.ResizeMode.ResizeToContents)
+        header.setSectionResizeMode(1,
+                                    QtWidgets.QHeaderView.ResizeMode.Stretch)
+        # enable updates again
+        self.setUpdatesEnabled(True)

dcscope/gui/widgets/mdi_subwindow_wo_close.py

@@ -0,0 +1,12 @@
+from PyQt6 import QtCore, QtWidgets
+
+
+class MDISubWindowWOButtons(QtWidgets.QMdiSubWindow):
+    def __init__(self, *args, **kwargs):
+        super(MDISubWindowWOButtons, self).__init__(*args, **kwargs)
+        self.setSystemMenu(None)
+        self.setWindowFlags(QtCore.Qt.WindowType.CustomizeWindowHint
+                            | QtCore.Qt.WindowType.WindowTitleHint)
+
+    def closeEvent(self, event):
+        event.ignore()

dcscope/gui/widgets/qrangeslider.py

@@ -0,0 +1,262 @@
+from PyQt6 import QtCore, QtGui, QtWidgets
+
+DEFAULT_CSS = """
+QRangeSlider * {
+    border: 0px;
+    padding: 0px;
+}
+QRangeSlider #Head {
+    background: #cef;
+}
+QRangeSlider #Span {
+    background: #16f;
+}
+QRangeSlider #Span:active {
+    background: #05f;
+}
+QRangeSlider #Tail {
+    background: #cef;
+}
+QRangeSlider > QSplitter::handle {
+    background: #08f;
+}
+QRangeSlider > QSplitter::handle:vertical {
+    height: 3px;
+}
+QRangeSlider > QSplitter::handle:pressed {
+    background: #0cf;
+}
+"""
+
+
+def scale(val, src, dst):
+    ret = ((val - src[0]) / float(src[1]-src[0])) * (dst[1]-dst[0]) + dst[0]
+    return int(ret)
+
+
+class Ui_Form(object):
+    def setupUi(self, Form):
+        Form.setObjectName("QRangeSlider")
+        Form.setStyleSheet(DEFAULT_CSS)
+        self.gridLayout = QtWidgets.QGridLayout(Form)
+        self.gridLayout.setContentsMargins(0, 0, 0, 0)
+        self.gridLayout.setSpacing(0)
+        self.gridLayout.setObjectName("gridLayout")
+        self._splitter = QtWidgets.QSplitter(Form)
+        self._splitter.setMinimumSize(QtCore.QSize(0, 0))
+        self._splitter.setMaximumSize(QtCore.QSize(16777215, 16777215))
+        self._splitter.setOrientation(QtCore.Qt.Orientation.Horizontal)
+        self._splitter.setObjectName("splitter")
+        self._head = QtWidgets.QGroupBox(self._splitter)
+        self._head.setTitle("")
+        self._head.setObjectName("Head")
+        self._handle = QtWidgets.QGroupBox(self._splitter)
+        self._handle.setTitle("")
+        self._handle.setObjectName("Span")
+        self._tail = QtWidgets.QGroupBox(self._splitter)
+        self._tail.setTitle("")
+        self._tail.setObjectName("Tail")
+        self.gridLayout.addWidget(self._splitter, 0, 0, 1, 1)
+        self.retranslateUi(Form)
+        QtCore.QMetaObject.connectSlotsByName(Form)
+
+    def retranslateUi(self, Form):
+        _translate = QtCore.QCoreApplication.translate
+        Form.setWindowTitle(_translate("QRangeSlider", "QRangeSlider"))
+
+
+class Element(QtWidgets.QGroupBox):
+    def __init__(self, parent, main, *args, **kwargs):
+        super(Element, self).__init__(parent, *args, **kwargs)
+        self.main = main
+
+    def setStyleSheet(self, style):
+        self.parent().setStyleSheet(style)
+
+    def textColor(self):
+        return getattr(self, '__textColor', QtGui.QColor(125, 125, 125))
+
+    def setTextColor(self, color):
+        if type(color) is tuple and len(color) == 3:
+            color = QtGui.QColor(color[0], color[1], color[2])
+        elif type(color) is int:
+            color = QtGui.QColor(color, color, color)
+        setattr(self, '__textColor', color)
+
+    def paintEvent(self, event):
+        qp = QtGui.QPainter()
+        qp.begin(self)
+        if self.main.drawValues():
+            self.drawText(event, qp)
+        qp.end()
+
+
+class Head(Element):
+    def __init__(self, parent, main, *args, **kwargs):
+        super(Head, self).__init__(parent, main, *args, **kwargs)
+
+    def drawText(self, event, qp):
+        qp.setPen(self.textColor())
+        qp.setFont(QtGui.QFont('Arial', 10))
+        qp.drawText(event.rect(), QtCore.Qt.AlignmentFlag.AlignLeft,
+                    str(self.main.min()))
+
+
+class Tail(Element):
+    def __init__(self, parent, main, *args, **kwargs):
+        super(Tail, self).__init__(parent, main, *args, **kwargs)
+
+    def drawText(self, event, qp):
+        qp.setPen(self.textColor())
+        qp.setFont(QtGui.QFont('Arial', 10))
+        qp.drawText(event.rect(), QtCore.Qt.AlignmentFlag.AlignRight,
+                    str(self.main.max()))
+
+
+class Handle(Element):
+    def __init__(self, parent, main, *args, **kwargs):
+        super(Handle, self).__init__(parent, main, *args, **kwargs)
+
+    def drawText(self, event, qp):
+        qp.setPen(self.textColor())
+        qp.setFont(QtGui.QFont('Arial', 10))
+        qp.drawText(event.rect(), QtCore.Qt.AlignmentFlag.AlignLeft,
+                    str(self.main.start()))
+        qp.drawText(event.rect(), QtCore.Qt.AlignmentFlag.AlignRight,
+                    str(self.main.end()))
+
+
+class QRangeSlider(QtWidgets.QWidget, Ui_Form):
+    minValueChanged = QtCore.pyqtSignal(int)
+    maxValueChanged = QtCore.pyqtSignal(int)
+    startValueChanged = QtCore.pyqtSignal(int)
+    endValueChanged = QtCore.pyqtSignal(int)
+    rangeChanged = QtCore.pyqtSignal(int, int)
+
+    _INT_NUM = 2000
+    _SPLIT_START = 1
+    _SPLIT_END = 2
+
+    def __init__(self, parent=None, *args, **kwargs):
+        super(QRangeSlider, self).__init__(parent, *args, **kwargs)
+        self.setupUi(self)
+        self.setFixedHeight(21)
+        self.setMouseTracking(False)
+        self._splitter.splitterMoved.connect(self._handleMoveSplitter)
+        self._head_layout = QtWidgets.QHBoxLayout()
+        self._head_layout.setSpacing(0)
+        self._head_layout.setContentsMargins(0, 0, 0, 0)
+        self._head.setLayout(self._head_layout)
+        self.head = Head(self._head, main=self)
+        self._head_layout.addWidget(self.head)
+        self._handle_layout = QtWidgets.QHBoxLayout()
+        self._handle_layout.setSpacing(0)
+        self._handle_layout.setContentsMargins(0, 0, 0, 0)
+        self._handle.setLayout(self._handle_layout)
+        self.handle = Handle(self._handle, main=self)
+        self._handle_layout.addWidget(self.handle)
+        self._tail_layout = QtWidgets.QHBoxLayout()
+        self._tail_layout.setSpacing(0)
+        self._tail_layout.setContentsMargins(0, 0, 0, 0)
+        self._tail.setLayout(self._tail_layout)
+        self.tail = Tail(self._tail, main=self)
+        self._tail_layout.addWidget(self.tail)
+        # set limits
+        self.setMin(0)
+        self.setMax(self._INT_NUM)
+        self.setStart(0)
+        self.setEnd(self._INT_NUM)
+        self.setDrawValues(False)
+
+    @QtCore.pyqtSlot(object)
+    def resizeEvent(self, event):
+        # The geometry changed and `self.width` is different now. Adjust
+        # the entire range slider to reflect the new values.
+        self.setStart(self.start())
+        self.setEnd(self.end())
+        super(QRangeSlider, self).resizeEvent(event)
+
+    def min(self):
+        return getattr(self, '__min', None)
+
+    def max(self):
+        return getattr(self, '__max', None)
+
+    def setMin(self, value):
+        setattr(self, '__min', value)
+        self.minValueChanged.emit(value)
+
+    def setMax(self, value):
+        setattr(self, '__max', value)
+        self.maxValueChanged.emit(value)
+
+    def start(self):
+        return getattr(self, '__start', None)
+
+    def end(self):
+        return getattr(self, '__end', None)
+
+    def _setStart(self, value):
+        setattr(self, '__start', value)
+        self.startValueChanged.emit(value)
+        self.rangeChanged.emit(value, self.end())
+
+    def setStart(self, value):
+        v = self._valueToPos(value)
+        self._splitter.splitterMoved.disconnect()
+        self._splitter.moveSplitter(v, self._SPLIT_START)
+        self._splitter.refresh()
+        self._splitter.splitterMoved.connect(self._handleMoveSplitter)
+        self._setStart(value)
+
+    def _setEnd(self, value):
+        setattr(self, '__end', value)
+        self.endValueChanged.emit(value)
+        self.rangeChanged.emit(self.start(), value)
+
+    def setEnd(self, value):
+        v = self._valueToPos(value)
+        self._splitter.splitterMoved.disconnect()
+        self._splitter.moveSplitter(v, self._SPLIT_END)
+        self._splitter.refresh()
+        self._splitter.splitterMoved.connect(self._handleMoveSplitter)
+        self._setEnd(value)
+
+    def drawValues(self):
+        return getattr(self, '__drawValues', None)
+
+    def setDrawValues(self, draw):
+        setattr(self, '__drawValues', draw)
+
+    def getRange(self):
+        return self.start(), self.end()
+
+    def setRange(self, start, end):
+        self.setStart(start)
+        self.setEnd(end)
+
+    def setBackgroundStyle(self, style):
+        self._tail.setStyleSheet(style)
+        self._head.setStyleSheet(style)
+
+    def setSpanStyle(self, style):
+        self._handle.setStyleSheet(style)
+
+    def _valueToPos(self, value):
+        return scale(value, (self.min(), self.max()), (0, self.width()))
+
+    def _posToValue(self, xpos):
+        return scale(xpos, (0, self.width()), (self.min(), self.max()))
+
+    def _handleMoveSplitter(self, xpos, index):
+        hw = self._splitter.handleWidth()
+        if index == self._SPLIT_START:
+            v = self._posToValue(xpos)
+            if v >= self.end():
+                self.setEnd(self._INT_NUM)
+            self._setStart(v)
+        elif index == self._SPLIT_END:
+            v = self._posToValue(xpos + hw)
+            if v <= self.start():
+                self.setStart(0)
+            self._setEnd(v)