PySide6Plot 0.0.1__py3-none-any.whl

PySide6Plot/widgets/removable_table.py

@@ -0,0 +1,259 @@
+from qfluentwidgets import (
+    FluentIcon,
+    Action,
+    Flyout,
+    FlyoutAnimationType,
+    TableWidget,
+    CommandBarView,
+    TableItemDelegate,
+)
+from PySide6.QtWidgets import QTableView, QTableWidgetItem
+from PySide6.QtCore import Qt, Signal, QEvent, QModelIndex
+from PySide6.QtGui import QCursor
+from PySide6.QtWidgets import QWidget, QStyleOptionViewItem
+
+
+# https://forum.qt.io/topic/97628/qlistwidget-item-editing/13
+class JEditableListStyledItemDelegate(TableItemDelegate):
+    # class variable for "editStarted" signal, with QModelIndex parameter
+    editStarted = Signal(QModelIndex, name="editStarted")
+    # class variable for "editFinished" signal, with QModelIndex parameter
+    editFinished = Signal(QModelIndex, name="editFinished")
+
+    def __init__(self, parent: QTableView):
+        super().__init__(parent)
+        self.edit_created = False
+
+    def createEditor(self, parent: QWidget, option: QStyleOptionViewItem, index: QModelIndex):
+        editor = super().createEditor(parent, option, index)
+        self.edit_created = True
+        if editor is not None:
+            self.editStarted.emit(index)
+        return editor
+
+    def destroyEditor(self, editor: QWidget, index: QModelIndex):
+        if self.edit_created:
+            self.editFinished.emit(index)
+            self.edit_created = False
+        return super().destroyEditor(editor, index)
+
+
+class RemovableTable(TableWidget):
+    sigAcceptClicked = Signal(int)
+    sigRowClicked = Signal(int)
+    sigDeleteClicked = Signal(int)
+    sigMoveUpClicked = Signal(int)
+    sigMoveDownClicked = Signal(int)
+    sigNameEdited = Signal(int, str)
+
+    def __init__(
+        self,
+        parent=None,
+        show_row_index=False,
+        resize_columns_to_contents=True,
+        show_move_up_down_buttons=True,
+        show_delete_button=True,
+        show_rename_button=True,
+        accept_name="Select",
+        accept_icon=FluentIcon.ACCEPT,
+        link_default_slot=True,
+    ):
+        super().__init__(parent)
+        self.setBorderVisible(True)
+        self.setBorderRadius(8)
+        self.setWordWrap(False)
+        self.viewport().installEventFilter(self)
+        styledItemDelegate = JEditableListStyledItemDelegate(self)
+        styledItemDelegate.editFinished.connect(self.__on_name_changed)
+        self.setItemDelegate(styledItemDelegate)
+        self.current_item = None
+        self.show_row_index = show_row_index
+        self.resize_columns_to_contents = resize_columns_to_contents
+        self.show_move_up_down_buttons = show_move_up_down_buttons
+        self.show_delete_button = show_delete_button
+        self.show_rename_button = show_rename_button
+        self.accept_name = accept_name
+        self.accept_icon = accept_icon
+        self.act_from_self = False
+        if not self.show_row_index:
+            self.verticalHeader().hide()
+        if link_default_slot:
+            self.sigAcceptClicked.connect(self.accept_row_data)
+            self.sigDeleteClicked.connect(self.delete_row_data)
+            self.sigMoveUpClicked.connect(self.move_up_row_data)
+            self.sigMoveDownClicked.connect(self.move_down_row_data)
+
+    def show_menu_bar(self):
+        """
+        Show the menu bar with various actions such as accept, rename, move up, move down, and delete.
+        NOTE: Must specify the current item before calling this method.
+        """
+        self.command_bar = CommandBarView(self)
+        select_action = Action(self.accept_icon, self.accept_name)
+        select_action.triggered.connect(self.__on_accept_clicked)
+        self.command_bar.addAction(select_action)
+        if self.show_rename_button:
+            edit_action = Action(FluentIcon.FONT, "Rename")
+            edit_action.triggered.connect(self.__on_edit_row_clicked)
+            self.command_bar.addAction(edit_action)
+        if self.show_move_up_down_buttons:
+            if self.current_item.row() > 0:
+                move_up_action = Action(FluentIcon.UP, "Move up")
+                move_up_action.triggered.connect(self.__on_move_up_row_clicked)
+                self.command_bar.addAction(move_up_action)
+            if self.current_item.row() < self.rowCount() - 1:
+                move_down_action = Action(FluentIcon.DOWN, "Move down")
+                move_down_action.triggered.connect(self.__on_move_down_row_clicked)
+                self.command_bar.addAction(move_down_action)
+        if self.show_delete_button:
+            delete_action = Action(FluentIcon.DELETE, "Delete")
+            delete_action.triggered.connect(self.__on_delete_row_clicked)
+            self.command_bar.addAction(delete_action)
+        self.command_bar.resizeToSuitableWidth()
+        self.shown_cbar = Flyout.make(self.command_bar, QCursor.pos(), self, FlyoutAnimationType.FADE_IN, True)
+
+    def accept_row_data(self, row_index):
+        pass
+
+    def __on_accept_clicked(self):
+        if self.current_item is not None:
+            self.clearSelection()
+            self.shown_cbar.close()
+            self.sigAcceptClicked.emit(self.current_item.row())
+            self.current_item = None
+
+    def delete_row_data(self, row_index):
+        """
+        Delete a row of data from the table.
+
+        Args:
+            row_index (int): The index of the row to be deleted.
+        """
+        self.removeRow(row_index)
+
+    def __on_delete_row_clicked(self):
+        if self.current_item is not None:
+            self.clearSelection()
+            self.shown_cbar.close()
+            self.sigDeleteClicked.emit(self.current_item.row())
+            self.current_item = None
+
+    def move_up_row_data(self, row_index):
+        """
+        Moves the data in the specified row up by one row.
+
+        Args:
+            row_index (int): The index of the row to move up.
+
+        Returns:
+            None
+        """
+        for j in range(self.columnCount()):
+            temple = self.item(row_index, j).text()
+            self.item(row_index, j).setText(self.item(row_index - 1, j).text())
+            self.item(row_index - 1, j).setText(temple)
+
+    def __on_move_up_row_clicked(self):
+        if self.current_item is not None:
+            self.clearSelection()
+            self.shown_cbar.close()
+            self.sigMoveUpClicked.emit(self.current_item.row())
+            self.current_item = None
+
+    def move_down_row_data(self, row_index, mute_signal=False):
+        """
+        Move the data in the specified row down by one row.
+
+        Args:
+            row_index (int): The index of the row to move down.
+            mute_signal (bool, optional): Whether to mute the signal emitted during the move. Defaults to False.
+        """
+        for j in range(self.columnCount()):
+            temple = self.item(row_index, j).text()
+            self.item(row_index, j).setText(self.item(row_index + 1, j).text())
+            self.item(row_index + 1, j).setText(temple)
+
+    def __on_move_down_row_clicked(self):
+        if self.current_item is not None:
+            self.clearSelection()
+            self.shown_cbar.close()
+            self.sigMoveDownClicked.emit(self.current_item.row())
+            self.current_item = None
+
+    def rename(self, row_index):
+        self.editItem(self.item(row_index, 0))
+
+    def __on_edit_row_clicked(self):
+        if self.current_item is not None:
+            self.rename(self.current_item.row())
+            self.shown_cbar.close()
+
+    def __on_name_changed(self, index):
+        self.sigNameEdited.emit(index.row(), index.data())
+
+    def set_header_labels(self, labels):
+        """
+        Set the header labels for the table.
+
+        Args:
+            labels (list): A list of strings representing the header labels.
+
+        Returns:
+            None
+        """
+        self.setColumnCount(len(labels))
+        self.setHorizontalHeaderLabels(labels)
+        if self.resize_columns_to_contents:
+            self.resizeColumnsToContents()
+
+    def set_row_data_item(self, row_index, col_index, item):
+        """
+        Sets the data item for a specific row and column in the table.
+
+        Parameters:
+            row_index (int): The index of the row.
+            col_index (int): The index of the column.
+            item (QWidget or any): The item to be set in the table.
+
+        Returns:
+            None
+        """
+        if isinstance(item, QWidget):
+            item_text = " "
+            self.setItem(row_index, col_index, QTableWidgetItem(item_text))
+            self.setCellWidget(row_index, col_index, item)
+        else:
+            item = QTableWidgetItem(str(item))
+            if col_index != 0:
+                item.setFlags(item.flags() & ~Qt.ItemFlag.ItemIsEditable)
+            self.setItem(row_index, col_index, item)
+
+    def add_row_data(self, data_i):
+        """
+        Add a new row to the table and populate it with the given data.
+
+        Args:
+            data_i (list): The data to be added to the new row.
+
+        Returns:
+            None
+        """
+        row_count = self.rowCount()
+        self.setRowCount(row_count + 1)
+        for j, content in enumerate(data_i):
+            self.set_row_data_item(row_count, j, content)
+        if self.resize_columns_to_contents:
+            self.resizeColumnsToContents()
+
+    def eventFilter(self, source, event):
+        if event.type() == QEvent.Type.MouseButtonPress:
+            item = self.itemAt(event.pos())
+            if item is not None:
+                self.current_item = item
+                self.clearSelection()
+                self.selectRow(self.current_item.row())
+                if event.button() == Qt.MouseButton.LeftButton:
+                    self.sigRowClicked.emit(self.current_item.row())
+                elif event.button() == Qt.MouseButton.RightButton:
+                    self.show_menu_bar()
+        return super().eventFilter(source, event)

PySide6Plot/widgets/transparent_Line_edit.py

@@ -0,0 +1,69 @@
+from PySide6.QtCore import QEvent, QObject
+from qfluentwidgets import TransparentPushButton, LineEdit
+from PySide6.QtWidgets import QWidget, QVBoxLayout
+from PySide6.QtCore import Signal, Qt
+
+
+class TransparentLineEdit(QWidget):
+    sigTextEditFinished = Signal()
+
+    def __init__(self, parent=None):
+        super().__init__(parent=parent)
+        self.main_layout = QVBoxLayout()
+        self.main_layout.setContentsMargins(0, 0, 0, 0)
+        self.main_layout.setSpacing(0)
+        self.line_edit = LineEdit(parent=self)
+        self.push_button = TransparentPushButton(parent=self)
+        self.main_layout.addWidget(self.line_edit)
+        self.main_layout.addWidget(self.push_button)
+        self.line_edit.setVisible(False)
+        self.setLayout(self.main_layout)
+        self.push_button.clicked.connect(self.__show_line_edit)
+        self.line_edit.installEventFilter(self)
+
+    def set_text(self, text):
+        self.line_edit.setText(text)
+        self.push_button.setText(text)
+
+    def get_text(self):
+        return self.line_edit.text()
+
+    def __show_line_edit(self):
+        self.push_button.setVisible(False)
+        self.line_edit.setVisible(True)
+        self.line_edit.setFocus()
+
+    def __finish_edit(self):
+        self.sigTextEditFinished.emit()
+        self.push_button.setText(self.line_edit.text())
+        self.line_edit.setVisible(False)
+        self.push_button.setVisible(True)
+
+    def eventFilter(self, a0: QObject, a1: QEvent) -> bool:
+        if a0 == self.line_edit:
+            if a1.type() == QEvent.Type.FocusOut:
+                self.__finish_edit()
+                return False
+            if a1.type() == QEvent.Type.KeyPress:
+                if a1.key() in (Qt.Key.Key_Enter, Qt.Key.Key_Return):
+                    self.__finish_edit()
+                    return False
+                elif a1.key() == Qt.Key.Key_Escape:
+                    self.line_edit.setVisible(False)
+                    self.push_button.setVisible(True)
+                    return False
+        return super().eventFilter(a0, a1)
+
+
+if __name__ == "__main__":
+    from PySide6.QtWidgets import QApplication
+    import sys
+
+    if __name__ == "__main__":
+        app = QApplication(sys.argv)
+        window = QWidget()
+        widget = TransparentLineEdit()
+        window.setLayout(QVBoxLayout())
+        window.layout().addWidget(widget)
+        window.show()
+        sys.exit(app.exec())

PySide6Plot/widgets/transparent_selector.py

@@ -0,0 +1,208 @@
+from qfluentwidgets import (
+    TransparentDropDownPushButton,
+    Action,
+    FluentIcon,
+    CheckableMenu,
+    ColorDialog,
+    MenuIndicatorType,
+)
+from qfluentwidgets.common.icon import toQIcon
+from PySide6.QtGui import QColor, QPixmap, QIcon
+from PySide6.QtCore import Signal
+from PySide6.QtWidgets import QApplication
+import sys
+
+TRADITIONAL_COLORS = {
+    "Black": QColor(45, 45, 45),
+    "White": QColor(255, 255, 255),
+    "Red": QColor(255, 0, 0),
+    "Green": QColor(0, 255, 0),
+    "Blue": QColor(0, 0, 255),
+    "Yellow": QColor(255, 255, 0),
+    "Cyan": QColor(0, 255, 255),
+    "Magenta": QColor(255, 0, 255),
+    "Gray": QColor(128, 128, 128),
+    "Dark gray": QColor(64, 64, 64),
+    "Light gray": QColor(192, 192, 192),
+    "Orange": QColor(255, 165, 0),
+    "Purple": QColor(128, 0, 128),
+    "Brown": QColor(165, 42, 42),
+}
+
+SCIENTIFIC_COLORS = {
+    "Black": QColor(0, 0, 0),
+    "Red": QColor("#FF1F5B"),
+    "Blue": QColor("#009ADE"),
+    "Yellow": QColor("#FFC61E"),
+    "Purple": QColor("#AF58BA"),
+    "Orange": QColor("#F28522"),
+    "Green": QColor("#00CD6C"),
+    "Brown": QColor("#A6761D"),
+}
+
+DEFAULT_LINE_WIDTHS = {
+    "0.25 pt": 0.25 * 2,
+    "0.5 pt": 0.5 * 2,
+    "0.75 pt": 0.75 * 2,
+    "1 pt": 1 * 2,
+    "1.5 pt": 1.5 * 2,
+    "2.25 pt": 2.25 * 2,
+    "3 pt": 3 * 2,
+    "4.5 pt": 4.5 * 2,
+    "6 pt": 6 * 2,
+}
+
+DEFAULT_DASH_TYPE = {
+    "——————": [],
+    "——  ——  ": [5, 5],
+    "⋅⋅⋅⋅⋅⋅⋅⋅": [1, 1],
+    "-  ⋅  ": [3, 5, 1, 5],
+    "-  ⋅  ⋅": [3, 5, 1, 5, 1, 5],
+    "————  ": [10, 3],
+    "——   ": [5, 10],
+    "-    ⋅": [3, 10, 1, 10],
+    "-    ⋅    ⋅": [3, 10, 1, 10, 1, 10],
+    "- ⋅ ⋅": [3, 1, 1, 1, 1, 1],
+}
+
+
+class TransparentSelector(TransparentDropDownPushButton):
+    item_selected = Signal(str)
+
+    def __init__(self, items: dict, allow_custom=True, default_index=0, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.allow_custom = allow_custom
+        self.items = items
+        self.item_menu_actions = []
+
+        def generate_item_select_action(item_name):
+            item_action = Action(item_name)
+            item_action.setCheckable(True)
+            item_action.setChecked(False)
+            item_action.triggered.connect(lambda: self.on_item_menu_action_clicked(item_action))
+            return item_action
+
+        self.item_menu_actions = [
+            {"name": item_name, "value": value, "action": generate_item_select_action(item_name)}
+            for item_name, value in self.items.items()
+        ]
+        if self.allow_custom:
+            self.customized_item = None
+            self.item_menu_actions.append(
+                {
+                    "name": "customized",
+                    "value": self.customized_item,
+                    "action": generate_item_select_action("customized"),
+                }
+            )
+        self.item_menu_actions[default_index]["action"].setChecked(True)
+        self.current_item = self.item_menu_actions[default_index]["value"]
+        self.default_item = self.item_menu_actions[default_index]["value"]
+        self.item_menu = CheckableMenu(indicatorType=MenuIndicatorType.RADIO)
+        self.item_menu.addActions([item["action"] for item in self.item_menu_actions])
+        self.setMenu(self.item_menu)
+        self.setText(self.item_menu_actions[default_index]["action"].text())
+
+    def on_item_menu_action_clicked(self, action, emit=True):
+        if self.allow_custom and action.text() == "customized":
+            if self.get_custom_item():
+                self.current_item = self.customized_item
+            else:
+                self.set_item(self.current_item)
+                return False
+        else:
+            self.current_item = self.items[action.text()]
+        self.setText(action.text())
+        if emit:
+            self.item_selected.emit(action.text())
+        for other_action in self.item_menu_actions:
+            other_action["action"].setChecked(False)
+        action.setChecked(True)
+        return True
+
+    def set_item(self, item):
+        for action in self.item_menu_actions:
+            if action["value"] == item:
+                self.on_item_menu_action_clicked(action["action"], emit=False)
+                return 0
+        if self.allow_custom:
+            self.customized_item = item
+            self.current_item = item
+            action = self.item_menu_actions[-1]["action"]
+            self.setText(action.text())
+            for other_action in self.item_menu_actions:
+                other_action["action"].setChecked(False)
+            action.setChecked(True)
+            return 1
+        else:
+            raise ValueError("No such item in the menu")
+
+    def get_value(self, selected_text):
+        for action in self.item_menu_actions:
+            if action["name"] == selected_text:
+                return action["value"]
+        raise ValueError("No such item in the menu")
+
+    def get_custom_item(self):
+        return True
+
+
+class TransparentColorSelector(TransparentSelector):
+    def __init__(self, color_icon_width=24, color_icon_height=8, colors=SCIENTIFIC_COLORS, *args, **kwargs):
+        super().__init__(*args, items=colors, allow_custom=True, **kwargs)
+        self.color_icon_width = color_icon_width
+        self.color_icon_height = color_icon_height
+        for action in self.item_menu_actions[0:-1]:
+            action["action"].setIcon(self.__color_icon(colors[action["name"]]))
+        self.item_menu_actions[-1]["action"].setIcon(toQIcon(FluentIcon.PALETTE))
+        self.setIcon(self.__color_icon(self.current_item))
+
+    def on_item_menu_action_clicked(self, action, emit=True):
+        re = super().on_item_menu_action_clicked(action, emit)
+        if re:
+            self.setIcon(action.icon())
+        return re
+
+    def __color_icon(self, color):
+        pixmap = QPixmap(self.color_icon_width, self.color_icon_height)
+        pixmap.fill(color)
+        return QIcon(pixmap)
+
+    def set_item(self, item):
+        re = super().set_item(item)
+        if re == 1:
+            icon = toQIcon(self.__color_icon(item))
+            self.setIcon(icon)
+            self.item_menu_actions[-1]["action"].setIcon(icon)
+        return re
+
+    def get_custom_item(self):
+        if self.customized_item is not None:
+            default_color = self.customized_item
+        else:
+            default_color = self.current_item
+        w = ColorDialog(default_color, "Select Color", self.window())
+        if w.exec():
+            self.customized_item = w.color
+            self.item_menu_actions[-1]["value"] = self.customized_item
+            self.item_menu_actions[-1]["action"].setIcon(self.__color_icon(self.customized_item))
+            return True
+        else:
+            return False
+
+
+class TransparentLineWidthSelector(TransparentSelector):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, items=DEFAULT_LINE_WIDTHS, default_index=3, allow_custom=False, **kwargs)
+
+
+class TransparentDashTypeSelector(TransparentSelector):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, items=DEFAULT_DASH_TYPE, default_index=0, allow_custom=False, **kwargs)
+
+
+if __name__ == "__main__":
+    app = QApplication(sys.argv)
+    widget = TransparentColorSelector()
+    widget.show()
+    sys.exit(app.exec())